= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n\\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n result = []\\n q = deque()\\n q.append(root)\\n while q:\\n # TODO: Do not add next level if all nodes are None\\n for _ in range(len(q)):\\n node = q.popleft()\\n if not node:\\n result.append(\\\"$\\\")\\n #print(result)\\n else:\\n result.append(str(node.val))\\n #print(result)\\n q.append(node.left)\\n q.append(node.right)\\n\\n # remove null children\\n while result and result[-1] == \\\"$\\\":\\n result.pop()\\n #print(result)\\n return \\\"#\\\".join(result)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n\\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n # 1#2#3#-1#-1#4#5\\n print(data)\\n\\n if not data:\\n return None\\n\\n nodes = [TreeNode(int(parsed)) if parsed != \\\"$\\\" else None for parsed in data.split(\\\"#\\\")]\\n n = len(nodes)\\n result = nodes[0] # append root node\\n node = result # track current node\\n # i tracks parent nodes\\n # j tracks children nodes\\n i, j = 1, 1\\n\\n while j < n:\\n # assign children nodes\\n node.left = nodes[j] if j < n else None\\n j += 1\\n node.right = nodes[j] if j < n else None\\n j += 1\\n\\n # increment parent node up to a not null node\\n while not nodes[i]:\\n i += 1\\n node = nodes[i]\\n i += 1\\n\\n return result\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n return ','.join(result).rstrip(',')\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or data[i] == '':\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n res = []\\n\\n def dfs(root):\\n if not root:\\n res.append(\\\"N\\\")\\n return\\n \\n res.append(str(root.val))\\n dfs(root.left)\\n dfs(root.right)\\n\\n dfs(root)\\n return \\\",\\\".join(res)\\n \\n\\n def deserialize(self, data):\\n print(data)\\n vals = data.split(\\\",\\\")\\n self.i = 0\\n\\n def dfs():\\n if vals[self.i] == \\\"N\\\":\\n return None\\n \\n root = TreeNode(vals[self.i])\\n self.i += 1\\n root.left = dfs()\\n self.i += 1\\n root.right = dfs()\\n\\n \\n return root\\n\\n return dfs()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n return ','.join(result).rstrip(',')\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n while result and result[-1] == '':\\n result.pop()\\n return ','.join(result)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n def dfs(root):\\n nonlocal res\\n if not root:\\n res.append(\\\"N\\\")\\n return\\n res.append(str(root.val))\\n dfs(root.left)\\n dfs(root.right)\\n dfs(root)\\n return \\\",\\\".join(res)\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n vals = data.split(\\\",\\\")\\n self.i = 0\\n def dfs():\\n nonlocal vals\\n if vals[self.i] == \\\"N\\\":\\n self.i += 1\\n return None\\n node = TreeNode(int(vals[self.i]))\\n self.i += 1\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n return dfs()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\\"\\\"\\\"\\n res = []\\n\\n def dfs(root: Optional[TreeNode]) -> None:\\n if not root:\\n res.append('x')\\n return\\n res.append(str(root.val))\\n dfs(root.left)\\n dfs(root.right)\\n\\n dfs(root)\\n return ' '.join(res)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n def dfs(nodes) -> Optional[TreeNode]:\\n if not data:\\n return None\\n ch = next(nodes)\\n if ch == 'x':\\n return None\\n node = TreeNode(int(ch))\\n node.left = dfs(nodes)\\n node.right = dfs(nodes)\\n return node\\n\\n res = dfs(iter(data.split()))\\n return res\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\\n\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n serialized = []\\n def dfs(node):\\n if node:\\n serialized.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n else:\\n serialized.append(\\\"#\\\")\\n dfs(root)\\n return (\\\"+\\\").join(serialized)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n data = data.split(\\\"+\\\")\\n pointer = 0\\n def dfs():\\n nonlocal pointer\\n val = data[pointer]\\n pointer += 1\\n if val != \\\"#\\\":\\n node = TreeNode(int(val))\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n else:\\n return None\\n root = dfs()\\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return json.dumps([])\\n\\n queue = deque([root])\\n output = []\\n\\n while len(queue) > 0:\\n node = queue.popleft()\\n\\n if node is None:\\n output.append(None)\\n \\n if node:\\n output.append(node.val)\\n queue.append(node.left)\\n queue.append(node.right)\\n \\n i = len(output) - 1\\n while output[i] is None:\\n output.pop()\\n i -= 1\\n \\n print(output)\\n\\n return json.dumps(output)\\n\\n \\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n stree = json.loads(data)\\n if len(stree) == 0:\\n return None\\n \\n root = TreeNode(stree[0])\\n queue = deque([root])\\n i = 1\\n\\n while len(queue) > 0:\\n node = queue.popleft()\\n\\n if i < len(stree) and stree[i] is not None:\\n node.left = TreeNode(stree[i])\\n queue.append(node.left)\\n i += 1 \\n if i < len(stree) and stree[i] is not None:\\n node.right = TreeNode(stree[i])\\n queue.append(node.right)\\n i += 1\\n \\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n serial = []\\n # preorder dfs\\n def dfs(root):\\n if not root:\\n serial.append(\\\"N\\\")\\n return\\n serial.append(str(root.val))\\n dfs(root.left)\\n dfs(root.right)\\n return\\n dfs(root)\\n return \\\"#\\\".join(serial)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n tree = data.split(\\\"#\\\")\\n self.index = 0\\n # preorder dfs\\n def dfs():\\n if tree[self.index] == \\\"N\\\":\\n self.index += 1\\n return None\\n node = TreeNode(int(tree[self.index]))\\n self.index += 1\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n return dfs()\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n'''\\nGoal:\\nserialize => convert a binary tree to a string, preserve the 'none' nodes\\ndeserilize => convert string back to binary tree\\n\\nApproach:\\nSerialize:\\n- Use a BFS (queue) -> convert the binary tree into a string with comma delimited, preserve none node spaces with \\\"\\\"\\n- O(N) time, O(N) space\\n\\nDeserialize:\\n- check if string exists\\n- take in string \\\"1,2,3,,,\\\" -> convert to an array\\n- create root from first item in array -> add to queue\\n- create iterator (i), set as 1\\n- use a queue to loop and build tree\\n - popleft() current node\\n - check the index of the array (if its in the range) and for (2i) if its not an empty string\\n - set as current node's left and add to queue\\n - increment index\\n - do the same check above but for 2i + 1\\n - set as current node's right and add to queue\\n - increment index\\nreturn root \\n\\n'''\\nfrom collections import deque\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n result = []\\n queue = deque([root])\\n\\n while queue:\\n node = queue.popleft()\\n if node:\\n result.append(str(node.val))\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n result.append(\\\"\\\")\\n return \\\",\\\".join(result)\\n \\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n\\n nodeList = data.split(\\\",\\\")\\n root = TreeNode(int(nodeList[0]))\\n\\n queue = deque([root])\\n i = 1\\n\\n while queue:\\n node = queue.popleft()\\n if i < len(nodeList) and nodeList[i]:\\n node.left = TreeNode(int(nodeList[i]))\\n queue.append(node.left)\\n i += 1\\n if i < len(nodeList) and nodeList[i]:\\n node.right = TreeNode(int(nodeList[i]))\\n queue.append(node.right)\\n i += 1\\n return root\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n\\n def dfs(node):\\n if not node:\\n res.append(\\\"N\\\")\\n return \\n \\n res.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n\\n dfs(root)\\n return \\\",\\\".join(res)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n vals = data.split(\\\",\\\")\\n self.i = 0\\n\\n def dfs():\\n if vals[self.i] == \\\"N\\\":\\n self.i += 1\\n return None\\n\\n node = TreeNode(int(vals[self.i]))\\n self.i += 1\\n node.left = dfs()\\n node.right = dfs()\\n\\n return node\\n \\n return dfs()\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n while result and result[-1] == '':\\n result.pop()\\n return ','.join(result)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n return ','.join(result).rstrip(',')\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or data[i] == '':\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"class Codec:\\n\\n def serialize(self, root):\\n # use level order traversal to match LeetCode's serialization format\\n flat_bt = []\\n queue = collections.deque([root])\\n while queue:\\n node = queue.popleft()\\n if node:\\n flat_bt.append(str(node.val))\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n # you can use any char to represent null\\n # empty string means test for a non-null node is simply: flat_bt[i]\\n flat_bt.append('')\\n print(flat_bt)\\n return ','.join(flat_bt)\\n # time: O(n)\\n # space: O(n)\\n\\n def deserialize(self, data):\\n if not data:\\n return\\n flat_bt = data.split(',')\\n ans = TreeNode(flat_bt[0])\\n queue = collections.deque([ans])\\n i = 1\\n # when you pop a node, its children will be at i and i+1\\n while queue:\\n node = queue.popleft()\\n if i < len(flat_bt) and flat_bt[i]:\\n node.left = TreeNode(int(flat_bt[i]))\\n queue.append(node.left)\\n i += 1\\n if i < len(flat_bt) and flat_bt[i]:\\n node.right = TreeNode(int(flat_bt[i]))\\n queue.append(node.right)\\n i += 1\\n return ans\\n # time: O(n)\\n # space: O(n)\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n res = []\\n def pre(root):\\n if not root:\\n res.append('N')\\n return\\n res.append(str(root.val))\\n\\n pre(root.left)\\n pre(root.right)\\n\\n pre(root)\\n return \\\",\\\".join(res)\\n\\n\\n def deserialize(self, data):\\n val = data.split(',')\\n self.idx = 0\\n\\n def pre():\\n if val[self.idx] == 'N':\\n self.idx += 1\\n return None\\n\\n root = TreeNode(int(val[self.idx]))\\n self.idx += 1\\n \\n root.left = pre()\\n root.right = pre()\\n \\n return root\\n\\n return pre()\\n \\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n def dfs(root):\\n if not root:\\n res.append('N')\\n return\\n res.append(str(root.val))\\n dfs(root.left)\\n dfs(root.right)\\n \\n dfs(root)\\n print(','.join(res))\\n return ','.join(res)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n self.i = 0\\n data = data.split(',')\\n def dfs():\\n if data[self.i] == 'N':\\n self.i += 1\\n return None\\n node = TreeNode(int(data[self.i]))\\n self.i += 1\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n \\n return dfs()\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\nclass Codec:\\n \\n # Encodes a tree to a single string.\\n def serialize(self, root: Optional[TreeNode]) -> str:\\n res = []\\n\\n def dfs(node):\\n if not node:\\n res.append(\\\"N\\\")\\n return\\n res.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n\\n dfs(root)\\n return \\\",\\\".join(res)\\n \\n # Decodes your encoded data to tree.\\n def deserialize(self, data: str) -> Optional[TreeNode]:\\n vals = data.split(\\\",\\\")\\n self.i = 0\\n\\n def dfs():\\n if vals[self.i] == \\\"N\\\":\\n self.i += 1\\n return None\\n node = TreeNode(int(vals[self.i]))\\n self.i += 1\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n\\n return dfs()\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n\\n def dfs(node):\\n\\n if not node:\\n res.append(\\\"N\\\")\\n return\\n \\n res.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n \\n \\n dfs(root)\\n return \\\",\\\".join(res)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n self.i = 0\\n arr = data.split(\\\",\\\")\\n\\n def dfs():\\n\\n if arr[self.i] == \\\"N\\\":\\n self.i += 1\\n return None\\n \\n root = TreeNode(int(arr[self.i]))\\n self.i += 1\\n\\n root.left = dfs()\\n root.right = dfs()\\n return root\\n \\n return dfs()\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n\\n def dfs(node):\\n\\n if not node:\\n res.append(\\\"N\\\")\\n return\\n \\n res.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n \\n \\n dfs(root)\\n return \\\",\\\".join(res)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n self.i = 0\\n arr = data.split(\\\",\\\")\\n\\n def dfs():\\n\\n if arr[self.i] == \\\"N\\\":\\n self.i += 1\\n return None\\n \\n root = TreeNode(int(arr[self.i]))\\n self.i += 1\\n\\n root.left = dfs()\\n root.right = dfs()\\n return root\\n \\n return dfs()\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n while result and result[-1] == '':\\n result.pop()\\n return ','.join(result)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n result = \\\"\\\"\\n queue = deque()\\n queue.append((root, 0))\\n pLevel = 0\\n\\n while queue:\\n currNode, currLevel = queue.popleft()\\n if currLevel <= pLevel:\\n if currNode:\\n result += str(currNode.val) + \\\",\\\"\\n queue.append((currNode.left, currLevel + 1))\\n queue.append((currNode.right, currLevel + 1))\\n if currNode.left or currNode.right:\\n pLevel = max(pLevel, currLevel + 1)\\n else:\\n result += \\\"null,\\\"\\n # queue.append((None, currLevel + 1))\\n else:\\n break\\n # print(result)\\n return result[:-1]\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n \\n node_nums = data.split(\\\",\\\")\\n print(node_nums)\\n if node_nums[0] == \\\"null\\\":\\n return None\\n\\n root = TreeNode(int(node_nums[0]))\\n queue = deque()\\n queue.append(root)\\n\\n for idx in range(1,len(node_nums),2):\\n # print(idx)\\n head = queue.popleft()\\n if head:\\n left = node_nums[idx]\\n right = node_nums[idx+1]\\n\\n if left != \\\"null\\\":\\n head.left = TreeNode(int(left))\\n queue.append(head.left)\\n # else:\\n # queue.append(None)\\n\\n if right != \\\"null\\\":\\n head.right = TreeNode(int(right))\\n queue.append(head.right)\\n # else:\\n # queue.append(None)\\n # print(queue)\\n return root\\n # return root\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n def dfs(root):\\n if not root:\\n res.append(\\\"N\\\")\\n return\\n res.append(str(root.val))\\n dfs(root.left)\\n dfs(root.right)\\n dfs(root)\\n return \\\",\\\".join(res)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n\\n data = data.split(\\\",\\\")\\n i = 0\\n\\n def dfs():\\n nonlocal i\\n if data[i] == \\\"N\\\":\\n i += 1\\n return None\\n root = TreeNode(data[i])\\n i += 1\\n root.left = dfs()\\n root.right = dfs()\\n return root\\n return dfs()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n while result and result[-1] == '':\\n result.pop()\\n return ','.join(result)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n def serialize(self, root):\\n res = []\\n def dfs(node):\\n if not node:\\n res.append(\\\"N\\\")\\n return\\n res.append(str(node.val))\\n\\n dfs(node.left)\\n dfs(node.right)\\n\\n dfs(root)\\n \\n\\n return \\\",\\\".join(res)\\n\\n\\n\\n\\n\\n \\n\\n def deserialize(self, data):\\n vals = data.split(\\\",\\\")\\n self.i = 0\\n def dfs():\\n if vals[self.i] == \\\"N\\\":\\n self.i += 1\\n return\\n node = TreeNode(int(vals[self.i]))\\n self.i += 1\\n\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n return dfs()\\n\\n\\n\\n \",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return ''\\n queue = deque([root])\\n res = \\\"\\\"\\n \\n while queue:\\n node = queue.popleft()\\n res += \\\"#\\\"\\n if node:\\n res += str(node.val)\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n res += 'null'\\n continue\\n return res\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n\\n data = deque(data.split(\\\"#\\\")[1:])\\n \\n root = TreeNode(int(data.popleft()))\\n queue = deque([root])\\n while queue:\\n l = len(queue)\\n\\n node = queue.popleft()\\n if not node:\\n continue\\n\\n left, right = data.popleft(), data.popleft()\\n node.left = TreeNode(int(left)) if left != 'null' else None\\n queue.append(node.left)\\n node.right = TreeNode(int(right)) if right != 'null' else None\\n queue.append(node.right)\\n return root\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"89\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n ans = []\\n\\n # level order traversal\\n q = deque([root])\\n while q:\\n for i in range(len(q)): \\n node = q.popleft()\\n\\n if node:\\n ans.append(node.val)\\n if node.left:\\n q.append(node.left)\\n else:\\n q.append(None)\\n\\n if node.right:\\n q.append(node.right)\\n else:\\n q.append(None)\\n else:\\n ans.append(None)\\n\\n #convert ans to a string\\n return str(ans)\\n\\n\\n def deserialize(self, data):\\n # Convert string to list\\n data = data.strip('[]')\\n data_list = data.split(',')\\n data_list = [s.strip() for s in data_list]\\n\\n # Convert elements to actual values\\n def parse_value(s):\\n if s == 'None':\\n return None\\n else:\\n return int(s)\\n\\n data_list = [parse_value(s) for s in data_list]\\n\\n # Handle empty tree\\n if not data_list or data_list[0] is None:\\n return None\\n\\n # Initialize root node and queue\\n root = TreeNode(data_list[0])\\n queue = deque([root])\\n index = 1\\n\\n # Reconstruct the tree\\n while queue and index < len(data_list):\\n current = queue.popleft()\\n\\n # Assign left child\\n if index < len(data_list):\\n left_val = data_list[index]\\n index += 1\\n if left_val is not None:\\n current.left = TreeNode(left_val)\\n queue.append(current.left)\\n else:\\n current.left = None\\n\\n # Assign right child\\n if index < len(data_list):\\n right_val = data_list[index]\\n index += 1\\n if right_val is not None:\\n current.right = TreeNode(right_val)\\n queue.append(current.right)\\n else:\\n current.right = None\\n\\n return root\\n\\n\\n \\n\\n\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"89\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n\\n def dfs(node):\\n if node is None:\\n res.append(\\\"N\\\")\\n return\\n res.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n \\n dfs(root)\\n print(\\\"******\\\",res)\\n return \\\",\\\".join(res) \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n dataList = data.split(\\\",\\\")\\n self.i = 0\\n def dfs():\\n if dataList[self.i] == \\\"N\\\":\\n self.i += 1\\n return None\\n\\n node = TreeNode(int(dataList[self.i]))\\n self.i += 1\\n\\n node.left = dfs()\\n node.right = dfs()\\n return node \\n\\n return dfs() \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"91\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def helper(root):\\n if not root:\\n return \\\"N,\\\"\\n\\n return str(root.val) + \\\",\\\" + helper(root.left) + helper(root.right)\\n return helper(root)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n values = data.split(\\\",\\\")\\n index = [0]\\n\\n def helper():\\n if values[index[0]] == \\\"N\\\":\\n index[0] += 1\\n return None\\n\\n root = TreeNode(int(values[index[0]]))\\n index[0] += 1\\n root.left = helper()\\n root.right = helper()\\n return root\\n return helper()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"91\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n while result and result[-1] == '':\\n result.pop()\\n return ','.join(result)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\nimport math\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def height(root):\\n if not root:\\n return 0\\n left=height(root.left)\\n right=height(root.right)\\n return 1+max(left,right)\\n l=[]\\n def dfs(indx,root):\\n if not root:\\n return\\n\\n l.append(str(indx)+':'+str(root.val))\\n dfs(2*indx + 1,root.left)\\n dfs(2*indx + 2,root.right)\\n dfs(0,root)\\n return ' '.join(l)\\n\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n l=list(map(str,data.split()))\\n d=defaultdict(int)\\n for i in l:\\n indx,v=list(map(int,i.split(':')))\\n d[indx]=v\\n def dfs(indx):\\n if indx not in d:\\n return None\\n root=TreeNode()\\n root.val=d[indx]\\n root.left=dfs(2*indx + 1)\\n root.right=dfs(2*indx + 2)\\n return root\\n return dfs(0)\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n self.res = \\\"\\\"\\n def dfs(self, root):\\n if not root:\\n self.res += \\\" x\\\"\\n return\\n self.res += \\\" \\\" + str(root.val)\\n dfs(self, root.left)\\n dfs(self, root.right)\\n dfs(self, root)\\n return self.res\\n\\n \\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n nodes_list = iter(data.split())\\n def dfs(nodes):\\n val = next(nodes)\\n if val == \\\"x\\\":\\n return None \\n cur_node = TreeNode(int(val))\\n cur_node.left = dfs(nodes)\\n cur_node.right = dfs(nodes)\\n return cur_node\\n\\n return dfs(nodes_list)\\n \\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n if not root:\\n return '0'\\n cur = root\\n def dfs(cur, string):\\n string += str(cur.val)\\n string += \\\" \\\"\\n if cur.left:\\n string = dfs(cur.left, string)\\n else:\\n string += \\\"n \\\"\\n if cur.right:\\n string = dfs(cur.right, string)\\n else:\\n string += \\\"n \\\"\\n return string\\n \\n n = dfs(cur, \\\"\\\")\\n print(n)\\n return n\\n \\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n \\n\\n def deserialize(self, data):\\n \\n if data == '0':\\n return None\\n res = 0\\n data = data.split(\\\" \\\")[:-1]\\n for i, val in enumerate(data):\\n if val != \\\"n\\\":\\n data[i] = int(val)\\n root = TreeNode()\\n def dfs(cur, data, i):\\n cur.val = data[i]\\n if data[i+1] != \\\"n\\\":\\n cur.left = TreeNode()\\n i = dfs(cur.left, data, i+1)\\n else:\\n i += 1\\n if data[i+1] != \\\"n\\\":\\n cur.right = TreeNode()\\n i = dfs(cur.right, data, i+1)\\n else:\\n i += 1\\n \\n return i\\n dfs(root, data, 0)\\n return root\\n \\n \\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def dfs(root, s):\\n if root is None:\\n s += 'None,'\\n else:\\n s += str(root.val) + ','\\n s = dfs(root.left, s)\\n s = dfs(root.right, s)\\n return s\\n\\n return dfs(root, '')\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def decode(q):\\n if q[0] == 'None':\\n q.popleft()\\n return None\\n root = TreeNode(q[0])\\n q.popleft()\\n root.left = decode(q)\\n root.right = decode(q)\\n return root\\n\\n q = deque()\\n for node in data.split(','):\\n q.append(node)\\n return decode(q) \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"94\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n\\n def exporter(node):\\n if node is None:\\n res.append(\\\"N\\\")\\n return\\n\\n res.append(str(node.val))\\n exporter(node.left)\\n exporter(node.right)\\n\\n exporter(root)\\n\\n return \\\",\\\".join(res)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data[0] == \\\"N\\\":\\n return None\\n data = deque(data.split(\\\",\\\"))\\n\\n def importer(node):\\n val_left = data.popleft()\\n if val_left != \\\"N\\\":\\n node.left = TreeNode(val=int(val_left))\\n importer(node.left)\\n \\n val_right = data.popleft()\\n if val_right != \\\"N\\\":\\n node.right = TreeNode(val=int(val_right))\\n importer(node.right)\\n\\n root = TreeNode(val=int(data.popleft()))\\n importer(root)\\n return root\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"94\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def serializeNodes(node):\\n if not node:\\n return None\\n return {\\n 'v': node.val,\\n 'l': serializeNodes(node.left),\\n 'r': serializeNodes(node.right),\\n }\\n return json.dumps(serializeNodes(root))\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def buildNode(data):\\n if data == None:\\n return None\\n return TreeNode(\\n val=data['v'],\\n left=buildNode(data['l']),\\n right=buildNode(data['r']),\\n )\\n return buildNode(json.loads(data))\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n ans=''\\n def tree_to_str(node):\\n nonlocal ans\\n if not node: ans+='x,'\\n else:\\n ans+=str(node.val)+','\\n tree_to_str(node.left)\\n tree_to_str(node.right)\\n tree_to_str(root)\\n return ans[:-1]\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def str_to_tree():\\n val=sq.popleft()\\n if val=='x': return None\\n else:\\n node=TreeNode(val)\\n node.left=str_to_tree() #all left sub tree nodes will be removed in this!\\n node.right=str_to_tree()\\n return node\\n sq=deque(data.split(','))\\n root=str_to_tree()\\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"97\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root: Optional[TreeNode]) -> str:\\n self.serdata = \\\"\\\"\\n\\n def dfs(node):\\n if not node:\\n self.serdata += \\\"N,\\\"\\n return\\n \\n self.serdata += f\\\"{str(node.val)},\\\"\\n dfs(node.left)\\n dfs(node.right)\\n return\\n \\n dfs(root)\\n return self.serdata[:-1]\\n \\n\\n \\n # Decodes your encoded data to tree.\\n def deserialize(self, data: str) -> Optional[TreeNode]:\\n #print(data)\\n des_q = deque(data.split(\\\",\\\"))\\n\\n def dfs():\\n if des_q[0] == 'N':\\n des_q.popleft()\\n return None\\n\\n root = TreeNode(int(des_q[0]))\\n des_q.popleft()\\n root.left = dfs()\\n root.right = dfs()\\n return root\\n \\n return dfs()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"from enum import Enum\\n\\nclass Action(Enum):\\n PARSE_RIGHT = 1\\n PARSE_LEFT = 2\\n PARSE_VAL = 3\\n REMOVE_CLOSING = 4\\n\\nclass Codec:\\n\\n def serialize(self, root: Optional[TreeNode]) -> str:\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\\"\\\"\\\"\\n if root is None:\\n return ''\\n else:\\n return f\\\"[{root.val},{self.serialize(root.left)},{self.serialize(root.right)}]\\\"\\n\\n\\n def push_to_stack(self, node, stack):\\n stack.append((node, Action.PARSE_RIGHT))\\n stack.append((node, Action.PARSE_LEFT))\\n stack.append((node, Action.PARSE_VAL))\\n\\n def parse_val(self, ptr, data):\\n is_neg = data[ptr] == '-'\\n\\n if is_neg:\\n ptr += 1\\n\\n assert data[ptr].isdigit()\\n\\n start = ptr\\n while data[ptr].isdigit():\\n ptr += 1\\n \\n val = int(data[start:ptr])\\n\\n if is_neg:\\n val *= -1\\n\\n return ptr, val\\n\\n def deserialize(self, data: str) -> Optional[TreeNode]:\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\\"\\\"\\\"\\n if data == '':\\n return None\\n\\n stack = deque()\\n ptr = 1\\n root = TreeNode()\\n\\n self.push_to_stack(root, stack)\\n\\n while ptr < len(data):\\n # print(data[ptr:])\\n node, action = stack.pop()\\n\\n # print('Executing action', action, data[ptr:])\\n\\n if action == Action.PARSE_VAL:\\n ptr, val = self.parse_val(ptr, data)\\n node.val = val\\n elif action == Action.PARSE_LEFT:\\n assert data[ptr] == ','\\n ptr += 1\\n\\n if data[ptr] == ',':\\n node.left = None\\n else:\\n assert data[ptr] == '['\\n left_node = TreeNode()\\n self.push_to_stack(left_node, stack)\\n node.left = left_node\\n ptr += 1\\n elif action == Action.PARSE_RIGHT:\\n assert data[ptr] == ','\\n ptr += 1\\n\\n if data[ptr] == ']':\\n node.right = None\\n ptr += 1\\n else:\\n assert data[ptr] == '['\\n right_node = TreeNode()\\n stack.append((node, Action.REMOVE_CLOSING))\\n self.push_to_stack(right_node, stack)\\n node.right = right_node\\n ptr += 1\\n elif action == Action.REMOVE_CLOSING:\\n assert data[ptr] == ']'\\n ptr += 1\\n else:\\n raise ValueError(\\\"Invalid action\\\")\\n return root\\n\\n\\n\\n\\n\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# tree = ser.serialize(root)\\n# ans = deser.deserialize(tree)\\n# return ans\",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"EMPTY\\\"\\n encoded = \\\"\\\"\\n queue = []\\n queue.append(root)\\n while queue:\\n for _ in range(len(queue)):\\n node = queue.pop(0)\\n if node==\\\"#\\\":\\n encoded+=node\\n encoded+=\\\",\\\"\\n else:\\n encoded+=str(node.val)\\n encoded+=\\\",\\\"\\n if node.left:\\n queue.append(node.left)\\n else:\\n queue.append(\\\"#\\\")\\n if node.right:\\n queue.append(node.right)\\n else:\\n queue.append(\\\"#\\\")\\n return encoded[:-1]\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data==\\\"EMPTY\\\":\\n return None\\n string = data.split(\\\",\\\")\\n queue = []\\n root = None\\n i=0\\n while i<len(string):\\n s=string[i]\\n if root is None:\\n root = TreeNode(int(s))\\n queue.append(root)\\n i+=1\\n continue\\n if (len(queue))==0:\\n break\\n top = queue.pop(0)\\n if s==\\\"#\\\":\\n top.left=None\\n else:\\n top.left=TreeNode(int(s))\\n queue.append(top.left)\\n i+=1\\n if i<len(string):\\n s=string[i]\\n if s==\\\"#\\\":\\n top.right=None\\n else:\\n top.right=TreeNode(int(s))\\n queue.append(top.right)\\n i+=1 \\n return root\\n\\n\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"99\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n if not root:\\n return '#'\\n \\n result = []\\n queue = [root]\\n while queue:\\n node = queue.pop(0)\\n if node:\\n result.append(str(node.val))\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n result.append('#')\\n return ','.join(result)\\n \\n\\n def deserialize(self, data):\\n if data == '#':\\n return None\\n \\n data = data.split(',')\\n root = TreeNode(int(data[0]))\\n queue = [root]\\n i = 1\\n while queue:\\n node = queue.pop(0)\\n if data[i] != '#':\\n node.left = TreeNode(int(data[i]))\\n queue.append(node.left)\\n i += 1\\n if data[i] != '#':\\n node.right = TreeNode(int(data[i]))\\n queue.append(node.right)\\n i += 1\\n return root\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\\n\",\n \"runtime\": \"100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nfrom collections import deque\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"*\\\"\\n s = str(root.val) + \\\".\\\" + self.serialize(root.left) + self.serialize(root.right)\\n print(s)\\n return s\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _deserialize(i):\\n if i >= len(data):\\n return (None, -1)\\n if data[i] == \\\"*\\\":\\n return (None, i+1)\\n val_str = \\\"\\\"\\n while data[i] != \\\".\\\":\\n val_str += data[i]\\n i += 1\\n node = TreeNode(int(val_str))\\n l,right_i = _deserialize(i+1)\\n r,next_i = _deserialize(right_i)\\n node.left = l\\n node.right = r\\n return (node, next_i)\\n root,_ = _deserialize(0)\\n return root\\n\\n\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"4\\\"\\n else:\\n total_data = \\\"\\\"\\n stack = [root]\\n while(len(stack) > 0):\\n cur_node = stack.pop()\\n if cur_node.right is not None:\\n stack.append(cur_node.right)\\n if cur_node.left is not None:\\n stack.append(cur_node.left)\\n \\n total_data += self.encode_node(cur_node)\\n # print(total_data)\\n return total_data\\n\\n def encode_node(self, node):\\n data = \\\"\\\"\\n if node.left is None and node.right is None:\\n data += \\\"0\\\"\\n elif node.right is None:\\n data += \\\"1\\\"\\n elif node.left is None:\\n data += \\\"2\\\"\\n else:\\n data += \\\"3\\\"\\n data += str(node.val + 1000).zfill(4)\\n return data\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data[0] == \\\"4\\\":\\n return None\\n else:\\n root = self.decode_node(data[1:5])\\n stack = [root]\\n node_status = [data[0]]\\n # print(len(stack), len(node_status), data)\\n data = data[5:]\\n while(len(data)>0):\\n # print(len(stack), len(node_status), data)\\n cur_parent_node = stack.pop()\\n cur_node_status = node_status.pop()\\n if cur_node_status == \\\"0\\\":\\n continue\\n\\n cur_node = self.decode_node(data[1:5])\\n if cur_node_status == \\\"1\\\":\\n cur_parent_node.left = cur_node\\n elif cur_node_status == \\\"2\\\":\\n cur_parent_node.right = cur_node\\n else:\\n if cur_parent_node.left is None:\\n cur_parent_node.left = cur_node\\n stack.append(cur_parent_node)\\n node_status.append(cur_node_status)\\n else:\\n cur_parent_node.right = cur_node\\n \\n stack.append(cur_node)\\n node_status.append(data[0])\\n data = data[5:]\\n \\n return root\\n\\n # print(data)\\n # print(int(len(data)/5))\\n # return None\\n \\n\\n def decode_node(self, data):\\n value = int(data) - 1000\\n node = TreeNode(value)\\n return node\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"102\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n stack, track = [root], []\\n while stack:\\n node = stack.pop(0)\\n if not node:\\n track.append('*')\\n else:\\n track.append(str(node.val))\\n stack.append(node.left)\\n stack.append(node.right)\\n return '|'.join(track)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == '*':\\n return None\\n data = data.split('|')\\n root = TreeNode(int(data[0]))\\n parentlist, i = [root], 1\\n while i < len(data):\\n parent = parentlist.pop(0)\\n cur = data[i]\\n if cur != '*':\\n nextNode = TreeNode(int(cur))\\n parent.left = nextNode\\n parentlist.append(nextNode)\\n if i + 1 < len(data):\\n cur = data[i + 1]\\n if cur != '*':\\n nextNode = TreeNode(int(cur))\\n parent.right = nextNode\\n parentlist.append(nextNode)\\n i += 2\\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"103\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n # Attempt to do as before\\n # APPROACH: preorder traversal \\\"1(2(6,),3(4,5))\\\"\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"\\\"\\n res = [str(root.val)]\\n if root.left or root.right:\\n res.append(\\\"(\\\")\\n res.append(self.serialize(root.left))\\n res.append(\\\",\\\")\\n res.append(self.serialize(root.right))\\n res.append(\\\")\\\")\\n return \\\"\\\".join(res)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"\\\":\\n return None\\n if data.isnumeric() or data[0] == \\\"-\\\" and data[1:].isnumeric():\\n return TreeNode(int(data))\\n b = 0\\n while data[b] != \\\"(\\\":\\n b += 1\\n c = b + 1\\n brackets = 0\\n while c < len(data):\\n if data[c] == \\\"(\\\":\\n brackets += 1\\n if data[c] == \\\")\\\":\\n brackets -= 1\\n if brackets == 0 and data[c] == \\\",\\\":\\n break\\n c += 1\\n res = TreeNode(int(data[:b]))\\n res.left = self.deserialize(data[b + 1:c])\\n res.right = self.deserialize(data[c + 1:-1])\\n return res\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"104\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"\\\"\\n q = [(root,0)]; data = {}\\n data[0] = root.val\\n while q:\\n node, indx = q.pop(0)\\n if node.left:\\n data[indx*2 + 1] = node.left.val\\n q.append((node.left, indx*2 + 1))\\n else:\\n data[indx*2 + 1] = None\\n if node.right:\\n data[indx*2 + 2] = node.right.val\\n q.append((node.right, indx*2 + 2))\\n else:\\n data[indx*2 + 2] = None\\n d = \\\"\\\"\\n for i in data.keys():\\n if d:\\n d += \\\" \\\"\\n d += str(i) + \\\":\\\" + str(data[i])\\n # print(d) \\n return d\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n d = {}\\n if not data:\\n return []\\n for i in data.split():\\n key, val = i.split(\\\":\\\")\\n key = int(key)\\n if val != \\\"None\\\":\\n val = int(val)\\n else:\\n val = None\\n d[key] = val\\n data = d\\n root = None; nodes = {}\\n nodes[0] = TreeNode(data[0])\\n for i in sorted(data.keys()):\\n if data[i] != None:\\n root = nodes[i]\\n if i*2 + 1 in data and data[i*2 + 1] != None:\\n # print(i*2 + 1, \\\"left -->\\\", nodes[0])\\n root.left = TreeNode(data[i*2 + 1])\\n nodes[i*2 + 1] = root.left\\n if i*2 + 2 in data and data[i*2 + 2] != None:\\n # print(i*2 + 2, \\\"right -->\\\", nodes[0])\\n root.right = TreeNode(data[i*2 + 2])\\n nodes[i*2 + 2] = root.right\\n return nodes[0]\\n\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"104\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n \\n if root is None:\\n return \\\"None\\\"\\n else:\\n a = self.serialize(root.left)\\n b = self.serialize(root.right)\\n return ','.join([str(root.val), a, b])\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n \\n\\n def make_node(data):\\n if data[0] == \\\"None\\\":\\n data.pop(0)\\n return None\\n\\n root = TreeNode(data[0])\\n data.pop(0)\\n root.left = make_node(data)\\n root.right = make_node(data)\\n return root\\n\\n # O(n) to split and O(n) to reverse, now the pops will be O(1)\\n data_list = data.split(\\\",\\\")#[::-1]\\n return make_node(data_list)\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"105\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n q = deque([(root, 0)])\\n if not root:\\n return ''\\n res = f'{root.val}|'\\n cursor = 1\\n while q:\\n for i in range(len(q)):\\n node, i = q.popleft()\\n if node.left:\\n q.append((node.left, cursor))\\n res += f'{i},{cursor},{node.left.val}'\\n cursor += 1\\n else:\\n res += 'n'\\n res += '.'\\n if node.right:\\n q.append((node.right, cursor))\\n res += f'{i},{cursor},{node.right.val}'\\n cursor += 1\\n\\n else:\\n res += 'n'\\n res += '|'\\n return res\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == '':\\n return\\n i2n = {}\\n nodes = data.split('|')\\n root = TreeNode(int(nodes[0]))\\n i2n['0'] = root\\n\\n for nodepair in nodes[1:-1]:\\n doublet = nodepair.split('.')\\n datum1 = doublet[0].split(',')\\n if len(datum1) == 3:\\n p, i, v = datum1\\n n = TreeNode(int(v))\\n i2n[i] = n\\n i2n[p].left = n\\n datum2 = doublet[1].split(',')\\n if len(datum2) == 3:\\n p, i, v = datum2\\n n = TreeNode(int(v))\\n i2n[i] = n\\n i2n[p].right = n\\n return root\\n\\n\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"105\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"[]\\\"\\n \\n result = []\\n queue = [root]\\n \\n while queue:\\n node = queue.pop(0)\\n if node:\\n result.append(str(node.val))\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n result.append(\\\"null\\\")\\n \\n # Remove trailing \\\"null\\\" values for more compact representation\\n while result[-1] == \\\"null\\\":\\n result.pop()\\n \\n return \\\"[\\\" + \\\",\\\".join(result) + \\\"]\\\"\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"[]\\\":\\n return None\\n \\n values = data[1:-1].split(\\\",\\\")\\n root = TreeNode(int(values[0]))\\n queue = [root]\\n index = 1\\n \\n while queue:\\n node = queue.pop(0)\\n if index < len(values) and values[index] != \\\"null\\\":\\n node.left = TreeNode(int(values[index]))\\n queue.append(node.left)\\n index += 1\\n \\n if index < len(values) and values[index] != \\\"null\\\":\\n node.right = TreeNode(int(values[index]))\\n queue.append(node.right)\\n index += 1\\n \\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"107\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n # BFS \\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"\\\"\\n tree_str = \\\"\\\"\\n # BFS to get node values and add them to string\\n queue = [root]\\n while queue:\\n node = queue.pop(0)\\n if node:\\n tree_str += f\\\"{node.val},\\\"\\n #only add to queue if current node is not None\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n tree_str += \\\"None,\\\"\\n \\n return tree_str[:-1]\\n \\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n values = data.split(\\\",\\\")\\n\\n # BFS to build tree\\n i=0\\n root_node = TreeNode(values[0])\\n queue = [root_node]\\n while queue:\\n node = queue.pop(0)\\n # get children values and turn into TreeNode\\n left_child_val = values[(i*2)+1]\\n right_child_val = values[(i*2)+2]\\n # check left/right_child_val to make sure theyre not None\\n # and we're not adding None nodes to queue\\n if left_child_val != \\\"None\\\":\\n left = TreeNode(left_child_val)\\n node.left = left\\n queue.append(left)\\n if right_child_val != \\\"None\\\":\\n right = TreeNode(right_child_val)\\n node.right = right\\n queue.append(right)\\n i+=1\\n return root_node\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"108\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n \\n if root is None:\\n return \\\"\\\"\\n \\n left_part = self.serialize(root.left)\\n right_part = self.serialize(root.right)\\n val = str(root.val)\\n \\n return f\\\"{len(val)},{len(left_part)},{len(right_part)}#{val}{left_part}{right_part}\\\"\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n \\n if not data:\\n return None\\n \\n data_split = data.split(\\\"#\\\")\\n lens = [int(x) for x in data_split[0].split(\\\",\\\")]\\n data_part = data[len(data_split[0]) + 1:]\\n val = int(data_part[:lens[0]])\\n left_node = self.deserialize(data_part[lens[0]: (lens[0] + lens[1])])\\n right_node = self.deserialize(data_part[(lens[0] + lens[1]):])\\n root = TreeNode(val)\\n root.left = left_node\\n root.right = right_node\\n return root\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"109\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n if not root:\\n return \\\"\\\"\\n queue = [root]\\n result = []\\n while queue:\\n node = queue.pop(0)\\n if node:\\n result.append(str(node.val))\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n result.append(\\\"#\\\")\\n return \\\",\\\".join(result)\\n\\n def deserialize(self, data):\\n if not data:\\n return None\\n values = data.split(\\\",\\\")\\n root = TreeNode(int(values[0]))\\n queue = [root]\\n i = 1\\n while queue:\\n node = queue.pop(0)\\n if values[i] != \\\"#\\\":\\n left = TreeNode(int(values[i]))\\n node.left = left\\n queue.append(left)\\n i += 1\\n if values[i] != \\\"#\\\":\\n right = TreeNode(int(values[i]))\\n node.right = right\\n queue.append(right)\\n i += 1\\n return root\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"109\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n self.ans = \\\"\\\"\\n def preorder(node):\\n if node:\\n self.ans = self.ans + str(node.val) + \\\",\\\"\\n preorder(node.left)\\n preorder(node.right)\\n else:\\n self.ans = self.ans + \\\"N\\\" + \\\",\\\"\\n preorder(root)\\n return self.ans[:len(self.ans) - 1]\\n\\n def deserialize(self, data):\\n if data == \\\"\\\":\\n return []\\n self.i = -1\\n li = data.split(\\\",\\\")\\n def prepare():\\n self.i += 1\\n if self.i >= len(li):\\n return None\\n if li[self.i] == \\\"N\\\":\\n return None\\n node = TreeNode(li[self.i])\\n node.left = prepare()\\n node.right = prepare()\\n return node\\n\\n return prepare()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"110\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"EMPTY\\\"\\n encoded = \\\"\\\"\\n queue = []\\n queue.append(root)\\n while queue:\\n for _ in range(len(queue)):\\n node = queue.pop(0)\\n if node==\\\"#\\\":\\n encoded+=node\\n encoded+=\\\",\\\"\\n else:\\n encoded+=str(node.val)\\n encoded+=\\\",\\\"\\n if node.left:\\n queue.append(node.left)\\n else:\\n queue.append(\\\"#\\\")\\n if node.right:\\n queue.append(node.right)\\n else:\\n queue.append(\\\"#\\\")\\n return encoded[:-1]\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data==\\\"EMPTY\\\":\\n return None\\n string = data.split(\\\",\\\")\\n queue = []\\n root = None\\n i=0\\n while i<len(string):\\n s=string[i]\\n if root is None:\\n root = TreeNode(int(s))\\n queue.append(root)\\n i+=1\\n continue\\n if (len(queue))==0:\\n break\\n top = queue.pop(0)\\n if s==\\\"#\\\":\\n top.left=None\\n else:\\n top.left=TreeNode(int(s))\\n queue.append(top.left)\\n i+=1\\n if i<len(string):\\n s=string[i]\\n if s==\\\"#\\\":\\n top.right=None\\n else:\\n top.right=TreeNode(int(s))\\n queue.append(top.right)\\n i+=1 \\n return root\\n\\n\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"111\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n inorder = self.inorder(root, 0)\\n preorder = self.preorder(root)\\n #print(','.join(map(str, preorder)) + '--' + ','.join(map(str, inorder)))\\n return ';'.join(map(str, preorder)) + '|' + ';'.join(map(str, inorder))\\n\\n def preorder(self, root):\\n if not root: return []\\n left = self.preorder(root.left)\\n right = self.preorder(root.right)\\n return [(root.idx, root.val)] + left + right\\n\\n def inorder(self, root, idx):\\n if not root: return []\\n root.idx = idx\\n left = self.inorder(root.left, idx + 1)\\n right = self.inorder(root.right, idx + 2)\\n return left + [(root.idx, root.val)] + right\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == '|': return None\\n preorder, inorder = data.split('|')\\n preorder = preorder.split(';')\\n inorder = inorder.split(';')\\n return self.build_tree(preorder, inorder)\\n\\n def build_tree(self, preorder, inorder):\\n if len(preorder) == 0: return None\\n val = preorder[0]\\n root = TreeNode(int(preorder[0].split(', ')[1][:-1]))\\n idx = inorder.index(val)\\n left = self.build_tree(preorder[1:idx + 1], inorder[:idx])\\n right = self.build_tree(preorder[idx + 1:], inorder[idx + 1:])\\n root.left = left\\n root.right = right\\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"113\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n queue = deque()\\n queue.append(root)\\n\\n str_list = []\\n\\n while queue:\\n curr = queue.popleft()\\n if curr:\\n str_list.append(str(curr.val))\\n str_list.append(\\\"#\\\")\\n else:\\n str_list.append(\\\"null\\\")\\n str_list.append(\\\"#\\\")\\n continue\\n \\n if curr.left:\\n queue.append(curr.left)\\n elif not curr.left:\\n queue.append(None)\\n \\n if curr.right:\\n queue.append(curr.right)\\n elif not curr.right:\\n queue.append(None)\\n\\n str_list.pop()\\n return \\\"\\\".join(str_list)\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n\\n queue = deque()\\n de_list = data.split(\\\"#\\\")\\n\\n if de_list[0] == \\\"null\\\":\\n return\\n root_val = de_list.pop(0)\\n\\n root = TreeNode(int(root_val))\\n queue.append(root)\\n\\n while queue:\\n curr = queue.popleft()\\n\\n left = de_list.pop(0)\\n\\n if left != \\\"null\\\":\\n left_node = TreeNode(int(left))\\n curr.left = left_node\\n queue.append(left_node)\\n \\n right = de_list.pop(0)\\n if right != \\\"null\\\":\\n right_node = TreeNode(int(right))\\n curr.right = right_node\\n queue.append(right_node)\\n\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"114\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def preOrder(node):\\n if not node:\\n yield \\\"None\\\"\\n else:\\n yield str(node.val)\\n yield from preOrder(node.left)\\n yield from preOrder(node.right)\\n \\n return (' ').join([x for x in preOrder(root)])\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def helper():\\n if not data:\\n return None\\n val = data.popleft()\\n if val == \\\"None\\\":\\n return None\\n node = TreeNode(int(val))\\n node.left = helper()\\n node.right = helper()\\n return node\\n \\n data = deque(data.split(' '))\\n return helper()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"114\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n\\n what kind of traversal?\\n pre/in/post order depth first\\n or breadth first\\n \\\"\\\"\\\"\\n\\n def pre_order(node, st): \\n if not node:\\n st += \\\"null,\\\"\\n else:\\n st += \\\"{},\\\".format(node.val)\\n st = pre_order(node.left, st)\\n st = pre_order(node.right, st)\\n return st\\n \\n st = \\\"\\\"\\n st = pre_order(root,st)\\n return st \\n \\n\\n def deserialize(self, data): \\n \\\"\\\"\\\"Decodes your encoded data to tree. \\n \\n :type data: str \\n :rtype: TreeNode \\n read string and create tree back \\n\\n when found a null value child node, go to next spot for pre order traversal \\n \\n if currently in left side of immediate parent, next nodeval is added to right of immediate parent \\n if currently in right side of immediate parent, next nodeval is added to parent's parent's parent's right side \\n \\n \\\"\\\"\\\" \\n\\n value = data.split(\\\",\\\")\\n self.i = 0\\n\\n def dfs_des():\\n if value[self.i]==\\\"null\\\":\\n self.i += 1\\n return None\\n \\n nval = int(value[self.i])\\n root = TreeNode(nval)\\n self.i += 1\\n \\n root.left = dfs_des()\\n root.right = dfs_des()\\n\\n return root\\n \\n return dfs_des()\\n\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"115\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n serialized = []\\n def dfs(root):\\n if not root:\\n serialized.append(\\\"N\\\")\\n return\\n serialized.append(str(root.val))\\n dfs(root.left)\\n dfs(root.right)\\n return\\n dfs(root)\\n return \\\",\\\".join(serialized)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n data = data.split(\\\",\\\")\\n def build():\\n root = data.pop(0)\\n if root == \\\"N\\\":\\n return None\\n newtree = TreeNode(int(root))\\n newtree.left = build()\\n newtree.right = build()\\n return newtree\\n return build()\\n\\n\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"116\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n def serialize(self, root):\\n if not root:\\n return ''\\n return str(root.val) + ',' + self.serialize(root.left) + ',' + self.serialize(root.right) \\n \\n def deserialize(self, data):\\n dataList = data.split(',')\\n return self.deserialize_list(dataList)\\n \\n def deserialize_list(self, dataList):\\n if dataList:\\n val = dataList.pop(0)\\n if val:\\n node= TreeNode(val)\\n node.left = self.deserialize_list(dataList)\\n node.right = self.deserialize_list(dataList)\\n return node\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"118\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = [\\\"\\\"]\\n\\n def dfs(node):\\n if not node:\\n res[0] = res[0] + \\\"#\\\" + \\\" \\\"\\n return\\n\\n res[0] = res[0] + str(node.val) + \\\" \\\"\\n dfs(node.left)\\n dfs(node.right)\\n\\n dfs(root)\\n return res[0].strip(\\\" \\\")\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n code_list = data.split(\\\" \\\")\\n\\n if len(code_list) == 1:\\n return None\\n\\n pos = [0]\\n def dfs_decode():\\n if code_list[pos[0]] == \\\"#\\\":\\n return None\\n node = TreeNode(int(code_list[pos[0]]))\\n pos[0] += 1\\n node.left = dfs_decode()\\n pos[0] += 1\\n node.right = dfs_decode()\\n\\n return node\\n\\n return dfs_decode()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"118\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n self.string = ''\\n def dfs(node):\\n if self.string != '':\\n self.string += '|'\\n if not node:\\n self.string += 'N'\\n return\\n self.string += str(node.val)\\n dfs(node.left)\\n dfs(node.right)\\n dfs(root)\\n return self.string\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n self.i = 0\\n nodes = data.split('|')\\n def dfs():\\n if nodes[self.i] == 'N':\\n self.i += 1\\n return None\\n node = TreeNode(int(nodes[self.i]))\\n self.i += 1\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n return dfs()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"119\"\n },\n {\n \"code\": \"\\nclass Codec:\\n # Initializing our marker\\n MARKER = \\\"M\\\"\\n \\n def serialize_rec(self, node, stream):\\n # Adding marker to stream if the node is None\\n if node is None:\\n stream.append(self.MARKER)\\n return\\n\\n # Adding node to stream\\n stream.append(str(node.val))\\n\\n # Doing a pre-order tree traversal for serialization\\n self.serialize_rec(node.left, stream)\\n self.serialize_rec(node.right, stream)\\n\\n def serialize(self, root):\\n stream = []\\n self.serialize_rec(root, stream)\\n # Join the list to create a string with commas separating values\\n return ','.join(stream)\\n\\n def deserialize_helper(self, values):\\n # pop the first element from the list\\n val = values.pop(0)\\n\\n # Return None when a marker is encountered\\n if val == self.MARKER:\\n return None\\n\\n # Creating new Binary Tree Node from current value from the list\\n node = TreeNode(int(val))\\n\\n # Doing a pre-order tree traversal for deserialization\\n node.left = self.deserialize_helper(values)\\n node.right = self.deserialize_helper(values)\\n\\n # Return node if it exists\\n return node\\n\\n def deserialize(self, data):\\n values = data.split(',') # Split the data back into a list\\n return self.deserialize_helper(values)\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\\n\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"120\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n Null = '#'\\n\\n Sep = ','\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n sb = []\\n \\n self._serialize(root, sb)\\n\\n return \\\"\\\".join(sb)\\n\\n def _serialize(self, root, res):\\n\\n if root is None:\\n\\n res.append(self.Null)\\n\\n res.append(self.Sep)\\n\\n return\\n\\n ### preorder\\n\\n res.append(str(root.val))\\n res.append(self.Sep)\\n\\n self._serialize(root.left, res)\\n\\n self._serialize(root.right, res)\\n\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n nodes = data.split(self.Sep)\\n return self._deserialize(nodes)\\n\\n def _deserialize(self, nodes):\\n\\n if not nodes:\\n\\n return None\\n\\n first = nodes.pop(0)\\n\\n if first == self.Null:\\n\\n return None\\n\\n root = TreeNode(int(first))\\n\\n root.left = self._deserialize(nodes)\\n\\n root.right = self._deserialize(nodes)\\n\\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"120\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def helper(node):\\n if node is None:\\n return 'null,'\\n return str(node.val) + ',' + helper(node.left) + helper(node.right)\\n \\n return helper(root)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def helper(nodes):\\n val = nodes.pop(0)\\n if val == 'null':\\n return None\\n node = TreeNode(int(val))\\n node.left = helper(nodes)\\n node.right = helper(nodes)\\n return node\\n \\n node_list = data.split(',')\\n return helper(node_list[:-1])\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"121\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root == None:\\n return \\\"None,\\\"\\n\\n result = str(root.val) + \\\",\\\"\\n result = result + self.serialize(root.left)\\n result = result + self.serialize(root.right)\\n return result \\n \\n\\n def deserialize(self, data):\\n # print(data)\\n \\n def rdeserialize(data_list):\\n if data_list[0] == 'None':\\n data_list.pop(0)\\n return None\\n\\n root = TreeNode(data_list[0])\\n data_list.pop(0)\\n root.left = rdeserialize(data_list)\\n root.right = rdeserialize(data_list)\\n return root\\n\\n data_list = data.split(',')\\n root = rdeserialize(data_list)\\n return root \\n\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"122\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n preorder = []\\n curr = root\\n\\n def preorder_traverse(curr, res):\\n if curr is None:\\n res.append(\\\"#\\\")\\n else:\\n res.append(str(curr.val))\\n preorder_traverse(curr.left, res)\\n preorder_traverse(curr.right, res)\\n \\n preorder_traverse(curr, preorder)\\n return \\\",\\\".join(preorder)\\n \\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n data = data.split(\\\",\\\")\\n\\n def preorder():\\n val = data.pop(0)\\n if val == \\\"#\\\":\\n return None\\n node = TreeNode(int(val))\\n node.left = preorder()\\n node.right = preorder()\\n return node\\n \\n return preorder()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"122\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n\\n def serialize_helper(node):\\n if not node:\\n return 'None,'\\n return str(node.val) + ',' + serialize_helper(node.left) + serialize_helper(node.right)\\n \\n return serialize_helper(root)\\n # stack = [root]\\n # string = ''\\n\\n # while stack:\\n # node = stack.pop()\\n # string += str(node.val)\\n\\n # if node.left: stack.append(node.left)\\n # if node.right: stack.append(node.right)\\n # print(string)\\n # return string\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def rdeserialize(values):\\n if not values:\\n return None\\n value = values.pop(0)\\n if value == 'None':\\n return None\\n node = TreeNode(int(value))\\n node.left = rdeserialize(values)\\n node.right = rdeserialize(values)\\n return node\\n \\n values = data.split(',')\\n return rdeserialize(values)\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"124\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n\\n def helper(root):\\n if root == None:\\n rval.append('None')\\n return\\n \\n rval.append(str(root.val))\\n helper(root.left)\\n helper(root.right)\\n\\n\\n \\n rval = []\\n helper(root)\\n\\n return ','.join(rval)\\n\\n \\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n def helper(nodes):\\n if nodes[0] == 'None':\\n nodes.pop(0)\\n return None\\n \\n val = nodes.pop(0)\\n n = TreeNode(int(val))\\n n.left = helper(nodes)\\n n.right = helper(nodes)\\n\\n return n\\n\\n \\n return helper(data.split(','))\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"125\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n def serialize(self, root):\\n res = []\\n def serialize_helper(node):\\n if node is None:\\n res.append(\\\"NULL\\\")\\n return \\n res.append(str(node.val))\\n serialize_helper(node.left)\\n serialize_helper(node.right)\\n serialize_helper(root)\\n return ','.join(res)\\n\\n def deserialize(self, data):\\n values = data.split(',')\\n # print(values)\\n def helper(values):\\n value = values.pop(0)\\n if value == \\\"NULL\\\": return None\\n root = TreeNode(int(value))\\n root.left = helper(values)\\n root.right = helper(values)\\n return root\\n \\n root = helper(values)\\n return root\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"125\"\n },\n {\n \"code\": \"class Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return 'X,'\\n \\n left_serialized = self.serialize(root.left)\\n right_serialized = self.serialize(root.right)\\n \\n return str(root.val) + ',' + left_serialized + right_serialized\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def deserialize_helper(nodes):\\n if nodes[0] == 'X':\\n nodes.pop(0)\\n return None\\n \\n root = TreeNode(int(nodes[0]))\\n nodes.pop(0)\\n root.left = deserialize_helper(nodes)\\n root.right = deserialize_helper(nodes)\\n \\n return root\\n \\n nodes = data.split(',')\\n root = deserialize_helper(nodes)\\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"126\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\\"\\\"\\\"\\n def helper(node):\\n if not node:\\n return \\\"null\\\"\\n return str(node.val) + \\\",\\\" + helper(node.left) + \\\",\\\" + helper(node.right)\\n return helper(root)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\\"\\\"\\\"\\n\\n def helper(nodes):\\n val = nodes.pop(0)\\n if val == \\\"null\\\":\\n return None\\n node=TreeNode(int(val))\\n node.left=helper(nodes)\\n node.right=helper(nodes)\\n return node\\n\\n nodes_list=data.split(',')\\n return helper(nodes_list)\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"126\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n def _serialize(root, serialized):\\n if not root:\\n serialized.append('#')\\n else:\\n serialized.append(str(root.val))\\n _serialize(root.left, serialized)\\n _serialize(root.right, serialized)\\n \\n serialized = []\\n _serialize(root, serialized)\\n return \\\",\\\".join(serialized)\\n \\n\\n def deserialize(self, data):\\n def _deserialize(serialized):\\n if serialized[0] == '#':\\n serialized.pop(0)\\n return None\\n \\n val = int(serialized.pop(0))\\n root = TreeNode(val)\\n root.left = _deserialize(serialized)\\n root.right = _deserialize(serialized)\\n return root\\n \\n serialized = data.split(\\\",\\\")\\n return _deserialize(serialized)\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"127\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if (root is None):\\n return \\\"[]\\\"\\n\\n val = str(root.val)\\n\\n if (root.left is None):\\n return \\\"[\\\" + val + \\\"[]\\\" + self.serialize(root.right) + \\\"]\\\"\\n\\n if (root.right is None):\\n return \\\"[\\\" + val + self.serialize(root.left) + \\\"[]\\\" + \\\"]\\\"\\n\\n return \\\"[\\\" + val + self.serialize(root.left) + self.serialize(root.right) + \\\"]\\\"\\n\\n\\n \\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n def find_closing_brace_idx(s):\\n cnt = 1\\n for i in range(1, len(s)):\\n c = s[i]\\n if c == \\\"[\\\":\\n cnt += 1\\n elif c == \\\"]\\\":\\n cnt -= 1\\n\\n if cnt == 0:\\n return i\\n\\n if data == \\\"[]\\\":\\n return None\\n\\n left_tree_starting_brace = data[1:].index(\\\"[\\\") + 1\\n left_tree_closing_brace = find_closing_brace_idx(data[left_tree_starting_brace:])\\n left_tree_closing_brace += left_tree_starting_brace\\n\\n left = self.deserialize(data[left_tree_starting_brace: left_tree_closing_brace + 1])\\n right = self.deserialize(data[left_tree_closing_brace + 1: -1])\\n\\n val = int(data[1: left_tree_starting_brace])\\n\\n root = TreeNode(val)\\n root.left = left\\n root.right = right\\n\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"129\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n ret = []\\n def dfs(root):\\n if not root:\\n ret.append(\\\"None\\\")\\n return\\n ret.append(str(root.val))\\n dfs(root.left)\\n dfs(root.right)\\n dfs(root)\\n return \\\",\\\".join(ret)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n nodes = data.split(',')\\n def ds(l):\\n if l[0] == 'None':\\n l.pop(0)\\n return None\\n root = TreeNode(l.pop(0))\\n root.left = ds(l)\\n root.right = ds(l)\\n return root\\n root = ds(nodes)\\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"129\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n\\n def recurse(node, arr):\\n if not node:\\n arr.append(\\\"empty\\\")\\n return\\n \\n arr.append(str(node.val))\\n recurse(node.left, arr)\\n recurse(node.right, arr)\\n \\n arr = []\\n recurse(root,arr)\\n print(arr)\\n return \\\",\\\".join(arr)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if len(data) == 0:\\n return None\\n \\n def recurse(dataList):\\n if dataList[0] == \\\"empty\\\":\\n dataList.pop(0)\\n return\\n \\n node = TreeNode(int(dataList.pop(0)))\\n node.left = recurse(dataList)\\n node.right = recurse(dataList)\\n return node\\n\\n return recurse(data.split(\\\",\\\"))\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n self.serialize_dfs(root, res)\\n return \\\",\\\".join(res)\\n\\n def serialize_dfs(self, node, res):\\n if not node: # 1\\n res.append(\\\"N\\\")\\n return\\n \\n \\n res.append(str(node.val)) \\n self.serialize_dfs(node.left, res)\\n self.serialize_dfs(node.right, res)\\n\\n \\n \\n \\n # res: 1, 2 N N 3 4 N N 5 N N \\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n nodes = data.split(\\\",\\\")\\n return self.de_serialize_dfs(nodes)\\n\\n \\n def de_serialize_dfs(self, nodes):\\n if not nodes:\\n return None\\n\\n first = nodes.pop(0)\\n\\n if first == \\\"N\\\":\\n return None\\n\\n root = TreeNode(int(first))\\n root.left = self.de_serialize_dfs(nodes)\\n root.right = self.de_serialize_dfs(nodes)\\n\\n return root\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"131\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def dfs(root, st):\\n if not root:\\n st += \\\"#,\\\"\\n else:\\n st += f\\\"{root.val},\\\"\\n st = dfs(root.left, st)\\n st = dfs(root.right, st)\\n return st\\n return dfs(root, \\\"\\\")\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n arr = data.split(\\\",\\\")\\n \\n def dfs(arr):\\n if arr[0] == \\\"#\\\":\\n arr.pop(0)\\n return None\\n \\n root = TreeNode(arr[0])\\n arr.pop(0)\\n root.left = dfs(arr)\\n root.right = dfs(arr)\\n return root\\n \\n return dfs(arr)\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"131\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n self.ret = \\\"\\\"\\n def dfs(node):\\n if not node:\\n self.ret += \\\"None//\\\"\\n else:\\n self.ret += (str(node.val) + \\\"//\\\")\\n dfs(node.left)\\n dfs(node.right)\\n dfs(root)\\n return self.ret\\n \\n\\n def deserialize(self, data):\\n self.arr = data.split(\\\"//\\\")\\n self.arr = self.arr[:len(self.arr) - 1]\\n self.index = 0\\n def dfs():\\n print(self.index)\\n if self.arr[self.index] == \\\"None\\\":\\n self.index += 1\\n return None\\n root = TreeNode(int(self.arr[self.index]))\\n self.index += 1\\n root.left = dfs()\\n root.right = dfs()\\n return root\\n \\n return dfs()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"132\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n _str = ''\\n if not root: return _str\\n def dfs(node):\\n nonlocal _str\\n if not node:\\n _str += 'X,'\\n return\\n _str += str(node.val) + ','\\n dfs(node.left)\\n dfs(node.right)\\n \\n dfs(root)\\n return _str\\n\\n \\n\\n def deserialize(self, data):\\n def dfs(arr):\\n if arr[0] == 'X':\\n arr.pop(0)\\n return None\\n root = TreeNode(int(arr.pop(0)),dfs(arr),dfs(arr))\\n\\n return root\\n if data == '': return None\\n arr = data.split(',')\\n return dfs(arr)\\n\\n \\n\\n\\\"\\\"\\\"\\n def serialize(self, root):\\n if not root:\\n return ''\\n nodes = [str(root.val)]\\n dq = deque([root])\\n\\n while dq:\\n for _ in range(len(dq)):\\n cur = dq.popleft()\\n\\n if cur.left:\\n dq.append(cur.left)\\n nodes.append(str(cur.left.val))\\n else:\\n nodes.append('x')\\n if cur.right:\\n dq.append(cur.right)\\n nodes.append(str(cur.right.val))\\n else:\\n nodes.append('x')\\n \\n\\n return ','.join(nodes)\\n \\n\\n def deserialize(self, data):\\n print(data)\\n if data == '': return None\\n nodes = data.split(',')\\n root = TreeNode(nodes[0])\\n dq = deque([root])\\n i = 1\\n\\n while dq and i < len(nodes):\\n cur = dq.popleft()\\n if nodes[i] != 'x':\\n left = TreeNode(int(nodes[i]))\\n cur.left = left\\n dq.append(left)\\n i += 1\\n if nodes[i] != 'x':\\n right = TreeNode(int(nodes[i]))\\n cur.right = right\\n dq.append(right)\\n i += 1\\n \\n return root\\n\\\"\\\"\\\"\",\n \"runtime\": \"134\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n queue = deque()\\n queue.append(root)\\n\\n str_list = []\\n\\n while queue:\\n curr = queue.popleft()\\n if curr:\\n str_list.append(str(curr.val))\\n str_list.append(\\\"#\\\")\\n else:\\n str_list.append(\\\"null\\\")\\n str_list.append(\\\"#\\\")\\n continue\\n \\n if curr.left:\\n queue.append(curr.left)\\n elif not curr.left:\\n queue.append(None)\\n \\n if curr.right:\\n queue.append(curr.right)\\n elif not curr.right:\\n queue.append(None)\\n\\n str_list.pop()\\n return \\\"\\\".join(str_list)\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n\\n queue = deque()\\n de_list = data.split(\\\"#\\\")\\n\\n if de_list[0] == \\\"null\\\":\\n return\\n root_val = de_list.pop(0)\\n\\n root = TreeNode(int(root_val))\\n queue.append(root)\\n\\n while queue:\\n curr = queue.popleft()\\n\\n left = de_list.pop(0)\\n\\n if left != \\\"null\\\":\\n left_node = TreeNode(int(left))\\n curr.left = left_node\\n queue.append(left_node)\\n \\n right = de_list.pop(0)\\n if right != \\\"null\\\":\\n right_node = TreeNode(int(right))\\n curr.right = right_node\\n queue.append(right_node)\\n\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"134\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _serialize(node, string):\\n if node is None:\\n string += \\\"None,\\\"\\n else:\\n string += str(node.val) + \\\",\\\"\\n string = _serialize(node.left, string)\\n string = _serialize(node.right, string)\\n return string\\n \\n return _serialize(root, \\\"\\\")\\n \\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _deserialize(items):\\n \\\"\\\"\\\" a recursive helper function for deserialization.\\\"\\\"\\\"\\n if items[0] == 'None':\\n items.pop(0)\\n return None\\n \\n root = TreeNode(items[0])\\n items.pop(0)\\n root.left = _deserialize(items)\\n root.right = _deserialize(items)\\n return root\\n\\n data_list = data.split(',')\\n root = _deserialize(data_list)\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"135\"\n },\n {\n \"code\": \"class Codec:\\n def serialize(self, root):\\n def dfs(root):\\n if not root:\\n return \\\"N,\\\"\\n s=\\\"\\\"\\n s+=str(root.val)+\\\",\\\"\\n s+=dfs(root.left)\\n s+=dfs(root.right)\\n return s\\n Encode=dfs(root)\\n return Encode[:-1]\\n def deserialize(self, data):\\n def dfs(data):\\n if not data:\\n return None\\n current=data.pop(0)\\n if current==\\\"N\\\":\\n return None\\n root=TreeNode(int(current))\\n root.left=dfs(data)\\n root.right=dfs(data)\\n return root\\n data=data.split(\\\",\\\")\\n print(data)\\n return dfs(data)\",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def __init__(self):\\n self.str=\\\"(\\\"\\n self.newNode = None\\n self.index = 0\\n\\n def serialize(self, root):\\n if root is None:\\n self.str+=\\\")\\\"\\n return self.str\\n self.str+=\\\"{}\\\".format(root.val)\\n self.str+=\\\"(\\\"\\n self.serialize(root.left)\\n self.str+=\\\"(\\\"\\n self.serialize(root.right)\\n self.str+=\\\")\\\"\\n return self.str\\n\\n def fetchValue(self,string):\\n res=\\\"\\\"\\n index = self.index\\n while index<len(string):\\n value = string[index:index+1]\\n if value != ')' and value !='(':\\n res+=value\\n index+=1\\n else:\\n break\\n return res,index-1\\n def deserial(self,temp,string):\\n if self.index>=len(string):\\n return None\\n value = string[self.index:self.index+1]\\n if value == ')':\\n self.index+=1\\n return None\\n if self.newNode == None:\\n if value != '(' and value != ')':\\n val,ind = self.fetchValue(string)\\n self.newNode = TreeNode(val)\\n temp = self.newNode\\n self.index = ind\\n self.index+=1\\n self.deserial(temp,string)\\n else:\\n if value != '(' and value != ')':\\n val,ind = self.fetchValue(string)\\n temp = TreeNode(val)\\n self.index = ind\\n self.index+=1\\n self.deserial(temp,string)\\n return temp\\n self.index+=1\\n temp.left = self.deserial(temp,string)\\n self.index+=1\\n temp.right = self.deserial(temp,string)\\n self.index+=1\\n return temp\\n \\n def deserialize(self, data):\\n res = self.deserial(None,data)\\n return self.newNode\\n #return self.newNode\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"138\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def __init__(self):\\n self.str=\\\"(\\\"\\n self.newNode = None\\n self.index = 0\\n\\n def serialize(self, root):\\n if root is None:\\n self.str+=\\\")\\\"\\n return self.str\\n self.str+=\\\"{}\\\".format(root.val)\\n self.str+=\\\"(\\\"\\n self.serialize(root.left)\\n self.str+=\\\"(\\\"\\n self.serialize(root.right)\\n self.str+=\\\")\\\"\\n return self.str\\n\\n def fetchValue(self,string):\\n res=\\\"\\\"\\n index = self.index\\n while index<len(string):\\n value = string[index:index+1]\\n if value != ')' and value !='(':\\n res+=value\\n index+=1\\n else:\\n break\\n return res,index-1\\n def deserial(self,temp,string):\\n if self.index>=len(string):\\n return None\\n value = string[self.index:self.index+1]\\n if value == ')':\\n self.index+=1\\n return None\\n if self.newNode == None:\\n if value != '(' and value != ')':\\n val,ind = self.fetchValue(string)\\n self.newNode = TreeNode(val)\\n temp = self.newNode\\n self.index = ind\\n self.index+=1\\n self.deserial(temp,string)\\n else:\\n if value != '(' and value != ')':\\n val,ind = self.fetchValue(string)\\n temp = TreeNode(val)\\n self.index = ind\\n self.index+=1\\n self.deserial(temp,string)\\n return temp\\n self.index+=1\\n temp.left = self.deserial(temp,string)\\n self.index+=1\\n temp.right = self.deserial(temp,string)\\n self.index+=1\\n return temp\\n \\n def deserialize(self, data):\\n res = self.deserial(None,data)\\n return self.newNode\\n #return self.newNode\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"138\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def rserialize(root, string):\\n if root is None:\\n string+='None,'\\n else:\\n string+= str(root.val)+','\\n string = rserialize(root.left, string)\\n string = rserialize(root.right, string)\\n return string\\n \\n return rserialize(root, '')\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def rdeserialize(l):\\n if l[0] == 'None':\\n l.pop(0)\\n return None\\n root = TreeNode(l[0])\\n l.pop(0)\\n root.left = rdeserialize(l)\\n root.right = rdeserialize(l)\\n return root\\n \\n data_list = data.split(',')\\n root = rdeserialize(data_list)\\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _serialize(node, string):\\n if node is None:\\n string += \\\"None,\\\"\\n else:\\n string += str(node.val) + \\\",\\\"\\n string = _serialize(node.left, string)\\n string = _serialize(node.right, string)\\n return string\\n \\n return _serialize(root, \\\"\\\")\\n \\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _deserialize(items):\\n \\\"\\\"\\\" a recursive helper function for deserialization.\\\"\\\"\\\"\\n if items[0] == 'None':\\n items.pop(0)\\n return None\\n \\n root = TreeNode(items[0])\\n items.pop(0)\\n root.left = _deserialize(items)\\n root.right = _deserialize(items)\\n return root\\n\\n data_list = data.split(',')\\n root = _deserialize(data_list)\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"141\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\nimport math\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n #Perform level order traversal of the tree\\n if not root:\\n return ''\\n result = ['$']\\n stack = [root]\\n while stack:\\n nnodes = len(stack)\\n level_nodes = []\\n empty_level = True\\n for i in range(nnodes):\\n node = stack.pop()\\n if node:\\n level_nodes.insert(0, node.val)\\n empty_level = False\\n else:\\n level_nodes.insert(0, None)\\n continue\\n left = node.left if node.left else None\\n right = node.right if node.right else None\\n stack.insert(0, right)\\n stack.insert(0, left)\\n if empty_level:\\n return ' '.join(str(i) for i in result) \\n else:\\n #Add a separator to demarcate levels\\n level_nodes.append('$')\\n result += level_nodes\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n #Empty Tree\\n if data == '':\\n return \\n data = data.split(' ')\\n data.pop()\\n stack = []\\n base = 0\\n while data:\\n while data[-1]!='$':\\n val = data.pop()\\n node = TreeNode(int(val)) if val!='None' else None\\n #Last level contains only leaves, just add them to the stack\\n if base == 0:\\n stack.insert(0, node)\\n continue\\n #Pop 2 elements from the stack, assign them to right, left respectively\\n if node:\\n right = stack.pop()\\n left = stack.pop()\\n if left:\\n node.left = left\\n if right:\\n node.right = right\\n #Add this created node to the stack\\n stack.insert(0, node)\\n base+=1\\n data.pop()\\n #Stack will only contain the root once data is empty\\n return stack[0]\\n \\n\\n\\n \\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"142\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\nfrom collections import deque\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"\\\"\\n \\n r = []\\n q = deque()\\n q.append(root)\\n nnodes = 1\\n while q and nnodes > 0:\\n node = q.popleft()\\n if node is not None:\\n nnodes -= 1\\n r.append(node.val)\\n if node.left is not None:\\n q.append(node.left)\\n nnodes += 1\\n else: \\n q.append(None)\\n \\n \\n if node.right is not None:\\n q.append(node.right)\\n nnodes += 1\\n else:\\n q.append(None)\\n else:\\n r.append(1001)\\n \\n return ','.join([str(x) for x in r])\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"\\\":\\n return []\\n\\n ldata = [int(x) for x in data.split(',')]\\n q = deque()\\n\\n\\n root = TreeNode(ldata[0])\\n q.append(root)\\n ldata=ldata[1:] \\n \\n while q and len(ldata)>0:\\n node = q.popleft()\\n if node is not None:\\n if ldata[0] < 1001:\\n node.left = TreeNode(ldata[0])\\n if len(ldata) > 1 and ldata[1] < 1001:\\n node.right = TreeNode(ldata[1])\\n\\n q.append(node.left)\\n q.append(node.right)\\n ldata = ldata[2:]\\n\\n \\n return root\\n \\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"142\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"\\\"\\n \\n r = []\\n q = [root]\\n nnodes = 1\\n while q and nnodes > 0:\\n node = q.pop(0)\\n if node is not None:\\n nnodes -= 1\\n r.append(node.val)\\n if node.left is not None:\\n q.append(node.left)\\n nnodes += 1\\n else: \\n q.append(None)\\n \\n \\n if node.right is not None:\\n q.append(node.right)\\n nnodes += 1\\n else:\\n q.append(None)\\n else:\\n r.append(1001)\\n \\n return ','.join([str(x) for x in r])\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"\\\":\\n return []\\n\\n ldata = [int(x) for x in data.split(',')]\\n q = []\\n\\n\\n root = TreeNode(ldata[0])\\n q.append(root)\\n ldata=ldata[1:] \\n \\n while q and len(ldata)>0:\\n node = q.pop(0)\\n if node is not None:\\n if ldata[0] < 1001:\\n node.left = TreeNode(ldata[0])\\n if len(ldata) > 1 and ldata[1] < 1001:\\n node.right = TreeNode(ldata[1])\\n\\n q += [node.left, node.right]\\n ldata = ldata[2:]\\n\\n \\n return root\\n \\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"143\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root: TreeNode):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n\\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n\\n serData = str()\\n\\n def serializeHelper(node: TreeNode):\\n nonlocal serData\\n if not node:\\n serData += \\\"null,\\\"\\n return\\n serData += str(node.val) + \\\",\\\"\\n serializeHelper(node.left)\\n serializeHelper(node.right)\\n\\n serializeHelper(root)\\n return serData\\n\\n def deserialize(self, data: str):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n\\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n def deserializeHelper(values: list[str]):\\n nodeVal = values.pop(0)\\n if nodeVal == \\\"null\\\":\\n return None\\n node = TreeNode(int(nodeVal))\\n node.left = deserializeHelper(values)\\n node.right = deserializeHelper(values)\\n return node\\n return deserializeHelper(data.split(\\\",\\\"))\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"143\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\nfrom collections import deque\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"\\\"\\n \\n r = []\\n q = deque()\\n q.append(root)\\n nnodes = 1\\n while q and nnodes > 0:\\n node = q.popleft()\\n if node is not None:\\n nnodes -= 1\\n r.append(node.val)\\n if node.left is not None:\\n q.append(node.left)\\n nnodes += 1\\n else: \\n q.append(None)\\n \\n \\n if node.right is not None:\\n q.append(node.right)\\n nnodes += 1\\n else:\\n q.append(None)\\n else:\\n r.append(1001)\\n \\n return ','.join([str(x) for x in r])\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"\\\":\\n return []\\n\\n ldata = [int(x) for x in data.split(',')]\\n q = deque()\\n\\n\\n root = TreeNode(ldata[0])\\n q.append(root)\\n ldata=ldata[1:] \\n \\n while q and len(ldata)>0:\\n node = q.popleft()\\n if node is not None:\\n if ldata[0] < 1001:\\n node.left = TreeNode(ldata[0])\\n if len(ldata) > 1 and ldata[1] < 1001:\\n node.right = TreeNode(ldata[1])\\n\\n q.append(node.left)\\n q.append(node.right)\\n ldata = ldata[2:]\\n\\n \\n return root\\n \\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"145\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def serial(node, s):\\n if node is None:\\n s += 'None,'\\n else:\\n s += str(node.val)+','\\n s = serial(node.left,s)\\n s = serial(node.right, s)\\n return s\\n return serial(root, '')\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def rdeserialize(l):\\n \\\"\\\"\\\" a recursive helper function for deserialization.\\\"\\\"\\\"\\n if l[0] == 'None':\\n l.pop(0)\\n return None\\n \\n root = TreeNode(l[0])\\n l.pop(0)\\n root.left = rdeserialize(l)\\n root.right = rdeserialize(l)\\n return root\\n\\n data_list = data.split(',')\\n root = rdeserialize(data_list)\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class Codec:\\n def serialize(self, root):\\n if not root:\\n return \\\"N,\\\"\\n data = \\\"\\\"\\n queue = [root]\\n while queue:\\n for _ in range(len(queue)):\\n node = queue.pop(0)\\n if node:\\n data += str(node.val) + \\\",\\\"\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n data += \\\"N,\\\"\\n return data[:-1]\\n def deserialize(self, data):\\n if data==\\\"N,\\\":\\n return None\\n data = data.split(\\\",\\\")\\n root = TreeNode(int(data.pop(0)))\\n queue = [root]\\n while queue:\\n for _ in range(len(queue)):\\n node=queue.pop(0)\\n left_val, right_val = data.pop(0), data.pop(0)\\n if left_val != \\\"N\\\":\\n node.left = TreeNode(int(left_val))\\n queue.append(node.left)\\n if right_val != \\\"N\\\":\\n node.right = TreeNode(int(right_val))\\n queue.append(node.right)\\n return root\\n\",\n \"runtime\": \"147\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\nfrom collections import deque\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"\\\"\\n \\n r = []\\n q = deque()\\n q.append(root)\\n nnodes = 1\\n while q and nnodes > 0:\\n node = q.popleft()\\n if node is not None:\\n nnodes -= 1\\n r.append(node.val)\\n if node.left is not None:\\n q.append(node.left)\\n nnodes += 1\\n else: \\n q.append(None)\\n \\n \\n if node.right is not None:\\n q.append(node.right)\\n nnodes += 1\\n else:\\n q.append(None)\\n else:\\n r.append(1001)\\n \\n return ','.join([str(x) for x in r])\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"\\\":\\n return []\\n\\n ldata = [int(x) for x in data.split(',')]\\n q = deque()\\n\\n\\n root = TreeNode(ldata[0])\\n q.append(root)\\n ldata=ldata[1:] \\n \\n while q and len(ldata)>0:\\n node = q.popleft()\\n if node is not None:\\n if ldata[0] < 1001:\\n node.left = TreeNode(ldata[0])\\n if len(ldata) > 1 and ldata[1] < 1001:\\n node.right = TreeNode(ldata[1])\\n\\n q.append(node.left)\\n q.append(node.right)\\n ldata = ldata[2:]\\n\\n \\n return root\\n \\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"147\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def dfs(root, s):\\n if root is None:\\n s += 'None,'\\n else:\\n s += str(root.val) + ','\\n s = dfs(root.left, s)\\n s = dfs(root.right, s)\\n return s\\n\\n return dfs(root, '')\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def decode(l):\\n if l[0] == 'None':\\n l.pop(0)\\n return None\\n root = TreeNode(l[0])\\n l.pop(0)\\n root.left = decode(l)\\n root.right = decode(l)\\n return root\\n\\n l = data.split(',')\\n return decode(l) \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"148\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"\\\"\\n \\n r = []\\n q = [root]\\n nnodes = 1\\n while q and nnodes > 0:\\n node = q.pop(0)\\n if node is not None:\\n nnodes -= 1\\n r.append(node.val)\\n if node.left is not None:\\n q.append(node.left)\\n nnodes += 1\\n else: \\n q.append(None)\\n \\n \\n if node.right is not None:\\n q.append(node.right)\\n nnodes += 1\\n else:\\n q.append(None)\\n else:\\n r.append(1001)\\n \\n return ','.join([str(x) for x in r])\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"\\\":\\n return []\\n\\n ldata = [int(x) for x in data.split(',')]\\n q = []\\n\\n\\n root = TreeNode(ldata[0])\\n q.append(root)\\n ldata=ldata[1:] \\n \\n while q and len(ldata)>0:\\n node = q.pop(0)\\n if node is not None:\\n if ldata[0] < 1001:\\n node.left = TreeNode(ldata[0])\\n if len(ldata) > 1 and ldata[1] < 1001:\\n node.right = TreeNode(ldata[1])\\n\\n q += [node.left, node.right]\\n ldata = ldata[2:]\\n\\n \\n return root\\n \\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"149\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\nfrom collections import deque\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"\\\"\\n \\n r = []\\n q = deque()\\n q.append(root)\\n nnodes = 1\\n while q and nnodes > 0:\\n node = q.popleft()\\n if node is not None:\\n nnodes -= 1\\n r.append(node.val)\\n if node.left is not None:\\n q.append(node.left)\\n nnodes += 1\\n else: \\n q.append(None)\\n \\n \\n if node.right is not None:\\n q.append(node.right)\\n nnodes += 1\\n else:\\n q.append(None)\\n else:\\n r.append(1001)\\n \\n return ','.join([str(x) for x in r])\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"\\\":\\n return []\\n\\n ldata = [int(x) for x in data.split(',')]\\n q = deque()\\n\\n\\n root = TreeNode(ldata[0])\\n q.append(root)\\n ldata=ldata[1:] \\n \\n while q and len(ldata)>0:\\n node = q.popleft()\\n if node is not None:\\n if ldata[0] < 1001:\\n node.left = TreeNode(ldata[0])\\n if len(ldata) > 1 and ldata[1] < 1001:\\n node.right = TreeNode(ldata[1])\\n\\n q.append(node.left)\\n q.append(node.right)\\n ldata = ldata[2:]\\n\\n \\n return root\\n \\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"151\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def __init__(self):\\n self.str=\\\"(\\\"\\n self.newNode = None\\n self.index = 0\\n\\n def serialize(self, root):\\n if root is None:\\n self.str+=\\\")\\\"\\n return self.str\\n self.str+=\\\"{}\\\".format(root.val)\\n self.str+=\\\"(\\\"\\n self.serialize(root.left)\\n self.str+=\\\"(\\\"\\n self.serialize(root.right)\\n self.str+=\\\")\\\"\\n return self.str\\n\\n def fetchValue(self,string):\\n res=\\\"\\\"\\n index = self.index\\n while index<len(string):\\n value = string[index:index+1]\\n if value != ')' and value !='(':\\n res+=value\\n index+=1\\n else:\\n break\\n return res,index-1\\n def deserial(self,temp,string):\\n if self.index>=len(string):\\n return None\\n value = string[self.index:self.index+1]\\n if value == ')':\\n self.index+=1\\n return None\\n if self.newNode == None:\\n if value != '(' and value != ')':\\n val,ind = self.fetchValue(string)\\n self.newNode = TreeNode(val)\\n temp = self.newNode\\n self.index = ind\\n self.index+=1\\n self.deserial(temp,string)\\n else:\\n if value != '(' and value != ')':\\n val,ind = self.fetchValue(string)\\n temp = TreeNode(val)\\n self.index = ind\\n self.index+=1\\n self.deserial(temp,string)\\n return temp\\n self.index+=1\\n temp.left = self.deserial(temp,string)\\n self.index+=1\\n temp.right = self.deserial(temp,string)\\n self.index+=1\\n return temp\\n \\n def deserialize(self, data):\\n res = self.deserial(None,data)\\n return self.newNode\\n #return self.newNode\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"runtime\": \"151\"\n },\n {\n \"code\": \"class Codec:\\n def serialize(self, root):\\n if not root:\\n return \\\"\\\"\\n queue = []\\n queue.append(root)\\n self.ser = \\\"\\\"\\n while queue:\\n size = len(queue) \\n for i in range(size):\\n node = queue.pop(0)\\n if node:\\n self.ser += str(node.val) \\n queue.append(node.left) \\n queue.append(node.right)\\n else:\\n self.ser += (\\\"null\\\")\\n self.ser += \\\",\\\"\\n return self.ser\\n\\n def deserialize(self, data):\\n if len(data) == 0:\\n return None\\n nodes = data.split(',')\\n root_node = TreeNode(int(nodes[0]))\\n queue = deque()\\n queue.append(root_node)\\n cur_pos = 1\\n while len(queue) > 0:\\n cur = queue.popleft()\\n if nodes[cur_pos] != 'null':\\n cur.left = TreeNode(int(nodes[cur_pos]))\\n queue.append(cur.left)\\n cur_pos += 1\\n if nodes[cur_pos] != 'null':\\n cur.right = TreeNode(int(nodes[cur_pos]))\\n queue.append(cur.right)\\n cur_pos += 1\\n return root_node\\n\\n\\n\\n\\n\",\n \"runtime\": \"152\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":123,"string":"123"},"mm_list":{"kind":"list like","value":[{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n global r\n r = root\n return \"\"\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n return r\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"18700"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nfrom collections import deque\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n res = \"\"\n \n q = deque()\n\n q.append(root)\n\n while q:\n length = len(q)\n\n for _ in range(length):\n\n curr = q.popleft()\n if not curr:\n res += \"*\"\n else:\n res += 's'\n res += str(curr.val)\n res += 'e'\n if curr:\n q.append(curr.left)\n q.append(curr.right)\n \n \n return res\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n\n arr = []\n\n print(data)\n\n startWordIndex = -1\n\n for i in range(len(data)):\n if data[i] == '*':\n arr.append(None)\n if data[i] == 's':\n startWordIndex = i\n if data[i] == 'e':\n arr.append(int(data[startWordIndex+1:i]))\n\n while arr and arr[-1] is None: # or use 'null' if that is the marker\n arr.pop()\n\n return arr\n q = deque()\n\n root = TreeNode(val = arr[0])\n\n q.append(root)\n\n i = 0\n\n while q:\n length = len(q)\n\n for _ in range(length):\n\n curr = q.popleft()\n\n\n if i + 1 < len(arr) and arr[i+1] != None:\n\n leftie = TreeNode(val = arr[i+1])\n curr.left = leftie\n q.append(leftie)\n else:\n curr.left = None\n \n if i + 2 < len(arr) and arr[i+2] != None:\n rightie = TreeNode(val = arr[i+2])\n curr.right = rightie\n q.append(rightie)\n else:\n curr.right = None\n i = i + length\n return root\n\n \n\n\n\n\n\n\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"18800"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nfrom collections import deque\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n res = \"\"\n \n q = deque()\n\n q.append(root)\n\n while q:\n length = len(q)\n\n for _ in range(length):\n\n curr = q.popleft()\n if not curr:\n res += \"*\"\n else:\n res += 's'\n res += str(curr.val)\n res += 'e'\n if curr:\n q.append(curr.left)\n q.append(curr.right)\n \n \n return res\n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n\n arr = []\n\n print(data)\n\n startWordIndex = -1\n\n for i in range(len(data)):\n if data[i] == '*':\n arr.append(None)\n if data[i] == 's':\n startWordIndex = i\n if data[i] == 'e':\n arr.append(int(data[startWordIndex+1:i]))\n\n while arr and arr[-1] is None: # or use 'null' if that is the marker\n arr.pop()\n\n return arr\n q = deque()\n\n root = TreeNode(val = arr[0])\n\n q.append(root)\n\n i = 0\n\n while q:\n length = len(q)\n\n for _ in range(length):\n\n curr = q.popleft()\n\n\n if i + 1 < len(arr) and arr[i+1] != None:\n\n leftie = TreeNode(val = arr[i+1])\n curr.left = leftie\n q.append(leftie)\n else:\n curr.left = None\n \n if i + 2 < len(arr) and arr[i+2] != None:\n rightie = TreeNode(val = arr[i+2])\n curr.right = rightie\n q.append(rightie)\n else:\n curr.right = None\n i = i + length\n return root\n\n \n\n\n\n\n\n\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"18900"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n if not root:\n return \"\"\n \n res = \"\"\n queue = collections.deque()\n queue.append(root)\n\n while queue:\n q = len(queue)\n\n for i in range(q):\n node = queue.popleft()\n if node:\n res += str(node.val)\n queue.append(node.left)\n queue.append(node.right)\n else:\n res += 'null'\n res += ' '\n # res += ' ' \n return res\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n res = []\n data = data.strip()\n data = data.split()\n for i in range(len(data) - 1, -1, -1):\n if data[i] == 'null':\n data.pop(i)\n else:\n break\n \n for i in range(len(data)):\n if data[i] == 'null':\n data[i] = None\n else:\n data[i] = int(data[i])\n return data\n \n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"19000"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n d = {}\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n key = ''\n if root == None:\n self.d['N'] = root\n return 'N'\n key += str(root.val)\n stack = [root]\n while stack:\n curr = stack.pop()\n if curr.left != None:\n stack.append(curr.left)\n key += str(curr.left.val)\n else:\n key += 'N'\n if curr.right != None:\n stack.append(curr.right)\n key += str(curr.right.val)\n else:\n key += 'N'\n self.d[key] = root\n return key \n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n return self.d[data]\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"19100"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nimport ctypes\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n return str(id(root))\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n return ctypes.cast(int(data), ctypes.py_object).value\n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"19200"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n queue = [root]\n string = []\n last_num_index = 0\n i = 0\n while queue:\n current = queue.pop(0)\n i += 1\n if current == None:\n string.append('(4)null')\n continue\n else:\n value = str(current.val)\n last_num_index = i\n string.append('(' + str(len(value)) + ')' + value)\n if current.left:\n queue.append(current.left)\n else:\n queue.append(None)\n if current.right:\n queue.append(current.right)\n else:\n queue.append(None)\n print(string)\n return ''.join(string[:last_num_index])\n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n i = 1\n length = ''\n solution = []\n while i < len(data):\n j = i\n while data[j] != ')':\n print(type(length))\n print(type(data[j]))\n length = length + str(data[j])\n length = str(length)\n j += 1\n num_length = int(length)\n if data[j + 1 : j + num_length + 1] == 'null':\n solution.append(None)\n else:\n solution.append(int(data[j + 1 : j + num_length + 1]))\n length = ''\n i = j + num_length + 2\n print(solution)\n return solution\n\n\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"19300"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n queue = [root]\n string = []\n last_num_index = 0\n i = 0\n while queue:\n current = queue.pop(0)\n i += 1\n if current == None:\n string.append('(4)null')\n continue\n else:\n value = str(current.val)\n last_num_index = i\n string.append('(' + str(len(value)) + ')' + value)\n if current.left:\n queue.append(current.left)\n else:\n queue.append(None)\n if current.right:\n queue.append(current.right)\n else:\n queue.append(None)\n # print(string)\n return ''.join(string[:last_num_index])\n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n i = 1\n length = ''\n solution = []\n while i < len(data):\n j = i\n while data[j] != ')':\n # print(type(length))\n # print(type(data[j]))\n length = length + str(data[j])\n length = str(length)\n j += 1\n num_length = int(length)\n if data[j + 1 : j + num_length + 1] == 'null':\n solution.append(None)\n else:\n solution.append(int(data[j + 1 : j + num_length + 1]))\n length = ''\n i = j + num_length + 2\n # print(solution)\n return solution\n\n\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"19300"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n # def getHeight(root):\n # if not root:\n # return 0\n \n # lh = getHeight(root.left)\n # rh = getHeight(root.right)\n\n # return 1 + max(lh, rh)\n \n # h = getHeight(root)\n # print(\"height\", h)\n # q = [root]\n # nums = []\n # while q:\n # l = []\n # qLen = len(q)\n # for i in range(qLen):\n # node = q.pop(0)\n # if node:\n # l.append(node.val)\n # q.append(node.left)\n # q.append(node.right)\n # else:\n # if h > 0:\n # l.append(None)\n # h -= 1\n # nums += l\n # s = \"[\"\n # for i in range(len(nums)):\n # if nums[i] is None:\n # s += \"null\"\n # else:\n # s += str(nums[i])\n # if i < len(nums) - 1:\n # s += \",\"\n # s += \"]\"\n # return s\n if not root:\n return \"\"\n \n res = \"\"\n queue = collections.deque()\n queue.append(root)\n\n while queue:\n q = len(queue)\n\n for i in range(q):\n node = queue.popleft()\n if node:\n res += str(node.val)\n queue.append(node.left)\n queue.append(node.right)\n else:\n res += 'null'\n res += ' '\n # res += ' ' \n return res\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n # if data == \"[]\":\n # return None\n\n # data = data[1:-1].split(',')\n # root = TreeNode(data[0])\n # q = [root]\n # l = True\n # c = None\n\n # for i in range(1, len(data)):\n # node = TreeNode(data[i])\n\n # if l:\n # c = q.pop(0)\n # c.left = node\n # l = False\n # else:\n # c.right = node\n # l = True\n \n # if data[i] is not \"null\":\n # q.append(node)\n \n # return root\n res = []\n data = data.strip()\n data = data.split()\n for i in range(len(data) - 1, -1, -1):\n if data[i] == 'null':\n data.pop(i)\n else:\n break\n \n for i in range(len(data)):\n if data[i] == 'null':\n data[i] = None\n else:\n data[i] = int(data[i])\n return data\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"19400"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if root is None:\n return \"None\"\n \n left = self.serialize(root.left)\n right = self.serialize(root.right)\n \n return f\"{str(root.val)},{left},{right}\"\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == \"None\":\n return None\n tree = data.split(\",\")\n\n def dfs():\n node = tree.pop(0)\n if node == \"None\":\n return None\n treeNode = TreeNode(int(node))\n treeNode.left = dfs()\n treeNode.right = dfs()\n return treeNode\n\n return dfs()\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"19800"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n serialized = []\n def dfs(root):\n if not root:\n serialized.append(\"N\")\n return\n serialized.append(str(root.val))\n dfs(root.left)\n dfs(root.right)\n return\n dfs(root)\n return \",\".join(serialized)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n from collections import deque\n data = deque(data.split(\",\"))\n def build():\n root = data.popleft()\n if root == \"N\":\n return None\n newtree = TreeNode(int(root))\n newtree.left = build()\n newtree.right = build()\n return newtree\n return build()\n\n\n\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"19900"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n\n if not root:\n return \"\"\n\n def _serialize(node):\n if not node:\n ans.append(\"None\")\n return\n ans.append(str(node.val))\n _serialize(node.left)\n _serialize(node.right)\n\n ans = []\n _serialize(root)\n return \",\".join(ans)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data:\n return None\n\n def _deserialize(d):\n val = d.pop(0)\n if val == \"None\":\n return None\n \n root = TreeNode(val)\n root.left = _deserialize(d)\n root.right = _deserialize(d)\n\n return root\n\n data_list = data.split(\",\")\n return _deserialize(data_list)\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20000"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n # BFS或DFS都可唯一确定一个完全二叉树\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def dfs(root, results):\n if root == None:\n results.append('#')\n return\n\n results.append(str(root.val))\n dfs(root.left, results)\n dfs(root.right, results)\n\n results = []\n dfs(root, results)\n return ' '.join(results)\n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def dfs(src):\n node = next(src)\n if node == '#':\n return None\n\n root = TreeNode(int(node))\n root.left = dfs(src)\n root.right = dfs(src)\n return root\n\n src = iter(data.split())\n return dfs(src)\n\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20100"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return \"\"\n \n output = \"\"\n queue = deque({root})\n while queue:\n curr = queue.popleft()\n if not curr:\n output += \"*,\"\n continue\n output += str(curr.val) + \",\"\n queue.append(curr.left)\n queue.append(curr.right)\n return output\n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data:\n return None\n \n nodes = data.split(\",\")\n root = TreeNode(int(nodes[0]))\n queue = deque({root})\n i = 1\n while queue and i < len(nodes):\n curr = queue.popleft()\n if nodes[i] != \"*\":\n left = TreeNode(int(nodes[i]))\n curr.left = left\n queue.append(left)\n i += 1\n if nodes[i] != \"*\":\n right = TreeNode(int(nodes[i]))\n curr.right = right\n queue.append(right)\n i += 1\n \n return root\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20200"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\nfrom collections import deque\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n res = []\n self.dfs(root, res)\n return ','.join(res)\n \n def dfs(self, root, res):\n if root == None:\n res.append('#')\n return\n\n res.append(str(root.val))\n self.dfs(root.left, res)\n self.dfs(root.right, res)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n # using deque to solve\n data_list = deque(data.split(','))\n\n return self.build_tree(data_list)\n \n def build_tree(self, data_list):\n if data_list is None:\n return None\n \n val = data_list.popleft()\n\n if val == '#':\n return None\n\n node = TreeNode(int(val))\n\n node.left = self.build_tree(data_list)\n node.right = self.build_tree(data_list)\n\n return node\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20200"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n\n self.s = \"\"\n self.serialize_dfs(root)\n \n return self.s\n\n def serialize_dfs(self,curr):\n \n if not curr:\n self.s+=\"X\"+\",\"\n return\n \n self.s+=str(curr.val)+\",\"\n\n self.serialize_dfs(curr.left)\n self.serialize_dfs(curr.right)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n root,pointer = self.build(0,data.split(\",\"))\n return root\n\n def build(self,pointer,data):\n if pointer >= len(data) or data[pointer] == \"X\" or data[pointer] == \"\":\n return None, pointer + 1\n \n node = TreeNode(int(data[pointer]))\n pointer += 1\n node.left, pointer = self.build(pointer,data) \n node.right, pointer = self.build(pointer,data) \n \n return node, pointer\n\n\n \n\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20300"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return ''\n queue = deque([root])\n res = \"\"\n \n while queue:\n node = queue.popleft()\n res += \"#\"\n if node:\n res += str(node.val)\n queue.append(node.left)\n queue.append(node.right)\n else:\n res += 'null'\n continue\n return res\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data:\n return None\n\n data = deque(data.split(\"#\")[1:])\n \n root = TreeNode(int(data.popleft()))\n queue = deque([root])\n while queue:\n l = len(queue)\n\n node = queue.popleft()\n if not node:\n continue\n\n left, right = data.popleft(), data.popleft()\n node.left = TreeNode(int(left)) if left != 'null' else None\n queue.append(node.left)\n node.right = TreeNode(int(right)) if right != 'null' else None\n queue.append(node.right)\n return root\n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20300"},{"code":"class Codec:\n\n def serialize(self, root):\n # use level order traversal to match LeetCode's serialization format\n flat_bt = []\n queue = collections.deque([root])\n while queue:\n node = queue.pop()\n if node:\n flat_bt.append(str(node.val))\n queue.appendleft(node.left)\n queue.appendleft(node.right)\n else:\n # you can use any char to represent null\n # empty string means test for a non-null node is simply: flat_bt[i]\n flat_bt.append('')\n return ','.join(flat_bt)\n # time: O(n)\n # space: O(n)\n\n def deserialize(self, data):\n if not data:\n return\n flat_bt = data.split(',')\n ans = TreeNode(flat_bt[0])\n queue = collections.deque([ans])\n i = 1\n # when you pop a node, its children will be at i and i+1\n while queue:\n node = queue.pop()\n if i < len(flat_bt) and flat_bt[i]:\n node.left = TreeNode(int(flat_bt[i]))\n queue.appendleft(node.left)\n i += 1\n if i < len(flat_bt) and flat_bt[i]:\n node.right = TreeNode(int(flat_bt[i]))\n queue.appendleft(node.right)\n i += 1\n return ans\n # time: O(n)\n # space: O(n)","memory":"20400"},{"code":"class Codec:\n\n def serialize(self, root):\n # use level order traversal to match LeetCode's serialization format\n flat_bt = []\n queue = collections.deque([root])\n while queue:\n node = queue.pop()\n if node:\n flat_bt.append(str(node.val))\n queue.appendleft(node.left)\n queue.appendleft(node.right)\n else:\n # you can use any char to represent null\n # empty string means test for a non-null node is simply: flat_bt[i]\n flat_bt.append('')\n return ','.join(flat_bt)\n # time: O(n)\n # space: O(n)\n\n def deserialize(self, data):\n if not data:\n return\n flat_bt = data.split(',')\n ans = TreeNode(flat_bt[0])\n queue = collections.deque([ans])\n i = 1\n # when you pop a node, its children will be at i and i+1\n while queue:\n node = queue.pop()\n if i < len(flat_bt) and flat_bt[i]:\n node.left = TreeNode(int(flat_bt[i]))\n queue.appendleft(node.left)\n i += 1\n if i < len(flat_bt) and flat_bt[i]:\n node.right = TreeNode(int(flat_bt[i]))\n queue.appendleft(node.right)\n i += 1\n return ans\n # time: O(n)\n # space: O(n)","memory":"20400"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n :type root: TreeNode\n :rtype: str\n \"\"\"\n if root is None:\n return \"4\"\n else:\n total_data = \"\"\n stack = [root]\n while(len(stack) > 0):\n cur_node = stack.pop()\n if cur_node.right is not None:\n stack.append(cur_node.right)\n if cur_node.left is not None:\n stack.append(cur_node.left)\n \n total_data += self.encode_node(cur_node)\n # print(total_data)\n return total_data\n\n def encode_node(self, node):\n data = \"\"\n if node.left is None and node.right is None:\n data += \"0\"\n elif node.right is None:\n data += \"1\"\n elif node.left is None:\n data += \"2\"\n else:\n data += \"3\"\n data += str(node.val + 1000).zfill(4)\n return data\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data[0] == \"4\":\n return None\n else:\n root = self.decode_node(data[1:5])\n stack = [root]\n node_status = [data[0]]\n # print(len(stack), len(node_status), data)\n data = data[5:]\n while(len(data)>0):\n # print(len(stack), len(node_status), data)\n cur_parent_node = stack.pop()\n cur_node_status = node_status.pop()\n if cur_node_status == \"0\":\n continue\n\n cur_node = self.decode_node(data[1:5])\n if cur_node_status == \"1\":\n cur_parent_node.left = cur_node\n elif cur_node_status == \"2\":\n cur_parent_node.right = cur_node\n else:\n if cur_parent_node.left is None:\n cur_parent_node.left = cur_node\n stack.append(cur_parent_node)\n node_status.append(cur_node_status)\n else:\n cur_parent_node.right = cur_node\n \n stack.append(cur_node)\n node_status.append(data[0])\n data = data[5:]\n \n return root\n\n # print(data)\n # print(int(len(data)/5))\n # return None\n \n\n def decode_node(self, data):\n value = int(data) - 1000\n node = TreeNode(value)\n return node\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20500"},{"code":"class Codec:\n\n def serialize(self, root: Optional[TreeNode]):\n if not root:\n return \"\"\n left = self.serialize(root.left)\n right = self.serialize(root.right)\n val = root.val\n if right:\n return f\"{val}({left})({right})\"\n if left:\n return f\"{val}({left})\"\n return f\"{val}\"\n\n def deserialize(self, data: str):\n if not data:\n return None\n root = TreeNode()\n stack = deque([[root, False, False, None]])\n for token in parse(data):\n curr_node, is_real, has_left, parent = stack[-1]\n if token == \"(\":\n node = TreeNode()\n if has_left:\n curr_node.right = node\n else:\n curr_node.left = node\n stack[-1][2] = True\n stack.append([node, False, False, curr_node])\n elif token == \")\":\n if not is_real:\n if curr_node is parent.left:\n parent.left = None\n else:\n parent.right = None\n stack.pop()\n else:\n stack[-1][1] = True\n curr_node.val = token\n return root\n\ndef parse(s: str):\n is_positive = True\n num = 0\n has_number = False\n for char in s:\n if char == \"-\":\n is_positive = False\n num = 0\n has_number = True\n elif char.isnumeric():\n num = num * 10 + int(char)\n has_number = True\n else:\n if has_number:\n yield num if is_positive else -num\n yield char\n is_positive = True\n num = 0\n has_number = False\n if has_number:\n yield num if is_positive else -num","memory":"20500"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n res = []\n\n def dfs(node):\n if not node:\n res.append(\"N\")\n return\n res.append(str(node.val))\n dfs(node.left)\n dfs(node.right)\n dfs(root)\n return \",\".join(res)\n\n\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n vals = data.split(\",\")\n self.i = 0\n\n def dfs():\n if vals[self.i] == \"N\":\n self.i += 1\n return None\n node = TreeNode(int(vals[self.i]))\n self.i += 1\n node.left = dfs()\n node.right = dfs()\n return node\n return dfs()\n\n\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20600"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def _preorder(node):\n if node is None:\n result.append('')\n return\n result.append(str(node.val))\n _preorder(node.left)\n _preorder(node.right)\n \n result = []\n _preorder(root)\n while result and result[-1] == '':\n result.pop()\n return ','.join(result)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def _des(i=0):\n if i >= len(data) or len(data[i]) == 0:\n return None, i + 1\n node = TreeNode(int(data[i]))\n node.left, i = _des(i + 1)\n node.right, i = _des(i)\n return node, i\n \n data = data.split(',')\n return _des()[0]\n \n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20600"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n self.ans = \"\"\n def preorder(node):\n if node:\n self.ans = self.ans + str(node.val) + \",\"\n preorder(node.left)\n preorder(node.right)\n else:\n self.ans = self.ans + \"N\" + \",\"\n preorder(root)\n return self.ans[:len(self.ans) - 1]\n\n def deserialize(self, data):\n if data == \"\":\n return []\n self.i = -1\n li = data.split(\",\")\n def prepare():\n self.i += 1\n if self.i >= len(li):\n return None\n if li[self.i] == \"N\":\n return None\n node = TreeNode(li[self.i])\n node.left = prepare()\n node.right = prepare()\n return node\n\n return prepare()\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20700"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def _preorder(node):\n if node is None:\n result.append('')\n return\n result.append(str(node.val))\n _preorder(node.left)\n _preorder(node.right)\n \n result = []\n _preorder(root)\n while result and result[-1] == '':\n result.pop()\n return ','.join(result)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def _des(i=0):\n if i >= len(data) or len(data[i]) == 0:\n return None, i + 1\n node = TreeNode(int(data[i]))\n node.left, i = _des(i + 1)\n node.right, i = _des(i)\n return node, i\n \n data = data.split(',')\n return _des()[0]\n \n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20700"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n lis=[]\n def dfs(node):\n if not node:\n lis.append(\"N\")\n return\n lis.append(str(node.val))\n dfs(node.left)\n dfs(node.right)\n return lis\n dfs(root)\n return \",\".join(lis)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n lis=data.split(\",\")\n self.i=0\n def dfs():\n\n if lis[self.i]==\"N\":\n self.i+=1\n return None\n newNode= TreeNode(int(lis[self.i]))\n self.i+=1\n newNode.left=dfs()\n newNode.right=dfs()\n return newNode\n\n root=dfs()\n\n return root\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20800"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def _preorder(node):\n if node is None:\n result.append('')\n return\n result.append(str(node.val))\n _preorder(node.left)\n _preorder(node.right)\n \n result = []\n _preorder(root)\n while result and result[-1] == '':\n result.pop()\n return ','.join(result)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def _des(i=0):\n if i >= len(data) or len(data[i]) == 0:\n return None, i + 1\n node = TreeNode(int(data[i]))\n node.left, i = _des(i + 1)\n node.right, i = _des(i)\n return node, i\n \n data = data.split(',')\n return _des()[0]\n \n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20800"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def _preorder(node):\n if node is None:\n result.append('')\n return\n result.append(str(node.val))\n _preorder(node.left)\n _preorder(node.right)\n \n result = []\n _preorder(root)\n return ','.join(result).rstrip(',')\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def _des(i=0):\n if i >= len(data) or len(data[i]) == 0:\n return None, i + 1\n node = TreeNode(int(data[i]))\n node.left, i = _des(i + 1)\n node.right, i = _des(i)\n return node, i\n \n data = data.split(',')\n return _des()[0]\n \n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20900"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def _preorder(node):\n if node is None:\n result.append('')\n return\n result.append(str(node.val))\n _preorder(node.left)\n _preorder(node.right)\n \n result = []\n _preorder(root)\n return ','.join(result).rstrip(',')\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def _des(i=0):\n if i >= len(data) or len(data[i]) == 0:\n return None, i + 1\n node = TreeNode(int(data[i]))\n node.left, i = _des(i + 1)\n node.right, i = _des(i)\n return node, i\n \n data = data.split(',')\n return _des()[0]\n \n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"20900"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n ans = []\n\n # level order traversal\n q = deque([root])\n while q:\n for i in range(len(q)): \n node = q.popleft()\n\n if node:\n ans.append(node.val)\n if node.left:\n q.append(node.left)\n else:\n q.append(None)\n\n if node.right:\n q.append(node.right)\n else:\n q.append(None)\n else:\n ans.append(None)\n\n #convert ans to a string\n return str(ans)\n\n\n def deserialize(self, data):\n # Convert string to list\n data = data.strip('[]')\n data_list = data.split(',')\n data_list = [s.strip() for s in data_list]\n\n # Convert elements to actual values\n def parse_value(s):\n if s == 'None':\n return None\n else:\n return int(s)\n\n data_list = [parse_value(s) for s in data_list]\n\n # Handle empty tree\n if not data_list or data_list[0] is None:\n return None\n\n # Initialize root node and queue\n root = TreeNode(data_list[0])\n queue = deque([root])\n index = 1\n\n # Reconstruct the tree\n while queue and index < len(data_list):\n current = queue.popleft()\n\n # Assign left child\n if index < len(data_list):\n left_val = data_list[index]\n index += 1\n if left_val is not None:\n current.left = TreeNode(left_val)\n queue.append(current.left)\n else:\n current.left = None\n\n # Assign right child\n if index < len(data_list):\n right_val = data_list[index]\n index += 1\n if right_val is not None:\n current.right = TreeNode(right_val)\n queue.append(current.right)\n else:\n current.right = None\n\n return root\n\n\n \n\n\n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21000"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def preOrder(node):\n if not node:\n yield \"None\"\n else:\n yield str(node.val)\n yield from preOrder(node.left)\n yield from preOrder(node.right)\n \n return (' ').join([x for x in preOrder(root)])\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def helper():\n if not data:\n return None\n val = data.popleft()\n if val == \"None\":\n return None\n node = TreeNode(int(val))\n node.left = helper()\n node.right = helper()\n return node\n \n data = deque(data.split(' '))\n return helper()\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21000"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return \"na\"\n\n q=deque([root])\n final = [str(root.val)]\n\n while len(q) > 0:\n node = q.popleft()\n\n if node.left:\n q.append(node.left)\n final.append(str(node.left.val))\n else:\n final.append(\"na\")\n\n if node.right:\n q.append(node.right)\n final.append(str(node.right.val))\n else:\n final.append(\"na\")\n\n return \"|\".join(final)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == \"na\":\n return None\n\n nodes = data.split(\"|\")\n root = TreeNode(int(nodes[0]))\n q = deque([(0, root)])\n na = 0 #num of na's\n\n while len(q) > 0:\n i, node = q.popleft()\n\n if not node:\n na += 1\n continue\n\n li, ri = 2*(i-na) + 1, 2*(i-na) + 2\n left, right = nodes[li], nodes[ri]\n\n if left != \"na\":\n node.left = TreeNode(int(left))\n q.append((li, node.left))\n\n if right != \"na\":\n node.right = TreeNode(int(right))\n q.append((ri, node.right))\n\n return root\n# ['1', '2', '3', 'na', 'na', '4', '5', 'na', 'na', 'na', 'na']\n# [(0, '1'), (1, '2'), (2, '3'), (3, 'na'), (4, 'na'), (5, '4'), (6, '5'), (7, 'na'), (8, 'na'), (9, 'na'), (10, 'na')]\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21100"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return \"na\"\n\n q=deque([root])\n final = [root.val]\n\n while len(q) > 0:\n node = q.popleft()\n\n if node.left:\n q.append(node.left)\n final.append(node.left.val)\n else:\n final.append(\"na\")\n\n if node.right:\n q.append(node.right)\n final.append(node.right.val)\n else:\n final.append(\"na\")\n\n return \"|\".join(str(s) for s in final)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == \"na\":\n return None\n\n nodes = data.split(\"|\")\n root = TreeNode(int(nodes[0]))\n q = deque([(0, root)])\n na = 0 #num of na's\n\n while len(q) > 0:\n i, node = q.popleft()\n\n if not node:\n na += 1\n continue\n\n li, ri = 2*(i-na) + 1, 2*(i-na) + 2\n left, right = nodes[li], nodes[ri]\n\n if left != \"na\":\n node.left = TreeNode(int(left))\n q.append((li, node.left))\n\n if right != \"na\":\n node.right = TreeNode(int(right))\n q.append((ri, node.right))\n\n return root\n \n# ['1', '2', '3', 'na', 'na', '4', '5', 'na', 'na', 'na', 'na']\n# [(0, '1'), (1, '2'), (2, '3'), (3, 'na'), (4, 'na'), (5, '4'), (6, '5'), (7, 'na'), (8, 'na'), (9, 'na'), (10, 'na')]\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21100"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return \"na\"\n\n q=deque([root])\n final = [root.val]\n\n while len(q) > 0:\n node = q.popleft()\n\n if node.left:\n q.append(node.left)\n final.append(node.left.val)\n else:\n final.append(\"na\")\n\n if node.right:\n q.append(node.right)\n final.append(node.right.val)\n else:\n final.append(\"na\")\n\n return \"|\".join(str(s) for s in final)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == \"na\":\n return None\n\n nodes = data.split(\"|\")\n root = TreeNode(int(nodes[0]))\n q = deque([(0, root)])\n na = 0 #num of na's\n\n while len(q) > 0:\n i, node = q.popleft()\n\n if not node:\n na += 1\n continue\n\n li, ri = 2*(i-na) + 1, 2*(i-na) + 2\n left, right = nodes[li], nodes[ri]\n\n if left != \"na\":\n node.left = TreeNode(int(left))\n q.append((li, node.left))\n\n if right != \"na\":\n node.right = TreeNode(int(right))\n q.append((ri, node.right))\n\n return root\n \n# ['1', '2', '3', 'na', 'na', '4', '5', 'na', 'na', 'na', 'na']\n# [(0, '1'), (1, '2'), (2, '3'), (3, 'na'), (4, 'na'), (5, '4'), (6, '5'), (7, 'na'), (8, 'na'), (9, 'na'), (10, 'na')]\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21200"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return 'None'\n return str(root.val) + ',' + self.serialize(root.left) + ',' + self.serialize(root.right)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n values = data.split(\",\")\n i = 0\n def dfs():\n nonlocal i\n if values[i] == 'None':\n i += 1\n return None\n node = TreeNode(int(values[i]))\n i += 1\n node.left = dfs()\n node.right = dfs()\n return node\n return dfs()\n\n \n\n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21300"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def dfs(node):\n if node is None:\n result.append(\"None\")\n return\n result.append(str(node.val))\n dfs(node.left)\n dfs(node.right)\n result=[]\n dfs(root)\n return \",\".join(result) \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def dfs():\n val=next(vals)\n if val==\"None\":\n return None\n node=TreeNode(int(val))\n node.left=dfs()\n node.right=dfs()\n return node\n \n vals=iter(data.split(\",\"))\n return dfs()\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21400"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n res = []\n def dfs(root):\n if not root:\n res.append(None)\n return\n \n res.append(root.val)\n dfs(root.left)\n dfs(root.right)\n \n dfs(root)\n return ' '.join(map(str, res))\n \n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n data = data.split()\n self.i = 0\n def dfs():\n if data[self.i] == 'None':\n self.i += 1\n return None\n node = TreeNode(val=int(data[self.i]))\n self.i += 1\n node.left = dfs()\n node.right = dfs()\n return node\n return dfs()\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21400"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n # global var\n ans = []\n\n def order(root):\n if not root:\n ans.append(\"null\")\n return\n\n ans.append(str(root.val))\n order(root.left)\n order(root.right)\n \n order(root)\n return \",\".join(ans)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n vals = data.split(\",\")\n self.i = 0\n\n def dfs():\n if vals[self.i] == \"null\":\n self.i += 1\n return None\n\n node = TreeNode(int(vals[self.i]))\n self.i += 1\n node.left = dfs()\n node.right = dfs()\n return node\n\n return dfs()\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21500"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n nodes = []\n\n def dfs(node) :\n if node is None:\n nodes.append('null')\n return\n \n nodes.append(str(node.val))\n dfs(node.left)\n dfs(node.right)\n \n dfs(root)\n return \",\".join(nodes)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n print(data)\n\n nodes = data.split(\",\")\n\n # [1,2,null,null,3,4,null,null,5,null,null]\n\n index = [0]\n\n def build() -> TreeNode:\n \n nodeIndex = index[0]\n\n if nodes[nodeIndex] == \"null\":\n return None\n \n node = TreeNode(int(nodes[nodeIndex])) # 1\n index[0] += 1\n node.left = build()\n index[0] += 1\n node.right = build()\n\n return node\n \n \n return build()\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21500"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n res = []\n def dfs(node):\n if not node:\n res.append(\"NA\")\n return\n res.append(str(node.val))\n dfs(node.left)\n dfs(node.right)\n dfs(root)\n return \",\".join(res)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n nodes = data.split(\",\")\n self.i = 0\n def dfs():\n if nodes[self.i] == \"NA\":\n self.i += 1\n return None\n node = TreeNode(int(nodes[self.i]))\n self.i += 1\n node.left = dfs()\n node.right = dfs()\n return node\n return dfs()\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21600"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n # def helper(root):\n # if not root:\n # return 0\n # return max(helper(root.left), helper(root.right)) + 1\n # h = helper(root)\n # res = [None] * (2**h - 1)\n # print(res)\n if not root:\n return \"\"\n res = [root.val]\n deq = collections.deque([root])\n while deq:\n for i in range(len(deq)):\n el = deq.popleft()\n if el.left:\n deq.append(el.left)\n if el.right:\n deq.append(el.right)\n res.append(el.left.val if el.left else None)\n res.append(el.right.val if el.right else None)\n # while not res[-1]:\n # res.pop()\n return \",\".join(map(str,res))\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data:\n return None\n data = list(map(lambda x: int(x) if x != \"None\" else None, data.split(',')))\n root = TreeNode(data[0])\n i = 1\n deq = collections.deque([root])\n while deq:\n tree = deq.popleft()\n if data[i] is not None:\n tree.left = TreeNode(data[i])\n deq.append(tree.left)\n if data[i + 1] is not None:\n tree.right = TreeNode(data[i + 1])\n deq.append(tree.right)\n i += 2\n print(root)\n return root\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21700"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return \"\"\n q = [(root,0)]; data = {}\n data[0] = root.val\n while q:\n node, indx = q.pop(0)\n if node.left:\n data[indx*2 + 1] = node.left.val\n q.append((node.left, indx*2 + 1))\n else:\n data[indx*2 + 1] = None\n if node.right:\n data[indx*2 + 2] = node.right.val\n q.append((node.right, indx*2 + 2))\n else:\n data[indx*2 + 2] = None\n d = \"\"\n for i in data.keys():\n if d:\n d += \" \"\n d += str(i) + \":\" + str(data[i])\n # print(d) \n return d\n\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n d = {}\n if not data:\n return []\n for i in data.split():\n key, val = i.split(\":\")\n key = int(key)\n if val != \"None\":\n val = int(val)\n else:\n val = None\n d[key] = val\n data = d\n root = None; nodes = {}\n nodes[0] = TreeNode(data[0])\n for i in sorted(data.keys()):\n if data[i] != None:\n root = nodes[i]\n if i*2 + 1 in data and data[i*2 + 1] != None:\n # print(i*2 + 1, \"left -->\", nodes[0])\n root.left = TreeNode(data[i*2 + 1])\n nodes[i*2 + 1] = root.left\n if i*2 + 2 in data and data[i*2 + 2] != None:\n # print(i*2 + 2, \"right -->\", nodes[0])\n root.right = TreeNode(data[i*2 + 2])\n nodes[i*2 + 2] = root.right\n return nodes[0]\n\n\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21700"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n # preorder traversal\n res = []\n def traverse(root):\n if not root:\n res.append(\"null\")\n return\n res.append(str(root.val))\n traverse(root.left)\n traverse(root.right)\n traverse(root)\n print(res)\n # the first is the root\n # second is the left\n # third is the right\n\n return \",\".join(res)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n data = data.split(\",\")\n\n # when returning, need to \"jump\" by number of nodes traversed\n # return when a null is reached\n # each node will look down two indicies\n created_nodes = [None] * len(data)\n def createNodeAndReturnNumberOfIndicies(index):\n if index > len(data) or data[index] == \"null\":\n return 1\n if not created_nodes[index] and data[index] != \"null\":\n created_nodes[index] = TreeNode(int(data[index]))\n indicies_left = createNodeAndReturnNumberOfIndicies(index + 1)\n right_index = index + indicies_left + 1\n indicies_right = createNodeAndReturnNumberOfIndicies(right_index)\n created_nodes[index].left = created_nodes[index + 1]\n created_nodes[index].right = created_nodes[right_index]\n return 1 + indicies_left + indicies_right\n \n createNodeAndReturnNumberOfIndicies(0)\n return created_nodes[0]\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"21800"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n self.list = []\n\n def _postorderTraversal(curr: TreeNode) -> None:\n if curr is None:\n self.list.append(\"None\")\n return\n\n _postorderTraversal(curr.left)\n _postorderTraversal(curr.right)\n self.list.append(str(curr.val))\n \n _postorderTraversal(root)\n \n print(\":\".join(self.list))\n return \":\".join(self.list)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data:\n return None\n \n self.list = data.split(\":\")\n self.index = len(self.list) - 1\n\n def _reversePostorderTraversal() -> Optional[TreeNode]:\n if self.index < 0:\n return None\n \n if self.list[self.index] == \"None\":\n self.index -= 1\n return None\n \n root = TreeNode(int(self.list[self.index]))\n self.index -= 1\n\n root.right = _reversePostorderTraversal()\n root.left = _reversePostorderTraversal()\n\n return root\n \n return _reversePostorderTraversal()\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"22100"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n # id:val:left_id:right_id\n # if not present, use *\n def __init__(self):\n self.id = 0\n def getId(self):\n self.id += 1\n return self.id\n\n def getRecords(self, id, node, records):\n # the node should be valid\n ans = str(id) + ':' + str(node.val) + ':'\n if node.left:\n left_id = self.getId()\n ans += str(left_id) + ':'\n self.getRecords(left_id, node.left, records)\n else:\n ans += '*:'\n \n if node.right:\n right_id = self.getId()\n ans += str(right_id)\n self.getRecords(right_id, node.right, records)\n else:\n ans += '*'\n records.append(ans)\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return \"\"\n records = []\n self.getRecords(0, root, records)\n return '|'.join(records)\n \n def build(self, id, map):\n print(id)\n val, left_id, right_id = map[id]\n res = TreeNode(val)\n if left_id != '*':\n res.left = self.build(int(left_id), map)\n if right_id != '*':\n res.right = self.build(int(right_id), map)\n return res\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data:\n return None\n records = data.split('|')\n map = {}\n for record in records:\n id, val, left_id, right_id = record.split(':')\n map[int(id)] = (int(val), left_id, right_id)\n\n return self.build(0, map)\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"22200"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\nimport json\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n self.res = []\n def rserialize(p_level):\n n_level = []\n atleast_one_node = False\n for node in p_level:\n # storing the parent level nodes in the self.res & the children nodes in n_level\n # check whether atleast one node exists in next level before making a call\n # idea based on how Leetcode serializes binary tree\n if node:\n self.res.append(str(node.val))\n if node.left or node.right:\n atleast_one_node = True\n n_level.append(node.left)\n n_level.append(node.right)\n else:\n self.res.append(str(node))\n if atleast_one_node:\n rserialize(n_level)\n p_level = [root]\n rserialize(p_level)\n res = \",\".join(self.res)\n return res\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n data = data.split(\",\")\n def rdeserialize(start,p_level):\n # start represents starting index of the children nodes\n ptr = start\n n_level = []\n for node in p_level:\n # if parent node is None, move to the next parent node\n if not node:\n continue\n # ptr indicates the index of the children node\n if ptr < len(data):\n node.left = TreeNode(int(data[ptr])) if data[ptr] != \"None\" else None\n n_level.append(node.left)\n ptr += 1\n if ptr < len(data):\n node.right = TreeNode(int(data[ptr])) if data[ptr] != \"None\" else None\n n_level.append(node.right)\n ptr += 1\n # n_level should have atleast one node or one none\n if n_level:\n rdeserialize(ptr,n_level)\n p_level = []\n if data[0] != \"None\":\n root_node = TreeNode(int(data[0]))\n p_level = [root_node]\n rdeserialize(1,p_level)\n return root_node\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"22300"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n storage = {}\n def helper(root, idx):\n if root == None:\n return\n storage[idx] = root.val\n helper(root.left, idx * 2)\n helper(root.right, idx * 2 + 1)\n helper(root, 1)\n answer = []\n for key, val in storage.items():\n answer.append(str(key) + \"*\" + str(val))\n return ','.join(answer)\n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == '':\n return None\n nodes = data.split(',')\n storage = {}\n for node in nodes:\n key = int(node.split(\"*\")[0])\n val = int(node.split(\"*\")[1])\n storage[key] = val\n def helper(idx):\n if idx in storage:\n node = TreeNode(storage[idx])\n node.left = helper(idx * 2)\n node.right = helper(idx * 2 + 1)\n return node\n else:\n return None\n return helper(1)\n\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"22400"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\n\nclass Codec:\n \"\"\"\n IDEA-2\n \n same as Idea-1, but lets try optimize a bit\n \"\"\"\n\n def serialize(self, root):\n n = 0\n entries = [] \n\n def do_indexing(node=root):\n nonlocal n, entries\n\n if not node:\n return \"\"\n \n curr_idx = n\n n += 1\n entries.append(\"\")\n\n idx_left = do_indexing(node.left)\n idx_right = do_indexing(node.right)\n\n entries[curr_idx] = str(node.val) + \"_\" + idx_left + \"_\" + idx_right\n\n return str(curr_idx)\n \n do_indexing()\n\n return \" \".join(entries)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data or not len(data):\n return None\n\n entries = data.split(\" \")\n n = len(entries)\n\n nodes = [entry.split(\"_\") for entry in entries]\n nodes_real = [TreeNode(int(nod[0])) for nod in nodes]\n\n for i in range(n):\n left_idx, right_idx = nodes[i][1], nodes[i][2]\n if left_idx:\n nodes_real[i].left = nodes_real[int(left_idx)]\n if right_idx:\n nodes_real[i].right = nodes_real[int(right_idx)]\n\n return nodes_real[0]\n\n\nclass Codec1:\n \"\"\"\n IDEA-1 \n\n > nodes value may not be unique\n\n what if we assign a number to each node.\n and store the left and right of nodes as that node's number\n We don't even need to assign the number, we can use array and array index can be that number.\n\n then it will look like\n [\n (node_value, left_index, right_index)\n .\n .\n .\n ]\n if left_index is empty, that mean it is None.\n\n to transform to string, we will store in \n \"nodeValue1_leftIndex1_rightIndex1 nodeValue2_leftIndex2_rightIndex2\"\n\n\n time: O(n)\n space: O(3n)\n \"\"\"\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n hmap = {} # node to index\n hmap[None] = \"\"\n n = 0\n nodes = []\n \n def do_indexing(node=root):\n nonlocal n, nodes, hmap\n\n if not node:\n return\n\n if node not in hmap:\n hmap[node] = n\n nodes.append((node, n))\n n += 1\n\n do_indexing(node.left)\n do_indexing(node.right)\n \n do_indexing()\n entries = [] \n for node in nodes:\n entry = str(node[0].val) + \"_\" + str(hmap[node[0].left]) + \"_\" + str(hmap[node[0].right])\n entries.append(entry)\n\n return \" \".join(entries)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data or not len(data):\n return None\n\n entries = data.split(\" \")\n n = len(entries)\n\n nodes = [entry.split(\"_\") for entry in entries]\n nodes_real = [TreeNode(int(nod[0])) for nod in nodes]\n\n for i in range(n):\n left_idx, right_idx = nodes[i][1], nodes[i][2]\n if left_idx:\n nodes_real[i].left = nodes_real[int(left_idx)]\n if right_idx:\n nodes_real[i].right = nodes_real[int(right_idx)]\n\n return nodes_real[0]\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"22500"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\nimport json\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def traverse(root):\n if not root:\n return None\n v = dict(val=root.val)\n if root.left:\n v['left'] = traverse(root.left)\n if root.right:\n v['right'] = traverse(root.right)\n return v\n\n v = traverse(root)\n return json.dumps(v)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def traverse(d):\n if not d:\n return None\n root = TreeNode(d['val'])\n root.left = traverse(d.get('left'))\n root.right = traverse(d.get('right'))\n return root\n\n return traverse(json.loads(data))\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"22600"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n res = []\n q = collections.deque()\n q.append(root)\n while q:\n node = q.popleft()\n if not node:\n res.append(\"null\")\n else: \n res.append(str(node.val)) \n q.append(node.left)\n q.append(node.right)\n \n # print(res)\n return \",\".join(res)\n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n data = data.split(\",\")\n # print(data)\n\n q = collections.deque()\n rootVal = data.pop(0)\n if rootVal == \"null\":\n return None\n\n root = TreeNode(rootVal)\n q.append(root)\n\n while q:\n node = q.popleft()\n if len(data) >= 2:\n left = data.pop(0)\n right = data.pop(0)\n node.left = TreeNode(left)\n node.right = TreeNode(right)\n q.append(node.left)\n q.append(node.right)\n\n return root\n\n\n\n# tree = TreeNode(1, TreeNode(2), TreeNode(3, TreeNode(4), TreeNode(5)))\n# ser = Codec()\n# # ser.serialize(tree)\n# # Your Codec object will be instantiated and called as such:\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(tree))","memory":"22700"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n res = []\n q = collections.deque()\n q.append(root)\n while q:\n node = q.popleft()\n if not node:\n res.append(\"null\")\n else: \n res.append(str(node.val)) \n q.append(node.left)\n q.append(node.right)\n \n # print(res)\n return \",\".join(res)\n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n data = data.split(\",\")\n # print(data)\n\n q = collections.deque()\n rootVal = data.pop(0)\n if rootVal == \"null\":\n return None\n\n root = TreeNode(rootVal)\n q.append(root)\n\n while q:\n node = q.popleft()\n if len(data) >= 2:\n left = data.pop(0)\n right = data.pop(0)\n node.left = TreeNode(left)\n node.right = TreeNode(right)\n q.append(node.left)\n q.append(node.right)\n\n return root\n\n\n\n# tree = TreeNode(1, TreeNode(2), TreeNode(3, TreeNode(4), TreeNode(5)))\n# ser = Codec()\n# # ser.serialize(tree)\n# # Your Codec object will be instantiated and called as such:\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(tree))","memory":"22700"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n l=[]\n def encode(root, position):\n if root==None:\n return\n l.append(str(position) + ',' + str(root.val))\n encode(root.left, 2*position+1)\n encode(root.right, 2*position+2)\n return\n\n encode(root, 0)\n print(';'.join(l))\n return ';'.join(l)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n l=data.split(';')\n if len(l)==0 or (len(l)==1 and l[0]==''):\n return None\n d={}\n for i in l:\n tup=i.split(',')\n d[int(tup[0])] = int(tup[1])\n print(d)\n nodes={}\n nodes[0] = TreeNode(d[0])\n def insertNode(position):\n if position in nodes:\n return\n if not ((position-1)//2) in nodes:\n insertNode((position-1)//2)\n nodes[position]=TreeNode(d[position])\n if position%2==0:\n nodes[(position-1)//2].right=nodes[position]\n else:\n nodes[(position-1)//2].left=nodes[position]\n return\n \n for i in d.keys():\n insertNode(i)\n \n return nodes[0]\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"22800"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n l=[]\n def encode(root, position):\n if root==None:\n return\n l.append(str(position) + ',' + str(root.val))\n encode(root.left, 2*position+1)\n encode(root.right, 2*position+2)\n return\n\n encode(root, 0)\n print(';'.join(l))\n return ';'.join(l)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n l=data.split(';')\n if len(l)==0 or (len(l)==1 and l[0]==''):\n return None\n d={}\n for i in l:\n tup=i.split(',')\n d[int(tup[0])] = int(tup[1])\n print(d)\n nodes={}\n nodes[0] = TreeNode(d[0])\n def insertNode(position):\n if position in nodes:\n return\n if not ((position-1)//2) in nodes:\n insertNode((position-1)//2)\n nodes[position]=TreeNode(d[position])\n if position%2==0:\n nodes[(position-1)//2].right=nodes[position]\n else:\n nodes[(position-1)//2].left=nodes[position]\n return\n \n for i in d.keys():\n insertNode(i)\n \n return nodes[0]\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"22800"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n serializedTree = []\n def dfs(root):\n if not root: return 0\n serializedTree.append(None)\n index = len(serializedTree) - 1\n nodesInLeft = dfs(root.left)\n nodesInRight = dfs(root.right)\n serializedTree[index] = (root.val,nodesInLeft,nodesInRight)\n return nodesInLeft + nodesInRight + 1\n dfs(root)\n return \",\".join([str(ele) for tup in serializedTree for ele in tup])\n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n data = [int(strnum) for strnum in data.split(\",\") if strnum]\n data = [(data[i],data[i+1],data[i+2]) for i in range(0,len(data),3)]\n def buildTree(start,end):\n if end < start: return\n val,numLeftNodes, numRightNodes = data[start]\n root = TreeNode(val)\n root.left = buildTree(start+1, start+numLeftNodes)\n root.right = buildTree(start+numLeftNodes+1, start+numLeftNodes+numRightNodes)\n return root\n return buildTree(0, len(data)-1)\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"22900"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n res = []\n q = collections.deque()\n\n if root:\n q.append(root)\n res.append(str(root.val))\n\n while q:\n for _ in range(len(q)):\n node = q.popleft()\n if node.left:\n q.append(node.left)\n res.append(str(node.left.val))\n else:\n res.append(\"null\")\n if node.right:\n q.append(node.right)\n res.append(str(node.right.val))\n else:\n res.append(\"null\")\n return \",\".join(res)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data:\n return []\n data = data.split(\",\")\n \n q = collections.deque()\n self.i = 1\n root = TreeNode(data[0])\n q.append(root)\n \n while q:\n node = q.popleft()\n if self.i < len(data):\n node.left = TreeNode(data[self.i])\n q.append(node.left)\n self.i += 1\n if self.i < len(data):\n node.right = TreeNode(data[self.i])\n q.append(node.right)\n self.i += 1\n return root\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23000"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n # Attempt to do as before\n # APPROACH: preorder traversal \"1(2(6,),3(4,5))\"\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return \"\"\n res = [str(root.val)]\n if root.left or root.right:\n res.append(\"(\")\n res.append(self.serialize(root.left))\n res.append(\",\")\n res.append(self.serialize(root.right))\n res.append(\")\")\n return \"\".join(res)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == \"\":\n return None\n if data.isnumeric() or data[0] == \"-\" and data[1:].isnumeric():\n return TreeNode(int(data))\n b = 0\n while data[b] != \"(\":\n b += 1\n c = b + 1\n brackets = 0\n while c < len(data):\n if data[c] == \"(\":\n brackets += 1\n if data[c] == \")\":\n brackets -= 1\n if brackets == 0 and data[c] == \",\":\n break\n c += 1\n res = TreeNode(int(data[:b]))\n res.left = self.deserialize(data[b + 1:c])\n res.right = self.deserialize(data[c + 1:-1])\n return res\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23100"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def serializeNodes(node):\n if not node:\n return None\n return {\n 'v': node.val,\n 'l': serializeNodes(node.left),\n 'r': serializeNodes(node.right),\n }\n return json.dumps(serializeNodes(root))\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def buildNode(data):\n if data == None:\n return None\n return TreeNode(\n val=data['v'],\n left=buildNode(data['l']),\n right=buildNode(data['r']),\n )\n return buildNode(json.loads(data))\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23100"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nimport json\n\nclass Codec:\n \n def serialize_to_json(self, node):\n if not node:\n return None\n response = dict()\n response[\"left\"] = self.serialize_to_json(node.left)\n response[\"right\"] = self.serialize_to_json(node.right)\n response[\"val\"] = node.val\n return response\n \n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n response = json.dumps(self.serialize_to_json(root))\n return response\n \n def deserialize_from_json(self, data):\n if not data:\n return None\n response = TreeNode(data[\"val\"])\n response.left = self.deserialize_from_json(data[\"left\"])\n response.right = self.deserialize_from_json(data[\"right\"])\n return response\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n \n return self.deserialize_from_json(json.loads(data))\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23200"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n # bfs traversal\n if not root:\n return \"\"\n arr = []\n def bfs(queue,level):\n nonlocal arr\n if not queue:\n return\n next_queue = collections.deque()\n while queue:\n node,idx = queue.pop()\n arr.append(str(idx)+\",\"+str(node.val))\n #arr[-1][idx]= str(node.val)\n if node.left != None:\n next_queue.append((node.left,idx*2+1))\n if node.right != None:\n next_queue.append((node.right,idx*2+2))\n if next_queue:\n bfs(next_queue,level+1)\n\n queue = collections.deque()\n queue.append((root,0))\n bfs(queue,0)\n \n return \"|\".join(arr)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == \"\":\n return []\n\n data = data.split(\"|\")\n inDict = dict()\n for d in data:\n d = d.split(\",\")\n ind,val = int(d[0]),int(d[1])\n inDict[ind]=val\n \n \n def build_tree(idx):\n if idx not in inDict:\n return None\n root = TreeNode(inDict[idx])\n root.left = build_tree(2*idx+1)\n root.right = build_tree(2*idx+2)\n return root\n\n root = build_tree(0)\n return root\n\n \n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23300"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root: TreeNode) -> str:\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n strings = [] \n nodes = [(0, root)]\n while nodes:\n idx, node = nodes.pop(0)\n if node is None:\n strings.append('null')\n continue\n strings.append(str(node.val) if node.val is not None else 'null')\n if node.val is not None:\n nodes.append((idx*2 + 1, node.left)) \n nodes.append((idx*2 + 2, node.right))\n if strings[0] == 'null':\n return ''\n return ','.join(strings)\n \n\n def deserialize(self, data: str) -> TreeNode:\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if len(data) > 0:\n data = data.split(',') \n n = len(data) \n nodes = [None for _ in range(n)] \n for idx in range(n-1,-1,-1): \n val = data[idx] \n left_node = nodes[idx*2 + 1] if idx*2+1 < n else None\n right_node = nodes[idx*2 + 2] if idx*2+2 < n else None\n node = TreeNode(val)\n node.left = left_node\n node.right = right_node\n nodes[idx] = node\n return nodes[0]\n else:\n return None\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23400"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if (root is None):\n return \"[]\"\n\n val = str(root.val)\n\n if (root.left is None):\n return \"[\" + val + \"[]\" + self.serialize(root.right) + \"]\"\n\n if (root.right is None):\n return \"[\" + val + self.serialize(root.left) + \"[]\" + \"]\"\n\n return \"[\" + val + self.serialize(root.left) + self.serialize(root.right) + \"]\"\n\n\n def find_closing_brace_idx(self, s):\n cnt = 1\n for i in range(1, len(s)):\n c = s[i]\n if c == \"[\":\n cnt += 1\n elif c == \"]\":\n cnt -= 1\n\n if cnt == 0:\n return i\n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n\n # [1 [2] [3 [4] [5]]]\n\n if data == \"[]\":\n return None\n\n left_tree_starting_brace = data[1:].index(\"[\") + 1\n left_tree_closing_brace = self.find_closing_brace_idx(data[left_tree_starting_brace:])\n left_tree_closing_brace += left_tree_starting_brace\n\n left = self.deserialize(data[left_tree_starting_brace: left_tree_closing_brace + 1])\n right = self.deserialize(data[left_tree_closing_brace + 1: -1])\n\n val = int(data[1: left_tree_starting_brace])\n\n root = TreeNode(val)\n root.left = left\n root.right = right\n\n return root\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23500"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if (root is None):\n return \"[]\"\n\n val = str(root.val)\n\n if (root.left is None):\n return \"[\" + val + \"[]\" + self.serialize(root.right) + \"]\"\n\n if (root.right is None):\n return \"[\" + val + self.serialize(root.left) + \"[]\" + \"]\"\n\n return \"[\" + val + self.serialize(root.left) + self.serialize(root.right) + \"]\"\n\n\n \n\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n\n def find_closing_brace_idx(s):\n cnt = 1\n for i in range(1, len(s)):\n c = s[i]\n if c == \"[\":\n cnt += 1\n elif c == \"]\":\n cnt -= 1\n\n if cnt == 0:\n return i\n\n if data == \"[]\":\n return None\n\n left_tree_starting_brace = data[1:].index(\"[\") + 1\n left_tree_closing_brace = find_closing_brace_idx(data[left_tree_starting_brace:])\n left_tree_closing_brace += left_tree_starting_brace\n\n left = self.deserialize(data[left_tree_starting_brace: left_tree_closing_brace + 1])\n right = self.deserialize(data[left_tree_closing_brace + 1: -1])\n\n val = int(data[1: left_tree_starting_brace])\n\n root = TreeNode(val)\n root.left = left\n root.right = right\n\n return root\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23500"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root: return '()'\n return '(' + str(root.val) + self.serialize(root.left) + self.serialize(root.right) + ')' \n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == '()':\n return None\n i = 1\n while data[i] != '(':\n i += 1\n\n root = TreeNode(int(data[1:i]))\n count = 1\n left1 = i\n right1 = i+1\n while count:\n if data[right1] == '(':\n count += 1\n elif data[right1] == ')':\n count -= 1\n right1 += 1\n left2 = right1\n right1 -= 1\n right2 = len(data) - 2\n\n root.left = self.deserialize(data[left1:right1+1])\n root.right = self.deserialize(data[left2:right2+1])\n\n return root\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23600"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root: return '()'\n return '(' + str(root.val) + self.serialize(root.left) + self.serialize(root.right) + ')' \n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == '()':\n return None\n i = 1\n while data[i] != '(':\n i += 1\n\n root = TreeNode(int(data[1:i]))\n count = 1\n left1 = i\n right1 = i+1\n while count:\n if data[right1] == '(':\n count += 1\n elif data[right1] == ')':\n count -= 1\n right1 += 1\n left2 = right1\n right1 -= 1\n right2 = len(data) - 2\n\n root.left = self.deserialize(data[left1:right1+1])\n root.right = self.deserialize(data[left2:right2+1])\n\n return root\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23600"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def dfs(root):\n if root == None:\n return \"\"\n l = dfs(root.left)\n r = dfs(root.right)\n return str(root.val) + \"{\" + l + \"}\" + \"{\" + r + \"}\"\n return dfs(root)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def dfs(s):\n # print(s, \"--s\")\n if len(s) == 0:\n return None\n n = len(s)\n val = \"\"\n i = 0\n while s[i] != \"{\":\n val += s[i]\n i += 1\n # print(val, \"--val\")\n node = TreeNode(int(val))\n\n \n st = [\"{\"]\n l = \"\"\n i += 1\n while i < n:\n if s[i] == \"}\":\n if len(st) == 1:\n st.pop()\n break\n else:\n st.pop()\n elif s[i] == \"{\":\n st.append(\"{\")\n l += s[i]\n i += 1\n # print(l, \"--l\")\n # print(s[i+2:-1], \"--r\")\n\n node.left = dfs(l)\n node.right = dfs(s[i+2:-1])\n return node\n # print(data)\n return dfs(data)\n\n\n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23700"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return \"\"\n return f\"{root.val}[{self.serialize(root.left)}][{self.serialize(root.right)}]\"\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n brackets = {}\n stack = []\n for index, char in enumerate(data):\n if char == \"[\":\n stack.append(index)\n elif char == \"]\":\n brackets[stack.pop()] = index\n # print(data)\n def f(left, right):\n # print(left, right)\n if left > right:\n return None\n i = left + 1\n while i <= right and data[i].isdigit():\n i += 1\n # print(left, i)\n val = int(data[left:i])\n node = TreeNode(val)\n if i < right:\n left_open = i\n left_close = brackets[left_open]\n right_open = left_close + 1\n right_close = brackets[right_open]\n node.left = f(left_open + 1, left_close - 1)\n node.right = f(right_open + 1, right_close - 1)\n return node\n return f(0, len(data) - 1)\n\n\n \n\n\n \n\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23800"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nimport pickle\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n r = pickle.dumps(root)\n s = r.hex()\n return s\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n b = bytes.fromhex(data)\n r = pickle.loads(b, encoding='bytes')\n return r\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"23900"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def dfs(root, st):\n if not root:\n st += \"#,\"\n else:\n st += f\"{root.val},\"\n st = dfs(root.left, st)\n st = dfs(root.right, st)\n return st\n return dfs(root, \"\")\n\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n arr = data.split(\",\")\n \n def dfs(arr):\n if arr[0] == \"#\":\n arr.pop(0)\n return None\n \n root = TreeNode(arr[0])\n arr.pop(0)\n root.left = dfs(arr)\n root.right = dfs(arr)\n return root\n \n return dfs(arr)\n\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"24000"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def helper(root, out):\n if not root:\n out += '#,'\n else:\n out += '{},'.format(root.val)\n out = helper(root.left, out)\n out = helper(root.right, out)\n return out\n out = ''\n \n return helper(root, out)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def helper(l):\n l0 = l.pop(0)\n if l0 == '#':\n return None\n root = TreeNode(l0)\n root.left = helper(l)\n root.right = helper(l)\n return root\n l = data.split(',')\n root = helper(l)\n return root\n\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"24100"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nimport pickle\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n r = pickle.dumps(root)\n s = r.hex()\n return s\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n b = bytes.fromhex(data)\n r = pickle.loads(b, encoding='bytes')\n print(\"decode\", r)\n return r\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"24200"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\nimport json\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def dfs(r=root):\n if r is None:\n return None \n else:\n if r.left and r.right:\n return {'root': r.val, 'left': dfs(r.left), 'right': dfs(r.right)}\n elif r.left:\n return {'root': r.val, 'left': dfs(r.left), 'right': None}\n elif r.right:\n return {'root': r.val, 'left': None, 'right': dfs(r.right)}\n else:\n return {'root': r.val, 'left':None, 'right':None}\n return json.dumps(dfs())\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def dfs(tdict):\n if tdict is None:\n return None\n root = TreeNode(tdict['root'])\n l = r= None\n if tdict['left']:\n l = dfs(tdict['left'])\n if tdict['right']:\n r = dfs(tdict['right'])\n root.left = l\n root.right = r\n return root\n treeDict = json.loads(data)\n #print(treeDict)\n return dfs(treeDict)\n\n\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"24300"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n res = \"\"\n def doit(node, res):\n if not node:\n res += \"# \"\n else:\n res += f\"{node.val} \"\n res = doit(node.left, res)\n res = doit(node.right, res)\n return res\n\n return doit(root, \"\")\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def doit():\n val = next(vals)\n if val == \"#\":\n return None\n node = TreeNode(int(val))\n node.left = doit()\n node.right = doit()\n return node\n \n vals = iter(data.strip().split())\n return doit()\n\n\n # data_list = deque(data.strip().split())\n # # create dummy node that points to root\n # head = TreeNode(\"head\")\n # node_val = data_list.popleft()\n # if node_val != \"null\":\n # root = TreeNode(int(node_val))\n # head.right = root\n # roots = [] # keeps track of past roots so we can access them\n # while data_list:\n # while root:\n # roots.append(root)\n # node_val = data_list.popleft()\n # if node_val != \"null\":\n # root.left = TreeNode(int(node_val))\n # root = root.left\n \n # root = roots.pop()\n # node_val = data_list.popleft()\n # if node_val != \"null\":\n # root.right = TreeNode(int(node_val))\n # root = root.right\n \n # return head.right\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"24400"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if root == None:\n return \"\"\n ids = dict()\n s = [root]\n c = 0\n while s:\n n = s.pop()\n if n != None:\n ids[n] = c\n c += 1\n if n.left:\n s.append(n.left)\n if n.right:\n s.append(n.right)\n rt = ids[root]\n data = []\n s = [root]\n while s:\n n = s.pop()\n data_element=[str(ids[n]), str(n.val)]\n if n.left:\n s.append(n.left)\n data_element.append(str(ids[n.left]))\n else:\n data_element.append('N')\n if n.right:\n s.append(n.right)\n data_element.append(str(ids[n.right]))\n else:\n data_element.append('N')\n data.append(data_element)\n els = \"\"\n for e in data:\n if els == \"\":\n els += \",\".join(e)\n else:\n els += \"DEL\" + \",\".join(e)\n final = f\"{rt}|{els}\"\n return final\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data:\n return None\n def build(id, adj, el):\n if id == None:\n None\n else:\n return TreeNode(el[id], build(adj[id][0], adj, el), build(adj[id][1], adj, el))\n\n def tfm(c):\n if c == 'N':\n return None\n else:\n return int(c)\n root = tfm(data.split('|')[0])\n datas = list(map(lambda x: x.split(\",\"), data.split(\"|\")[1].split(\"DEL\")))\n d = dict()\n adj = dict()\n for e in datas:\n d[int(e[0])] = int(e[1])\n adj[int(e[0])] = [tfm(e[2]), tfm(e[3])]\n return build(root, adj, d)\n \n\n\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"24600"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n if root == None:\n return \"\"\n return \"{\" + str(root.val) + \"}{\" + self.serialize(root.left) + \"}{\" + self.serialize(root.right) + \"}\"\n \n\n def deserialize(self, data):\n brackets = 0\n part = 0; prev = 1\n root = None\n for i, c in enumerate(data):\n if c == \"{\":\n brackets += 1\n elif c == \"}\":\n brackets -= 1\n if brackets == 0:\n if part == 0:\n root = TreeNode(int(data[prev:i]))\n elif part == 1:\n root.left = self.deserialize(data[prev:i])\n else:\n root.right = self.deserialize(data[prev:i])\n part += 1\n prev = i + 2\n return root\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"24700"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if root is None:\n return \"[]\"\n return f\"[{root.val},{self.serialize(root.left)},{self.serialize(root.right)}]\"\n\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == '[]':\n return None\n closed = 0\n val = ''\n leftData = ''\n rightData = ''\n tmp = ''\n for i in range(len(data)):\n if i == 0:\n continue\n if len(val) == 0:\n if data[i] == ',' and closed == 0:\n val = tmp\n tmp = ''\n continue\n elif len(leftData) == 0:\n if data[i] == ',' and closed == 0:\n leftData = tmp\n tmp = ''\n continue\n else:\n if data[i] == ']' and closed == 0:\n rightData = tmp\n tmp = ''\n continue\n tmp += data[i]\n if data[i] == '[':\n closed += 1\n elif data[i] == ']':\n closed -= 1\n return TreeNode(int(val), self.deserialize(leftData), self.deserialize(rightData))\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"24800"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n pre_s = ''\n in_s = ''\n\n index = 45\n\n def preorder(root):\n nonlocal pre_s, index\n if root == None:\n return\n root.index = index\n pre_s += chr(root.val + 1045) + '#' + chr(index) + ','\n index += 1\n preorder(root.left)\n preorder(root.right)\n \n def inorder(root):\n nonlocal in_s\n if root == None:\n return\n inorder(root.left)\n in_s += chr(root.val + 1045) + '#' + chr(root.index) + ','\n inorder(root.right)\n\n preorder(root)\n inorder(root)\n return pre_s[:-1] + '+' + in_s[:-1]\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n [preorder, inorder] = [d.split(',') if len(d) > 0 else [] for d in data.split('+')]\n inorder_map = {}\n for i, num in enumerate(inorder):\n inorder_map[num] = i\n index = 0\n\n def construct(left, right):\n nonlocal index\n if left > right:\n return None\n val_and_idx = preorder[index]\n [val, node_idx] = val_and_idx.split('#')\n val = ord(val) - 1045\n root = TreeNode(val)\n index += 1\n root.left = construct(left, inorder_map[val_and_idx] - 1)\n root.right = construct(inorder_map[val_and_idx] + 1, right)\n return root\n \n return construct(0, len(inorder) - 1)\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"25000"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n DELIMITER = '#'\n NULL = 'NULL'\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root: return self.NULL\n\n \n left_serialized = self.serialize(root.left)\n right_serialized = self.serialize(root.right)\n \n serialized = str(root.val)\n serialized += f'{self.DELIMITER}{str(len(left_serialized))}{self.DELIMITER}'\n serialized += left_serialized\n serialized += right_serialized\n return serialized\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == self.NULL: return None\n first_delimiter = None\n second_delimiter = None\n for idx in range(len(data)):\n if data[idx] == self.DELIMITER:\n if first_delimiter is None:\n first_delimiter = idx\n continue\n elif second_delimiter is None:\n second_delimiter = idx\n continue\n else:\n break\n \n root = TreeNode(int(data[:first_delimiter]))\n len_left_serialized = int(data[first_delimiter + 1: second_delimiter])\n root.left = self.deserialize(data[second_delimiter + 1:second_delimiter + 1 + len_left_serialized])\n root.right = self.deserialize(data[second_delimiter + 1 + len_left_serialized:])\n return root\n\n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"25100"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n # pre root l r\n # in l root r\n self.preOrderArr = []\n self.inOrderArr = []\n def preOrder(root, level):\n if root:\n self.preOrderArr.append(str(root.val) + \":\" + str(level))\n preOrder(root.left, level+1)\n preOrder(root.right, level+1)\n def inOrder(root, level):\n if root:\n inOrder(root.left, level +1)\n self.inOrderArr.append(str(root.val) + \":\" + str(level))\n inOrder(root.right, level +1)\n\n preOrder(root, 0)\n inOrder(root, 0)\n return \",\".join(self.preOrderArr) + \"@\" + \",\".join(self.inOrderArr)\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if \"@\" == data:\n return None\n data = data.split(\"@\")\n preOrderArr = data[0].split(\",\")\n inOrderArr = data[1].split(\",\")\n\n print(preOrderArr, inOrderArr)\n\n def constructTree(preOrderArr, inOrderArr):\n if inOrderArr:\n val = preOrderArr.pop(0)\n idx = inOrderArr.index(val)\n return TreeNode(int(val.split(\":\")[0]), constructTree(preOrderArr, inOrderArr[:idx]), constructTree(preOrderArr, inOrderArr[idx+1:]))\n\n return constructTree(preOrderArr, inOrderArr)\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"25200"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def preorder(node: TreeNode, result: List[int]=[]) -> List[int]:\n if node == None:\n return result\n \n result.append(f\"{id(node)}:{node.val}\")\n preorder(node.left, result)\n preorder(node.right, result)\n return result\n \n def inorder(node: TreeNode, result: List[int]=[]) -> List[int]:\n if node == None:\n return result\n \n inorder(node.left, result)\n result.append(f\"{id(node)}:{node.val}\")\n inorder(node.right, result)\n return result\n \n preorder_str = \",\".join(preorder(root))\n inorder_str = \",\".join(inorder(root))\n\n return f\"{preorder_str}\\n{inorder_str}\"\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n preorder_str, inorder_str = data.split(\"\\n\")\n if len(inorder_str) == 0:\n return None\n \n preorder = []\n for entry in preorder_str.split(\",\"):\n nodeid, val = entry.split(\":\")\n preorder.append((int(nodeid), int(val)))\n \n inorder = []\n for entry in inorder_str.split(\",\"):\n nodeid, val = entry.split(\":\")\n inorder.append((int(nodeid), int(val)))\n\n def buildTree(preorder: List[Tuple[int, int]], inorder: List[Tuple[int, int]]) -> TreeNode:\n if len(inorder) == 0:\n return None\n nodeid, val = next(preorder)\n node = TreeNode(val)\n partition = inorder.index((nodeid, val))\n node.left = buildTree(preorder, inorder[:partition])\n node.right = buildTree(preorder, inorder[partition + 1:])\n return node\n \n return buildTree(iter(preorder), inorder)\n\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"25300"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n tree = defaultdict(list)\n def traverse(node, rootNode=False):\n if not node:\n return None\n if rootNode:\n key = 'root'\n else:\n key = str(id(node))\n tree[key].append(node.val)\n tree[key].append(traverse(node.left))\n tree[key].append(traverse(node.right))\n\n return key\n \n traverse(root, rootNode=True)\n print(json.dumps(tree))\n return json.dumps(tree)\n\n \n \n \n\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n tree = json.loads(data)\n def traverse(node):\n if not node:\n return None\n treeNode = TreeNode(tree[node][0])\n treeNode.left = traverse(tree[node][1])\n treeNode.right = traverse(tree[node][2])\n return treeNode\n if not tree:\n return None\n root = traverse('root')\n\n return root\n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"25400"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n def serialize(self, root):\n def DFS_pack(node):\n if not node: return \"None\"\n s = \"{\" + str(node.val) + \",\"\n s = s + DFS_pack(node.left) + \",\"\n s = s + DFS_pack(node.right) + \"}\"\n return s\n if not root: return \"\"\n return DFS_pack(root)\n def deserialize(self, data):\n def DFS_unpack(S):\n if S==\"None\" or not S: return None \n n1 = 0\n while n1<len(S) and S[n1]!=',': n1 += 1\n v = S[1:n1] # value\n if S[n1+1:].startswith(\"None\"): n2 = n1 + 5\n else:\n n2, c1, c2 = 0, 0, 0\n for i in range(n1+1, len(S)):\n if S[i]==\"{\": c1 += 1\n elif S[i]==\"}\": c2 += 1\n if c1>0 and c1==c2: \n n2 = i + 1\n break\n L = S[n1+1:n2] # left child \n R = S[n2+1:len(S)-1] # right child \n left = DFS_unpack(L)\n right = DFS_unpack(R)\n node = TreeNode(v)\n node.left = left\n node.right = right\n return node \n return DFS_unpack(data) \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"25600"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n def serialize(self, root):\n def DFS_pack(node):\n if not node: return \"None\"\n s = \"{\" + str(node.val) + \",\"\n s = s + DFS_pack(node.left) + \",\"\n s = s + DFS_pack(node.right) + \"}\"\n return s\n return DFS_pack(root)\n def deserialize(self, data):\n def DFS_unpack(S):\n if S==\"None\" or not S: return None \n n1 = 0\n while n1<len(S) and S[n1]!=',': n1 += 1\n v = S[1:n1] # value\n if S[n1+1:].startswith(\"None\"): n2 = n1 + 5\n else:\n n2, c1, c2 = 0, 0, 0\n for i in range(n1+1, len(S)):\n if S[i]==\"{\": c1 += 1\n elif S[i]==\"}\": c2 += 1\n if c1>0 and c1==c2: \n n2 = i + 1\n break\n L = S[n1+1:n2] # left child \n R = S[n2+1:len(S)-1] # right child \n left = DFS_unpack(L)\n right = DFS_unpack(R)\n node = TreeNode(v)\n node.left = left\n node.right = right\n return node \n return DFS_unpack(data) \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"25600"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n \"\"\"\n > nodes value may not be unique\n\n what if we assign a number to each node.\n and store the left and right of nodes as that node's number\n We don't even need to assign the number, we can use array and array index can be that number.\n\n then it will look like\n [\n (node_value, left_index, right_index)\n .\n .\n .\n ]\n if left_index is empty, that mean it is None.\n \"\"\"\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n hmap = {} # node to index\n hmap[None] = \"\"\n n = 0\n nodes = []\n \n def do_indexing(node=root):\n nonlocal n, nodes, hmap\n\n if not node:\n return\n\n if node not in hmap:\n hmap[node] = n\n nodes.append((node, n))\n n += 1\n\n do_indexing(node.left)\n do_indexing(node.right)\n \n do_indexing()\n entries = [] \n for node in nodes:\n entry = str(node[0].val) + \"_\" + str(hmap[node[0].left]) + \"_\" + str(hmap[node[0].right])\n entries.append(entry)\n\n return \" \".join(entries)\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if not data or not len(data):\n return None\n \n entries = data.split(\" \")\n n = len(entries)\n\n nodes = [entry.split(\"_\") for entry in entries]\n print(nodes)\n nodes_real = [TreeNode(int(nod[0])) for nod in nodes]\n\n for i in range(n):\n left_idx, right_idx = nodes[i][1], nodes[i][2]\n if left_idx:\n nodes_real[i].left = nodes_real[int(left_idx)]\n if right_idx:\n nodes_real[i].right = nodes_real[int(right_idx)]\n\n return nodes_real[0]\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"25700"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n\n if not root:\n return '-1001'\n\n return f'{root.val}({self.serialize(root.left)} {self.serialize(root.right)})'\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n\n value_str = ''\n \n # extract root value\n i = 0\n while i != len(data) and data[i] not in '( )':\n value_str += data[i]\n i += 1\n \n # skip '(/ /)'\n i += 1\n\n # identify None value\n if value_str == '-1001':\n return None\n\n node = TreeNode( int(value_str) )\n\n # find new_data for recursion\n left = right = ''\n brackets_opened = 0\n # len(data) - 1 bcs we don't want to include ')'\n while i < len(data) - 1:\n if data[i] == '(':\n brackets_opened += 1\n elif data[i] == ')':\n brackets_opened -= 1\n \n if brackets_opened == 0 and data[i] == ' ':\n left, right = right, left\n else:\n right += data[i]\n \n i += 1\n\n node.left = self.deserialize(left)\n node.right = self.deserialize(right)\n\n return node\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"25800"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n \n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n \n def serialize_recursive(node, string):\n if not node:\n string += 'end,'\n else:\n string += str(node.val) + ','\n string = serialize_recursive(node.left, string)\n string = serialize_recursive(node.right, string)\n \n return string\n \n return serialize_recursive(root, '')\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n \n def deserialize_recursive(l):\n if l[0] == 'end':\n l.pop(0)\n return None\n \n node = TreeNode(l[0])\n l.pop(0)\n node.left = deserialize_recursive(l)\n node.right = deserialize_recursive(l)\n \n return node\n \n \n data_list = data.split(',')\n return deserialize_recursive(data_list)\n \n\n \n \n \n \n \n \n \n \n \n\n# def serialize(self, root):\n# \"\"\"Encodes a tree to a single string.\n \n# :type root: TreeNode\n# :rtype: str\n# \"\"\"\n# def rserialize(root, string):\n# if not root:\n# string += 'None,' # indicate end of tree\n# else:\n# # preorder traversal\n# string += str(root.val) + ','\n# string = rserialize(root.left, string)\n# string = rserialize(root.right, string)\n \n# return string\n \n# return rserialize(root, '')\n \n\n# def deserialize(self, data):\n# \"\"\"Decodes your encoded data to tree.\n \n# :type data: str\n# :rtype: TreeNode\n# \"\"\"\n\n# def rdeserialize(l):\n# if l[0] == 'None':\n# l.pop(0)\n# return None\n \n# root = TreeNode(l[0])\n# l.pop(0)\n# root.left = rdeserialize(l)\n# root.right = rdeserialize(l)\n# return root\n \n# data_list = data.split(',')\n# root = rdeserialize(data_list) \n# return root\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"25900"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n #follow format of val<left>right with n being there in place of values right or left if they are none \n if root == None: \n return \"n\"\n return f\"{root.val}<{self.serialize(root.left)}>{self.serialize(root.right)}\"\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n \n if data == \"n\": \n return None\n \n \n root_val_string = ''\n for i in range(len(data)):\n if data[i] == '<': \n data = data[i+1:]\n break\n else: \n root_val_string += data[i]\n \n right_string = ''\n left_string = ''\n open_count = 1 \n close_count = 0\n for i in range(len(data)):\n if data[i] == '<':\n left_string += data[i]\n open_count += 1 \n elif data[i] == '>': \n close_count += 1 \n if open_count == close_count:\n right_string = data[i+1:]\n break \n else: \n left_string += data[i]\n else: \n left_string += data[i]\n \n \n root = TreeNode(val=int(root_val_string))\n root.left = self.deserialize(left_string) \n root.right = self.deserialize(right_string)\n return root \n \n \n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"26000"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n if not root:\n return \"\"\n\n root_val = str(root.val)\n root_len = len(root_val)\n\n left_child = self.serialize(root.left)\n left_child_len = len(left_child)\n\n right_child = self.serialize(root.right)\n right_child_len = len(right_child)\n\n return f'{root_len}#{left_child_len}#{right_child_len}#{root_val}{left_child}{right_child}'\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n if data == \"\":\n return None\n hash_count = 0\n count = 0\n i = 0\n stack = []\n while hash_count != 3:\n if data[i] == \"#\":\n hash_count += 1\n stack.append(count)\n count = 0\n else:\n count = count*10 + int(data[i])\n i += 1\n r_val = data[i:i+stack[0]]\n lc_val = data[i+stack[0]: i + stack[0] + stack[1]]\n rc_val = data[i+stack[0]+stack[1]: i + stack[0] + stack[1]+stack[2]]\n\n root = TreeNode(int(r_val))\n left_child = self.deserialize(lc_val)\n right_child = self.deserialize(rc_val)\n root.left = left_child\n root.right = right_child\n \n return root\n \n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"26100"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n output = []\n to_process = [root]\n while to_process:\n current = to_process.pop(0)\n if current is not None:\n output.append(current.val)\n to_process.append(current.left)\n to_process.append(current.right)\n else:\n output.append(None)\n while output and output[-1] is None:\n output.pop()\n return (\"[\" + \",\".join([str(o) for o in output]) + \"]\").replace(\"None\", \"null\")\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n data_list = eval(data.replace(\"null\", \"None\"))\n if not data_list:\n return None\n root = TreeNode(data_list.pop(0))\n n = len(data_list)\n to_process = [root]\n for i in range(n)[::2]:\n val_left = data_list[i]\n if i + 1 < n:\n val_right = data_list[i + 1]\n add_right = True\n else:\n add_right = False\n node = to_process.pop(0)\n # Add val_left\n if val_left is None:\n node.left = None\n else:\n node.left = TreeNode(val_left)\n to_process.append(node.left)\n # Add val_right\n if add_right:\n if val_right is None:\n node.right = None\n else:\n node.right = TreeNode(val_right)\n to_process.append(node.right)\n\n return root\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"26300"},{"code":"def getList(root: Optional[TreeNode]):\n ans: list[None | int] = []\n queue = [root]\n while len(queue) > 0:\n top = queue.pop(0)\n if top is not None:\n ans.append(top.val)\n else:\n ans.append(None)\n if top:\n queue.append(top.left)\n queue.append(top.right)\n\n # remove all None from end of ans\n i = len(ans) - 1\n while i >= 0 and ans[i] == None:\n i -= 1\n return ans[0: i + 1]\n\n\ndef formTree(values: list[int | None]):\n if not values:\n return None\n if values[0] is None:\n return None\n root = TreeNode(values[0])\n queue: List[Optional[TreeNode]] = [root]\n i = 1\n while i < len(values):\n top = queue.pop(0)\n if top is not None:\n top.left = TreeNode(values[i]) if values[i] != None else None\n i += 1\n queue.append(top.left)\n if i < len(values):\n top.right = TreeNode(values[i]) if values[i] != None else None\n i += 1\n queue.append(top.right)\n else:\n continue\n return root\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n return str(getList(root))\n \n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n return formTree(eval(data))\n\n \n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"26400"},{"code":"class Codec:\n def serialize(self, root):\n if not root:\n return \"N\"\n left = self.serialize(root.left)\n right = self.serialize(root.right)\n return f\"{root.val},{len(left)}:{left},{len(right)}:{right}\"\n\n def deserialize(self, data):\n end = 0\n while end < len(data) and data[end] != \",\":\n end += 1\n\n if data[:end] == \"N\":\n return None\n\n val = int(data[:end])\n\n start = end + 1\n end = start\n while end < len(data) and data[end] != \":\":\n end += 1\n length = int(data[start:end])\n left = data[end + 1 : end + 1 + length]\n\n start = end + 1 + length + 1\n end = start\n while end < len(data) and data[end] != \":\":\n end += 1\n length = int(data[start:end])\n right = data[end + 1 : end + 1 + length]\n\n node = TreeNode(val)\n node.left = self.deserialize(left)\n node.right = self.deserialize(right)\n return node","memory":"26500"},{"code":"# Definition for a binary tree node.\n# class TreeNode(object):\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Codec:\n\n def serialize(self, root):\n \"\"\"Encodes a tree to a single string.\n \n :type root: TreeNode\n :rtype: str\n \"\"\"\n def helper(root, string):\n if root is None:\n string += 'None,'\n else:\n string += str(root.val) + ','\n string = helper(root.left, string)\n string = helper(root.right, string)\n \n return string\n return helper(root, \"\")\n\n def deserialize(self, data):\n \"\"\"Decodes your encoded data to tree.\n \n :type data: str\n :rtype: TreeNode\n \"\"\"\n def helper(l):\n if l[0] == 'None':\n l.pop(0)\n return None\n \n root = TreeNode(l[0])\n l.pop(0)\n root.left = helper(l)\n root.right = helper(l)\n return root\n \n datal = data.split(',')\n root = helper(datal)\n return root\n\n# Your Codec object will be instantiated and called as such:\n# ser = Codec()\n# deser = Codec()\n# ans = deser.deserialize(ser.serialize(root))","memory":"26600"}],"string":"[\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n global r\\n r = root\\n return \\\"\\\"\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n return r\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"18700\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nfrom collections import deque\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = \\\"\\\"\\n \\n q = deque()\\n\\n q.append(root)\\n\\n while q:\\n length = len(q)\\n\\n for _ in range(length):\\n\\n curr = q.popleft()\\n if not curr:\\n res += \\\"*\\\"\\n else:\\n res += 's'\\n res += str(curr.val)\\n res += 'e'\\n if curr:\\n q.append(curr.left)\\n q.append(curr.right)\\n \\n \\n return res\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n arr = []\\n\\n print(data)\\n\\n startWordIndex = -1\\n\\n for i in range(len(data)):\\n if data[i] == '*':\\n arr.append(None)\\n if data[i] == 's':\\n startWordIndex = i\\n if data[i] == 'e':\\n arr.append(int(data[startWordIndex+1:i]))\\n\\n while arr and arr[-1] is None: # or use 'null' if that is the marker\\n arr.pop()\\n\\n return arr\\n q = deque()\\n\\n root = TreeNode(val = arr[0])\\n\\n q.append(root)\\n\\n i = 0\\n\\n while q:\\n length = len(q)\\n\\n for _ in range(length):\\n\\n curr = q.popleft()\\n\\n\\n if i + 1 < len(arr) and arr[i+1] != None:\\n\\n leftie = TreeNode(val = arr[i+1])\\n curr.left = leftie\\n q.append(leftie)\\n else:\\n curr.left = None\\n \\n if i + 2 < len(arr) and arr[i+2] != None:\\n rightie = TreeNode(val = arr[i+2])\\n curr.right = rightie\\n q.append(rightie)\\n else:\\n curr.right = None\\n i = i + length\\n return root\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nfrom collections import deque\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = \\\"\\\"\\n \\n q = deque()\\n\\n q.append(root)\\n\\n while q:\\n length = len(q)\\n\\n for _ in range(length):\\n\\n curr = q.popleft()\\n if not curr:\\n res += \\\"*\\\"\\n else:\\n res += 's'\\n res += str(curr.val)\\n res += 'e'\\n if curr:\\n q.append(curr.left)\\n q.append(curr.right)\\n \\n \\n return res\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n arr = []\\n\\n print(data)\\n\\n startWordIndex = -1\\n\\n for i in range(len(data)):\\n if data[i] == '*':\\n arr.append(None)\\n if data[i] == 's':\\n startWordIndex = i\\n if data[i] == 'e':\\n arr.append(int(data[startWordIndex+1:i]))\\n\\n while arr and arr[-1] is None: # or use 'null' if that is the marker\\n arr.pop()\\n\\n return arr\\n q = deque()\\n\\n root = TreeNode(val = arr[0])\\n\\n q.append(root)\\n\\n i = 0\\n\\n while q:\\n length = len(q)\\n\\n for _ in range(length):\\n\\n curr = q.popleft()\\n\\n\\n if i + 1 < len(arr) and arr[i+1] != None:\\n\\n leftie = TreeNode(val = arr[i+1])\\n curr.left = leftie\\n q.append(leftie)\\n else:\\n curr.left = None\\n \\n if i + 2 < len(arr) and arr[i+2] != None:\\n rightie = TreeNode(val = arr[i+2])\\n curr.right = rightie\\n q.append(rightie)\\n else:\\n curr.right = None\\n i = i + length\\n return root\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n if not root:\\n return \\\"\\\"\\n \\n res = \\\"\\\"\\n queue = collections.deque()\\n queue.append(root)\\n\\n while queue:\\n q = len(queue)\\n\\n for i in range(q):\\n node = queue.popleft()\\n if node:\\n res += str(node.val)\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n res += 'null'\\n res += ' '\\n # res += ' ' \\n return res\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n res = []\\n data = data.strip()\\n data = data.split()\\n for i in range(len(data) - 1, -1, -1):\\n if data[i] == 'null':\\n data.pop(i)\\n else:\\n break\\n \\n for i in range(len(data)):\\n if data[i] == 'null':\\n data[i] = None\\n else:\\n data[i] = int(data[i])\\n return data\\n \\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"19000\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n d = {}\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n key = ''\\n if root == None:\\n self.d['N'] = root\\n return 'N'\\n key += str(root.val)\\n stack = [root]\\n while stack:\\n curr = stack.pop()\\n if curr.left != None:\\n stack.append(curr.left)\\n key += str(curr.left.val)\\n else:\\n key += 'N'\\n if curr.right != None:\\n stack.append(curr.right)\\n key += str(curr.right.val)\\n else:\\n key += 'N'\\n self.d[key] = root\\n return key \\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n return self.d[data]\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"19100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nimport ctypes\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n return str(id(root))\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n return ctypes.cast(int(data), ctypes.py_object).value\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n queue = [root]\\n string = []\\n last_num_index = 0\\n i = 0\\n while queue:\\n current = queue.pop(0)\\n i += 1\\n if current == None:\\n string.append('(4)null')\\n continue\\n else:\\n value = str(current.val)\\n last_num_index = i\\n string.append('(' + str(len(value)) + ')' + value)\\n if current.left:\\n queue.append(current.left)\\n else:\\n queue.append(None)\\n if current.right:\\n queue.append(current.right)\\n else:\\n queue.append(None)\\n print(string)\\n return ''.join(string[:last_num_index])\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n i = 1\\n length = ''\\n solution = []\\n while i < len(data):\\n j = i\\n while data[j] != ')':\\n print(type(length))\\n print(type(data[j]))\\n length = length + str(data[j])\\n length = str(length)\\n j += 1\\n num_length = int(length)\\n if data[j + 1 : j + num_length + 1] == 'null':\\n solution.append(None)\\n else:\\n solution.append(int(data[j + 1 : j + num_length + 1]))\\n length = ''\\n i = j + num_length + 2\\n print(solution)\\n return solution\\n\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"19300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n queue = [root]\\n string = []\\n last_num_index = 0\\n i = 0\\n while queue:\\n current = queue.pop(0)\\n i += 1\\n if current == None:\\n string.append('(4)null')\\n continue\\n else:\\n value = str(current.val)\\n last_num_index = i\\n string.append('(' + str(len(value)) + ')' + value)\\n if current.left:\\n queue.append(current.left)\\n else:\\n queue.append(None)\\n if current.right:\\n queue.append(current.right)\\n else:\\n queue.append(None)\\n # print(string)\\n return ''.join(string[:last_num_index])\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n i = 1\\n length = ''\\n solution = []\\n while i < len(data):\\n j = i\\n while data[j] != ')':\\n # print(type(length))\\n # print(type(data[j]))\\n length = length + str(data[j])\\n length = str(length)\\n j += 1\\n num_length = int(length)\\n if data[j + 1 : j + num_length + 1] == 'null':\\n solution.append(None)\\n else:\\n solution.append(int(data[j + 1 : j + num_length + 1]))\\n length = ''\\n i = j + num_length + 2\\n # print(solution)\\n return solution\\n\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"19300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n # def getHeight(root):\\n # if not root:\\n # return 0\\n \\n # lh = getHeight(root.left)\\n # rh = getHeight(root.right)\\n\\n # return 1 + max(lh, rh)\\n \\n # h = getHeight(root)\\n # print(\\\"height\\\", h)\\n # q = [root]\\n # nums = []\\n # while q:\\n # l = []\\n # qLen = len(q)\\n # for i in range(qLen):\\n # node = q.pop(0)\\n # if node:\\n # l.append(node.val)\\n # q.append(node.left)\\n # q.append(node.right)\\n # else:\\n # if h > 0:\\n # l.append(None)\\n # h -= 1\\n # nums += l\\n # s = \\\"[\\\"\\n # for i in range(len(nums)):\\n # if nums[i] is None:\\n # s += \\\"null\\\"\\n # else:\\n # s += str(nums[i])\\n # if i < len(nums) - 1:\\n # s += \\\",\\\"\\n # s += \\\"]\\\"\\n # return s\\n if not root:\\n return \\\"\\\"\\n \\n res = \\\"\\\"\\n queue = collections.deque()\\n queue.append(root)\\n\\n while queue:\\n q = len(queue)\\n\\n for i in range(q):\\n node = queue.popleft()\\n if node:\\n res += str(node.val)\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n res += 'null'\\n res += ' '\\n # res += ' ' \\n return res\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n # if data == \\\"[]\\\":\\n # return None\\n\\n # data = data[1:-1].split(',')\\n # root = TreeNode(data[0])\\n # q = [root]\\n # l = True\\n # c = None\\n\\n # for i in range(1, len(data)):\\n # node = TreeNode(data[i])\\n\\n # if l:\\n # c = q.pop(0)\\n # c.left = node\\n # l = False\\n # else:\\n # c.right = node\\n # l = True\\n \\n # if data[i] is not \\\"null\\\":\\n # q.append(node)\\n \\n # return root\\n res = []\\n data = data.strip()\\n data = data.split()\\n for i in range(len(data) - 1, -1, -1):\\n if data[i] == 'null':\\n data.pop(i)\\n else:\\n break\\n \\n for i in range(len(data)):\\n if data[i] == 'null':\\n data[i] = None\\n else:\\n data[i] = int(data[i])\\n return data\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"None\\\"\\n \\n left = self.serialize(root.left)\\n right = self.serialize(root.right)\\n \\n return f\\\"{str(root.val)},{left},{right}\\\"\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"None\\\":\\n return None\\n tree = data.split(\\\",\\\")\\n\\n def dfs():\\n node = tree.pop(0)\\n if node == \\\"None\\\":\\n return None\\n treeNode = TreeNode(int(node))\\n treeNode.left = dfs()\\n treeNode.right = dfs()\\n return treeNode\\n\\n return dfs()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"19800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n serialized = []\\n def dfs(root):\\n if not root:\\n serialized.append(\\\"N\\\")\\n return\\n serialized.append(str(root.val))\\n dfs(root.left)\\n dfs(root.right)\\n return\\n dfs(root)\\n return \\\",\\\".join(serialized)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n from collections import deque\\n data = deque(data.split(\\\",\\\"))\\n def build():\\n root = data.popleft()\\n if root == \\\"N\\\":\\n return None\\n newtree = TreeNode(int(root))\\n newtree.left = build()\\n newtree.right = build()\\n return newtree\\n return build()\\n\\n\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"19900\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n\\n if not root:\\n return \\\"\\\"\\n\\n def _serialize(node):\\n if not node:\\n ans.append(\\\"None\\\")\\n return\\n ans.append(str(node.val))\\n _serialize(node.left)\\n _serialize(node.right)\\n\\n ans = []\\n _serialize(root)\\n return \\\",\\\".join(ans)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n\\n def _deserialize(d):\\n val = d.pop(0)\\n if val == \\\"None\\\":\\n return None\\n \\n root = TreeNode(val)\\n root.left = _deserialize(d)\\n root.right = _deserialize(d)\\n\\n return root\\n\\n data_list = data.split(\\\",\\\")\\n return _deserialize(data_list)\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20000\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n # BFS或DFS都可唯一确定一个完全二叉树\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def dfs(root, results):\\n if root == None:\\n results.append('#')\\n return\\n\\n results.append(str(root.val))\\n dfs(root.left, results)\\n dfs(root.right, results)\\n\\n results = []\\n dfs(root, results)\\n return ' '.join(results)\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def dfs(src):\\n node = next(src)\\n if node == '#':\\n return None\\n\\n root = TreeNode(int(node))\\n root.left = dfs(src)\\n root.right = dfs(src)\\n return root\\n\\n src = iter(data.split())\\n return dfs(src)\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"\\\"\\n \\n output = \\\"\\\"\\n queue = deque({root})\\n while queue:\\n curr = queue.popleft()\\n if not curr:\\n output += \\\"*,\\\"\\n continue\\n output += str(curr.val) + \\\",\\\"\\n queue.append(curr.left)\\n queue.append(curr.right)\\n return output\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n \\n nodes = data.split(\\\",\\\")\\n root = TreeNode(int(nodes[0]))\\n queue = deque({root})\\n i = 1\\n while queue and i < len(nodes):\\n curr = queue.popleft()\\n if nodes[i] != \\\"*\\\":\\n left = TreeNode(int(nodes[i]))\\n curr.left = left\\n queue.append(left)\\n i += 1\\n if nodes[i] != \\\"*\\\":\\n right = TreeNode(int(nodes[i]))\\n curr.right = right\\n queue.append(right)\\n i += 1\\n \\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20200\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\nfrom collections import deque\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n self.dfs(root, res)\\n return ','.join(res)\\n \\n def dfs(self, root, res):\\n if root == None:\\n res.append('#')\\n return\\n\\n res.append(str(root.val))\\n self.dfs(root.left, res)\\n self.dfs(root.right, res)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n # using deque to solve\\n data_list = deque(data.split(','))\\n\\n return self.build_tree(data_list)\\n \\n def build_tree(self, data_list):\\n if data_list is None:\\n return None\\n \\n val = data_list.popleft()\\n\\n if val == '#':\\n return None\\n\\n node = TreeNode(int(val))\\n\\n node.left = self.build_tree(data_list)\\n node.right = self.build_tree(data_list)\\n\\n return node\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20200\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n\\n self.s = \\\"\\\"\\n self.serialize_dfs(root)\\n \\n return self.s\\n\\n def serialize_dfs(self,curr):\\n \\n if not curr:\\n self.s+=\\\"X\\\"+\\\",\\\"\\n return\\n \\n self.s+=str(curr.val)+\\\",\\\"\\n\\n self.serialize_dfs(curr.left)\\n self.serialize_dfs(curr.right)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n root,pointer = self.build(0,data.split(\\\",\\\"))\\n return root\\n\\n def build(self,pointer,data):\\n if pointer >= len(data) or data[pointer] == \\\"X\\\" or data[pointer] == \\\"\\\":\\n return None, pointer + 1\\n \\n node = TreeNode(int(data[pointer]))\\n pointer += 1\\n node.left, pointer = self.build(pointer,data) \\n node.right, pointer = self.build(pointer,data) \\n \\n return node, pointer\\n\\n\\n \\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return ''\\n queue = deque([root])\\n res = \\\"\\\"\\n \\n while queue:\\n node = queue.popleft()\\n res += \\\"#\\\"\\n if node:\\n res += str(node.val)\\n queue.append(node.left)\\n queue.append(node.right)\\n else:\\n res += 'null'\\n continue\\n return res\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n\\n data = deque(data.split(\\\"#\\\")[1:])\\n \\n root = TreeNode(int(data.popleft()))\\n queue = deque([root])\\n while queue:\\n l = len(queue)\\n\\n node = queue.popleft()\\n if not node:\\n continue\\n\\n left, right = data.popleft(), data.popleft()\\n node.left = TreeNode(int(left)) if left != 'null' else None\\n queue.append(node.left)\\n node.right = TreeNode(int(right)) if right != 'null' else None\\n queue.append(node.right)\\n return root\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20300\"\n },\n {\n \"code\": \"class Codec:\\n\\n def serialize(self, root):\\n # use level order traversal to match LeetCode's serialization format\\n flat_bt = []\\n queue = collections.deque([root])\\n while queue:\\n node = queue.pop()\\n if node:\\n flat_bt.append(str(node.val))\\n queue.appendleft(node.left)\\n queue.appendleft(node.right)\\n else:\\n # you can use any char to represent null\\n # empty string means test for a non-null node is simply: flat_bt[i]\\n flat_bt.append('')\\n return ','.join(flat_bt)\\n # time: O(n)\\n # space: O(n)\\n\\n def deserialize(self, data):\\n if not data:\\n return\\n flat_bt = data.split(',')\\n ans = TreeNode(flat_bt[0])\\n queue = collections.deque([ans])\\n i = 1\\n # when you pop a node, its children will be at i and i+1\\n while queue:\\n node = queue.pop()\\n if i < len(flat_bt) and flat_bt[i]:\\n node.left = TreeNode(int(flat_bt[i]))\\n queue.appendleft(node.left)\\n i += 1\\n if i < len(flat_bt) and flat_bt[i]:\\n node.right = TreeNode(int(flat_bt[i]))\\n queue.appendleft(node.right)\\n i += 1\\n return ans\\n # time: O(n)\\n # space: O(n)\",\n \"memory\": \"20400\"\n },\n {\n \"code\": \"class Codec:\\n\\n def serialize(self, root):\\n # use level order traversal to match LeetCode's serialization format\\n flat_bt = []\\n queue = collections.deque([root])\\n while queue:\\n node = queue.pop()\\n if node:\\n flat_bt.append(str(node.val))\\n queue.appendleft(node.left)\\n queue.appendleft(node.right)\\n else:\\n # you can use any char to represent null\\n # empty string means test for a non-null node is simply: flat_bt[i]\\n flat_bt.append('')\\n return ','.join(flat_bt)\\n # time: O(n)\\n # space: O(n)\\n\\n def deserialize(self, data):\\n if not data:\\n return\\n flat_bt = data.split(',')\\n ans = TreeNode(flat_bt[0])\\n queue = collections.deque([ans])\\n i = 1\\n # when you pop a node, its children will be at i and i+1\\n while queue:\\n node = queue.pop()\\n if i < len(flat_bt) and flat_bt[i]:\\n node.left = TreeNode(int(flat_bt[i]))\\n queue.appendleft(node.left)\\n i += 1\\n if i < len(flat_bt) and flat_bt[i]:\\n node.right = TreeNode(int(flat_bt[i]))\\n queue.appendleft(node.right)\\n i += 1\\n return ans\\n # time: O(n)\\n # space: O(n)\",\n \"memory\": \"20400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"4\\\"\\n else:\\n total_data = \\\"\\\"\\n stack = [root]\\n while(len(stack) > 0):\\n cur_node = stack.pop()\\n if cur_node.right is not None:\\n stack.append(cur_node.right)\\n if cur_node.left is not None:\\n stack.append(cur_node.left)\\n \\n total_data += self.encode_node(cur_node)\\n # print(total_data)\\n return total_data\\n\\n def encode_node(self, node):\\n data = \\\"\\\"\\n if node.left is None and node.right is None:\\n data += \\\"0\\\"\\n elif node.right is None:\\n data += \\\"1\\\"\\n elif node.left is None:\\n data += \\\"2\\\"\\n else:\\n data += \\\"3\\\"\\n data += str(node.val + 1000).zfill(4)\\n return data\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data[0] == \\\"4\\\":\\n return None\\n else:\\n root = self.decode_node(data[1:5])\\n stack = [root]\\n node_status = [data[0]]\\n # print(len(stack), len(node_status), data)\\n data = data[5:]\\n while(len(data)>0):\\n # print(len(stack), len(node_status), data)\\n cur_parent_node = stack.pop()\\n cur_node_status = node_status.pop()\\n if cur_node_status == \\\"0\\\":\\n continue\\n\\n cur_node = self.decode_node(data[1:5])\\n if cur_node_status == \\\"1\\\":\\n cur_parent_node.left = cur_node\\n elif cur_node_status == \\\"2\\\":\\n cur_parent_node.right = cur_node\\n else:\\n if cur_parent_node.left is None:\\n cur_parent_node.left = cur_node\\n stack.append(cur_parent_node)\\n node_status.append(cur_node_status)\\n else:\\n cur_parent_node.right = cur_node\\n \\n stack.append(cur_node)\\n node_status.append(data[0])\\n data = data[5:]\\n \\n return root\\n\\n # print(data)\\n # print(int(len(data)/5))\\n # return None\\n \\n\\n def decode_node(self, data):\\n value = int(data) - 1000\\n node = TreeNode(value)\\n return node\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"class Codec:\\n\\n def serialize(self, root: Optional[TreeNode]):\\n if not root:\\n return \\\"\\\"\\n left = self.serialize(root.left)\\n right = self.serialize(root.right)\\n val = root.val\\n if right:\\n return f\\\"{val}({left})({right})\\\"\\n if left:\\n return f\\\"{val}({left})\\\"\\n return f\\\"{val}\\\"\\n\\n def deserialize(self, data: str):\\n if not data:\\n return None\\n root = TreeNode()\\n stack = deque([[root, False, False, None]])\\n for token in parse(data):\\n curr_node, is_real, has_left, parent = stack[-1]\\n if token == \\\"(\\\":\\n node = TreeNode()\\n if has_left:\\n curr_node.right = node\\n else:\\n curr_node.left = node\\n stack[-1][2] = True\\n stack.append([node, False, False, curr_node])\\n elif token == \\\")\\\":\\n if not is_real:\\n if curr_node is parent.left:\\n parent.left = None\\n else:\\n parent.right = None\\n stack.pop()\\n else:\\n stack[-1][1] = True\\n curr_node.val = token\\n return root\\n\\ndef parse(s: str):\\n is_positive = True\\n num = 0\\n has_number = False\\n for char in s:\\n if char == \\\"-\\\":\\n is_positive = False\\n num = 0\\n has_number = True\\n elif char.isnumeric():\\n num = num * 10 + int(char)\\n has_number = True\\n else:\\n if has_number:\\n yield num if is_positive else -num\\n yield char\\n is_positive = True\\n num = 0\\n has_number = False\\n if has_number:\\n yield num if is_positive else -num\",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n\\n def dfs(node):\\n if not node:\\n res.append(\\\"N\\\")\\n return\\n res.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n dfs(root)\\n return \\\",\\\".join(res)\\n\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n vals = data.split(\\\",\\\")\\n self.i = 0\\n\\n def dfs():\\n if vals[self.i] == \\\"N\\\":\\n self.i += 1\\n return None\\n node = TreeNode(int(vals[self.i]))\\n self.i += 1\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n return dfs()\\n\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20600\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n while result and result[-1] == '':\\n result.pop()\\n return ','.join(result)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20600\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n self.ans = \\\"\\\"\\n def preorder(node):\\n if node:\\n self.ans = self.ans + str(node.val) + \\\",\\\"\\n preorder(node.left)\\n preorder(node.right)\\n else:\\n self.ans = self.ans + \\\"N\\\" + \\\",\\\"\\n preorder(root)\\n return self.ans[:len(self.ans) - 1]\\n\\n def deserialize(self, data):\\n if data == \\\"\\\":\\n return []\\n self.i = -1\\n li = data.split(\\\",\\\")\\n def prepare():\\n self.i += 1\\n if self.i >= len(li):\\n return None\\n if li[self.i] == \\\"N\\\":\\n return None\\n node = TreeNode(li[self.i])\\n node.left = prepare()\\n node.right = prepare()\\n return node\\n\\n return prepare()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20700\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n while result and result[-1] == '':\\n result.pop()\\n return ','.join(result)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20700\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n lis=[]\\n def dfs(node):\\n if not node:\\n lis.append(\\\"N\\\")\\n return\\n lis.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n return lis\\n dfs(root)\\n return \\\",\\\".join(lis)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n lis=data.split(\\\",\\\")\\n self.i=0\\n def dfs():\\n\\n if lis[self.i]==\\\"N\\\":\\n self.i+=1\\n return None\\n newNode= TreeNode(int(lis[self.i]))\\n self.i+=1\\n newNode.left=dfs()\\n newNode.right=dfs()\\n return newNode\\n\\n root=dfs()\\n\\n return root\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n while result and result[-1] == '':\\n result.pop()\\n return ','.join(result)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n return ','.join(result).rstrip(',')\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20900\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def _preorder(node):\\n if node is None:\\n result.append('')\\n return\\n result.append(str(node.val))\\n _preorder(node.left)\\n _preorder(node.right)\\n \\n result = []\\n _preorder(root)\\n return ','.join(result).rstrip(',')\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def _des(i=0):\\n if i >= len(data) or len(data[i]) == 0:\\n return None, i + 1\\n node = TreeNode(int(data[i]))\\n node.left, i = _des(i + 1)\\n node.right, i = _des(i)\\n return node, i\\n \\n data = data.split(',')\\n return _des()[0]\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"20900\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n ans = []\\n\\n # level order traversal\\n q = deque([root])\\n while q:\\n for i in range(len(q)): \\n node = q.popleft()\\n\\n if node:\\n ans.append(node.val)\\n if node.left:\\n q.append(node.left)\\n else:\\n q.append(None)\\n\\n if node.right:\\n q.append(node.right)\\n else:\\n q.append(None)\\n else:\\n ans.append(None)\\n\\n #convert ans to a string\\n return str(ans)\\n\\n\\n def deserialize(self, data):\\n # Convert string to list\\n data = data.strip('[]')\\n data_list = data.split(',')\\n data_list = [s.strip() for s in data_list]\\n\\n # Convert elements to actual values\\n def parse_value(s):\\n if s == 'None':\\n return None\\n else:\\n return int(s)\\n\\n data_list = [parse_value(s) for s in data_list]\\n\\n # Handle empty tree\\n if not data_list or data_list[0] is None:\\n return None\\n\\n # Initialize root node and queue\\n root = TreeNode(data_list[0])\\n queue = deque([root])\\n index = 1\\n\\n # Reconstruct the tree\\n while queue and index < len(data_list):\\n current = queue.popleft()\\n\\n # Assign left child\\n if index < len(data_list):\\n left_val = data_list[index]\\n index += 1\\n if left_val is not None:\\n current.left = TreeNode(left_val)\\n queue.append(current.left)\\n else:\\n current.left = None\\n\\n # Assign right child\\n if index < len(data_list):\\n right_val = data_list[index]\\n index += 1\\n if right_val is not None:\\n current.right = TreeNode(right_val)\\n queue.append(current.right)\\n else:\\n current.right = None\\n\\n return root\\n\\n\\n \\n\\n\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21000\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def preOrder(node):\\n if not node:\\n yield \\\"None\\\"\\n else:\\n yield str(node.val)\\n yield from preOrder(node.left)\\n yield from preOrder(node.right)\\n \\n return (' ').join([x for x in preOrder(root)])\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def helper():\\n if not data:\\n return None\\n val = data.popleft()\\n if val == \\\"None\\\":\\n return None\\n node = TreeNode(int(val))\\n node.left = helper()\\n node.right = helper()\\n return node\\n \\n data = deque(data.split(' '))\\n return helper()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21000\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"na\\\"\\n\\n q=deque([root])\\n final = [str(root.val)]\\n\\n while len(q) > 0:\\n node = q.popleft()\\n\\n if node.left:\\n q.append(node.left)\\n final.append(str(node.left.val))\\n else:\\n final.append(\\\"na\\\")\\n\\n if node.right:\\n q.append(node.right)\\n final.append(str(node.right.val))\\n else:\\n final.append(\\\"na\\\")\\n\\n return \\\"|\\\".join(final)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"na\\\":\\n return None\\n\\n nodes = data.split(\\\"|\\\")\\n root = TreeNode(int(nodes[0]))\\n q = deque([(0, root)])\\n na = 0 #num of na's\\n\\n while len(q) > 0:\\n i, node = q.popleft()\\n\\n if not node:\\n na += 1\\n continue\\n\\n li, ri = 2*(i-na) + 1, 2*(i-na) + 2\\n left, right = nodes[li], nodes[ri]\\n\\n if left != \\\"na\\\":\\n node.left = TreeNode(int(left))\\n q.append((li, node.left))\\n\\n if right != \\\"na\\\":\\n node.right = TreeNode(int(right))\\n q.append((ri, node.right))\\n\\n return root\\n# ['1', '2', '3', 'na', 'na', '4', '5', 'na', 'na', 'na', 'na']\\n# [(0, '1'), (1, '2'), (2, '3'), (3, 'na'), (4, 'na'), (5, '4'), (6, '5'), (7, 'na'), (8, 'na'), (9, 'na'), (10, 'na')]\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"na\\\"\\n\\n q=deque([root])\\n final = [root.val]\\n\\n while len(q) > 0:\\n node = q.popleft()\\n\\n if node.left:\\n q.append(node.left)\\n final.append(node.left.val)\\n else:\\n final.append(\\\"na\\\")\\n\\n if node.right:\\n q.append(node.right)\\n final.append(node.right.val)\\n else:\\n final.append(\\\"na\\\")\\n\\n return \\\"|\\\".join(str(s) for s in final)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"na\\\":\\n return None\\n\\n nodes = data.split(\\\"|\\\")\\n root = TreeNode(int(nodes[0]))\\n q = deque([(0, root)])\\n na = 0 #num of na's\\n\\n while len(q) > 0:\\n i, node = q.popleft()\\n\\n if not node:\\n na += 1\\n continue\\n\\n li, ri = 2*(i-na) + 1, 2*(i-na) + 2\\n left, right = nodes[li], nodes[ri]\\n\\n if left != \\\"na\\\":\\n node.left = TreeNode(int(left))\\n q.append((li, node.left))\\n\\n if right != \\\"na\\\":\\n node.right = TreeNode(int(right))\\n q.append((ri, node.right))\\n\\n return root\\n \\n# ['1', '2', '3', 'na', 'na', '4', '5', 'na', 'na', 'na', 'na']\\n# [(0, '1'), (1, '2'), (2, '3'), (3, 'na'), (4, 'na'), (5, '4'), (6, '5'), (7, 'na'), (8, 'na'), (9, 'na'), (10, 'na')]\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"na\\\"\\n\\n q=deque([root])\\n final = [root.val]\\n\\n while len(q) > 0:\\n node = q.popleft()\\n\\n if node.left:\\n q.append(node.left)\\n final.append(node.left.val)\\n else:\\n final.append(\\\"na\\\")\\n\\n if node.right:\\n q.append(node.right)\\n final.append(node.right.val)\\n else:\\n final.append(\\\"na\\\")\\n\\n return \\\"|\\\".join(str(s) for s in final)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"na\\\":\\n return None\\n\\n nodes = data.split(\\\"|\\\")\\n root = TreeNode(int(nodes[0]))\\n q = deque([(0, root)])\\n na = 0 #num of na's\\n\\n while len(q) > 0:\\n i, node = q.popleft()\\n\\n if not node:\\n na += 1\\n continue\\n\\n li, ri = 2*(i-na) + 1, 2*(i-na) + 2\\n left, right = nodes[li], nodes[ri]\\n\\n if left != \\\"na\\\":\\n node.left = TreeNode(int(left))\\n q.append((li, node.left))\\n\\n if right != \\\"na\\\":\\n node.right = TreeNode(int(right))\\n q.append((ri, node.right))\\n\\n return root\\n \\n# ['1', '2', '3', 'na', 'na', '4', '5', 'na', 'na', 'na', 'na']\\n# [(0, '1'), (1, '2'), (2, '3'), (3, 'na'), (4, 'na'), (5, '4'), (6, '5'), (7, 'na'), (8, 'na'), (9, 'na'), (10, 'na')]\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21200\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return 'None'\\n return str(root.val) + ',' + self.serialize(root.left) + ',' + self.serialize(root.right)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n values = data.split(\\\",\\\")\\n i = 0\\n def dfs():\\n nonlocal i\\n if values[i] == 'None':\\n i += 1\\n return None\\n node = TreeNode(int(values[i]))\\n i += 1\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n return dfs()\\n\\n \\n\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def dfs(node):\\n if node is None:\\n result.append(\\\"None\\\")\\n return\\n result.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n result=[]\\n dfs(root)\\n return \\\",\\\".join(result) \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def dfs():\\n val=next(vals)\\n if val==\\\"None\\\":\\n return None\\n node=TreeNode(int(val))\\n node.left=dfs()\\n node.right=dfs()\\n return node\\n \\n vals=iter(data.split(\\\",\\\"))\\n return dfs()\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n def dfs(root):\\n if not root:\\n res.append(None)\\n return\\n \\n res.append(root.val)\\n dfs(root.left)\\n dfs(root.right)\\n \\n dfs(root)\\n return ' '.join(map(str, res))\\n \\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n data = data.split()\\n self.i = 0\\n def dfs():\\n if data[self.i] == 'None':\\n self.i += 1\\n return None\\n node = TreeNode(val=int(data[self.i]))\\n self.i += 1\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n return dfs()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n # global var\\n ans = []\\n\\n def order(root):\\n if not root:\\n ans.append(\\\"null\\\")\\n return\\n\\n ans.append(str(root.val))\\n order(root.left)\\n order(root.right)\\n \\n order(root)\\n return \\\",\\\".join(ans)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n vals = data.split(\\\",\\\")\\n self.i = 0\\n\\n def dfs():\\n if vals[self.i] == \\\"null\\\":\\n self.i += 1\\n return None\\n\\n node = TreeNode(int(vals[self.i]))\\n self.i += 1\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n\\n return dfs()\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21500\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n nodes = []\\n\\n def dfs(node) :\\n if node is None:\\n nodes.append('null')\\n return\\n \\n nodes.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n \\n dfs(root)\\n return \\\",\\\".join(nodes)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n print(data)\\n\\n nodes = data.split(\\\",\\\")\\n\\n # [1,2,null,null,3,4,null,null,5,null,null]\\n\\n index = [0]\\n\\n def build() -> TreeNode:\\n \\n nodeIndex = index[0]\\n\\n if nodes[nodeIndex] == \\\"null\\\":\\n return None\\n \\n node = TreeNode(int(nodes[nodeIndex])) # 1\\n index[0] += 1\\n node.left = build()\\n index[0] += 1\\n node.right = build()\\n\\n return node\\n \\n \\n return build()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21500\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n def dfs(node):\\n if not node:\\n res.append(\\\"NA\\\")\\n return\\n res.append(str(node.val))\\n dfs(node.left)\\n dfs(node.right)\\n dfs(root)\\n return \\\",\\\".join(res)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n nodes = data.split(\\\",\\\")\\n self.i = 0\\n def dfs():\\n if nodes[self.i] == \\\"NA\\\":\\n self.i += 1\\n return None\\n node = TreeNode(int(nodes[self.i]))\\n self.i += 1\\n node.left = dfs()\\n node.right = dfs()\\n return node\\n return dfs()\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21600\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n # def helper(root):\\n # if not root:\\n # return 0\\n # return max(helper(root.left), helper(root.right)) + 1\\n # h = helper(root)\\n # res = [None] * (2**h - 1)\\n # print(res)\\n if not root:\\n return \\\"\\\"\\n res = [root.val]\\n deq = collections.deque([root])\\n while deq:\\n for i in range(len(deq)):\\n el = deq.popleft()\\n if el.left:\\n deq.append(el.left)\\n if el.right:\\n deq.append(el.right)\\n res.append(el.left.val if el.left else None)\\n res.append(el.right.val if el.right else None)\\n # while not res[-1]:\\n # res.pop()\\n return \\\",\\\".join(map(str,res))\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n data = list(map(lambda x: int(x) if x != \\\"None\\\" else None, data.split(',')))\\n root = TreeNode(data[0])\\n i = 1\\n deq = collections.deque([root])\\n while deq:\\n tree = deq.popleft()\\n if data[i] is not None:\\n tree.left = TreeNode(data[i])\\n deq.append(tree.left)\\n if data[i + 1] is not None:\\n tree.right = TreeNode(data[i + 1])\\n deq.append(tree.right)\\n i += 2\\n print(root)\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21700\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"\\\"\\n q = [(root,0)]; data = {}\\n data[0] = root.val\\n while q:\\n node, indx = q.pop(0)\\n if node.left:\\n data[indx*2 + 1] = node.left.val\\n q.append((node.left, indx*2 + 1))\\n else:\\n data[indx*2 + 1] = None\\n if node.right:\\n data[indx*2 + 2] = node.right.val\\n q.append((node.right, indx*2 + 2))\\n else:\\n data[indx*2 + 2] = None\\n d = \\\"\\\"\\n for i in data.keys():\\n if d:\\n d += \\\" \\\"\\n d += str(i) + \\\":\\\" + str(data[i])\\n # print(d) \\n return d\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n d = {}\\n if not data:\\n return []\\n for i in data.split():\\n key, val = i.split(\\\":\\\")\\n key = int(key)\\n if val != \\\"None\\\":\\n val = int(val)\\n else:\\n val = None\\n d[key] = val\\n data = d\\n root = None; nodes = {}\\n nodes[0] = TreeNode(data[0])\\n for i in sorted(data.keys()):\\n if data[i] != None:\\n root = nodes[i]\\n if i*2 + 1 in data and data[i*2 + 1] != None:\\n # print(i*2 + 1, \\\"left -->\\\", nodes[0])\\n root.left = TreeNode(data[i*2 + 1])\\n nodes[i*2 + 1] = root.left\\n if i*2 + 2 in data and data[i*2 + 2] != None:\\n # print(i*2 + 2, \\\"right -->\\\", nodes[0])\\n root.right = TreeNode(data[i*2 + 2])\\n nodes[i*2 + 2] = root.right\\n return nodes[0]\\n\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21700\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n # preorder traversal\\n res = []\\n def traverse(root):\\n if not root:\\n res.append(\\\"null\\\")\\n return\\n res.append(str(root.val))\\n traverse(root.left)\\n traverse(root.right)\\n traverse(root)\\n print(res)\\n # the first is the root\\n # second is the left\\n # third is the right\\n\\n return \\\",\\\".join(res)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n data = data.split(\\\",\\\")\\n\\n # when returning, need to \\\"jump\\\" by number of nodes traversed\\n # return when a null is reached\\n # each node will look down two indicies\\n created_nodes = [None] * len(data)\\n def createNodeAndReturnNumberOfIndicies(index):\\n if index > len(data) or data[index] == \\\"null\\\":\\n return 1\\n if not created_nodes[index] and data[index] != \\\"null\\\":\\n created_nodes[index] = TreeNode(int(data[index]))\\n indicies_left = createNodeAndReturnNumberOfIndicies(index + 1)\\n right_index = index + indicies_left + 1\\n indicies_right = createNodeAndReturnNumberOfIndicies(right_index)\\n created_nodes[index].left = created_nodes[index + 1]\\n created_nodes[index].right = created_nodes[right_index]\\n return 1 + indicies_left + indicies_right\\n \\n createNodeAndReturnNumberOfIndicies(0)\\n return created_nodes[0]\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"21800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n self.list = []\\n\\n def _postorderTraversal(curr: TreeNode) -> None:\\n if curr is None:\\n self.list.append(\\\"None\\\")\\n return\\n\\n _postorderTraversal(curr.left)\\n _postorderTraversal(curr.right)\\n self.list.append(str(curr.val))\\n \\n _postorderTraversal(root)\\n \\n print(\\\":\\\".join(self.list))\\n return \\\":\\\".join(self.list)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n \\n self.list = data.split(\\\":\\\")\\n self.index = len(self.list) - 1\\n\\n def _reversePostorderTraversal() -> Optional[TreeNode]:\\n if self.index < 0:\\n return None\\n \\n if self.list[self.index] == \\\"None\\\":\\n self.index -= 1\\n return None\\n \\n root = TreeNode(int(self.list[self.index]))\\n self.index -= 1\\n\\n root.right = _reversePostorderTraversal()\\n root.left = _reversePostorderTraversal()\\n\\n return root\\n \\n return _reversePostorderTraversal()\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"22100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n # id:val:left_id:right_id\\n # if not present, use *\\n def __init__(self):\\n self.id = 0\\n def getId(self):\\n self.id += 1\\n return self.id\\n\\n def getRecords(self, id, node, records):\\n # the node should be valid\\n ans = str(id) + ':' + str(node.val) + ':'\\n if node.left:\\n left_id = self.getId()\\n ans += str(left_id) + ':'\\n self.getRecords(left_id, node.left, records)\\n else:\\n ans += '*:'\\n \\n if node.right:\\n right_id = self.getId()\\n ans += str(right_id)\\n self.getRecords(right_id, node.right, records)\\n else:\\n ans += '*'\\n records.append(ans)\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"\\\"\\n records = []\\n self.getRecords(0, root, records)\\n return '|'.join(records)\\n \\n def build(self, id, map):\\n print(id)\\n val, left_id, right_id = map[id]\\n res = TreeNode(val)\\n if left_id != '*':\\n res.left = self.build(int(left_id), map)\\n if right_id != '*':\\n res.right = self.build(int(right_id), map)\\n return res\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n records = data.split('|')\\n map = {}\\n for record in records:\\n id, val, left_id, right_id = record.split(':')\\n map[int(id)] = (int(val), left_id, right_id)\\n\\n return self.build(0, map)\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"22200\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\nimport json\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n self.res = []\\n def rserialize(p_level):\\n n_level = []\\n atleast_one_node = False\\n for node in p_level:\\n # storing the parent level nodes in the self.res & the children nodes in n_level\\n # check whether atleast one node exists in next level before making a call\\n # idea based on how Leetcode serializes binary tree\\n if node:\\n self.res.append(str(node.val))\\n if node.left or node.right:\\n atleast_one_node = True\\n n_level.append(node.left)\\n n_level.append(node.right)\\n else:\\n self.res.append(str(node))\\n if atleast_one_node:\\n rserialize(n_level)\\n p_level = [root]\\n rserialize(p_level)\\n res = \\\",\\\".join(self.res)\\n return res\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n data = data.split(\\\",\\\")\\n def rdeserialize(start,p_level):\\n # start represents starting index of the children nodes\\n ptr = start\\n n_level = []\\n for node in p_level:\\n # if parent node is None, move to the next parent node\\n if not node:\\n continue\\n # ptr indicates the index of the children node\\n if ptr < len(data):\\n node.left = TreeNode(int(data[ptr])) if data[ptr] != \\\"None\\\" else None\\n n_level.append(node.left)\\n ptr += 1\\n if ptr < len(data):\\n node.right = TreeNode(int(data[ptr])) if data[ptr] != \\\"None\\\" else None\\n n_level.append(node.right)\\n ptr += 1\\n # n_level should have atleast one node or one none\\n if n_level:\\n rdeserialize(ptr,n_level)\\n p_level = []\\n if data[0] != \\\"None\\\":\\n root_node = TreeNode(int(data[0]))\\n p_level = [root_node]\\n rdeserialize(1,p_level)\\n return root_node\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"22300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n storage = {}\\n def helper(root, idx):\\n if root == None:\\n return\\n storage[idx] = root.val\\n helper(root.left, idx * 2)\\n helper(root.right, idx * 2 + 1)\\n helper(root, 1)\\n answer = []\\n for key, val in storage.items():\\n answer.append(str(key) + \\\"*\\\" + str(val))\\n return ','.join(answer)\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == '':\\n return None\\n nodes = data.split(',')\\n storage = {}\\n for node in nodes:\\n key = int(node.split(\\\"*\\\")[0])\\n val = int(node.split(\\\"*\\\")[1])\\n storage[key] = val\\n def helper(idx):\\n if idx in storage:\\n node = TreeNode(storage[idx])\\n node.left = helper(idx * 2)\\n node.right = helper(idx * 2 + 1)\\n return node\\n else:\\n return None\\n return helper(1)\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"22400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\n\\nclass Codec:\\n \\\"\\\"\\\"\\n IDEA-2\\n \\n same as Idea-1, but lets try optimize a bit\\n \\\"\\\"\\\"\\n\\n def serialize(self, root):\\n n = 0\\n entries = [] \\n\\n def do_indexing(node=root):\\n nonlocal n, entries\\n\\n if not node:\\n return \\\"\\\"\\n \\n curr_idx = n\\n n += 1\\n entries.append(\\\"\\\")\\n\\n idx_left = do_indexing(node.left)\\n idx_right = do_indexing(node.right)\\n\\n entries[curr_idx] = str(node.val) + \\\"_\\\" + idx_left + \\\"_\\\" + idx_right\\n\\n return str(curr_idx)\\n \\n do_indexing()\\n\\n return \\\" \\\".join(entries)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data or not len(data):\\n return None\\n\\n entries = data.split(\\\" \\\")\\n n = len(entries)\\n\\n nodes = [entry.split(\\\"_\\\") for entry in entries]\\n nodes_real = [TreeNode(int(nod[0])) for nod in nodes]\\n\\n for i in range(n):\\n left_idx, right_idx = nodes[i][1], nodes[i][2]\\n if left_idx:\\n nodes_real[i].left = nodes_real[int(left_idx)]\\n if right_idx:\\n nodes_real[i].right = nodes_real[int(right_idx)]\\n\\n return nodes_real[0]\\n\\n\\nclass Codec1:\\n \\\"\\\"\\\"\\n IDEA-1 \\n\\n > nodes value may not be unique\\n\\n what if we assign a number to each node.\\n and store the left and right of nodes as that node's number\\n We don't even need to assign the number, we can use array and array index can be that number.\\n\\n then it will look like\\n [\\n (node_value, left_index, right_index)\\n .\\n .\\n .\\n ]\\n if left_index is empty, that mean it is None.\\n\\n to transform to string, we will store in \\n \\\"nodeValue1_leftIndex1_rightIndex1 nodeValue2_leftIndex2_rightIndex2\\\"\\n\\n\\n time: O(n)\\n space: O(3n)\\n \\\"\\\"\\\"\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n hmap = {} # node to index\\n hmap[None] = \\\"\\\"\\n n = 0\\n nodes = []\\n \\n def do_indexing(node=root):\\n nonlocal n, nodes, hmap\\n\\n if not node:\\n return\\n\\n if node not in hmap:\\n hmap[node] = n\\n nodes.append((node, n))\\n n += 1\\n\\n do_indexing(node.left)\\n do_indexing(node.right)\\n \\n do_indexing()\\n entries = [] \\n for node in nodes:\\n entry = str(node[0].val) + \\\"_\\\" + str(hmap[node[0].left]) + \\\"_\\\" + str(hmap[node[0].right])\\n entries.append(entry)\\n\\n return \\\" \\\".join(entries)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data or not len(data):\\n return None\\n\\n entries = data.split(\\\" \\\")\\n n = len(entries)\\n\\n nodes = [entry.split(\\\"_\\\") for entry in entries]\\n nodes_real = [TreeNode(int(nod[0])) for nod in nodes]\\n\\n for i in range(n):\\n left_idx, right_idx = nodes[i][1], nodes[i][2]\\n if left_idx:\\n nodes_real[i].left = nodes_real[int(left_idx)]\\n if right_idx:\\n nodes_real[i].right = nodes_real[int(right_idx)]\\n\\n return nodes_real[0]\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"22500\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\nimport json\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def traverse(root):\\n if not root:\\n return None\\n v = dict(val=root.val)\\n if root.left:\\n v['left'] = traverse(root.left)\\n if root.right:\\n v['right'] = traverse(root.right)\\n return v\\n\\n v = traverse(root)\\n return json.dumps(v)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def traverse(d):\\n if not d:\\n return None\\n root = TreeNode(d['val'])\\n root.left = traverse(d.get('left'))\\n root.right = traverse(d.get('right'))\\n return root\\n\\n return traverse(json.loads(data))\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"22600\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n q = collections.deque()\\n q.append(root)\\n while q:\\n node = q.popleft()\\n if not node:\\n res.append(\\\"null\\\")\\n else: \\n res.append(str(node.val)) \\n q.append(node.left)\\n q.append(node.right)\\n \\n # print(res)\\n return \\\",\\\".join(res)\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n data = data.split(\\\",\\\")\\n # print(data)\\n\\n q = collections.deque()\\n rootVal = data.pop(0)\\n if rootVal == \\\"null\\\":\\n return None\\n\\n root = TreeNode(rootVal)\\n q.append(root)\\n\\n while q:\\n node = q.popleft()\\n if len(data) >= 2:\\n left = data.pop(0)\\n right = data.pop(0)\\n node.left = TreeNode(left)\\n node.right = TreeNode(right)\\n q.append(node.left)\\n q.append(node.right)\\n\\n return root\\n\\n\\n\\n# tree = TreeNode(1, TreeNode(2), TreeNode(3, TreeNode(4), TreeNode(5)))\\n# ser = Codec()\\n# # ser.serialize(tree)\\n# # Your Codec object will be instantiated and called as such:\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(tree))\",\n \"memory\": \"22700\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n q = collections.deque()\\n q.append(root)\\n while q:\\n node = q.popleft()\\n if not node:\\n res.append(\\\"null\\\")\\n else: \\n res.append(str(node.val)) \\n q.append(node.left)\\n q.append(node.right)\\n \\n # print(res)\\n return \\\",\\\".join(res)\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n data = data.split(\\\",\\\")\\n # print(data)\\n\\n q = collections.deque()\\n rootVal = data.pop(0)\\n if rootVal == \\\"null\\\":\\n return None\\n\\n root = TreeNode(rootVal)\\n q.append(root)\\n\\n while q:\\n node = q.popleft()\\n if len(data) >= 2:\\n left = data.pop(0)\\n right = data.pop(0)\\n node.left = TreeNode(left)\\n node.right = TreeNode(right)\\n q.append(node.left)\\n q.append(node.right)\\n\\n return root\\n\\n\\n\\n# tree = TreeNode(1, TreeNode(2), TreeNode(3, TreeNode(4), TreeNode(5)))\\n# ser = Codec()\\n# # ser.serialize(tree)\\n# # Your Codec object will be instantiated and called as such:\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(tree))\",\n \"memory\": \"22700\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n l=[]\\n def encode(root, position):\\n if root==None:\\n return\\n l.append(str(position) + ',' + str(root.val))\\n encode(root.left, 2*position+1)\\n encode(root.right, 2*position+2)\\n return\\n\\n encode(root, 0)\\n print(';'.join(l))\\n return ';'.join(l)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n l=data.split(';')\\n if len(l)==0 or (len(l)==1 and l[0]==''):\\n return None\\n d={}\\n for i in l:\\n tup=i.split(',')\\n d[int(tup[0])] = int(tup[1])\\n print(d)\\n nodes={}\\n nodes[0] = TreeNode(d[0])\\n def insertNode(position):\\n if position in nodes:\\n return\\n if not ((position-1)//2) in nodes:\\n insertNode((position-1)//2)\\n nodes[position]=TreeNode(d[position])\\n if position%2==0:\\n nodes[(position-1)//2].right=nodes[position]\\n else:\\n nodes[(position-1)//2].left=nodes[position]\\n return\\n \\n for i in d.keys():\\n insertNode(i)\\n \\n return nodes[0]\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"22800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n l=[]\\n def encode(root, position):\\n if root==None:\\n return\\n l.append(str(position) + ',' + str(root.val))\\n encode(root.left, 2*position+1)\\n encode(root.right, 2*position+2)\\n return\\n\\n encode(root, 0)\\n print(';'.join(l))\\n return ';'.join(l)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n l=data.split(';')\\n if len(l)==0 or (len(l)==1 and l[0]==''):\\n return None\\n d={}\\n for i in l:\\n tup=i.split(',')\\n d[int(tup[0])] = int(tup[1])\\n print(d)\\n nodes={}\\n nodes[0] = TreeNode(d[0])\\n def insertNode(position):\\n if position in nodes:\\n return\\n if not ((position-1)//2) in nodes:\\n insertNode((position-1)//2)\\n nodes[position]=TreeNode(d[position])\\n if position%2==0:\\n nodes[(position-1)//2].right=nodes[position]\\n else:\\n nodes[(position-1)//2].left=nodes[position]\\n return\\n \\n for i in d.keys():\\n insertNode(i)\\n \\n return nodes[0]\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"22800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n serializedTree = []\\n def dfs(root):\\n if not root: return 0\\n serializedTree.append(None)\\n index = len(serializedTree) - 1\\n nodesInLeft = dfs(root.left)\\n nodesInRight = dfs(root.right)\\n serializedTree[index] = (root.val,nodesInLeft,nodesInRight)\\n return nodesInLeft + nodesInRight + 1\\n dfs(root)\\n return \\\",\\\".join([str(ele) for tup in serializedTree for ele in tup])\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n data = [int(strnum) for strnum in data.split(\\\",\\\") if strnum]\\n data = [(data[i],data[i+1],data[i+2]) for i in range(0,len(data),3)]\\n def buildTree(start,end):\\n if end < start: return\\n val,numLeftNodes, numRightNodes = data[start]\\n root = TreeNode(val)\\n root.left = buildTree(start+1, start+numLeftNodes)\\n root.right = buildTree(start+numLeftNodes+1, start+numLeftNodes+numRightNodes)\\n return root\\n return buildTree(0, len(data)-1)\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"22900\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = []\\n q = collections.deque()\\n\\n if root:\\n q.append(root)\\n res.append(str(root.val))\\n\\n while q:\\n for _ in range(len(q)):\\n node = q.popleft()\\n if node.left:\\n q.append(node.left)\\n res.append(str(node.left.val))\\n else:\\n res.append(\\\"null\\\")\\n if node.right:\\n q.append(node.right)\\n res.append(str(node.right.val))\\n else:\\n res.append(\\\"null\\\")\\n return \\\",\\\".join(res)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return []\\n data = data.split(\\\",\\\")\\n \\n q = collections.deque()\\n self.i = 1\\n root = TreeNode(data[0])\\n q.append(root)\\n \\n while q:\\n node = q.popleft()\\n if self.i < len(data):\\n node.left = TreeNode(data[self.i])\\n q.append(node.left)\\n self.i += 1\\n if self.i < len(data):\\n node.right = TreeNode(data[self.i])\\n q.append(node.right)\\n self.i += 1\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23000\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n # Attempt to do as before\\n # APPROACH: preorder traversal \\\"1(2(6,),3(4,5))\\\"\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"\\\"\\n res = [str(root.val)]\\n if root.left or root.right:\\n res.append(\\\"(\\\")\\n res.append(self.serialize(root.left))\\n res.append(\\\",\\\")\\n res.append(self.serialize(root.right))\\n res.append(\\\")\\\")\\n return \\\"\\\".join(res)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"\\\":\\n return None\\n if data.isnumeric() or data[0] == \\\"-\\\" and data[1:].isnumeric():\\n return TreeNode(int(data))\\n b = 0\\n while data[b] != \\\"(\\\":\\n b += 1\\n c = b + 1\\n brackets = 0\\n while c < len(data):\\n if data[c] == \\\"(\\\":\\n brackets += 1\\n if data[c] == \\\")\\\":\\n brackets -= 1\\n if brackets == 0 and data[c] == \\\",\\\":\\n break\\n c += 1\\n res = TreeNode(int(data[:b]))\\n res.left = self.deserialize(data[b + 1:c])\\n res.right = self.deserialize(data[c + 1:-1])\\n return res\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def serializeNodes(node):\\n if not node:\\n return None\\n return {\\n 'v': node.val,\\n 'l': serializeNodes(node.left),\\n 'r': serializeNodes(node.right),\\n }\\n return json.dumps(serializeNodes(root))\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def buildNode(data):\\n if data == None:\\n return None\\n return TreeNode(\\n val=data['v'],\\n left=buildNode(data['l']),\\n right=buildNode(data['r']),\\n )\\n return buildNode(json.loads(data))\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nimport json\\n\\nclass Codec:\\n \\n def serialize_to_json(self, node):\\n if not node:\\n return None\\n response = dict()\\n response[\\\"left\\\"] = self.serialize_to_json(node.left)\\n response[\\\"right\\\"] = self.serialize_to_json(node.right)\\n response[\\\"val\\\"] = node.val\\n return response\\n \\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n response = json.dumps(self.serialize_to_json(root))\\n return response\\n \\n def deserialize_from_json(self, data):\\n if not data:\\n return None\\n response = TreeNode(data[\\\"val\\\"])\\n response.left = self.deserialize_from_json(data[\\\"left\\\"])\\n response.right = self.deserialize_from_json(data[\\\"right\\\"])\\n return response\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n \\n return self.deserialize_from_json(json.loads(data))\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23200\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n # bfs traversal\\n if not root:\\n return \\\"\\\"\\n arr = []\\n def bfs(queue,level):\\n nonlocal arr\\n if not queue:\\n return\\n next_queue = collections.deque()\\n while queue:\\n node,idx = queue.pop()\\n arr.append(str(idx)+\\\",\\\"+str(node.val))\\n #arr[-1][idx]= str(node.val)\\n if node.left != None:\\n next_queue.append((node.left,idx*2+1))\\n if node.right != None:\\n next_queue.append((node.right,idx*2+2))\\n if next_queue:\\n bfs(next_queue,level+1)\\n\\n queue = collections.deque()\\n queue.append((root,0))\\n bfs(queue,0)\\n \\n return \\\"|\\\".join(arr)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"\\\":\\n return []\\n\\n data = data.split(\\\"|\\\")\\n inDict = dict()\\n for d in data:\\n d = d.split(\\\",\\\")\\n ind,val = int(d[0]),int(d[1])\\n inDict[ind]=val\\n \\n \\n def build_tree(idx):\\n if idx not in inDict:\\n return None\\n root = TreeNode(inDict[idx])\\n root.left = build_tree(2*idx+1)\\n root.right = build_tree(2*idx+2)\\n return root\\n\\n root = build_tree(0)\\n return root\\n\\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root: TreeNode) -> str:\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n strings = [] \\n nodes = [(0, root)]\\n while nodes:\\n idx, node = nodes.pop(0)\\n if node is None:\\n strings.append('null')\\n continue\\n strings.append(str(node.val) if node.val is not None else 'null')\\n if node.val is not None:\\n nodes.append((idx*2 + 1, node.left)) \\n nodes.append((idx*2 + 2, node.right))\\n if strings[0] == 'null':\\n return ''\\n return ','.join(strings)\\n \\n\\n def deserialize(self, data: str) -> TreeNode:\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if len(data) > 0:\\n data = data.split(',') \\n n = len(data) \\n nodes = [None for _ in range(n)] \\n for idx in range(n-1,-1,-1): \\n val = data[idx] \\n left_node = nodes[idx*2 + 1] if idx*2+1 < n else None\\n right_node = nodes[idx*2 + 2] if idx*2+2 < n else None\\n node = TreeNode(val)\\n node.left = left_node\\n node.right = right_node\\n nodes[idx] = node\\n return nodes[0]\\n else:\\n return None\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if (root is None):\\n return \\\"[]\\\"\\n\\n val = str(root.val)\\n\\n if (root.left is None):\\n return \\\"[\\\" + val + \\\"[]\\\" + self.serialize(root.right) + \\\"]\\\"\\n\\n if (root.right is None):\\n return \\\"[\\\" + val + self.serialize(root.left) + \\\"[]\\\" + \\\"]\\\"\\n\\n return \\\"[\\\" + val + self.serialize(root.left) + self.serialize(root.right) + \\\"]\\\"\\n\\n\\n def find_closing_brace_idx(self, s):\\n cnt = 1\\n for i in range(1, len(s)):\\n c = s[i]\\n if c == \\\"[\\\":\\n cnt += 1\\n elif c == \\\"]\\\":\\n cnt -= 1\\n\\n if cnt == 0:\\n return i\\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n # [1 [2] [3 [4] [5]]]\\n\\n if data == \\\"[]\\\":\\n return None\\n\\n left_tree_starting_brace = data[1:].index(\\\"[\\\") + 1\\n left_tree_closing_brace = self.find_closing_brace_idx(data[left_tree_starting_brace:])\\n left_tree_closing_brace += left_tree_starting_brace\\n\\n left = self.deserialize(data[left_tree_starting_brace: left_tree_closing_brace + 1])\\n right = self.deserialize(data[left_tree_closing_brace + 1: -1])\\n\\n val = int(data[1: left_tree_starting_brace])\\n\\n root = TreeNode(val)\\n root.left = left\\n root.right = right\\n\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23500\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if (root is None):\\n return \\\"[]\\\"\\n\\n val = str(root.val)\\n\\n if (root.left is None):\\n return \\\"[\\\" + val + \\\"[]\\\" + self.serialize(root.right) + \\\"]\\\"\\n\\n if (root.right is None):\\n return \\\"[\\\" + val + self.serialize(root.left) + \\\"[]\\\" + \\\"]\\\"\\n\\n return \\\"[\\\" + val + self.serialize(root.left) + self.serialize(root.right) + \\\"]\\\"\\n\\n\\n \\n\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n def find_closing_brace_idx(s):\\n cnt = 1\\n for i in range(1, len(s)):\\n c = s[i]\\n if c == \\\"[\\\":\\n cnt += 1\\n elif c == \\\"]\\\":\\n cnt -= 1\\n\\n if cnt == 0:\\n return i\\n\\n if data == \\\"[]\\\":\\n return None\\n\\n left_tree_starting_brace = data[1:].index(\\\"[\\\") + 1\\n left_tree_closing_brace = find_closing_brace_idx(data[left_tree_starting_brace:])\\n left_tree_closing_brace += left_tree_starting_brace\\n\\n left = self.deserialize(data[left_tree_starting_brace: left_tree_closing_brace + 1])\\n right = self.deserialize(data[left_tree_closing_brace + 1: -1])\\n\\n val = int(data[1: left_tree_starting_brace])\\n\\n root = TreeNode(val)\\n root.left = left\\n root.right = right\\n\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23500\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root: return '()'\\n return '(' + str(root.val) + self.serialize(root.left) + self.serialize(root.right) + ')' \\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == '()':\\n return None\\n i = 1\\n while data[i] != '(':\\n i += 1\\n\\n root = TreeNode(int(data[1:i]))\\n count = 1\\n left1 = i\\n right1 = i+1\\n while count:\\n if data[right1] == '(':\\n count += 1\\n elif data[right1] == ')':\\n count -= 1\\n right1 += 1\\n left2 = right1\\n right1 -= 1\\n right2 = len(data) - 2\\n\\n root.left = self.deserialize(data[left1:right1+1])\\n root.right = self.deserialize(data[left2:right2+1])\\n\\n return root\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23600\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root: return '()'\\n return '(' + str(root.val) + self.serialize(root.left) + self.serialize(root.right) + ')' \\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == '()':\\n return None\\n i = 1\\n while data[i] != '(':\\n i += 1\\n\\n root = TreeNode(int(data[1:i]))\\n count = 1\\n left1 = i\\n right1 = i+1\\n while count:\\n if data[right1] == '(':\\n count += 1\\n elif data[right1] == ')':\\n count -= 1\\n right1 += 1\\n left2 = right1\\n right1 -= 1\\n right2 = len(data) - 2\\n\\n root.left = self.deserialize(data[left1:right1+1])\\n root.right = self.deserialize(data[left2:right2+1])\\n\\n return root\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23600\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def dfs(root):\\n if root == None:\\n return \\\"\\\"\\n l = dfs(root.left)\\n r = dfs(root.right)\\n return str(root.val) + \\\"{\\\" + l + \\\"}\\\" + \\\"{\\\" + r + \\\"}\\\"\\n return dfs(root)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def dfs(s):\\n # print(s, \\\"--s\\\")\\n if len(s) == 0:\\n return None\\n n = len(s)\\n val = \\\"\\\"\\n i = 0\\n while s[i] != \\\"{\\\":\\n val += s[i]\\n i += 1\\n # print(val, \\\"--val\\\")\\n node = TreeNode(int(val))\\n\\n \\n st = [\\\"{\\\"]\\n l = \\\"\\\"\\n i += 1\\n while i < n:\\n if s[i] == \\\"}\\\":\\n if len(st) == 1:\\n st.pop()\\n break\\n else:\\n st.pop()\\n elif s[i] == \\\"{\\\":\\n st.append(\\\"{\\\")\\n l += s[i]\\n i += 1\\n # print(l, \\\"--l\\\")\\n # print(s[i+2:-1], \\\"--r\\\")\\n\\n node.left = dfs(l)\\n node.right = dfs(s[i+2:-1])\\n return node\\n # print(data)\\n return dfs(data)\\n\\n\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23700\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"\\\"\\n return f\\\"{root.val}[{self.serialize(root.left)}][{self.serialize(root.right)}]\\\"\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n brackets = {}\\n stack = []\\n for index, char in enumerate(data):\\n if char == \\\"[\\\":\\n stack.append(index)\\n elif char == \\\"]\\\":\\n brackets[stack.pop()] = index\\n # print(data)\\n def f(left, right):\\n # print(left, right)\\n if left > right:\\n return None\\n i = left + 1\\n while i <= right and data[i].isdigit():\\n i += 1\\n # print(left, i)\\n val = int(data[left:i])\\n node = TreeNode(val)\\n if i < right:\\n left_open = i\\n left_close = brackets[left_open]\\n right_open = left_close + 1\\n right_close = brackets[right_open]\\n node.left = f(left_open + 1, left_close - 1)\\n node.right = f(right_open + 1, right_close - 1)\\n return node\\n return f(0, len(data) - 1)\\n\\n\\n \\n\\n\\n \\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nimport pickle\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n r = pickle.dumps(root)\\n s = r.hex()\\n return s\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n b = bytes.fromhex(data)\\n r = pickle.loads(b, encoding='bytes')\\n return r\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"23900\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def dfs(root, st):\\n if not root:\\n st += \\\"#,\\\"\\n else:\\n st += f\\\"{root.val},\\\"\\n st = dfs(root.left, st)\\n st = dfs(root.right, st)\\n return st\\n return dfs(root, \\\"\\\")\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n arr = data.split(\\\",\\\")\\n \\n def dfs(arr):\\n if arr[0] == \\\"#\\\":\\n arr.pop(0)\\n return None\\n \\n root = TreeNode(arr[0])\\n arr.pop(0)\\n root.left = dfs(arr)\\n root.right = dfs(arr)\\n return root\\n \\n return dfs(arr)\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"24000\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def helper(root, out):\\n if not root:\\n out += '#,'\\n else:\\n out += '{},'.format(root.val)\\n out = helper(root.left, out)\\n out = helper(root.right, out)\\n return out\\n out = ''\\n \\n return helper(root, out)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def helper(l):\\n l0 = l.pop(0)\\n if l0 == '#':\\n return None\\n root = TreeNode(l0)\\n root.left = helper(l)\\n root.right = helper(l)\\n return root\\n l = data.split(',')\\n root = helper(l)\\n return root\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"24100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nimport pickle\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n r = pickle.dumps(root)\\n s = r.hex()\\n return s\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n b = bytes.fromhex(data)\\n r = pickle.loads(b, encoding='bytes')\\n print(\\\"decode\\\", r)\\n return r\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"24200\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\nimport json\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def dfs(r=root):\\n if r is None:\\n return None \\n else:\\n if r.left and r.right:\\n return {'root': r.val, 'left': dfs(r.left), 'right': dfs(r.right)}\\n elif r.left:\\n return {'root': r.val, 'left': dfs(r.left), 'right': None}\\n elif r.right:\\n return {'root': r.val, 'left': None, 'right': dfs(r.right)}\\n else:\\n return {'root': r.val, 'left':None, 'right':None}\\n return json.dumps(dfs())\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def dfs(tdict):\\n if tdict is None:\\n return None\\n root = TreeNode(tdict['root'])\\n l = r= None\\n if tdict['left']:\\n l = dfs(tdict['left'])\\n if tdict['right']:\\n r = dfs(tdict['right'])\\n root.left = l\\n root.right = r\\n return root\\n treeDict = json.loads(data)\\n #print(treeDict)\\n return dfs(treeDict)\\n\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"24300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n res = \\\"\\\"\\n def doit(node, res):\\n if not node:\\n res += \\\"# \\\"\\n else:\\n res += f\\\"{node.val} \\\"\\n res = doit(node.left, res)\\n res = doit(node.right, res)\\n return res\\n\\n return doit(root, \\\"\\\")\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def doit():\\n val = next(vals)\\n if val == \\\"#\\\":\\n return None\\n node = TreeNode(int(val))\\n node.left = doit()\\n node.right = doit()\\n return node\\n \\n vals = iter(data.strip().split())\\n return doit()\\n\\n\\n # data_list = deque(data.strip().split())\\n # # create dummy node that points to root\\n # head = TreeNode(\\\"head\\\")\\n # node_val = data_list.popleft()\\n # if node_val != \\\"null\\\":\\n # root = TreeNode(int(node_val))\\n # head.right = root\\n # roots = [] # keeps track of past roots so we can access them\\n # while data_list:\\n # while root:\\n # roots.append(root)\\n # node_val = data_list.popleft()\\n # if node_val != \\\"null\\\":\\n # root.left = TreeNode(int(node_val))\\n # root = root.left\\n \\n # root = roots.pop()\\n # node_val = data_list.popleft()\\n # if node_val != \\\"null\\\":\\n # root.right = TreeNode(int(node_val))\\n # root = root.right\\n \\n # return head.right\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"24400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root == None:\\n return \\\"\\\"\\n ids = dict()\\n s = [root]\\n c = 0\\n while s:\\n n = s.pop()\\n if n != None:\\n ids[n] = c\\n c += 1\\n if n.left:\\n s.append(n.left)\\n if n.right:\\n s.append(n.right)\\n rt = ids[root]\\n data = []\\n s = [root]\\n while s:\\n n = s.pop()\\n data_element=[str(ids[n]), str(n.val)]\\n if n.left:\\n s.append(n.left)\\n data_element.append(str(ids[n.left]))\\n else:\\n data_element.append('N')\\n if n.right:\\n s.append(n.right)\\n data_element.append(str(ids[n.right]))\\n else:\\n data_element.append('N')\\n data.append(data_element)\\n els = \\\"\\\"\\n for e in data:\\n if els == \\\"\\\":\\n els += \\\",\\\".join(e)\\n else:\\n els += \\\"DEL\\\" + \\\",\\\".join(e)\\n final = f\\\"{rt}|{els}\\\"\\n return final\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data:\\n return None\\n def build(id, adj, el):\\n if id == None:\\n None\\n else:\\n return TreeNode(el[id], build(adj[id][0], adj, el), build(adj[id][1], adj, el))\\n\\n def tfm(c):\\n if c == 'N':\\n return None\\n else:\\n return int(c)\\n root = tfm(data.split('|')[0])\\n datas = list(map(lambda x: x.split(\\\",\\\"), data.split(\\\"|\\\")[1].split(\\\"DEL\\\")))\\n d = dict()\\n adj = dict()\\n for e in datas:\\n d[int(e[0])] = int(e[1])\\n adj[int(e[0])] = [tfm(e[2]), tfm(e[3])]\\n return build(root, adj, d)\\n \\n\\n\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"24600\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n if root == None:\\n return \\\"\\\"\\n return \\\"{\\\" + str(root.val) + \\\"}{\\\" + self.serialize(root.left) + \\\"}{\\\" + self.serialize(root.right) + \\\"}\\\"\\n \\n\\n def deserialize(self, data):\\n brackets = 0\\n part = 0; prev = 1\\n root = None\\n for i, c in enumerate(data):\\n if c == \\\"{\\\":\\n brackets += 1\\n elif c == \\\"}\\\":\\n brackets -= 1\\n if brackets == 0:\\n if part == 0:\\n root = TreeNode(int(data[prev:i]))\\n elif part == 1:\\n root.left = self.deserialize(data[prev:i])\\n else:\\n root.right = self.deserialize(data[prev:i])\\n part += 1\\n prev = i + 2\\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"24700\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if root is None:\\n return \\\"[]\\\"\\n return f\\\"[{root.val},{self.serialize(root.left)},{self.serialize(root.right)}]\\\"\\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == '[]':\\n return None\\n closed = 0\\n val = ''\\n leftData = ''\\n rightData = ''\\n tmp = ''\\n for i in range(len(data)):\\n if i == 0:\\n continue\\n if len(val) == 0:\\n if data[i] == ',' and closed == 0:\\n val = tmp\\n tmp = ''\\n continue\\n elif len(leftData) == 0:\\n if data[i] == ',' and closed == 0:\\n leftData = tmp\\n tmp = ''\\n continue\\n else:\\n if data[i] == ']' and closed == 0:\\n rightData = tmp\\n tmp = ''\\n continue\\n tmp += data[i]\\n if data[i] == '[':\\n closed += 1\\n elif data[i] == ']':\\n closed -= 1\\n return TreeNode(int(val), self.deserialize(leftData), self.deserialize(rightData))\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"24800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n pre_s = ''\\n in_s = ''\\n\\n index = 45\\n\\n def preorder(root):\\n nonlocal pre_s, index\\n if root == None:\\n return\\n root.index = index\\n pre_s += chr(root.val + 1045) + '#' + chr(index) + ','\\n index += 1\\n preorder(root.left)\\n preorder(root.right)\\n \\n def inorder(root):\\n nonlocal in_s\\n if root == None:\\n return\\n inorder(root.left)\\n in_s += chr(root.val + 1045) + '#' + chr(root.index) + ','\\n inorder(root.right)\\n\\n preorder(root)\\n inorder(root)\\n return pre_s[:-1] + '+' + in_s[:-1]\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n [preorder, inorder] = [d.split(',') if len(d) > 0 else [] for d in data.split('+')]\\n inorder_map = {}\\n for i, num in enumerate(inorder):\\n inorder_map[num] = i\\n index = 0\\n\\n def construct(left, right):\\n nonlocal index\\n if left > right:\\n return None\\n val_and_idx = preorder[index]\\n [val, node_idx] = val_and_idx.split('#')\\n val = ord(val) - 1045\\n root = TreeNode(val)\\n index += 1\\n root.left = construct(left, inorder_map[val_and_idx] - 1)\\n root.right = construct(inorder_map[val_and_idx] + 1, right)\\n return root\\n \\n return construct(0, len(inorder) - 1)\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"25000\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n DELIMITER = '#'\\n NULL = 'NULL'\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root: return self.NULL\\n\\n \\n left_serialized = self.serialize(root.left)\\n right_serialized = self.serialize(root.right)\\n \\n serialized = str(root.val)\\n serialized += f'{self.DELIMITER}{str(len(left_serialized))}{self.DELIMITER}'\\n serialized += left_serialized\\n serialized += right_serialized\\n return serialized\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == self.NULL: return None\\n first_delimiter = None\\n second_delimiter = None\\n for idx in range(len(data)):\\n if data[idx] == self.DELIMITER:\\n if first_delimiter is None:\\n first_delimiter = idx\\n continue\\n elif second_delimiter is None:\\n second_delimiter = idx\\n continue\\n else:\\n break\\n \\n root = TreeNode(int(data[:first_delimiter]))\\n len_left_serialized = int(data[first_delimiter + 1: second_delimiter])\\n root.left = self.deserialize(data[second_delimiter + 1:second_delimiter + 1 + len_left_serialized])\\n root.right = self.deserialize(data[second_delimiter + 1 + len_left_serialized:])\\n return root\\n\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"25100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n # pre root l r\\n # in l root r\\n self.preOrderArr = []\\n self.inOrderArr = []\\n def preOrder(root, level):\\n if root:\\n self.preOrderArr.append(str(root.val) + \\\":\\\" + str(level))\\n preOrder(root.left, level+1)\\n preOrder(root.right, level+1)\\n def inOrder(root, level):\\n if root:\\n inOrder(root.left, level +1)\\n self.inOrderArr.append(str(root.val) + \\\":\\\" + str(level))\\n inOrder(root.right, level +1)\\n\\n preOrder(root, 0)\\n inOrder(root, 0)\\n return \\\",\\\".join(self.preOrderArr) + \\\"@\\\" + \\\",\\\".join(self.inOrderArr)\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if \\\"@\\\" == data:\\n return None\\n data = data.split(\\\"@\\\")\\n preOrderArr = data[0].split(\\\",\\\")\\n inOrderArr = data[1].split(\\\",\\\")\\n\\n print(preOrderArr, inOrderArr)\\n\\n def constructTree(preOrderArr, inOrderArr):\\n if inOrderArr:\\n val = preOrderArr.pop(0)\\n idx = inOrderArr.index(val)\\n return TreeNode(int(val.split(\\\":\\\")[0]), constructTree(preOrderArr, inOrderArr[:idx]), constructTree(preOrderArr, inOrderArr[idx+1:]))\\n\\n return constructTree(preOrderArr, inOrderArr)\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"25200\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def preorder(node: TreeNode, result: List[int]=[]) -> List[int]:\\n if node == None:\\n return result\\n \\n result.append(f\\\"{id(node)}:{node.val}\\\")\\n preorder(node.left, result)\\n preorder(node.right, result)\\n return result\\n \\n def inorder(node: TreeNode, result: List[int]=[]) -> List[int]:\\n if node == None:\\n return result\\n \\n inorder(node.left, result)\\n result.append(f\\\"{id(node)}:{node.val}\\\")\\n inorder(node.right, result)\\n return result\\n \\n preorder_str = \\\",\\\".join(preorder(root))\\n inorder_str = \\\",\\\".join(inorder(root))\\n\\n return f\\\"{preorder_str}\\\\n{inorder_str}\\\"\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n preorder_str, inorder_str = data.split(\\\"\\\\n\\\")\\n if len(inorder_str) == 0:\\n return None\\n \\n preorder = []\\n for entry in preorder_str.split(\\\",\\\"):\\n nodeid, val = entry.split(\\\":\\\")\\n preorder.append((int(nodeid), int(val)))\\n \\n inorder = []\\n for entry in inorder_str.split(\\\",\\\"):\\n nodeid, val = entry.split(\\\":\\\")\\n inorder.append((int(nodeid), int(val)))\\n\\n def buildTree(preorder: List[Tuple[int, int]], inorder: List[Tuple[int, int]]) -> TreeNode:\\n if len(inorder) == 0:\\n return None\\n nodeid, val = next(preorder)\\n node = TreeNode(val)\\n partition = inorder.index((nodeid, val))\\n node.left = buildTree(preorder, inorder[:partition])\\n node.right = buildTree(preorder, inorder[partition + 1:])\\n return node\\n \\n return buildTree(iter(preorder), inorder)\\n\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"25300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n tree = defaultdict(list)\\n def traverse(node, rootNode=False):\\n if not node:\\n return None\\n if rootNode:\\n key = 'root'\\n else:\\n key = str(id(node))\\n tree[key].append(node.val)\\n tree[key].append(traverse(node.left))\\n tree[key].append(traverse(node.right))\\n\\n return key\\n \\n traverse(root, rootNode=True)\\n print(json.dumps(tree))\\n return json.dumps(tree)\\n\\n \\n \\n \\n\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n tree = json.loads(data)\\n def traverse(node):\\n if not node:\\n return None\\n treeNode = TreeNode(tree[node][0])\\n treeNode.left = traverse(tree[node][1])\\n treeNode.right = traverse(tree[node][2])\\n return treeNode\\n if not tree:\\n return None\\n root = traverse('root')\\n\\n return root\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"25400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n def serialize(self, root):\\n def DFS_pack(node):\\n if not node: return \\\"None\\\"\\n s = \\\"{\\\" + str(node.val) + \\\",\\\"\\n s = s + DFS_pack(node.left) + \\\",\\\"\\n s = s + DFS_pack(node.right) + \\\"}\\\"\\n return s\\n if not root: return \\\"\\\"\\n return DFS_pack(root)\\n def deserialize(self, data):\\n def DFS_unpack(S):\\n if S==\\\"None\\\" or not S: return None \\n n1 = 0\\n while n1<len(S) and S[n1]!=',': n1 += 1\\n v = S[1:n1] # value\\n if S[n1+1:].startswith(\\\"None\\\"): n2 = n1 + 5\\n else:\\n n2, c1, c2 = 0, 0, 0\\n for i in range(n1+1, len(S)):\\n if S[i]==\\\"{\\\": c1 += 1\\n elif S[i]==\\\"}\\\": c2 += 1\\n if c1>0 and c1==c2: \\n n2 = i + 1\\n break\\n L = S[n1+1:n2] # left child \\n R = S[n2+1:len(S)-1] # right child \\n left = DFS_unpack(L)\\n right = DFS_unpack(R)\\n node = TreeNode(v)\\n node.left = left\\n node.right = right\\n return node \\n return DFS_unpack(data) \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"25600\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n def serialize(self, root):\\n def DFS_pack(node):\\n if not node: return \\\"None\\\"\\n s = \\\"{\\\" + str(node.val) + \\\",\\\"\\n s = s + DFS_pack(node.left) + \\\",\\\"\\n s = s + DFS_pack(node.right) + \\\"}\\\"\\n return s\\n return DFS_pack(root)\\n def deserialize(self, data):\\n def DFS_unpack(S):\\n if S==\\\"None\\\" or not S: return None \\n n1 = 0\\n while n1<len(S) and S[n1]!=',': n1 += 1\\n v = S[1:n1] # value\\n if S[n1+1:].startswith(\\\"None\\\"): n2 = n1 + 5\\n else:\\n n2, c1, c2 = 0, 0, 0\\n for i in range(n1+1, len(S)):\\n if S[i]==\\\"{\\\": c1 += 1\\n elif S[i]==\\\"}\\\": c2 += 1\\n if c1>0 and c1==c2: \\n n2 = i + 1\\n break\\n L = S[n1+1:n2] # left child \\n R = S[n2+1:len(S)-1] # right child \\n left = DFS_unpack(L)\\n right = DFS_unpack(R)\\n node = TreeNode(v)\\n node.left = left\\n node.right = right\\n return node \\n return DFS_unpack(data) \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"25600\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n \\\"\\\"\\\"\\n > nodes value may not be unique\\n\\n what if we assign a number to each node.\\n and store the left and right of nodes as that node's number\\n We don't even need to assign the number, we can use array and array index can be that number.\\n\\n then it will look like\\n [\\n (node_value, left_index, right_index)\\n .\\n .\\n .\\n ]\\n if left_index is empty, that mean it is None.\\n \\\"\\\"\\\"\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n hmap = {} # node to index\\n hmap[None] = \\\"\\\"\\n n = 0\\n nodes = []\\n \\n def do_indexing(node=root):\\n nonlocal n, nodes, hmap\\n\\n if not node:\\n return\\n\\n if node not in hmap:\\n hmap[node] = n\\n nodes.append((node, n))\\n n += 1\\n\\n do_indexing(node.left)\\n do_indexing(node.right)\\n \\n do_indexing()\\n entries = [] \\n for node in nodes:\\n entry = str(node[0].val) + \\\"_\\\" + str(hmap[node[0].left]) + \\\"_\\\" + str(hmap[node[0].right])\\n entries.append(entry)\\n\\n return \\\" \\\".join(entries)\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if not data or not len(data):\\n return None\\n \\n entries = data.split(\\\" \\\")\\n n = len(entries)\\n\\n nodes = [entry.split(\\\"_\\\") for entry in entries]\\n print(nodes)\\n nodes_real = [TreeNode(int(nod[0])) for nod in nodes]\\n\\n for i in range(n):\\n left_idx, right_idx = nodes[i][1], nodes[i][2]\\n if left_idx:\\n nodes_real[i].left = nodes_real[int(left_idx)]\\n if right_idx:\\n nodes_real[i].right = nodes_real[int(right_idx)]\\n\\n return nodes_real[0]\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"25700\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n\\n if not root:\\n return '-1001'\\n\\n return f'{root.val}({self.serialize(root.left)} {self.serialize(root.right)})'\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n\\n value_str = ''\\n \\n # extract root value\\n i = 0\\n while i != len(data) and data[i] not in '( )':\\n value_str += data[i]\\n i += 1\\n \\n # skip '(/ /)'\\n i += 1\\n\\n # identify None value\\n if value_str == '-1001':\\n return None\\n\\n node = TreeNode( int(value_str) )\\n\\n # find new_data for recursion\\n left = right = ''\\n brackets_opened = 0\\n # len(data) - 1 bcs we don't want to include ')'\\n while i < len(data) - 1:\\n if data[i] == '(':\\n brackets_opened += 1\\n elif data[i] == ')':\\n brackets_opened -= 1\\n \\n if brackets_opened == 0 and data[i] == ' ':\\n left, right = right, left\\n else:\\n right += data[i]\\n \\n i += 1\\n\\n node.left = self.deserialize(left)\\n node.right = self.deserialize(right)\\n\\n return node\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"25800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n \\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n \\n def serialize_recursive(node, string):\\n if not node:\\n string += 'end,'\\n else:\\n string += str(node.val) + ','\\n string = serialize_recursive(node.left, string)\\n string = serialize_recursive(node.right, string)\\n \\n return string\\n \\n return serialize_recursive(root, '')\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n \\n def deserialize_recursive(l):\\n if l[0] == 'end':\\n l.pop(0)\\n return None\\n \\n node = TreeNode(l[0])\\n l.pop(0)\\n node.left = deserialize_recursive(l)\\n node.right = deserialize_recursive(l)\\n \\n return node\\n \\n \\n data_list = data.split(',')\\n return deserialize_recursive(data_list)\\n \\n\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n\\n# def serialize(self, root):\\n# \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n# :type root: TreeNode\\n# :rtype: str\\n# \\\"\\\"\\\"\\n# def rserialize(root, string):\\n# if not root:\\n# string += 'None,' # indicate end of tree\\n# else:\\n# # preorder traversal\\n# string += str(root.val) + ','\\n# string = rserialize(root.left, string)\\n# string = rserialize(root.right, string)\\n \\n# return string\\n \\n# return rserialize(root, '')\\n \\n\\n# def deserialize(self, data):\\n# \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n# :type data: str\\n# :rtype: TreeNode\\n# \\\"\\\"\\\"\\n\\n# def rdeserialize(l):\\n# if l[0] == 'None':\\n# l.pop(0)\\n# return None\\n \\n# root = TreeNode(l[0])\\n# l.pop(0)\\n# root.left = rdeserialize(l)\\n# root.right = rdeserialize(l)\\n# return root\\n \\n# data_list = data.split(',')\\n# root = rdeserialize(data_list) \\n# return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"25900\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n #follow format of val<left>right with n being there in place of values right or left if they are none \\n if root == None: \\n return \\\"n\\\"\\n return f\\\"{root.val}<{self.serialize(root.left)}>{self.serialize(root.right)}\\\"\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n \\n if data == \\\"n\\\": \\n return None\\n \\n \\n root_val_string = ''\\n for i in range(len(data)):\\n if data[i] == '<': \\n data = data[i+1:]\\n break\\n else: \\n root_val_string += data[i]\\n \\n right_string = ''\\n left_string = ''\\n open_count = 1 \\n close_count = 0\\n for i in range(len(data)):\\n if data[i] == '<':\\n left_string += data[i]\\n open_count += 1 \\n elif data[i] == '>': \\n close_count += 1 \\n if open_count == close_count:\\n right_string = data[i+1:]\\n break \\n else: \\n left_string += data[i]\\n else: \\n left_string += data[i]\\n \\n \\n root = TreeNode(val=int(root_val_string))\\n root.left = self.deserialize(left_string) \\n root.right = self.deserialize(right_string)\\n return root \\n \\n \\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"26000\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n if not root:\\n return \\\"\\\"\\n\\n root_val = str(root.val)\\n root_len = len(root_val)\\n\\n left_child = self.serialize(root.left)\\n left_child_len = len(left_child)\\n\\n right_child = self.serialize(root.right)\\n right_child_len = len(right_child)\\n\\n return f'{root_len}#{left_child_len}#{right_child_len}#{root_val}{left_child}{right_child}'\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n if data == \\\"\\\":\\n return None\\n hash_count = 0\\n count = 0\\n i = 0\\n stack = []\\n while hash_count != 3:\\n if data[i] == \\\"#\\\":\\n hash_count += 1\\n stack.append(count)\\n count = 0\\n else:\\n count = count*10 + int(data[i])\\n i += 1\\n r_val = data[i:i+stack[0]]\\n lc_val = data[i+stack[0]: i + stack[0] + stack[1]]\\n rc_val = data[i+stack[0]+stack[1]: i + stack[0] + stack[1]+stack[2]]\\n\\n root = TreeNode(int(r_val))\\n left_child = self.deserialize(lc_val)\\n right_child = self.deserialize(rc_val)\\n root.left = left_child\\n root.right = right_child\\n \\n return root\\n \\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"26100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n output = []\\n to_process = [root]\\n while to_process:\\n current = to_process.pop(0)\\n if current is not None:\\n output.append(current.val)\\n to_process.append(current.left)\\n to_process.append(current.right)\\n else:\\n output.append(None)\\n while output and output[-1] is None:\\n output.pop()\\n return (\\\"[\\\" + \\\",\\\".join([str(o) for o in output]) + \\\"]\\\").replace(\\\"None\\\", \\\"null\\\")\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n data_list = eval(data.replace(\\\"null\\\", \\\"None\\\"))\\n if not data_list:\\n return None\\n root = TreeNode(data_list.pop(0))\\n n = len(data_list)\\n to_process = [root]\\n for i in range(n)[::2]:\\n val_left = data_list[i]\\n if i + 1 < n:\\n val_right = data_list[i + 1]\\n add_right = True\\n else:\\n add_right = False\\n node = to_process.pop(0)\\n # Add val_left\\n if val_left is None:\\n node.left = None\\n else:\\n node.left = TreeNode(val_left)\\n to_process.append(node.left)\\n # Add val_right\\n if add_right:\\n if val_right is None:\\n node.right = None\\n else:\\n node.right = TreeNode(val_right)\\n to_process.append(node.right)\\n\\n return root\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"26300\"\n },\n {\n \"code\": \"def getList(root: Optional[TreeNode]):\\n ans: list[None | int] = []\\n queue = [root]\\n while len(queue) > 0:\\n top = queue.pop(0)\\n if top is not None:\\n ans.append(top.val)\\n else:\\n ans.append(None)\\n if top:\\n queue.append(top.left)\\n queue.append(top.right)\\n\\n # remove all None from end of ans\\n i = len(ans) - 1\\n while i >= 0 and ans[i] == None:\\n i -= 1\\n return ans[0: i + 1]\\n\\n\\ndef formTree(values: list[int | None]):\\n if not values:\\n return None\\n if values[0] is None:\\n return None\\n root = TreeNode(values[0])\\n queue: List[Optional[TreeNode]] = [root]\\n i = 1\\n while i < len(values):\\n top = queue.pop(0)\\n if top is not None:\\n top.left = TreeNode(values[i]) if values[i] != None else None\\n i += 1\\n queue.append(top.left)\\n if i < len(values):\\n top.right = TreeNode(values[i]) if values[i] != None else None\\n i += 1\\n queue.append(top.right)\\n else:\\n continue\\n return root\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n return str(getList(root))\\n \\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n return formTree(eval(data))\\n\\n \\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"26400\"\n },\n {\n \"code\": \"class Codec:\\n def serialize(self, root):\\n if not root:\\n return \\\"N\\\"\\n left = self.serialize(root.left)\\n right = self.serialize(root.right)\\n return f\\\"{root.val},{len(left)}:{left},{len(right)}:{right}\\\"\\n\\n def deserialize(self, data):\\n end = 0\\n while end < len(data) and data[end] != \\\",\\\":\\n end += 1\\n\\n if data[:end] == \\\"N\\\":\\n return None\\n\\n val = int(data[:end])\\n\\n start = end + 1\\n end = start\\n while end < len(data) and data[end] != \\\":\\\":\\n end += 1\\n length = int(data[start:end])\\n left = data[end + 1 : end + 1 + length]\\n\\n start = end + 1 + length + 1\\n end = start\\n while end < len(data) and data[end] != \\\":\\\":\\n end += 1\\n length = int(data[start:end])\\n right = data[end + 1 : end + 1 + length]\\n\\n node = TreeNode(val)\\n node.left = self.deserialize(left)\\n node.right = self.deserialize(right)\\n return node\",\n \"memory\": \"26500\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode(object):\\n# def __init__(self, x):\\n# self.val = x\\n# self.left = None\\n# self.right = None\\n\\nclass Codec:\\n\\n def serialize(self, root):\\n \\\"\\\"\\\"Encodes a tree to a single string.\\n \\n :type root: TreeNode\\n :rtype: str\\n \\\"\\\"\\\"\\n def helper(root, string):\\n if root is None:\\n string += 'None,'\\n else:\\n string += str(root.val) + ','\\n string = helper(root.left, string)\\n string = helper(root.right, string)\\n \\n return string\\n return helper(root, \\\"\\\")\\n\\n def deserialize(self, data):\\n \\\"\\\"\\\"Decodes your encoded data to tree.\\n \\n :type data: str\\n :rtype: TreeNode\\n \\\"\\\"\\\"\\n def helper(l):\\n if l[0] == 'None':\\n l.pop(0)\\n return None\\n \\n root = TreeNode(l[0])\\n l.pop(0)\\n root.left = helper(l)\\n root.right = helper(l)\\n return root\\n \\n datal = data.split(',')\\n root = helper(datal)\\n return root\\n\\n# Your Codec object will be instantiated and called as such:\\n# ser = Codec()\\n# deser = Codec()\\n# ans = deser.deserialize(ser.serialize(root))\",\n \"memory\": \"26600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":91,"string":"91"}}},{"rowIdx":35,"cells":{"question_id":{"kind":"number","value":81,"string":"81"},"name":{"kind":"string","value":"search-in-rotated-sorted-array-ii"},"content":{"kind":"string","value":"<p>There is an integer array <code>nums</code> sorted in non-decreasing order (not necessarily with <strong>distinct</strong> values).</p>\n\n<p>Before being passed to your function, <code>nums</code> is <strong>rotated</strong> at an unknown pivot index <code>k</code> (<code>0 <= k < nums.length</code>) such that the resulting array is <code>[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]</code> (<strong>0-indexed</strong>). For example, <code>[0,1,2,4,4,4,5,6,6,7]</code> might be rotated at pivot index <code>5</code> and become <code>[4,5,6,6,7,0,1,2,4,4]</code>.</p>\n\n<p>Given the array <code>nums</code> <strong>after</strong> the rotation and an integer <code>target</code>, return <code>true</code><em> if </em><code>target</code><em> is in </em><code>nums</code><em>, or </em><code>false</code><em> if it is not in </em><code>nums</code><em>.</em></p>\n\n<p>You must decrease the overall operation steps as much as possible.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<pre><strong>Input:</strong> nums = [2,5,6,0,0,1,2], target = 0\n<strong>Output:</strong> true\n</pre><p><strong class=\"example\">Example 2:</strong></p>\n<pre><strong>Input:</strong> nums = [2,5,6,0,0,1,2], target = 3\n<strong>Output:</strong> false\n</pre>\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 5000</code></li>\n\t<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>\n\t<li><code>nums</code> is guaranteed to be rotated at some pivot.</li>\n\t<li><code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code></li>\n</ul>\n\n<p> </p>\n<p><strong>Follow up:</strong> This problem is similar to <a href=\"/problems/search-in-rotated-sorted-array/description/\" target=\"_blank\">Search in Rotated Sorted Array</a>, but <code>nums</code> may contain <strong>duplicates</strong>. Would this affect the runtime complexity? How and why?</p>\n"},"acRate":{"kind":"number","value":38.14841781650061,"string":"38.148418"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","binary-search"],"string":"[\n \"array\",\n \"binary-search\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"32\", 0.0166], [\"33\", 0.0499], [\"34\", 0.0997], [\"35\", 0.1164], [\"36\", 0.0997], [\"37\", 0.1828], [\"38\", 0.2826], [\"39\", 0.5818], [\"40\", 0.3657], [\"41\", 0.5818], [\"42\", 1.4129], [\"43\", 2.4767], [\"44\", 1.5625], [\"45\", 2.1941], [\"46\", 3.607], [\"47\", 5.0366], [\"48\", 3.873], [\"49\", 4.0559], [\"50\", 7.4801], [\"51\", 7.7626], [\"52\", 6.2001], [\"53\", 6.4162], [\"54\", 7.4468], [\"55\", 7.9953], [\"56\", 6.2168], [\"57\", 4.3883], [\"58\", 5.1695], [\"59\", 4.3717], [\"60\", 3.2247]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16800\", 0.3989], [\"16900\", 5.4023], [\"17000\", 23.9694], [\"17100\", 41.9714]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n return True if target in nums else False","runtime":"32"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n l, r = 0, len(nums)-1\n\n while l<=r:\n m = l + (r-l)//2\n if nums[m] == target: return True\n\n if nums[l] < nums[m]:\n if nums[l] <= target < nums[m]:\n r = m - 1\n else:\n l = m + 1\n elif nums[l] > nums[m]:\n if nums[m] < target <= nums[r]:\n l = m + 1\n else:\n r = m - 1\n else:\n l += 1\n return False","runtime":"33"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n return target in nums","runtime":"34"},{"code":"# same as search in rotated sorted array, but with dupes\n\nclass Solution:\n def search(self, nums: List[int], target: int) -> bool:\n # MINES\n if len(nums) == 0:\n return False\n if len(nums) == 1:\n return nums[0] == target\n \n l, r = 0, len(nums) - 1\n while l <= r:\n m = (l + r) // 2\n if nums[m] == target:\n return True\n if nums[m] == nums[l] == nums[r]:\n l += 1\n r -= 1\n continue\n # Right half is sorted\n if nums[m] <= nums[r]:\n print(f\"I should be getting here. r = {r}\")\n if nums[r] == target:\n return True\n if nums[m] < target < nums[r]:\n l = m + 1\n else:\n r = m - 1\n \n # Left half is sorted\n elif nums[m] >= nums[l]:\n if nums[l] == target:\n return True\n if nums[l] < target < nums[m]:\n r = m - 1\n else:\n l = m + 1\n\n \n return False","runtime":"35"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n left, right = 0, len(nums) - 1\n\n while left <= right:\n # mid = left + (right - left) // 2 \n mid = (left+right)//2\n\n if nums[mid] == target:\n return True\n\n if nums[left] < nums[mid]:\n if nums[left] <= target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n\n elif nums[left] > nums[mid]:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n \n # if nums[left] == nums[mid], we cannot determine which part is sorted\n # so we have to search both parts\n else:\n left += 1\n\n return False\n \n #TC: O(n)\n #SC: O(1)","runtime":"36"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n \n l, r = 0, len(nums)-1\n while l <= r:\n mid = l + (r-l)//2\n if nums[mid] == target:\n return True\n\n if nums[l] == nums[r]:\n r-=1\n elif nums[l] <= nums[mid]:\n if nums[l] <= target and target < nums[mid]:\n r = mid - 1\n else:\n l = mid + 1\n else:\n if nums[mid] < target and target <= nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n return False","runtime":"37"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n \n l, r = 0, len(nums) - 1 \n \n while l <= r: \n m = l + (r - l) // 2\n if target == nums[m]: \n return True\n \n if nums[l] < nums[m]: \n if nums[l] <= target < nums[m]: \n r = m - 1 \n else:\n l = m + 1 \n elif nums[l] > nums[m]: \n if nums[m] < target <= nums[r]: \n l = m + 1 \n else:\n r = m - 1 \n else: \n l += 1\n return False \n ","runtime":"38"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n if target in nums:\n return(True)\n return(False)\n ","runtime":"39"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n if target in nums:\n return True\n return False","runtime":"40"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n nums = set(nums)\n return target in nums\n ","runtime":"41"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n n=len(nums)\n low, high= 0, n-1\n\n while low<=high:\n mid=low+(high-low)//2\n if nums[mid] == target:\n return True\n\n if nums[low] == nums[mid] and nums[mid] == nums[high]:\n low+=1\n high-=1\n continue\n\n if nums[low] <= nums[mid]:\n if nums[low] <= target <= nums[mid]:\n high=mid-1\n else:\n low=mid+1\n else:\n if nums[mid] <= target <= nums[high]:\n low=mid+1\n else:\n high=mid-1\n return False\n\n ","runtime":"41"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n # ans = False\n for num in nums:\n if num == target:\n return True\n return False","runtime":"42"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n for num in nums:\n if num == target:\n return True\n return False\n ","runtime":"42"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n low, high = 0, len(nums) - 1\n\n while low <= high:\n mid = (low + high) // 2\n if nums[mid] == target:\n return True\n \n if nums[low] == nums[mid]:\n low += 1\n continue\n \n if nums[low] <= nums[mid]:\n if nums[low] <= target <= nums[mid]:\n high = mid - 1\n else:\n low = mid + 1\n else:\n if nums[mid] <= target <= nums[high]:\n low = mid + 1\n else:\n high = mid - 1\n \n return False","runtime":"43"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n nums.sort()\n if target in nums:\n return True\n return False","runtime":"43"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n l, r = 0, len(nums) - 1 \n while (l <= r):\n mid = (l + r) // 2\n if nums[mid] == target:\n return True\n\n if nums[l] == nums[mid]:\n l += 1\n continue\n \n if nums[l] <= nums[mid]:\n if nums[l] <= target <= nums[mid]:\n r = mid - 1\n else:\n l = mid + 1\n else:\n if nums[mid] <= target <= nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n\n return False","runtime":"44"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n return target in nums\n \n ","runtime":"44"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n if target in nums:\n return True\n return False","runtime":"45"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n def binarysearch(nums,target):\n l = 0\n r = len(nums)-1\n while l<=r :\n while (l < r and nums[l] == nums[r]):\n l+=1\n mid = (l+r)//2\n if nums[mid] == target:\n return True\n #[left][right]\n if nums[mid] >= nums[l] : #mid in left\n if nums[mid] > target and target >= nums[l] : #target in left \n r = mid-1\n else:\n l = mid+1\n else: #mid in right\n if nums[r] >= target and nums[mid] < target: #target in right\n l = mid+1\n else:\n r = mid-1\n return False\n return binarysearch(nums,target)\n\n ","runtime":"46"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n i=0\n while(i<len(nums)):\n if(nums[i]==target):\n return True\n i+=1 \n return False\n ","runtime":"46"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if nums[mid] == target:\n return True\n \n if nums[left] == nums[mid]:\n left += 1\n continue\n\n if nums[left] <= nums[mid]:\n if nums[left] <= target <= nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] <= target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n\n\n return False","runtime":"47"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n\n low = 0\n high = len(nums)-1\n\n while low <= high:\n mid = (low+high)//2\n if nums[mid] == target:\n return True\n\n if nums[low] == nums[mid] == nums[high]:\n low += 1\n high -= 1\n continue\n if nums[low] <= nums[mid]:\n if nums[low] <= target and target <= nums[mid]:\n high = mid - 1\n else:\n low = mid + 1\n else:\n if nums[mid] <= target and target <= nums[high]:\n low = mid + 1\n else:\n high = mid - 1\n \n return False ","runtime":"47"},{"code":"class Solution(object):\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = left + (right - left)//2\n if nums[mid] == target:\n return True\n # skip the duplicates\n while left < mid and nums[left] == nums[mid]:\n left += 1\n while mid < right and nums[mid] == nums[right]:\n right -= 1\n if nums[left] <= nums[mid]:\n if nums[left] <= target and target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] < target and target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n return False","runtime":"48"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n return True if target in nums else False\n \n # find pivot\n k = find_pivot(nums)\n print(k)\n\n # do normal binary search with skewed array\n l = 0\n r = len(nums)-1\n n = len(nums)\n\n while l<r:\n m = (l+r)//2\n mv = nums[fix(m, k, n)]\n \n if mv > target:\n r = m-1\n elif mv < target:\n l = m+1\n else:\n return True\n\n if nums[fix(l, k, n)] == target:\n return True\n\n return False\n\ndef fix(i, k, n):\n return (i+k)%n\n\ndef find_pivot(nums):\n l = 0\n r = len(nums)-1\n\n while l+1 < r:\n print(l, r)\n m = (l+r)//2\n\n if nums[r] > nums[l]:\n return l\n elif m == 0 or nums[m-1] > nums[m]:\n return m\n elif nums[m] < nums[r]:\n r = m\n elif nums[m] > nums[r]:\n l = m\n else:\n dupe = nums[l]\n while l < r and nums[l] == dupe:\n l += 1\n \n if nums[l] < nums[r]:\n return l\n\n return r","runtime":"48"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n return True if target in nums else False","runtime":"49"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n left = 0\n right = len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if nums[mid] == target:\n return True\n if nums[left] == nums[mid] == nums[right]:\n left += 1\n right -= 1\n continue\n elif nums[mid] >= nums[left]:\n if nums[left] <= target <= nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] <= target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n \n return False","runtime":"49"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n low = 0\n high = len(nums)-1\n while low<=high:\n mid = (low+high)//2\n print(mid,low,high,nums[mid],nums[low],nums[high])\n if nums[mid]==target:\n return True\n if nums[low]==nums[mid] and nums[mid]==nums[high]:\n high-=1\n low+=1\n elif nums[low]<=nums[mid]:\n if nums[low]<=target<nums[mid]:\n high = mid-1\n else:\n low = mid+1\n else:\n if nums[mid]<target<=nums[high]:\n low = mid + 1\n else:\n high = mid - 1\n return False\n ","runtime":"50"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n low=0\n high=len(nums)-1\n while(low<=high):\n mid=low+(high-low)//2\n if(nums[mid]==target):\n return True \n if(nums[low]==nums[mid] and nums[high]==nums[mid]):\n low+= 1\n high-=1\n continue\n if(nums[low]<=nums[mid]):\n if(nums[low]<=target<=nums[mid]):\n high=mid-1 \n else:\n low=mid+1\n else:\n if(nums[mid]<=target<=nums[high]):\n low=mid+1 \n else:\n high=mid-1 \n return False","runtime":"50"},{"code":"class Solution:\n def search(self, arr: List[int], target: int) -> bool:\n l = 0\n h = len(arr) - 1\n \n while l <= h:\n mid = (l + h) // 2\n \n if arr[mid] == target:\n return True\n \n # If duplicates at the boundaries, shrink the range\n if arr[mid] == arr[l] == arr[h]:\n l += 1\n h -= 1\n # If left side is sorted\n elif arr[l] <= arr[mid]:\n if arr[l] <= target < arr[mid]:\n h = mid - 1\n else:\n l = mid + 1\n # If right side is sorted\n else:\n if arr[mid] < target <= arr[h]:\n l = mid + 1\n else:\n h = mid - 1\n \n return False\n","runtime":"51"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n left, right = 0, len(nums)-1\n\n while left <= right:\n\n\n while left < right and nums[left] == nums[left+1]:\n left+=1\n while left < right and nums[right] == nums[right-1]:\n right-=1\n\n mid = left + (right-left) // 2\n\n if nums[mid] == target:\n return True\n\n if nums[left] <= nums[mid]:\n if nums[left] <= target < nums[mid]:\n right = mid -1\n else:\n left = mid + 1\n\n else:\n if nums[mid] < target <= nums[right]:\n left = mid+1\n else:\n right = mid - 1\n\n return False\n ","runtime":"51"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n if target in nums:\n return True\n else:\n return False\n ","runtime":"52"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n n = len(nums)\n low, high = 0, n - 1\n while low <= high:\n mid = (low + high) // 2\n\n if nums[mid] == target:\n return True\n if nums[low] == nums[mid] == nums[high]:\n low += 1\n high -= 1\n continue\n\n if nums[low] <= nums[mid]:\n if nums[low] <= target <= nums[mid]:\n high = mid - 1\n else:\n low = mid + 1\n else:\n if nums[mid] <= target <= nums[high]:\n low = mid + 1\n else:\n high = mid - 1\n\n return False\n ","runtime":"52"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n left = 0\n right = len(nums) - 1\n while left <= right:\n middle = (left + right) // 2\n if nums[middle] == target:\n return True\n if (nums[left] == nums[middle] and nums[middle] == nums[right]):\n left += 1\n right -= 1\n elif nums[left] <= nums[middle]:\n if nums[left] <= target and target < nums[middle]:\n right = middle - 1\n else:\n left = middle + 1 \n else:\n if target > nums[middle] and target <= nums[right]:\n left = middle + 1\n else:\n right = middle - 1\n return False\n\n \n ","runtime":"53"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n def binary_search(l, r, target):\n while l <= r:\n mid = (r - l) // 2 + l\n if nums[mid] == target:\n return True\n if nums[mid] < target:\n l = mid + 1\n else:\n r = mid - 1\n return False\n\n def find_pivot(l, r):\n anchor = nums[r]\n pivot = 0\n while l <= r:\n mid = (r - l) // 2 + l\n if nums[mid] <= anchor:\n pivot = mid\n r = mid - 1\n else:\n l = l + 1\n return pivot\n\n def search_in_rotated(l, r, target):\n pivot = find_pivot(l, r)\n if target > nums[r]:\n return binary_search(0, pivot - 1, target)\n return binary_search(pivot, len(nums) - 1, target)\n\n l = 0\n r = len(nums) - 1\n\n while l <= r: \n mid = (r - l) // 2 + l\n if nums[r] == target or nums[l] == target or nums[mid] == target:\n return True\n if nums[mid] == nums[r] == nums[l]:\n l += 1\n r -= 1\n continue\n if target <= nums[mid] <= nums[r] or nums[mid] <= nums[r] <= target: #target is on left side of mid\n return search_in_rotated(l, mid, target)\n else:\n return search_in_rotated(mid, r, target)\n #return search_in_rotated(l,r,target)\n return False\n\n \n \n ","runtime":"53"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n n=len(nums)\n low=0\n high=n-1\n ans=False\n while low<=high:\n mid=(low+high)//2\n if nums[mid]==target:\n ans=True\n if nums[low]==nums[mid] and nums[mid]==nums[high]:\n low+=1\n high-=1\n continue\n if nums[low]<=nums[mid]:\n if nums[low]<=target and target<=nums[mid]:\n high=mid-1\n else:\n low=mid+1\n else:\n if nums[mid]<=target and target<=nums[high]:\n low=mid+1\n else:\n high=mid-1\n return ans\n \n ","runtime":"54"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n low=0\n high=len(nums)-1\n while low<=high:\n mid=(low+high)//2\n if nums[mid]==target:\n return True\n if nums[low]==nums[mid] and nums[mid]==nums[high]:\n low+=1\n high-=1\n continue\n elif nums[low]<=nums[mid]:\n if target>=nums[low] and target<=nums[mid]:\n high=mid-1\n else:\n low=mid+1\n else:\n if target>=nums[mid] and target<=nums[high]:\n low=mid+1\n else:\n high=mid-1\n return False\n ","runtime":"54"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n for i in nums:\n if i==target:\n return True","runtime":"55"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n left=0\n right=len(nums)-1\n while(left<=right):\n mid=(left+right)//2\n if nums[mid]==target:\n return True\n if nums[left]==target:\n return True\n if nums[right]==target:\n return True\n if nums[mid]<nums[right]:\n if target>nums[mid] and target<nums[right]:\n left=mid+1\n else:\n right=mid-1\n elif nums[left]<nums[mid]:\n if target<nums[mid] and target>nums[left]:\n right=mid-1\n else:\n left=mid+1\n else:\n left+=1\n right-=1\n return False","runtime":"55"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n l,r=0,len(nums)-1\n if len(nums) <= 3:\n return any([num == target for num in nums])\n while l < r-1:\n m = (l+r)//2\n if nums[m] == target:\n return True\n if nums[m] < target:\n if nums[r] == target:\n return True\n if nums[r] > target:\n l = m+1\n else:\n while l < r and nums[r] <= target:\n if nums[r] == target:\n return True\n r -= 1\n elif nums[m] > target:\n if nums[l] == target:\n return True\n if nums[l] < target:\n r = m - 1\n else:\n while l < r and nums[l] >= target:\n if nums[l] == target:\n return True\n l += 1\n return nums[l] == target or nums[r] == target\n","runtime":"56"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n low, high = 0, len(nums) - 1\n\n while low <= high:\n mid = (low + high) // 2\n \n if nums[mid] == target:\n return True\n\n if nums[low] == nums[mid]:\n low += 1\n continue\n \n if nums[low] <= nums[mid]:\n if nums[low] <= target <= nums[mid]:\n high = mid - 1\n else:\n low = mid + 1\n else:\n if nums[mid] <= target <= nums[high]:\n low = mid + 1\n else:\n high = mid - 1\n \n return False","runtime":"56"},{"code":"class Solution(object):\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = left + (right - left)//2\n if nums[mid] == target:\n return True\n # skip the duplicates\n while left < mid and nums[left] == nums[mid]:\n left += 1\n while mid < right and nums[mid] == nums[right]:\n right -= 1\n if nums[left] <= nums[mid]:\n if nums[left] <= target and target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] < target and target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n return False","runtime":"57"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n if target in nums:\n return True\n return False\n ","runtime":"57"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n start, end = 0, len(nums) - 1\n \n while start <= end:\n mid = start + (end - start) // 2\n if nums[mid] == target:\n return True\n elif nums[start] < nums[mid]:\n if nums[start] <= target < nums[mid]:\n end = mid - 1\n else:\n start = mid + 1\n elif nums[mid] < nums[start]:\n if nums[mid] < target <= nums[end]:\n start = mid + 1\n else:\n end = mid - 1\n else:\n start += 1\n \n return False","runtime":"58"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n start, end = 0, len(nums) - 1\n \n while start <= end:\n mid = start + (end - start) // 2\n if nums[mid] == target:\n return True\n elif nums[start] < nums[mid]:\n if nums[start] <= target < nums[mid]:\n end = mid - 1\n else:\n start = mid + 1\n elif nums[mid] < nums[start]:\n if nums[mid] < target <= nums[end]:\n start = mid + 1\n else:\n end = mid - 1\n else:\n start += 1\n \n return False","runtime":"58"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n start, end = 0, len(nums) - 1\n\n while start <= end:\n mid = start + (end-start) // 2\n if nums[mid] == target:\n return True\n elif nums[start] < nums[mid]:\n if nums[start] <= target < nums[mid]:\n end = mid - 1\n else:\n start = mid + 1\n elif nums[start] > nums[mid]:\n if nums[mid] < target <= nums[end]:\n start = mid + 1\n else:\n end = mid - 1\n else:\n start += 1\n return False","runtime":"59"},{"code":"class Solution:\n \"\"\"\n def binary_search_rotated(self, nums: List[int], target: int, low: int, high: int) -> bool:\n while low <= high:\n mid = low + int((high - low) / 2)\n\n if nums[mid] < target:\n if nums[left] <= nums[mid]:\n left = mid + 1\n \n else:\n \"\"\"\n\n def binary_search(self, nums, target):\n left = 0\n right = len(nums) - 1\n while left <= right:\n mid = left + int((right - left) / 2)\n\n if nums[mid] < target:\n left = mid + 1\n elif nums[mid] > target:\n right = mid - 1\n else:\n return True\n return False\n\n \n def search(self, nums: List[int], target: int) -> bool:\n for i in range(0, len(nums) - 1):\n if nums[i] > nums[i+1]:\n nums = nums[i+1:] + nums[0:i+1]\n return self.binary_search(nums, target)\n #return self.binary_search_rotated(nums, target, 0, len(nums) - 1)\n ","runtime":"60"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n \n index=0\n for i in range(1,len(nums)):\n if(nums[i-1]>nums[i]):\n mini=nums[i]\n index=i\n break\n start=0\n end=index-1\n mid=0\n while(start<=end):\n mid=(start+end)//2\n if(nums[mid]==target):\n return True\n elif(nums[mid]>target):\n end=mid-1\n else:\n start=mid+1\n start=index\n end=len(nums)-1\n mid=0\n while(start<=end):\n mid=(start+end)//2\n if(nums[mid]==target):\n return True\n elif(nums[mid]>target):\n end=mid-1\n else:\n start=mid+1\n return False","runtime":"60"}],"string":"[\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n return True if target in nums else False\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n l, r = 0, len(nums)-1\\n\\n while l<=r:\\n m = l + (r-l)//2\\n if nums[m] == target: return True\\n\\n if nums[l] < nums[m]:\\n if nums[l] <= target < nums[m]:\\n r = m - 1\\n else:\\n l = m + 1\\n elif nums[l] > nums[m]:\\n if nums[m] < target <= nums[r]:\\n l = m + 1\\n else:\\n r = m - 1\\n else:\\n l += 1\\n return False\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n return target in nums\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# same as search in rotated sorted array, but with dupes\\n\\nclass Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n # MINES\\n if len(nums) == 0:\\n return False\\n if len(nums) == 1:\\n return nums[0] == target\\n \\n l, r = 0, len(nums) - 1\\n while l <= r:\\n m = (l + r) // 2\\n if nums[m] == target:\\n return True\\n if nums[m] == nums[l] == nums[r]:\\n l += 1\\n r -= 1\\n continue\\n # Right half is sorted\\n if nums[m] <= nums[r]:\\n print(f\\\"I should be getting here. r = {r}\\\")\\n if nums[r] == target:\\n return True\\n if nums[m] < target < nums[r]:\\n l = m + 1\\n else:\\n r = m - 1\\n \\n # Left half is sorted\\n elif nums[m] >= nums[l]:\\n if nums[l] == target:\\n return True\\n if nums[l] < target < nums[m]:\\n r = m - 1\\n else:\\n l = m + 1\\n\\n \\n return False\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n left, right = 0, len(nums) - 1\\n\\n while left <= right:\\n # mid = left + (right - left) // 2 \\n mid = (left+right)//2\\n\\n if nums[mid] == target:\\n return True\\n\\n if nums[left] < nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n\\n elif nums[left] > nums[mid]:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n # if nums[left] == nums[mid], we cannot determine which part is sorted\\n # so we have to search both parts\\n else:\\n left += 1\\n\\n return False\\n \\n #TC: O(n)\\n #SC: O(1)\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n \\n l, r = 0, len(nums)-1\\n while l <= r:\\n mid = l + (r-l)//2\\n if nums[mid] == target:\\n return True\\n\\n if nums[l] == nums[r]:\\n r-=1\\n elif nums[l] <= nums[mid]:\\n if nums[l] <= target and target < nums[mid]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n else:\\n if nums[mid] < target and target <= nums[r]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n return False\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n \\n l, r = 0, len(nums) - 1 \\n \\n while l <= r: \\n m = l + (r - l) // 2\\n if target == nums[m]: \\n return True\\n \\n if nums[l] < nums[m]: \\n if nums[l] <= target < nums[m]: \\n r = m - 1 \\n else:\\n l = m + 1 \\n elif nums[l] > nums[m]: \\n if nums[m] < target <= nums[r]: \\n l = m + 1 \\n else:\\n r = m - 1 \\n else: \\n l += 1\\n return False \\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n if target in nums:\\n return(True)\\n return(False)\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n if target in nums:\\n return True\\n return False\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n nums = set(nums)\\n return target in nums\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n n=len(nums)\\n low, high= 0, n-1\\n\\n while low<=high:\\n mid=low+(high-low)//2\\n if nums[mid] == target:\\n return True\\n\\n if nums[low] == nums[mid] and nums[mid] == nums[high]:\\n low+=1\\n high-=1\\n continue\\n\\n if nums[low] <= nums[mid]:\\n if nums[low] <= target <= nums[mid]:\\n high=mid-1\\n else:\\n low=mid+1\\n else:\\n if nums[mid] <= target <= nums[high]:\\n low=mid+1\\n else:\\n high=mid-1\\n return False\\n\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n # ans = False\\n for num in nums:\\n if num == target:\\n return True\\n return False\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n for num in nums:\\n if num == target:\\n return True\\n return False\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n low, high = 0, len(nums) - 1\\n\\n while low <= high:\\n mid = (low + high) // 2\\n if nums[mid] == target:\\n return True\\n \\n if nums[low] == nums[mid]:\\n low += 1\\n continue\\n \\n if nums[low] <= nums[mid]:\\n if nums[low] <= target <= nums[mid]:\\n high = mid - 1\\n else:\\n low = mid + 1\\n else:\\n if nums[mid] <= target <= nums[high]:\\n low = mid + 1\\n else:\\n high = mid - 1\\n \\n return False\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n nums.sort()\\n if target in nums:\\n return True\\n return False\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n l, r = 0, len(nums) - 1 \\n while (l <= r):\\n mid = (l + r) // 2\\n if nums[mid] == target:\\n return True\\n\\n if nums[l] == nums[mid]:\\n l += 1\\n continue\\n \\n if nums[l] <= nums[mid]:\\n if nums[l] <= target <= nums[mid]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n else:\\n if nums[mid] <= target <= nums[r]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n\\n return False\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n return target in nums\\n \\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n if target in nums:\\n return True\\n return False\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n def binarysearch(nums,target):\\n l = 0\\n r = len(nums)-1\\n while l<=r :\\n while (l < r and nums[l] == nums[r]):\\n l+=1\\n mid = (l+r)//2\\n if nums[mid] == target:\\n return True\\n #[left][right]\\n if nums[mid] >= nums[l] : #mid in left\\n if nums[mid] > target and target >= nums[l] : #target in left \\n r = mid-1\\n else:\\n l = mid+1\\n else: #mid in right\\n if nums[r] >= target and nums[mid] < target: #target in right\\n l = mid+1\\n else:\\n r = mid-1\\n return False\\n return binarysearch(nums,target)\\n\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n i=0\\n while(i<len(nums)):\\n if(nums[i]==target):\\n return True\\n i+=1 \\n return False\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if nums[mid] == target:\\n return True\\n \\n if nums[left] == nums[mid]:\\n left += 1\\n continue\\n\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target <= nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] <= target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n\\n return False\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n\\n low = 0\\n high = len(nums)-1\\n\\n while low <= high:\\n mid = (low+high)//2\\n if nums[mid] == target:\\n return True\\n\\n if nums[low] == nums[mid] == nums[high]:\\n low += 1\\n high -= 1\\n continue\\n if nums[low] <= nums[mid]:\\n if nums[low] <= target and target <= nums[mid]:\\n high = mid - 1\\n else:\\n low = mid + 1\\n else:\\n if nums[mid] <= target and target <= nums[high]:\\n low = mid + 1\\n else:\\n high = mid - 1\\n \\n return False \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution(object):\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = left + (right - left)//2\\n if nums[mid] == target:\\n return True\\n # skip the duplicates\\n while left < mid and nums[left] == nums[mid]:\\n left += 1\\n while mid < right and nums[mid] == nums[right]:\\n right -= 1\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target and target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] < target and target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return False\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n return True if target in nums else False\\n \\n # find pivot\\n k = find_pivot(nums)\\n print(k)\\n\\n # do normal binary search with skewed array\\n l = 0\\n r = len(nums)-1\\n n = len(nums)\\n\\n while l<r:\\n m = (l+r)//2\\n mv = nums[fix(m, k, n)]\\n \\n if mv > target:\\n r = m-1\\n elif mv < target:\\n l = m+1\\n else:\\n return True\\n\\n if nums[fix(l, k, n)] == target:\\n return True\\n\\n return False\\n\\ndef fix(i, k, n):\\n return (i+k)%n\\n\\ndef find_pivot(nums):\\n l = 0\\n r = len(nums)-1\\n\\n while l+1 < r:\\n print(l, r)\\n m = (l+r)//2\\n\\n if nums[r] > nums[l]:\\n return l\\n elif m == 0 or nums[m-1] > nums[m]:\\n return m\\n elif nums[m] < nums[r]:\\n r = m\\n elif nums[m] > nums[r]:\\n l = m\\n else:\\n dupe = nums[l]\\n while l < r and nums[l] == dupe:\\n l += 1\\n \\n if nums[l] < nums[r]:\\n return l\\n\\n return r\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n return True if target in nums else False\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n left = 0\\n right = len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if nums[mid] == target:\\n return True\\n if nums[left] == nums[mid] == nums[right]:\\n left += 1\\n right -= 1\\n continue\\n elif nums[mid] >= nums[left]:\\n if nums[left] <= target <= nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] <= target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n return False\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n low = 0\\n high = len(nums)-1\\n while low<=high:\\n mid = (low+high)//2\\n print(mid,low,high,nums[mid],nums[low],nums[high])\\n if nums[mid]==target:\\n return True\\n if nums[low]==nums[mid] and nums[mid]==nums[high]:\\n high-=1\\n low+=1\\n elif nums[low]<=nums[mid]:\\n if nums[low]<=target<nums[mid]:\\n high = mid-1\\n else:\\n low = mid+1\\n else:\\n if nums[mid]<target<=nums[high]:\\n low = mid + 1\\n else:\\n high = mid - 1\\n return False\\n \",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n low=0\\n high=len(nums)-1\\n while(low<=high):\\n mid=low+(high-low)//2\\n if(nums[mid]==target):\\n return True \\n if(nums[low]==nums[mid] and nums[high]==nums[mid]):\\n low+= 1\\n high-=1\\n continue\\n if(nums[low]<=nums[mid]):\\n if(nums[low]<=target<=nums[mid]):\\n high=mid-1 \\n else:\\n low=mid+1\\n else:\\n if(nums[mid]<=target<=nums[high]):\\n low=mid+1 \\n else:\\n high=mid-1 \\n return False\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, arr: List[int], target: int) -> bool:\\n l = 0\\n h = len(arr) - 1\\n \\n while l <= h:\\n mid = (l + h) // 2\\n \\n if arr[mid] == target:\\n return True\\n \\n # If duplicates at the boundaries, shrink the range\\n if arr[mid] == arr[l] == arr[h]:\\n l += 1\\n h -= 1\\n # If left side is sorted\\n elif arr[l] <= arr[mid]:\\n if arr[l] <= target < arr[mid]:\\n h = mid - 1\\n else:\\n l = mid + 1\\n # If right side is sorted\\n else:\\n if arr[mid] < target <= arr[h]:\\n l = mid + 1\\n else:\\n h = mid - 1\\n \\n return False\\n\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n left, right = 0, len(nums)-1\\n\\n while left <= right:\\n\\n\\n while left < right and nums[left] == nums[left+1]:\\n left+=1\\n while left < right and nums[right] == nums[right-1]:\\n right-=1\\n\\n mid = left + (right-left) // 2\\n\\n if nums[mid] == target:\\n return True\\n\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n right = mid -1\\n else:\\n left = mid + 1\\n\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid+1\\n else:\\n right = mid - 1\\n\\n return False\\n \",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n if target in nums:\\n return True\\n else:\\n return False\\n \",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n n = len(nums)\\n low, high = 0, n - 1\\n while low <= high:\\n mid = (low + high) // 2\\n\\n if nums[mid] == target:\\n return True\\n if nums[low] == nums[mid] == nums[high]:\\n low += 1\\n high -= 1\\n continue\\n\\n if nums[low] <= nums[mid]:\\n if nums[low] <= target <= nums[mid]:\\n high = mid - 1\\n else:\\n low = mid + 1\\n else:\\n if nums[mid] <= target <= nums[high]:\\n low = mid + 1\\n else:\\n high = mid - 1\\n\\n return False\\n \",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n left = 0\\n right = len(nums) - 1\\n while left <= right:\\n middle = (left + right) // 2\\n if nums[middle] == target:\\n return True\\n if (nums[left] == nums[middle] and nums[middle] == nums[right]):\\n left += 1\\n right -= 1\\n elif nums[left] <= nums[middle]:\\n if nums[left] <= target and target < nums[middle]:\\n right = middle - 1\\n else:\\n left = middle + 1 \\n else:\\n if target > nums[middle] and target <= nums[right]:\\n left = middle + 1\\n else:\\n right = middle - 1\\n return False\\n\\n \\n \",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n def binary_search(l, r, target):\\n while l <= r:\\n mid = (r - l) // 2 + l\\n if nums[mid] == target:\\n return True\\n if nums[mid] < target:\\n l = mid + 1\\n else:\\n r = mid - 1\\n return False\\n\\n def find_pivot(l, r):\\n anchor = nums[r]\\n pivot = 0\\n while l <= r:\\n mid = (r - l) // 2 + l\\n if nums[mid] <= anchor:\\n pivot = mid\\n r = mid - 1\\n else:\\n l = l + 1\\n return pivot\\n\\n def search_in_rotated(l, r, target):\\n pivot = find_pivot(l, r)\\n if target > nums[r]:\\n return binary_search(0, pivot - 1, target)\\n return binary_search(pivot, len(nums) - 1, target)\\n\\n l = 0\\n r = len(nums) - 1\\n\\n while l <= r: \\n mid = (r - l) // 2 + l\\n if nums[r] == target or nums[l] == target or nums[mid] == target:\\n return True\\n if nums[mid] == nums[r] == nums[l]:\\n l += 1\\n r -= 1\\n continue\\n if target <= nums[mid] <= nums[r] or nums[mid] <= nums[r] <= target: #target is on left side of mid\\n return search_in_rotated(l, mid, target)\\n else:\\n return search_in_rotated(mid, r, target)\\n #return search_in_rotated(l,r,target)\\n return False\\n\\n \\n \\n \",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n n=len(nums)\\n low=0\\n high=n-1\\n ans=False\\n while low<=high:\\n mid=(low+high)//2\\n if nums[mid]==target:\\n ans=True\\n if nums[low]==nums[mid] and nums[mid]==nums[high]:\\n low+=1\\n high-=1\\n continue\\n if nums[low]<=nums[mid]:\\n if nums[low]<=target and target<=nums[mid]:\\n high=mid-1\\n else:\\n low=mid+1\\n else:\\n if nums[mid]<=target and target<=nums[high]:\\n low=mid+1\\n else:\\n high=mid-1\\n return ans\\n \\n \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n low=0\\n high=len(nums)-1\\n while low<=high:\\n mid=(low+high)//2\\n if nums[mid]==target:\\n return True\\n if nums[low]==nums[mid] and nums[mid]==nums[high]:\\n low+=1\\n high-=1\\n continue\\n elif nums[low]<=nums[mid]:\\n if target>=nums[low] and target<=nums[mid]:\\n high=mid-1\\n else:\\n low=mid+1\\n else:\\n if target>=nums[mid] and target<=nums[high]:\\n low=mid+1\\n else:\\n high=mid-1\\n return False\\n \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n for i in nums:\\n if i==target:\\n return True\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n left=0\\n right=len(nums)-1\\n while(left<=right):\\n mid=(left+right)//2\\n if nums[mid]==target:\\n return True\\n if nums[left]==target:\\n return True\\n if nums[right]==target:\\n return True\\n if nums[mid]<nums[right]:\\n if target>nums[mid] and target<nums[right]:\\n left=mid+1\\n else:\\n right=mid-1\\n elif nums[left]<nums[mid]:\\n if target<nums[mid] and target>nums[left]:\\n right=mid-1\\n else:\\n left=mid+1\\n else:\\n left+=1\\n right-=1\\n return False\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n l,r=0,len(nums)-1\\n if len(nums) <= 3:\\n return any([num == target for num in nums])\\n while l < r-1:\\n m = (l+r)//2\\n if nums[m] == target:\\n return True\\n if nums[m] < target:\\n if nums[r] == target:\\n return True\\n if nums[r] > target:\\n l = m+1\\n else:\\n while l < r and nums[r] <= target:\\n if nums[r] == target:\\n return True\\n r -= 1\\n elif nums[m] > target:\\n if nums[l] == target:\\n return True\\n if nums[l] < target:\\n r = m - 1\\n else:\\n while l < r and nums[l] >= target:\\n if nums[l] == target:\\n return True\\n l += 1\\n return nums[l] == target or nums[r] == target\\n\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n low, high = 0, len(nums) - 1\\n\\n while low <= high:\\n mid = (low + high) // 2\\n \\n if nums[mid] == target:\\n return True\\n\\n if nums[low] == nums[mid]:\\n low += 1\\n continue\\n \\n if nums[low] <= nums[mid]:\\n if nums[low] <= target <= nums[mid]:\\n high = mid - 1\\n else:\\n low = mid + 1\\n else:\\n if nums[mid] <= target <= nums[high]:\\n low = mid + 1\\n else:\\n high = mid - 1\\n \\n return False\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution(object):\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = left + (right - left)//2\\n if nums[mid] == target:\\n return True\\n # skip the duplicates\\n while left < mid and nums[left] == nums[mid]:\\n left += 1\\n while mid < right and nums[mid] == nums[right]:\\n right -= 1\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target and target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] < target and target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return False\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n if target in nums:\\n return True\\n return False\\n \",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n start, end = 0, len(nums) - 1\\n \\n while start <= end:\\n mid = start + (end - start) // 2\\n if nums[mid] == target:\\n return True\\n elif nums[start] < nums[mid]:\\n if nums[start] <= target < nums[mid]:\\n end = mid - 1\\n else:\\n start = mid + 1\\n elif nums[mid] < nums[start]:\\n if nums[mid] < target <= nums[end]:\\n start = mid + 1\\n else:\\n end = mid - 1\\n else:\\n start += 1\\n \\n return False\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n start, end = 0, len(nums) - 1\\n \\n while start <= end:\\n mid = start + (end - start) // 2\\n if nums[mid] == target:\\n return True\\n elif nums[start] < nums[mid]:\\n if nums[start] <= target < nums[mid]:\\n end = mid - 1\\n else:\\n start = mid + 1\\n elif nums[mid] < nums[start]:\\n if nums[mid] < target <= nums[end]:\\n start = mid + 1\\n else:\\n end = mid - 1\\n else:\\n start += 1\\n \\n return False\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n start, end = 0, len(nums) - 1\\n\\n while start <= end:\\n mid = start + (end-start) // 2\\n if nums[mid] == target:\\n return True\\n elif nums[start] < nums[mid]:\\n if nums[start] <= target < nums[mid]:\\n end = mid - 1\\n else:\\n start = mid + 1\\n elif nums[start] > nums[mid]:\\n if nums[mid] < target <= nums[end]:\\n start = mid + 1\\n else:\\n end = mid - 1\\n else:\\n start += 1\\n return False\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n \\\"\\\"\\\"\\n def binary_search_rotated(self, nums: List[int], target: int, low: int, high: int) -> bool:\\n while low <= high:\\n mid = low + int((high - low) / 2)\\n\\n if nums[mid] < target:\\n if nums[left] <= nums[mid]:\\n left = mid + 1\\n \\n else:\\n \\\"\\\"\\\"\\n\\n def binary_search(self, nums, target):\\n left = 0\\n right = len(nums) - 1\\n while left <= right:\\n mid = left + int((right - left) / 2)\\n\\n if nums[mid] < target:\\n left = mid + 1\\n elif nums[mid] > target:\\n right = mid - 1\\n else:\\n return True\\n return False\\n\\n \\n def search(self, nums: List[int], target: int) -> bool:\\n for i in range(0, len(nums) - 1):\\n if nums[i] > nums[i+1]:\\n nums = nums[i+1:] + nums[0:i+1]\\n return self.binary_search(nums, target)\\n #return self.binary_search_rotated(nums, target, 0, len(nums) - 1)\\n \",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n \\n index=0\\n for i in range(1,len(nums)):\\n if(nums[i-1]>nums[i]):\\n mini=nums[i]\\n index=i\\n break\\n start=0\\n end=index-1\\n mid=0\\n while(start<=end):\\n mid=(start+end)//2\\n if(nums[mid]==target):\\n return True\\n elif(nums[mid]>target):\\n end=mid-1\\n else:\\n start=mid+1\\n start=index\\n end=len(nums)-1\\n mid=0\\n while(start<=end):\\n mid=(start+end)//2\\n if(nums[mid]==target):\\n return True\\n elif(nums[mid]>target):\\n end=mid-1\\n else:\\n start=mid+1\\n return False\",\n \"runtime\": \"60\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":47,"string":"47"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n for num in nums:\n if num == target:\n return True\n return False\n ","memory":"16800"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n # ans = False\n for num in nums:\n if num == target:\n return True\n return False","memory":"16900"},{"code":"class Solution:\n def search(self, arr: List[int], target: int) -> bool:\n l = 0\n h = len(arr) - 1\n while l <= h:\n mid = (l + h) // 2\n\n if arr[mid] == target:\n return True\n\n if arr[mid] == arr[l] and arr[mid] == arr[h]:\n l += 1\n h -= 1\n\n elif arr[l] <= arr[mid]:\n if arr[l] <= target < arr[mid]:\n h = mid - 1\n else:\n l = mid + 1\n else:\n if arr[mid] < target <= arr[h]:\n l = mid + 1\n else:\n h = mid - 1\n\n return False\n","memory":"16900"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n for i in nums:\n if i==target:\n return True","memory":"17000"},{"code":"class Solution(object):\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = left + (right - left)//2\n if nums[mid] == target:\n return True\n # skip the duplicates\n while left < mid and nums[left] == nums[mid]:\n left += 1\n while mid < right and nums[mid] == nums[right]:\n right -= 1\n if nums[left] <= nums[mid]:\n if nums[left] <= target and target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] < target and target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n return False","memory":"17000"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if nums[mid] == target:\n return True\n \n if nums[left] == nums[mid]:\n left += 1\n continue\n\n if nums[left] <= nums[mid]:\n if nums[left] <= target <= nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] <= target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n\n\n return False","memory":"17100"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> bool:\n n=len(nums)\n low=0\n high=n-1\n ans=False\n while low<=high:\n mid=(low+high)//2\n if nums[mid]==target:\n ans=True\n if nums[low]==nums[mid] and nums[mid]==nums[high]:\n low+=1\n high-=1\n continue\n if nums[low]<=nums[mid]:\n if nums[low]<=target and target<=nums[mid]:\n high=mid-1\n else:\n low=mid+1\n else:\n if nums[mid]<=target and target<=nums[high]:\n low=mid+1\n else:\n high=mid-1\n return ans\n \n ","memory":"17100"}],"string":"[\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n for num in nums:\\n if num == target:\\n return True\\n return False\\n \",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n # ans = False\\n for num in nums:\\n if num == target:\\n return True\\n return False\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, arr: List[int], target: int) -> bool:\\n l = 0\\n h = len(arr) - 1\\n while l <= h:\\n mid = (l + h) // 2\\n\\n if arr[mid] == target:\\n return True\\n\\n if arr[mid] == arr[l] and arr[mid] == arr[h]:\\n l += 1\\n h -= 1\\n\\n elif arr[l] <= arr[mid]:\\n if arr[l] <= target < arr[mid]:\\n h = mid - 1\\n else:\\n l = mid + 1\\n else:\\n if arr[mid] < target <= arr[h]:\\n l = mid + 1\\n else:\\n h = mid - 1\\n\\n return False\\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n for i in nums:\\n if i==target:\\n return True\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution(object):\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = left + (right - left)//2\\n if nums[mid] == target:\\n return True\\n # skip the duplicates\\n while left < mid and nums[left] == nums[mid]:\\n left += 1\\n while mid < right and nums[mid] == nums[right]:\\n right -= 1\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target and target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] < target and target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return False\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if nums[mid] == target:\\n return True\\n \\n if nums[left] == nums[mid]:\\n left += 1\\n continue\\n\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target <= nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] <= target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n\\n return False\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> bool:\\n n=len(nums)\\n low=0\\n high=n-1\\n ans=False\\n while low<=high:\\n mid=(low+high)//2\\n if nums[mid]==target:\\n ans=True\\n if nums[low]==nums[mid] and nums[mid]==nums[high]:\\n low+=1\\n high-=1\\n continue\\n if nums[low]<=nums[mid]:\\n if nums[low]<=target and target<=nums[mid]:\\n high=mid-1\\n else:\\n low=mid+1\\n else:\\n if nums[mid]<=target and target<=nums[high]:\\n low=mid+1\\n else:\\n high=mid-1\\n return ans\\n \\n \",\n \"memory\": \"17100\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":7,"string":"7"}}},{"rowIdx":36,"cells":{"question_id":{"kind":"number","value":82,"string":"82"},"name":{"kind":"string","value":"remove-duplicates-from-sorted-list-ii"},"content":{"kind":"string","value":"<p>Given the <code>head</code> of a sorted linked list, <em>delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list</em>. Return <em>the linked list <strong>sorted</strong> as well</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/01/04/linkedlist1.jpg\" style=\"width: 500px; height: 142px;\" />\n<pre>\n<strong>Input:</strong> head = [1,2,3,3,4,4,5]\n<strong>Output:</strong> [1,2,5]\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/01/04/linkedlist2.jpg\" style=\"width: 500px; height: 205px;\" />\n<pre>\n<strong>Input:</strong> head = [1,1,1,2,3]\n<strong>Output:</strong> [2,3]\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of nodes in the list is in the range <code>[0, 300]</code>.</li>\n\t<li><code>-100 <= Node.val <= 100</code></li>\n\t<li>The list is guaranteed to be <strong>sorted</strong> in ascending order.</li>\n</ul>\n"},"acRate":{"kind":"number","value":48.302717679333625,"string":"48.302718"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["linked-list","two-pointers"],"string":"[\n \"linked-list\",\n \"two-pointers\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"19\", 0.0127], [\"20\", 0.0254], [\"22\", 0.1269], [\"23\", 0.1523], [\"24\", 0.0761], [\"25\", 0.2284], [\"26\", 0.4441], [\"27\", 0.7613], [\"28\", 0.3934], [\"29\", 0.8501], [\"30\", 2.284], [\"31\", 2.0556], [\"32\", 1.6242], [\"33\", 2.855], [\"34\", 5.5577], [\"35\", 4.606], [\"36\", 3.6163], [\"37\", 6.1667], [\"38\", 8.5522], [\"39\", 6.4078], [\"40\", 5.7861], [\"41\", 6.8519], [\"42\", 8.6157], [\"43\", 6.7885], [\"44\", 5.0121], [\"45\", 4.9994], [\"46\", 4.1746], [\"47\", 3.1341], [\"48\", 1.9668]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16000\", 0.0127], [\"16100\", 0.0127], [\"16200\", 0.0508], [\"16300\", 0.8121], [\"16400\", 14.7697], [\"16500\", 47.494]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n h=head\n p=ListNode(-1)\n p.next=head\n b=p\n f=defaultdict(int)\n while h and h.next:\n if h.val!=h.next.val:\n p=p.next\n h=h.next\n else:\n c=h.val\n while c==h.val:\n h=h.next\n if h==None:\n break\n p.next=h\n\n\n return b.next\n \n \n \n\n\n \n\n\n ","runtime":"20"},{"code":"class Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n fake = ListNode(-1)\n fake.next = head\n # We use prev (for node just before duplications begins), curr (for the last node of the duplication group)...\n curr, prev = head, fake\n while curr:\n # while we have curr.next and its value is equal to curr...\n # It means, that we have one more duplicate...\n while curr.next and curr.val == curr.next.val:\n # So move curr pointer to the right...\n curr = curr.next\n # If it happens, that prev.next equal to curr...\n # It means, that we have only 1 element in the group of duplicated elements...\n if prev.next == curr:\n # Don't need to delete it, we move both pointers to right...\n prev = prev.next\n curr = curr.next\n # Otherwise, we need to skip a group of duplicated elements...\n # set prev.next = curr.next, and curr = prev.next...\n else:\n prev.next = curr.next\n curr = prev.next\n # Return the linked list...\n return fake.next ","runtime":"22"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]: \n prev = dummy = ListNode() \n curr = dummy.next = head\n while curr and curr.next:\n if curr.val != curr.next.val: \n prev = prev.next\n curr = curr.next\n else:\n while curr.next and curr.val == curr.next.val:\n curr = curr.next\n curr = curr.next\n prev.next = curr\n return dummy.next\n\n ","runtime":"23"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n original_head = head\n to_delete_val = set()\n\n prev = None\n while head:\n if not prev:\n prev = head\n head = head.next\n continue\n if prev.val == head.val:\n to_delete_val.add(head.val)\n prev = head\n head = head.next\n \n \n \n while original_head and original_head.val in to_delete_val:\n original_head = original_head.next\n\n head = original_head\n prev = None\n\n\n while head:\n if not prev:\n prev = head\n head = head.next\n continue\n if head.val in to_delete_val:\n prev.next = head.next\n else:\n prev= head\n head = head.next\n\n return original_head","runtime":"23"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n curr = ListNode(-1,head)\n prev = curr\n while head:\n if head.next and head.val == head.next.val:\n while head.next and head.val == head.next.val:\n head = head.next \n prev.next = head.next \n else: \n prev = prev.next\n head = head.next \n return curr.next\n","runtime":"24"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n duplicates = set()\n temp = head\n if not head: return\n while temp.next:\n if temp.val == temp.next.val:\n duplicates.add(temp.val)\n temp = temp.next\n print(duplicates)\n while head and head.val in duplicates:\n head = head.next\n if not head: return\n temp = head\n while temp.next:\n if temp.next.val in duplicates:\n temp.next = temp.next.next\n else:\n temp = temp.next\n return head","runtime":"25"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n #d-1-2-3-3-4-4-5\n # P C N\n dummy = ListNode(0,head)\n prev = dummy\n curr = head\n while curr:\n while curr.next and curr.val == curr.next.val:\n curr = curr.next\n if prev.next !=curr:\n prev.next = curr.next\n else:\n prev = prev.next\n curr=curr.next\n\n return dummy.next","runtime":"26"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n a = ListNode()\n temp = a\n while head:\n sum = 0\n pre = head\n while(head != None and head.val == pre.val):\n sum = sum+1\n head = head.next\n if(sum == 1):\n a.next = pre\n a = a.next\n a.next = None\n return temp.next\n\n ","runtime":"27"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(-1)\n p = dummy\n q = head\n\n while q:\n if q.next is not None and q.val == q.next.val:\n while q.next is not None and q.val == q.next.val:\n q = q.next\n q = q.next\n if q == None:\n p.next = None\n else:\n p.next = q\n p = p.next\n q = q.next\n return dummy.next\n \n\n","runtime":"28"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n output=ListNode(0,head)\n pre=output\n\n while head:\n if head.next and head.val ==head.next.val:\n while head.next and head.val ==head.next.val:\n head=head.next\n pre.next=head.next\n else:\n pre=pre.next\n head=head.next\n return output.next","runtime":"28"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n output=ListNode(0,head)\n pre=output\n while head:\n if head.next and head.val==head.next.val:\n while head.next and head.val==head.next.val:\n head=head.next\n pre.next=head.next\n else:\n pre=pre.next\n head=head.next\n # return output.next\n\n\n return output.next","runtime":"29"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0)\n dummy.next = head\n fast = head\n slow = dummy\n while fast:\n if fast.next and fast.val == fast.next.val:\n while fast.next and fast.val == fast.next.val:\n fast = fast.next\n slow.next = fast.next\n else:\n slow = slow.next\n fast = fast.next\n return dummy.next\n \n \n ","runtime":"29"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sentinel = ListNode(-1, head)\n prev = sentinel\n curr = head\n\n while curr:\n if curr.next and curr.val == curr.next.val:\n while curr.next and curr.val == curr.next.val:\n curr.next = curr.next.next\n prev.next = curr.next\n else:\n prev = curr\n curr = curr.next\n \n return sentinel.next","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return None\n l=[]\n temp=head\n while temp:\n l.append(temp.val)\n temp=temp.next\n c=Counter(l)\n a=[i for i in c if c[i]==1 ]\n if not a:\n return None\n head=ListNode(a[0])\n temp=head\n for i in range(1,len(a)):\n temp.next=ListNode(a[i])\n temp=temp.next\n return head","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return head\n \n dummy = ListNode(0)\n sentinel = dummy\n\n while head:\n if head.next and head.val == head.next.val:\n while head.next and head.val == head.next.val:\n head = head.next\n sentinel.next = head.next\n else:\n sentinel.next = head\n sentinel = sentinel.next\n head = head.next\n return dummy.next","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n \n if head.val != head.next.val:\n head.next = self.deleteDuplicates(head.next)\n return head\n else:\n while head.next and head.val == head.next.val:\n head.next = head.next.next\n return self.deleteDuplicates(head.next)","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return head\n \n dummy = ListNode(0)\n tail = dummy\n\n prev = None\n cnt = 0\n while head:\n if prev is None or prev.val != head.val: # can not just blindly append head is None in the end\n if cnt == 1:\n prev.next = tail.next\n tail.next = prev\n tail = prev\n prev = head\n cnt = 1\n else:\n cnt += 1\n head = head.next\n if cnt == 1:\n prev.next = tail.next\n tail.next = prev\n return dummy.next","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n current = head\n prev = ListNode(-101)\n dup = set()\n while current:\n if current.val == prev.val:\n dup.add(current.val)\n prev = current\n current = current.next\n \n current = head\n dummy = ListNode(-101)\n dummy.next = head\n prev = dummy\n while current:\n if current.val in dup:\n prev.next = current.next\n else:\n prev = current\n current = current.next\n\n return dummy.next","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n last_duplicate_number = -999\n new_head = None\n prev_node = None\n\n while head:\n next_head = head.next\n if next_head != None and head.val == next_head.val:\n last_duplicate_number = head.val\n elif head.val != last_duplicate_number:\n if new_head == None:\n new_head = head\n else:\n prev_node.next = head\n prev_node = head\n prev_node.next = None\n\n head = next_head\n \n return new_head","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0, head)\n cur = dummy\n\n while cur.next is not None and cur.next.next is not None:\n if cur.next.val == cur.next.next.val:\n same_value = cur.next.val\n while cur.next is not None and cur.next.val == same_value:\n cur.next = cur.next.next\n else:\n cur = cur.next\n \n return dummy.next","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(val=101,next=head)\n prev = dummy\n curr = head\n while curr and curr.next:\n if curr.val != curr.next.val:\n prev = prev.next\n curr = curr.next\n else:\n val = curr.val\n while curr.val == val:\n curr = curr.next\n if not curr:\n break\n prev.next = curr\n return dummy.next\n\n\n\n ","runtime":"34"},{"code":"class Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n h=head\n p=ListNode(-1)\n p.next=head\n b=p\n f=defaultdict(int)\n while h and h.next:\n if h.val!=h.next.val:\n p=p.next\n h=h.next\n else:\n c=h.val\n while c==h.val:\n h=h.next\n if h==None:\n break\n p.next=h\n\n\n return b.next\n \n\n ","runtime":"34"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(-1)\n prev = new_head\n\n cnt = 0\n num = -1\n\n while head:\n num = head.val\n curr = head\n head = head.next\n cnt = 0\n while head and num == head.val:\n cnt += 1\n head = head.next\n \n if cnt == 0:\n curr.next = None\n prev.next = curr\n prev = curr\n \n return new_head.next\n\n ","runtime":"35"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return head\n \n # cur.next is unique -> cur<cur.next<cur.next.next\n\n findHead = False\n # find head\n if head.next and head.next.val != head.val:\n # head = head\n # print('good')\n findHead = True\n else:\n cur = head\n while cur.next and cur.next.next:\n if cur.val!=cur.next.val and cur.next.val!=cur.next.next.val:\n # print('if', cur.next.val)\n head = cur.next\n findHead = True\n break\n cur = cur.next\n if not findHead:\n if not cur.next:\n return head\n if cur.next.val != cur.val:\n return cur.next\n else:\n return None\n \n\n # now the head is the real head\n # print(head)\n \n # the rest\n \n tail = head\n cur = head\n while cur.next and cur.next.next:\n # print(cur.val, cur.next.val, cur.next.next.val)\n if cur.val!=cur.next.val and cur.next.val!=cur.next.next.val:\n # print('if', cur.next.val)\n tail.next = cur.next\n tail = tail.next\n cur = cur.next\n # the rest\n if cur.next.val == cur.val:\n tail.next = None\n else:\n tail.next = cur.next\n return head","runtime":"35"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n res = ListNode(-1, head)\n prev = res\n curr = head\n\n while curr:\n if curr.next and curr.val == curr.next.val:\n while curr.next and curr.val == curr.next.val:\n curr.next = curr.next.next\n prev.next = curr.next\n curr = curr.next\n else:\n prev = curr\n curr = curr.next\n return res.next\n\n \n return res.next","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n current = head\n prev=None\n while current:\n if current.next and current.val==current.next.val:\n val=current.val\n while current!=None and current.val==val:\n current = current.next\n if prev!=None:\n prev.next=current\n else:\n head=current\n else:\n prev=current\n current=current.next\n return head","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n res = ListNode(-1, head)\n prev = res\n curr = head\n\n while curr:\n if curr.next and curr.val == curr.next.val:\n while curr.next and curr.val == curr.next.val:\n curr.next = curr.next.next\n prev.next = curr.next\n curr = curr.next\n else:\n prev = curr\n curr = curr.next\n return res.next","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0,head)\n l=dummy\n r=head\n while r:\n if r.next and r.val == r.next.val:\n while r.next and r.val == r.next.val:\n r = r.next\n l.next = r.next\n else:\n l = l.next\n r= r.next\n return dummy.next\n\n","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(-1)\n prev = new_head\n\n cnt = 0\n num = -1\n\n while head:\n num = head.val\n curr = head\n head = head.next\n cnt = 0\n while head and num == head.val:\n cnt += 1\n head = head.next\n \n if cnt == 0:\n curr.next = None\n prev.next = curr\n prev = curr\n \n return new_head.next\n\n ","runtime":"38"},{"code":"class ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\nclass Solution:\n def deleteDuplicates(self, head: ListNode) -> ListNode:\n # Create a dummy node to handle edge cases\n dummy = ListNode(0)\n dummy.next = head\n prev = dummy\n current = head\n \n while current:\n # Move through the duplicates\n while current.next and current.val == current.next.val:\n current = current.next\n \n # If prev.next is not equal to current, it means duplicates were detected\n if prev.next != current:\n prev.next = current.next\n else:\n prev = prev.next\n \n current = current.next\n \n return dummy.next\n","runtime":"38"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head == None or head.next == None:\n return head\n dummyNode = ListNode(float('-infinity'), head)\n dummy = dummyNode\n cur = head\n prevVal = float('infinity')\n while cur:\n if cur.next and cur.val == cur.next.val:\n cur = cur.next\n prevVal = cur.val\n else:\n if cur.val == prevVal:\n cur = cur.next\n else:\n prevVal = cur.val\n dummy.next = cur\n dummy = dummy.next\n dummy.next = None\n return dummyNode.next","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n l=[]\n temp=head\n while temp:\n l.append(temp.val)\n temp=temp.next\n d={}\n for i in l:\n d[i]=d[i]+1 if i in d else 1\n a=[i for i in d if d[i]==1]\n if not a:\n return None\n ls=ListNode(a[0])\n temp=ls\n for i in range(1,len(a)):\n temp.next=ListNode(a[i])\n temp=temp.next\n return ls\n ","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(val=101)\n prev = dummy\n curr = head\n hashmap = {}\n while curr:\n if curr.val not in hashmap:\n hashmap[curr.val] = 1\n else:\n hashmap[curr.val] += 1\n curr = curr.next\n for num in hashmap:\n if hashmap[num] == 1:\n prev.next = ListNode(num)\n prev = prev.next\n \n return dummy.next\n\n\n\n ","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def toArray(self, head: Optional[ListNode])->List[int]:\n list_ = []\n temp = head\n while temp != None:\n list_.append(temp.val)\n temp = temp.next\n return list_\n def toList(self, list_: List[int])->ListNode:\n if list_ == []:\n return None\n head = ListNode(list_[0])\n temp = head\n for i in range(1,len(list_)):\n temp.next = ListNode(list_[i])\n temp = temp.next\n return head\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head == None:\n return None\n array = self.toArray(head)\n list_ = []\n duplicates = []\n for i in array:\n if i not in list_ and i not in duplicates:\n list_.append(i)\n else:\n if i in list_:\n list_.pop()\n duplicates.append(i)\n return self.toList(list_)\n \n\n ","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n fake = ListNode(-1)\n fake.next = head\n prev, curr = fake, head\n while curr:\n while curr.next and curr.val == curr.next.val:\n curr = curr.next\n if prev.next == curr:\n prev = prev.next\n curr = curr.next\n else:\n prev.next = curr.next\n curr = prev.next\n return fake.next\n \n ","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n dummy = ListNode(0, head)\n prev, cur = dummy, head\n\n dup = -101\n\n while cur.next:\n if cur.val == cur.next.val:\n dup = cur.val\n \n # cur node is dup\n if cur.val == dup:\n prev.next = cur.next\n else:\n prev = prev.next\n \n cur = cur.next\n \n if cur.val == dup:\n prev.next = None\n \n return dummy.next\n\n ","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n tmp = head\n st = set()\n while tmp:\n if tmp.next and tmp.val == tmp.next.val:\n st.add(tmp.val)\n\n tmp = tmp.next\n \n \n\n while head and head.val in st:\n head = head.next\n\n tmp = head\n \n while tmp:\n if tmp.next and tmp.next.val in st:\n \n tmp.next = tmp.next.next\n else:\n tmp = tmp.next\n\n return head\n \n","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sentinel = ListNode(0, head)\n slow = sentinel\n fast = head\n while fast:\n if fast.next and fast.val == fast.next.val:\n while fast.next and fast.val == fast.next.val:\n fast = fast.next\n slow.next = fast.next\n else:\n slow = slow.next\n fast = fast.next\n return sentinel.next","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n fake = ListNode(-1)\n fake.next = head\n prev, curr = fake, head\n while curr:\n while curr.next and curr.val == curr.next.val:\n curr = curr.next\n if prev.next == curr:\n prev = prev.next\n curr = curr.next\n else:\n prev.next = curr.next\n curr = curr.next\n return fake.next\n \n ","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n numbers_range = [0] * 201\n\n temp = head\n\n while temp:\n num = temp.val\n offset_val = num + 100\n numbers_range[offset_val] += 1\n temp = temp.next\n \n new_head = None\n temp = None\n\n for i in range(len(numbers_range)):\n freq = numbers_range[i]\n if freq > 1:\n continue\n elif freq == 1:\n if temp:\n tail_node = ListNode(i-100)\n temp.next = tail_node\n temp = temp.next\n else:\n new_head = ListNode(i-100)\n temp = new_head\n \n return new_head\n ","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(-101, head)\n prev = ListNode(-102, dummy)\n slow = dummy\n fast = head\n\n while fast:\n flag = False\n while fast and fast.val == slow.val:\n flag = True\n fast = fast.next\n if flag:\n prev.next = fast\n slow = fast\n else:\n prev = slow\n slow.next = fast\n slow = fast\n if fast:\n fast = fast.next\n\n return dummy.next\n","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sentinel = ListNode(0, head)\n slow = sentinel\n fast = head\n while fast:\n if fast.next and fast.val == fast.next.val:\n while fast.next and fast.val == fast.next.val:\n fast = fast.next\n slow.next = fast.next\n elif not fast.next or fast.val != fast.next.val:\n slow = slow.next\n fast = fast.next\n return sentinel.next","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n dummy = ListNode()\n dummy.next = head\n prev, curr, n = dummy, head, head.next\n while curr:\n flag = False\n while n and n.val == curr.val:\n flag = True\n n = n.next\n if flag:\n prev.next = n\n else:\n prev = curr\n if not n:\n break\n curr, n = n, n.next\n\n return dummy.next","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sentinel = ListNode(0, head)\n slow = sentinel\n fast = head\n while fast:\n if fast.next and fast.val == fast.next.val:\n while fast.next and fast.val == fast.next.val:\n fast = fast.next\n slow.next = fast.next\n else:\n slow = slow.next\n fast = fast.next\n return sentinel.next","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode()\n new_head = dummy\n prev_val = -101\n while head and head.next:\n temp = head.next\n if head.val != prev_val and head.val != head.next.val:\n head.next = None\n new_head.next = head\n new_head = new_head.next\n prev_val = head.val\n head = temp\n \n if head and head.val != prev_val:\n new_head.next = head \n return dummy.next\n","runtime":"46"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n\n if not head or not head.next:\n return head\n # elif not head.next.next:\n # if head.val == head.next.val:\n # head = None\n # return head\n \n \n fp = head.next\n sp = head\n prev_sp = ListNode(1000, sp)\n dummy_head = prev_sp\n while fp:\n if sp.val == fp.val: \n fp = fp.next\n sp = sp.next \n else:\n if prev_sp.next != sp : \n prev_sp.next = fp \n else:\n prev_sp = sp\n sp =fp\n fp = fp.next\n\n if prev_sp.next != sp:\n sp.next = None\n prev_sp.next = fp\n \n head = dummy_head.next\n\n return head\n \n\n ","runtime":"46"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sentinel = ListNode(0, head)\n slow = sentinel\n fast = head\n while fast:\n if fast.next and fast.val == fast.next.val:\n while fast.next and fast.val == fast.next.val:\n fast = fast.next\n slow.next = fast.next\n elif not fast.next or fast.val != fast.next.val:\n slow = slow.next\n fast = fast.next\n return sentinel.next","runtime":"47"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n count = {}\n curr = head\n while curr:\n count[curr.val] = count.get(curr.val, 0) + 1\n curr = curr.next\n \n dummy = ListNode(0)\n new_list = dummy\n curr = head\n while curr:\n if count[curr.val] == 1:\n new_list.next = ListNode(curr.val)\n new_list = new_list.next\n curr = curr.next\n return dummy.next\n","runtime":"47"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n current_ref = head\n if current_ref is None or current_ref.next is None:\n return head\n\n duplicates = []\n last_keeper = head\n while last_keeper.next is not None:\n if last_keeper.val == last_keeper.next.val and last_keeper.val not in duplicates:\n duplicates.append(last_keeper.val)\n last_keeper = last_keeper.next\n \n new_head = head\n while new_head is not None and new_head.val in duplicates:\n new_head = new_head.next\n if new_head is None:\n return new_head\n prev_ref = new_head\n next_ref = prev_ref.next\n\n while next_ref is not None:\n if next_ref.val not in duplicates:\n prev_ref.next = next_ref\n prev_ref = next_ref\n next_ref = next_ref.next\n if next_ref is None:\n prev_ref.next = next_ref\n return new_head\n\n # if new_head.val in duplicates:\n # new_head = new_head.next\n \n \n\n\n # next_ref = current_ref\n # while next_ref is not None and current_ref.val == next_ref.val:\n # next_ref\n\n\n # if current_ref.next is None:\n # return head","runtime":"48"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n \n\n dummy = ListNode(-200,head)\n\n curr = dummy\n nxt1 = curr.next\n nxt2 = nxt1.next\n\n while nxt1 and nxt2:\n if nxt1.val == nxt2.val:\n while nxt1 and nxt2 and nxt1.val == nxt2.val:\n nxt1 = nxt1.next\n nxt2 = nxt2.next\n curr.next = nxt2\n nxt1 = curr.next\n if nxt1:\n nxt2 = nxt1.next\n else:\n curr = curr.next\n nxt1 = curr.next\n nxt2 = nxt1.next\n\n \n return dummy.next\n \n \n\n\n","runtime":"48"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n h=head\\n p=ListNode(-1)\\n p.next=head\\n b=p\\n f=defaultdict(int)\\n while h and h.next:\\n if h.val!=h.next.val:\\n p=p.next\\n h=h.next\\n else:\\n c=h.val\\n while c==h.val:\\n h=h.next\\n if h==None:\\n break\\n p.next=h\\n\\n\\n return b.next\\n \\n \\n \\n\\n\\n \\n\\n\\n \",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"class Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n fake = ListNode(-1)\\n fake.next = head\\n # We use prev (for node just before duplications begins), curr (for the last node of the duplication group)...\\n curr, prev = head, fake\\n while curr:\\n # while we have curr.next and its value is equal to curr...\\n # It means, that we have one more duplicate...\\n while curr.next and curr.val == curr.next.val:\\n # So move curr pointer to the right...\\n curr = curr.next\\n # If it happens, that prev.next equal to curr...\\n # It means, that we have only 1 element in the group of duplicated elements...\\n if prev.next == curr:\\n # Don't need to delete it, we move both pointers to right...\\n prev = prev.next\\n curr = curr.next\\n # Otherwise, we need to skip a group of duplicated elements...\\n # set prev.next = curr.next, and curr = prev.next...\\n else:\\n prev.next = curr.next\\n curr = prev.next\\n # Return the linked list...\\n return fake.next \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]: \\n prev = dummy = ListNode() \\n curr = dummy.next = head\\n while curr and curr.next:\\n if curr.val != curr.next.val: \\n prev = prev.next\\n curr = curr.next\\n else:\\n while curr.next and curr.val == curr.next.val:\\n curr = curr.next\\n curr = curr.next\\n prev.next = curr\\n return dummy.next\\n\\n \",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n original_head = head\\n to_delete_val = set()\\n\\n prev = None\\n while head:\\n if not prev:\\n prev = head\\n head = head.next\\n continue\\n if prev.val == head.val:\\n to_delete_val.add(head.val)\\n prev = head\\n head = head.next\\n \\n \\n \\n while original_head and original_head.val in to_delete_val:\\n original_head = original_head.next\\n\\n head = original_head\\n prev = None\\n\\n\\n while head:\\n if not prev:\\n prev = head\\n head = head.next\\n continue\\n if head.val in to_delete_val:\\n prev.next = head.next\\n else:\\n prev= head\\n head = head.next\\n\\n return original_head\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n curr = ListNode(-1,head)\\n prev = curr\\n while head:\\n if head.next and head.val == head.next.val:\\n while head.next and head.val == head.next.val:\\n head = head.next \\n prev.next = head.next \\n else: \\n prev = prev.next\\n head = head.next \\n return curr.next\\n\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n duplicates = set()\\n temp = head\\n if not head: return\\n while temp.next:\\n if temp.val == temp.next.val:\\n duplicates.add(temp.val)\\n temp = temp.next\\n print(duplicates)\\n while head and head.val in duplicates:\\n head = head.next\\n if not head: return\\n temp = head\\n while temp.next:\\n if temp.next.val in duplicates:\\n temp.next = temp.next.next\\n else:\\n temp = temp.next\\n return head\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n #d-1-2-3-3-4-4-5\\n # P C N\\n dummy = ListNode(0,head)\\n prev = dummy\\n curr = head\\n while curr:\\n while curr.next and curr.val == curr.next.val:\\n curr = curr.next\\n if prev.next !=curr:\\n prev.next = curr.next\\n else:\\n prev = prev.next\\n curr=curr.next\\n\\n return dummy.next\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n a = ListNode()\\n temp = a\\n while head:\\n sum = 0\\n pre = head\\n while(head != None and head.val == pre.val):\\n sum = sum+1\\n head = head.next\\n if(sum == 1):\\n a.next = pre\\n a = a.next\\n a.next = None\\n return temp.next\\n\\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(-1)\\n p = dummy\\n q = head\\n\\n while q:\\n if q.next is not None and q.val == q.next.val:\\n while q.next is not None and q.val == q.next.val:\\n q = q.next\\n q = q.next\\n if q == None:\\n p.next = None\\n else:\\n p.next = q\\n p = p.next\\n q = q.next\\n return dummy.next\\n \\n\\n\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n output=ListNode(0,head)\\n pre=output\\n\\n while head:\\n if head.next and head.val ==head.next.val:\\n while head.next and head.val ==head.next.val:\\n head=head.next\\n pre.next=head.next\\n else:\\n pre=pre.next\\n head=head.next\\n return output.next\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n output=ListNode(0,head)\\n pre=output\\n while head:\\n if head.next and head.val==head.next.val:\\n while head.next and head.val==head.next.val:\\n head=head.next\\n pre.next=head.next\\n else:\\n pre=pre.next\\n head=head.next\\n # return output.next\\n\\n\\n return output.next\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0)\\n dummy.next = head\\n fast = head\\n slow = dummy\\n while fast:\\n if fast.next and fast.val == fast.next.val:\\n while fast.next and fast.val == fast.next.val:\\n fast = fast.next\\n slow.next = fast.next\\n else:\\n slow = slow.next\\n fast = fast.next\\n return dummy.next\\n \\n \\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sentinel = ListNode(-1, head)\\n prev = sentinel\\n curr = head\\n\\n while curr:\\n if curr.next and curr.val == curr.next.val:\\n while curr.next and curr.val == curr.next.val:\\n curr.next = curr.next.next\\n prev.next = curr.next\\n else:\\n prev = curr\\n curr = curr.next\\n \\n return sentinel.next\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return None\\n l=[]\\n temp=head\\n while temp:\\n l.append(temp.val)\\n temp=temp.next\\n c=Counter(l)\\n a=[i for i in c if c[i]==1 ]\\n if not a:\\n return None\\n head=ListNode(a[0])\\n temp=head\\n for i in range(1,len(a)):\\n temp.next=ListNode(a[i])\\n temp=temp.next\\n return head\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return head\\n \\n dummy = ListNode(0)\\n sentinel = dummy\\n\\n while head:\\n if head.next and head.val == head.next.val:\\n while head.next and head.val == head.next.val:\\n head = head.next\\n sentinel.next = head.next\\n else:\\n sentinel.next = head\\n sentinel = sentinel.next\\n head = head.next\\n return dummy.next\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n \\n if head.val != head.next.val:\\n head.next = self.deleteDuplicates(head.next)\\n return head\\n else:\\n while head.next and head.val == head.next.val:\\n head.next = head.next.next\\n return self.deleteDuplicates(head.next)\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return head\\n \\n dummy = ListNode(0)\\n tail = dummy\\n\\n prev = None\\n cnt = 0\\n while head:\\n if prev is None or prev.val != head.val: # can not just blindly append head is None in the end\\n if cnt == 1:\\n prev.next = tail.next\\n tail.next = prev\\n tail = prev\\n prev = head\\n cnt = 1\\n else:\\n cnt += 1\\n head = head.next\\n if cnt == 1:\\n prev.next = tail.next\\n tail.next = prev\\n return dummy.next\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n current = head\\n prev = ListNode(-101)\\n dup = set()\\n while current:\\n if current.val == prev.val:\\n dup.add(current.val)\\n prev = current\\n current = current.next\\n \\n current = head\\n dummy = ListNode(-101)\\n dummy.next = head\\n prev = dummy\\n while current:\\n if current.val in dup:\\n prev.next = current.next\\n else:\\n prev = current\\n current = current.next\\n\\n return dummy.next\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n last_duplicate_number = -999\\n new_head = None\\n prev_node = None\\n\\n while head:\\n next_head = head.next\\n if next_head != None and head.val == next_head.val:\\n last_duplicate_number = head.val\\n elif head.val != last_duplicate_number:\\n if new_head == None:\\n new_head = head\\n else:\\n prev_node.next = head\\n prev_node = head\\n prev_node.next = None\\n\\n head = next_head\\n \\n return new_head\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0, head)\\n cur = dummy\\n\\n while cur.next is not None and cur.next.next is not None:\\n if cur.next.val == cur.next.next.val:\\n same_value = cur.next.val\\n while cur.next is not None and cur.next.val == same_value:\\n cur.next = cur.next.next\\n else:\\n cur = cur.next\\n \\n return dummy.next\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(val=101,next=head)\\n prev = dummy\\n curr = head\\n while curr and curr.next:\\n if curr.val != curr.next.val:\\n prev = prev.next\\n curr = curr.next\\n else:\\n val = curr.val\\n while curr.val == val:\\n curr = curr.next\\n if not curr:\\n break\\n prev.next = curr\\n return dummy.next\\n\\n\\n\\n \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n h=head\\n p=ListNode(-1)\\n p.next=head\\n b=p\\n f=defaultdict(int)\\n while h and h.next:\\n if h.val!=h.next.val:\\n p=p.next\\n h=h.next\\n else:\\n c=h.val\\n while c==h.val:\\n h=h.next\\n if h==None:\\n break\\n p.next=h\\n\\n\\n return b.next\\n \\n\\n \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(-1)\\n prev = new_head\\n\\n cnt = 0\\n num = -1\\n\\n while head:\\n num = head.val\\n curr = head\\n head = head.next\\n cnt = 0\\n while head and num == head.val:\\n cnt += 1\\n head = head.next\\n \\n if cnt == 0:\\n curr.next = None\\n prev.next = curr\\n prev = curr\\n \\n return new_head.next\\n\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return head\\n \\n # cur.next is unique -> cur<cur.next<cur.next.next\\n\\n findHead = False\\n # find head\\n if head.next and head.next.val != head.val:\\n # head = head\\n # print('good')\\n findHead = True\\n else:\\n cur = head\\n while cur.next and cur.next.next:\\n if cur.val!=cur.next.val and cur.next.val!=cur.next.next.val:\\n # print('if', cur.next.val)\\n head = cur.next\\n findHead = True\\n break\\n cur = cur.next\\n if not findHead:\\n if not cur.next:\\n return head\\n if cur.next.val != cur.val:\\n return cur.next\\n else:\\n return None\\n \\n\\n # now the head is the real head\\n # print(head)\\n \\n # the rest\\n \\n tail = head\\n cur = head\\n while cur.next and cur.next.next:\\n # print(cur.val, cur.next.val, cur.next.next.val)\\n if cur.val!=cur.next.val and cur.next.val!=cur.next.next.val:\\n # print('if', cur.next.val)\\n tail.next = cur.next\\n tail = tail.next\\n cur = cur.next\\n # the rest\\n if cur.next.val == cur.val:\\n tail.next = None\\n else:\\n tail.next = cur.next\\n return head\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n res = ListNode(-1, head)\\n prev = res\\n curr = head\\n\\n while curr:\\n if curr.next and curr.val == curr.next.val:\\n while curr.next and curr.val == curr.next.val:\\n curr.next = curr.next.next\\n prev.next = curr.next\\n curr = curr.next\\n else:\\n prev = curr\\n curr = curr.next\\n return res.next\\n\\n \\n return res.next\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n current = head\\n prev=None\\n while current:\\n if current.next and current.val==current.next.val:\\n val=current.val\\n while current!=None and current.val==val:\\n current = current.next\\n if prev!=None:\\n prev.next=current\\n else:\\n head=current\\n else:\\n prev=current\\n current=current.next\\n return head\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n res = ListNode(-1, head)\\n prev = res\\n curr = head\\n\\n while curr:\\n if curr.next and curr.val == curr.next.val:\\n while curr.next and curr.val == curr.next.val:\\n curr.next = curr.next.next\\n prev.next = curr.next\\n curr = curr.next\\n else:\\n prev = curr\\n curr = curr.next\\n return res.next\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0,head)\\n l=dummy\\n r=head\\n while r:\\n if r.next and r.val == r.next.val:\\n while r.next and r.val == r.next.val:\\n r = r.next\\n l.next = r.next\\n else:\\n l = l.next\\n r= r.next\\n return dummy.next\\n\\n\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(-1)\\n prev = new_head\\n\\n cnt = 0\\n num = -1\\n\\n while head:\\n num = head.val\\n curr = head\\n head = head.next\\n cnt = 0\\n while head and num == head.val:\\n cnt += 1\\n head = head.next\\n \\n if cnt == 0:\\n curr.next = None\\n prev.next = curr\\n prev = curr\\n \\n return new_head.next\\n\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\nclass Solution:\\n def deleteDuplicates(self, head: ListNode) -> ListNode:\\n # Create a dummy node to handle edge cases\\n dummy = ListNode(0)\\n dummy.next = head\\n prev = dummy\\n current = head\\n \\n while current:\\n # Move through the duplicates\\n while current.next and current.val == current.next.val:\\n current = current.next\\n \\n # If prev.next is not equal to current, it means duplicates were detected\\n if prev.next != current:\\n prev.next = current.next\\n else:\\n prev = prev.next\\n \\n current = current.next\\n \\n return dummy.next\\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head == None or head.next == None:\\n return head\\n dummyNode = ListNode(float('-infinity'), head)\\n dummy = dummyNode\\n cur = head\\n prevVal = float('infinity')\\n while cur:\\n if cur.next and cur.val == cur.next.val:\\n cur = cur.next\\n prevVal = cur.val\\n else:\\n if cur.val == prevVal:\\n cur = cur.next\\n else:\\n prevVal = cur.val\\n dummy.next = cur\\n dummy = dummy.next\\n dummy.next = None\\n return dummyNode.next\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n l=[]\\n temp=head\\n while temp:\\n l.append(temp.val)\\n temp=temp.next\\n d={}\\n for i in l:\\n d[i]=d[i]+1 if i in d else 1\\n a=[i for i in d if d[i]==1]\\n if not a:\\n return None\\n ls=ListNode(a[0])\\n temp=ls\\n for i in range(1,len(a)):\\n temp.next=ListNode(a[i])\\n temp=temp.next\\n return ls\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(val=101)\\n prev = dummy\\n curr = head\\n hashmap = {}\\n while curr:\\n if curr.val not in hashmap:\\n hashmap[curr.val] = 1\\n else:\\n hashmap[curr.val] += 1\\n curr = curr.next\\n for num in hashmap:\\n if hashmap[num] == 1:\\n prev.next = ListNode(num)\\n prev = prev.next\\n \\n return dummy.next\\n\\n\\n\\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def toArray(self, head: Optional[ListNode])->List[int]:\\n list_ = []\\n temp = head\\n while temp != None:\\n list_.append(temp.val)\\n temp = temp.next\\n return list_\\n def toList(self, list_: List[int])->ListNode:\\n if list_ == []:\\n return None\\n head = ListNode(list_[0])\\n temp = head\\n for i in range(1,len(list_)):\\n temp.next = ListNode(list_[i])\\n temp = temp.next\\n return head\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head == None:\\n return None\\n array = self.toArray(head)\\n list_ = []\\n duplicates = []\\n for i in array:\\n if i not in list_ and i not in duplicates:\\n list_.append(i)\\n else:\\n if i in list_:\\n list_.pop()\\n duplicates.append(i)\\n return self.toList(list_)\\n \\n\\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n fake = ListNode(-1)\\n fake.next = head\\n prev, curr = fake, head\\n while curr:\\n while curr.next and curr.val == curr.next.val:\\n curr = curr.next\\n if prev.next == curr:\\n prev = prev.next\\n curr = curr.next\\n else:\\n prev.next = curr.next\\n curr = prev.next\\n return fake.next\\n \\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n dummy = ListNode(0, head)\\n prev, cur = dummy, head\\n\\n dup = -101\\n\\n while cur.next:\\n if cur.val == cur.next.val:\\n dup = cur.val\\n \\n # cur node is dup\\n if cur.val == dup:\\n prev.next = cur.next\\n else:\\n prev = prev.next\\n \\n cur = cur.next\\n \\n if cur.val == dup:\\n prev.next = None\\n \\n return dummy.next\\n\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n tmp = head\\n st = set()\\n while tmp:\\n if tmp.next and tmp.val == tmp.next.val:\\n st.add(tmp.val)\\n\\n tmp = tmp.next\\n \\n \\n\\n while head and head.val in st:\\n head = head.next\\n\\n tmp = head\\n \\n while tmp:\\n if tmp.next and tmp.next.val in st:\\n \\n tmp.next = tmp.next.next\\n else:\\n tmp = tmp.next\\n\\n return head\\n \\n\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sentinel = ListNode(0, head)\\n slow = sentinel\\n fast = head\\n while fast:\\n if fast.next and fast.val == fast.next.val:\\n while fast.next and fast.val == fast.next.val:\\n fast = fast.next\\n slow.next = fast.next\\n else:\\n slow = slow.next\\n fast = fast.next\\n return sentinel.next\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n fake = ListNode(-1)\\n fake.next = head\\n prev, curr = fake, head\\n while curr:\\n while curr.next and curr.val == curr.next.val:\\n curr = curr.next\\n if prev.next == curr:\\n prev = prev.next\\n curr = curr.next\\n else:\\n prev.next = curr.next\\n curr = curr.next\\n return fake.next\\n \\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n numbers_range = [0] * 201\\n\\n temp = head\\n\\n while temp:\\n num = temp.val\\n offset_val = num + 100\\n numbers_range[offset_val] += 1\\n temp = temp.next\\n \\n new_head = None\\n temp = None\\n\\n for i in range(len(numbers_range)):\\n freq = numbers_range[i]\\n if freq > 1:\\n continue\\n elif freq == 1:\\n if temp:\\n tail_node = ListNode(i-100)\\n temp.next = tail_node\\n temp = temp.next\\n else:\\n new_head = ListNode(i-100)\\n temp = new_head\\n \\n return new_head\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(-101, head)\\n prev = ListNode(-102, dummy)\\n slow = dummy\\n fast = head\\n\\n while fast:\\n flag = False\\n while fast and fast.val == slow.val:\\n flag = True\\n fast = fast.next\\n if flag:\\n prev.next = fast\\n slow = fast\\n else:\\n prev = slow\\n slow.next = fast\\n slow = fast\\n if fast:\\n fast = fast.next\\n\\n return dummy.next\\n\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sentinel = ListNode(0, head)\\n slow = sentinel\\n fast = head\\n while fast:\\n if fast.next and fast.val == fast.next.val:\\n while fast.next and fast.val == fast.next.val:\\n fast = fast.next\\n slow.next = fast.next\\n elif not fast.next or fast.val != fast.next.val:\\n slow = slow.next\\n fast = fast.next\\n return sentinel.next\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n dummy = ListNode()\\n dummy.next = head\\n prev, curr, n = dummy, head, head.next\\n while curr:\\n flag = False\\n while n and n.val == curr.val:\\n flag = True\\n n = n.next\\n if flag:\\n prev.next = n\\n else:\\n prev = curr\\n if not n:\\n break\\n curr, n = n, n.next\\n\\n return dummy.next\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sentinel = ListNode(0, head)\\n slow = sentinel\\n fast = head\\n while fast:\\n if fast.next and fast.val == fast.next.val:\\n while fast.next and fast.val == fast.next.val:\\n fast = fast.next\\n slow.next = fast.next\\n else:\\n slow = slow.next\\n fast = fast.next\\n return sentinel.next\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode()\\n new_head = dummy\\n prev_val = -101\\n while head and head.next:\\n temp = head.next\\n if head.val != prev_val and head.val != head.next.val:\\n head.next = None\\n new_head.next = head\\n new_head = new_head.next\\n prev_val = head.val\\n head = temp\\n \\n if head and head.val != prev_val:\\n new_head.next = head \\n return dummy.next\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n\\n if not head or not head.next:\\n return head\\n # elif not head.next.next:\\n # if head.val == head.next.val:\\n # head = None\\n # return head\\n \\n \\n fp = head.next\\n sp = head\\n prev_sp = ListNode(1000, sp)\\n dummy_head = prev_sp\\n while fp:\\n if sp.val == fp.val: \\n fp = fp.next\\n sp = sp.next \\n else:\\n if prev_sp.next != sp : \\n prev_sp.next = fp \\n else:\\n prev_sp = sp\\n sp =fp\\n fp = fp.next\\n\\n if prev_sp.next != sp:\\n sp.next = None\\n prev_sp.next = fp\\n \\n head = dummy_head.next\\n\\n return head\\n \\n\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sentinel = ListNode(0, head)\\n slow = sentinel\\n fast = head\\n while fast:\\n if fast.next and fast.val == fast.next.val:\\n while fast.next and fast.val == fast.next.val:\\n fast = fast.next\\n slow.next = fast.next\\n elif not fast.next or fast.val != fast.next.val:\\n slow = slow.next\\n fast = fast.next\\n return sentinel.next\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n count = {}\\n curr = head\\n while curr:\\n count[curr.val] = count.get(curr.val, 0) + 1\\n curr = curr.next\\n \\n dummy = ListNode(0)\\n new_list = dummy\\n curr = head\\n while curr:\\n if count[curr.val] == 1:\\n new_list.next = ListNode(curr.val)\\n new_list = new_list.next\\n curr = curr.next\\n return dummy.next\\n\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n current_ref = head\\n if current_ref is None or current_ref.next is None:\\n return head\\n\\n duplicates = []\\n last_keeper = head\\n while last_keeper.next is not None:\\n if last_keeper.val == last_keeper.next.val and last_keeper.val not in duplicates:\\n duplicates.append(last_keeper.val)\\n last_keeper = last_keeper.next\\n \\n new_head = head\\n while new_head is not None and new_head.val in duplicates:\\n new_head = new_head.next\\n if new_head is None:\\n return new_head\\n prev_ref = new_head\\n next_ref = prev_ref.next\\n\\n while next_ref is not None:\\n if next_ref.val not in duplicates:\\n prev_ref.next = next_ref\\n prev_ref = next_ref\\n next_ref = next_ref.next\\n if next_ref is None:\\n prev_ref.next = next_ref\\n return new_head\\n\\n # if new_head.val in duplicates:\\n # new_head = new_head.next\\n \\n \\n\\n\\n # next_ref = current_ref\\n # while next_ref is not None and current_ref.val == next_ref.val:\\n # next_ref\\n\\n\\n # if current_ref.next is None:\\n # return head\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n \\n\\n dummy = ListNode(-200,head)\\n\\n curr = dummy\\n nxt1 = curr.next\\n nxt2 = nxt1.next\\n\\n while nxt1 and nxt2:\\n if nxt1.val == nxt2.val:\\n while nxt1 and nxt2 and nxt1.val == nxt2.val:\\n nxt1 = nxt1.next\\n nxt2 = nxt2.next\\n curr.next = nxt2\\n nxt1 = curr.next\\n if nxt1:\\n nxt2 = nxt1.next\\n else:\\n curr = curr.next\\n nxt1 = curr.next\\n nxt2 = nxt1.next\\n\\n \\n return dummy.next\\n \\n \\n\\n\\n\",\n \"runtime\": \"48\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":50,"string":"50"},"mm_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n left_node = ListNode(-1)\n new_head = left_node\n temp = {}\n dummy = head\n while dummy is not None:\n if dummy.val not in temp:\n temp[dummy.val] = [dummy]\n else:\n temp[dummy.val].append(dummy)\n dummy = dummy.next\n for value in temp.values():\n if len(value) < 2:\n left_node.next = value[0]\n left_node = left_node.next\n left_node.next = None\n \n return new_head.next \n","memory":"16000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0) # Create a dummy node to handle edge cases\n dummy.next = head\n previous = dummy\n current = head\n \n while current:\n # Skip nodes while there are duplicates\n while current.next and current.val == current.next.val:\n current = current.next\n # Check if previous node should skip current node\n if previous.next != current:\n previous.next = current.next\n else:\n previous = previous.next\n current = current.next\n \n head = dummy.next \n return head","memory":"16100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head == None or head.next == None:\n return head\n dummyNode = ListNode(float('-infinity'), head)\n dummy = dummyNode\n cur = head\n prevVal = float('infinity')\n while cur:\n if cur.next and cur.val == cur.next.val:\n cur = cur.next\n prevVal = cur.val\n else:\n if cur.val == prevVal:\n cur = cur.next\n else:\n prevVal = cur.val\n dummy.next = cur\n dummy = dummy.next\n dummy.next = None\n return dummyNode.next","memory":"16200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sentinel = ListNode(-1, head)\n prev = sentinel\n curr = head\n\n while curr:\n if curr.next and curr.val == curr.next.val:\n while curr.next and curr.val == curr.next.val:\n curr.next = curr.next.next\n prev.next = curr.next\n else:\n prev = curr\n curr = curr.next\n \n return sentinel.next","memory":"16300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0, head)\n cur = dummy\n \n while cur.next is not None and cur.next.next is not None:\n if cur.next.val == cur.next.next.val:\n same_value = cur.next.val\n while cur.next is not None and cur.next.val == same_value:\n cur.next = cur.next.next\n else:\n cur = cur.next\n \n return dummy.next","memory":"16300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode()\n new_head = dummy\n prev_val = -101\n while head and head.next:\n temp = head.next\n if head.val != prev_val and head.val != head.next.val:\n head.next = None\n new_head.next = head\n new_head = new_head.next\n prev_val = head.val\n head = temp\n \n if head and head.val != prev_val:\n new_head.next = head \n return dummy.next\n","memory":"16400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n tmp = head\n st = set()\n while tmp:\n if tmp.next and tmp.val == tmp.next.val:\n st.add(tmp.val)\n\n tmp = tmp.next\n \n \n\n while head and head.val in st:\n head = head.next\n\n tmp = head\n \n while tmp:\n if tmp.next and tmp.next.val in st:\n \n tmp.next = tmp.next.next\n else:\n tmp = tmp.next\n\n return head\n \n","memory":"16400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n output=ListNode(0,head)\n pre=output\n while head:\n if head.next and head.val==head.next.val:\n while head.next and head.val==head.next.val:\n head=head.next\n pre.next=head.next\n else:\n pre=pre.next\n head=head.next\n # return output.next\n\n\n return output.next","memory":"16500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n dummy=ListNode(0,head)\n prev=dummy\n cur=head\n while cur and cur.next:\n if cur.val==cur.next.val:\n while cur.next and cur.next.val==cur.val:\n cur=cur.next\n cur.next, cur=None, cur.next\n prev.next=cur\n else:\n prev=cur\n cur=cur.next\n\n return dummy.next","memory":"16500"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n left_node = ListNode(-1)\\n new_head = left_node\\n temp = {}\\n dummy = head\\n while dummy is not None:\\n if dummy.val not in temp:\\n temp[dummy.val] = [dummy]\\n else:\\n temp[dummy.val].append(dummy)\\n dummy = dummy.next\\n for value in temp.values():\\n if len(value) < 2:\\n left_node.next = value[0]\\n left_node = left_node.next\\n left_node.next = None\\n \\n return new_head.next \\n\",\n \"memory\": \"16000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0) # Create a dummy node to handle edge cases\\n dummy.next = head\\n previous = dummy\\n current = head\\n \\n while current:\\n # Skip nodes while there are duplicates\\n while current.next and current.val == current.next.val:\\n current = current.next\\n # Check if previous node should skip current node\\n if previous.next != current:\\n previous.next = current.next\\n else:\\n previous = previous.next\\n current = current.next\\n \\n head = dummy.next \\n return head\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head == None or head.next == None:\\n return head\\n dummyNode = ListNode(float('-infinity'), head)\\n dummy = dummyNode\\n cur = head\\n prevVal = float('infinity')\\n while cur:\\n if cur.next and cur.val == cur.next.val:\\n cur = cur.next\\n prevVal = cur.val\\n else:\\n if cur.val == prevVal:\\n cur = cur.next\\n else:\\n prevVal = cur.val\\n dummy.next = cur\\n dummy = dummy.next\\n dummy.next = None\\n return dummyNode.next\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sentinel = ListNode(-1, head)\\n prev = sentinel\\n curr = head\\n\\n while curr:\\n if curr.next and curr.val == curr.next.val:\\n while curr.next and curr.val == curr.next.val:\\n curr.next = curr.next.next\\n prev.next = curr.next\\n else:\\n prev = curr\\n curr = curr.next\\n \\n return sentinel.next\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0, head)\\n cur = dummy\\n \\n while cur.next is not None and cur.next.next is not None:\\n if cur.next.val == cur.next.next.val:\\n same_value = cur.next.val\\n while cur.next is not None and cur.next.val == same_value:\\n cur.next = cur.next.next\\n else:\\n cur = cur.next\\n \\n return dummy.next\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode()\\n new_head = dummy\\n prev_val = -101\\n while head and head.next:\\n temp = head.next\\n if head.val != prev_val and head.val != head.next.val:\\n head.next = None\\n new_head.next = head\\n new_head = new_head.next\\n prev_val = head.val\\n head = temp\\n \\n if head and head.val != prev_val:\\n new_head.next = head \\n return dummy.next\\n\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n tmp = head\\n st = set()\\n while tmp:\\n if tmp.next and tmp.val == tmp.next.val:\\n st.add(tmp.val)\\n\\n tmp = tmp.next\\n \\n \\n\\n while head and head.val in st:\\n head = head.next\\n\\n tmp = head\\n \\n while tmp:\\n if tmp.next and tmp.next.val in st:\\n \\n tmp.next = tmp.next.next\\n else:\\n tmp = tmp.next\\n\\n return head\\n \\n\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n output=ListNode(0,head)\\n pre=output\\n while head:\\n if head.next and head.val==head.next.val:\\n while head.next and head.val==head.next.val:\\n head=head.next\\n pre.next=head.next\\n else:\\n pre=pre.next\\n head=head.next\\n # return output.next\\n\\n\\n return output.next\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n dummy=ListNode(0,head)\\n prev=dummy\\n cur=head\\n while cur and cur.next:\\n if cur.val==cur.next.val:\\n while cur.next and cur.next.val==cur.val:\\n cur=cur.next\\n cur.next, cur=None, cur.next\\n prev.next=cur\\n else:\\n prev=cur\\n cur=cur.next\\n\\n return dummy.next\",\n \"memory\": \"16500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":9,"string":"9"}}},{"rowIdx":37,"cells":{"question_id":{"kind":"number","value":83,"string":"83"},"name":{"kind":"string","value":"remove-duplicates-from-sorted-list"},"content":{"kind":"string","value":"<p>Given the <code>head</code> of a sorted linked list, <em>delete all duplicates such that each element appears only once</em>. Return <em>the linked list <strong>sorted</strong> as well</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/01/04/list1.jpg\" style=\"width: 302px; height: 242px;\" />\n<pre>\n<strong>Input:</strong> head = [1,1,2]\n<strong>Output:</strong> [1,2]\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/01/04/list2.jpg\" style=\"width: 542px; height: 222px;\" />\n<pre>\n<strong>Input:</strong> head = [1,1,2,3,3]\n<strong>Output:</strong> [1,2,3]\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of nodes in the list is in the range <code>[0, 300]</code>.</li>\n\t<li><code>-100 <= Node.val <= 100</code></li>\n\t<li>The list is guaranteed to be <strong>sorted</strong> in ascending order.</li>\n</ul>\n"},"acRate":{"kind":"number","value":53.40370220592023,"string":"53.403702"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["linked-list"],"string":"[\n \"linked-list\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15\", 0.006], [\"18\", 0.006], [\"19\", 0.024], [\"20\", 0.036], [\"21\", 0.03], [\"22\", 0.042], [\"23\", 0.2521], [\"24\", 0.054], [\"25\", 0.138], [\"26\", 0.4561], [\"27\", 0.8102], [\"28\", 0.3961], [\"29\", 0.7562], [\"30\", 1.6984], [\"31\", 2.2745], [\"32\", 1.6204], [\"33\", 2.1545], [\"34\", 4.729], [\"35\", 5.0531], [\"36\", 3.4988], [\"37\", 4.2069], [\"38\", 8.7619], [\"39\", 7.9277], [\"40\", 5.9473], [\"41\", 5.8693], [\"42\", 9.068], [\"43\", 7.3456], [\"44\", 5.5512], [\"45\", 4.753], [\"46\", 5.0171], [\"47\", 3.6848], [\"48\", 2.5806]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15600\", 0.006], [\"16000\", 0.018], [\"16100\", 0.018], [\"16200\", 0.072], [\"16300\", 0.9722], [\"16400\", 18.232], [\"16500\", 50.3211]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n pointer = head\n while pointer:\n if pointer.next and pointer.next.val == pointer.val:\n pointer.next = pointer.next.next\n else:\n pointer = pointer.next\n return head","runtime":"18"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n cur=head\n while cur:\n while cur.next and cur.next.val==cur.val:\n cur.next=cur.next.next\n cur=cur.next\n return head\n\n \n # first = head\n # while first:\n\n # second = first.next\n # while second and second.val == first.val:\n # second = second.next\n \n # first.next = second\n # first = second\n \n # return head\n\n \n","runtime":"19"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head == None:\n return head\n else:\n current_node = head\n track = current_node.val\n while head:\n if head.next and head.next.val == track:\n temp = head.next\n if temp.next:\n head.next = temp.next\n else:\n head.next = None\n else:\n if head.next:\n head = head.next\n track = head.val\n else:\n break\n return current_node","runtime":"20"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return head\n\n prev = head\n cur = head.next\n\n while cur:\n if cur.val == prev.val:\n prev.next = cur.next\n else:\n prev = cur\n \n cur = cur.next\n\n return head\n","runtime":"21"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n current = head\n if head:\n while current and current.next:\n while current.next and current.val == current.next.val:\n current.next = current.next.next \n current = current.next\n return head\n ","runtime":"22"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n cur = head \n while cur:\n if cur.next and cur.val == cur.next.val:\n cur.next = cur.next.next\n else:\n cur = cur.next\n \n return head\n \n\n \n \n \n\n\n\n ","runtime":"23"},{"code":"class Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n cur = head\n while cur:\n if cur.next and cur.val == (cur.next).val:\n cur.next = (cur.next).next\n else:\n cur = cur.next\n return head","runtime":"23"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n tail = head\n\n while tail and tail.next:\n if tail.val == tail.next.val:\n tail.next = tail.next.next\n else:\n tail = tail.next\n\n return head\n","runtime":"24"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return head\n current = head\n while current.next:\n if current.val == current.next.val:\n current.next = current.next.next\n else:\n current = current.next\n return head","runtime":"25"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n curr = head\n while curr:\n\n while curr.next and curr.val==curr.next.val:\n curr.next = curr.next.next\n curr = curr.next\n return head\n","runtime":"26"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n cur = head \n while cur and cur.next:\n if cur.val == cur.next.val:\n cur.next = cur.next.next\n else:\n cur = cur.next\n\n return head","runtime":"26"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head == None:\n return None\n root = ListNode(head.val)\n root1 = root\n pre_val = -200\n while head is not None:\n #print(head.val)\n if pre_val == -200:\n pre_val = head.val\n head = head.next\n continue\n if head.val == pre_val:\n head = head.next\n continue\n #print(\"B\",head.val)\n root.next = ListNode(head.val)\n root = root.next\n pre_val = head.val\n head = head.next\n return root1","runtime":"27"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n current = head\n while (current != None):\n if current.next == None:\n break\n else:\n if current.next.val == current.val:\n current.next = current.next.next\n else:\n current = current.next\n return head","runtime":"27"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head==None:\n return None\n m = set()\n m.add(head.val)\n current = head\n next = current.next\n while next:\n if next.val in m:\n next = next.next\n current.next=None\n continue\n m.add(next.val)\n current.next = next\n current = next\n return head","runtime":"28"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n c = head\n while c and c.next:\n while c.next and c.val == c.next.val:\n c.next = c.next.next\n c = c.next\n \n return head\n\n \n ","runtime":"29"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n current = head\n while current is not None:\n next_node = current.next\n while next_node is not None and next_node.val == current.val:\n next_node = next_node.next\n current.next = next_node\n current = current.next\n return head","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n cur = head \n while cur:\n while cur.next and cur.next.val == cur.val:\n cur.next = cur.next.next\n cur = cur.next\n return head\n \n\n \n \n \n\n\n\n ","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n if head == None or head.next == None:\n return head\n \n prev = head\n curr = head.next\n \n while curr != None:\n if prev.val == curr.val:\n prev.next= curr.next\n curr = prev.next\n else:\n curr = curr.next\n prev = prev.next\n \n return head\n ","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n\n cur = head\n while cur.next:\n if cur.val == cur.next.val:\n cur.next = cur.next.next\n else:\n cur = cur.next\n\n return head","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: \n return head\n \n current = head\n while current.next:\n if current.val == current.next.val:\n current.next = current.next.next\n else:\n current = current.next\n \n return head\n ","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n c = head\n while c and c.next:\n while c.next and c.val == c.next.val:\n c.next = c.next.next\n c = c.next\n \n return head\n\n \n ","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n prev, curr = head, head.next\n while curr:\n if prev.val == curr.val:\n next_node = curr.next\n prev.next = next_node\n curr.next = None\n curr = next_node\n else:\n prev = curr\n curr = curr.next\n return head\n","runtime":"33"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:return None\n \n tmp=head\n tmp2=head.next\n last=head.val\n while tmp2:\n if tmp2.val==last:\n if not tmp2.next:\n tmp.next=None\n break\n tmp2=tmp2.next\n tmp.next=tmp2\n else:\n tmp=tmp2\n last=tmp.val\n tmp2=tmp2.next\n return head\n\n ","runtime":"34"},{"code":"# Definition for singly-linked list.\n# class ListNode(object):\n# def _init_(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution(object):\n def deleteDuplicates(self, head):\n cur = head\n while cur and cur.next:\n if cur.val == cur.next.val:\n cur.next = cur.next.next\n else:\n cur = cur.next\n return head","runtime":"34"},{"code":"class Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return None\n lastval = head.val\n cur = head.next\n last = head\n while cur is not None:\n if cur.val == lastval:\n cur = cur.next\n else:\n last.next = cur\n last = cur\n lastval = cur.val\n last.next = None\n return head\n","runtime":"35"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n dummy = ListNode(None, head)\n\n prev, cur = dummy, head\n\n while cur:\n if prev.val == cur.val:\n prev.next = cur.next\n else:\n prev = cur\n cur = cur.next\n \n return dummy.next\n ","runtime":"35"},{"code":"class Solution:\n def deleteDuplicates(self, head: ListNode) -> ListNode:\n if not head:\n return None\n \n temp = head\n temp2 = head.next\n last = head.val\n \n while temp2: # while end of Linked list\n if temp2.val == last: # Current number same as last number\n if not temp2.next: # If last element, just delete and break loop\n temp.next = None\n break\n temp2 = temp2.next # Not last, then delete that element\n temp.next = temp2 # and move to next element\n else: # If not the same as last element, jump to next node\n temp = temp2\n last = temp.val\n temp2 = temp2.next\n \n return head # return the head back\n\n\n ","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n l = []\n current = head\n while(current):\n l.append(current.val)\n current = current.next\n l1 = sorted(list(set(l)))\n\n ll = temp = ListNode(0)\n for i in l1:\n ll.next = ListNode(i)\n ll = ll.next\n return temp.next","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n currNode = head\n while currNode and currNode.next:\n if currNode.val == currNode.next.val:\n currNode.next = currNode.next.next\n else:\n currNode = currNode.next \n return head \n ","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n cur = head\n if head is None:\n return head\n while cur.next !=None:\n if cur.next.val == cur.val:\n cur.next = cur.next.next\n \n else:\n cur = cur.next\n return head","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next: return head\n new_head = head\n prev, curr = head, head.next\n while curr:\n if curr.val == prev.val:\n prev.next = curr.next\n curr = curr.next\n else:\n temp = curr\n curr = curr.next\n prev = temp\n \n return new_head","runtime":"38"},{"code":"class Solution:\n def deleteDuplicates(self, head: ListNode) -> ListNode:\n current = head\n while current is not None and current.next is not None:\n if current.next.val == current.val:\n current.next = current.next.next\n else:\n current = current.next\n return head","runtime":"38"},{"code":"class ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n current = head\n while current and current.next:\n if current.val == current.next.val:\n current.next = current.next.next\n else:\n current = current.next\n return head\n\n\n \n\n\n\n","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n seen = set()\n current = head\n prev = None\n\n while current:\n if current.val in seen:\n prev.next = current.next\n else:\n seen.add(current.val)\n prev = current\n current = current.next\n\n return head","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n c = head\n while c and c.next:\n while c.next and c.val == c.next.val:\n c.next = c.next.next\n c = c.next\n \n return head\n\n \n ","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n c = head\n while c and c.next:\n while c.next and c.val == c.next.val:\n c.next = c.next.next\n c = c.next\n \n return head\n\n \n ","runtime":"40"},{"code":"class Solution:\n def deleteDuplicates(self, head: ListNode) -> ListNode:\n if not head:\n return None\n \n temp = head\n temp2 = head.next\n last = head.val\n \n while temp2: \n if temp2.val == last: \n if not temp2.next: \n temp.next = None\n break\n temp2 = temp2.next \n temp.next = temp2 \n else: \n temp = temp2\n last = temp.val\n temp2 = temp2.next\n \n return head ","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n cur = head \n while cur:\n if cur.next and cur.val == cur.next.val:\n cur.next = cur.next.next\n else:\n cur = cur.next\n \n return head\n \n\n \n \n \n\n\n\n ","runtime":"41"},{"code":"class Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n # curr = head\n # while curr and curr.next:\n # if curr.val == curr.next.val:\n # curr.next = curr.next.next\n # else:\n # curr = curr.next\n \n # return head\n curr1=head\n curr2=head.next\n\n while(curr2):\n if curr1.val!=curr2.val:\n curr1=curr1.next\n curr2=curr2.next\n else:\n if curr2:\n curr2=curr2.next\n curr1.next=curr2\n else:\n curr2.next=None\n return head\n ","runtime":"42"},{"code":"class Solution:\n def deleteDuplicates(self, head: ListNode) -> ListNode:\n if not head:\n return None\n \n temp = head\n temp2 = head.next\n last = head.val\n \n while temp2: # while end of Linked list\n if temp2.val == last: # Current number same as last number\n if not temp2.next: # If last element, just delete and break loop\n temp.next = None\n break\n temp2 = temp2.next # Not last, then delete that element\n temp.next = temp2 # and move to next element\n else: # If not the same as last element, jump to next node\n temp = temp2\n last = temp.val\n temp2 = temp2.next\n \n return head # return the head back","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n temp=head\n while temp.next:\n if temp.next.val==temp.val:\n temp.next=temp.next.next\n else:\n temp=temp.next\n return head\n ","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n current = head\n while current is not None and current.next is not None:\n if current.next.val == current.val:\n current.next = current.next.next\n else:\n current = current.next\n return head\n","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return None\n curr = head\n while curr.next:\n if curr.val == curr.next.val:\n curr.next = curr.next.next\n else:\n curr = curr.next\n return head","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n c = head\n while c and c.next:\n if c.val == c.next.val:\n c.next = c.next.next\n else:\n c = c.next\n \n return head\n\n \n ","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n c = head\n while c and c.next:\n if c.val == c.next.val:\n c.next = c.next.next\n else:\n c = c.next\n \n return head\n\n \n ","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n cur = head\n\n while cur and cur.next:\n if cur.val == cur.next.val:\n cur.next = cur.next.next\n else:\n cur = cur.next\n \n return head","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n arr = []\n prev = head\n while head:\n if head.val not in arr:\n arr.append(head.val)\n temp = head\n else:\n temp.next = head.next\n head = head.next\n return prev\n","runtime":"46"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n res=head\n while head and head.next:\n if head.val==head.next.val:\n head.next=head.next.next\n else:\n head=head.next\n return res","runtime":"46"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n cur = head\n while cur and cur.next:\n if cur.val == cur.next.val:\n cur.next = cur.next.next\n else:\n cur = cur.next\n return head","runtime":"47"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n\n cur = head\n while cur.next:\n if cur.val == cur.next.val:\n cur.next = cur.next.next\n else:\n cur = cur.next\n\n return head","runtime":"47"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(-200, head)\n slow = dummy\n fast = head\n\n while fast:\n while fast and fast.val == slow.val:\n fast = fast.next\n slow.next = fast\n slow = fast\n if fast:\n fast = fast.next\n\n return dummy.next","runtime":"48"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n cur=head\n while cur and cur.next:\n if cur.val==cur.next.val:\n cur.next=cur.next.next\n else:\n cur=cur.next\n \n return head","runtime":"48"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n pointer = head\\n while pointer:\\n if pointer.next and pointer.next.val == pointer.val:\\n pointer.next = pointer.next.next\\n else:\\n pointer = pointer.next\\n return head\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n cur=head\\n while cur:\\n while cur.next and cur.next.val==cur.val:\\n cur.next=cur.next.next\\n cur=cur.next\\n return head\\n\\n \\n # first = head\\n # while first:\\n\\n # second = first.next\\n # while second and second.val == first.val:\\n # second = second.next\\n \\n # first.next = second\\n # first = second\\n \\n # return head\\n\\n \\n\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head == None:\\n return head\\n else:\\n current_node = head\\n track = current_node.val\\n while head:\\n if head.next and head.next.val == track:\\n temp = head.next\\n if temp.next:\\n head.next = temp.next\\n else:\\n head.next = None\\n else:\\n if head.next:\\n head = head.next\\n track = head.val\\n else:\\n break\\n return current_node\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return head\\n\\n prev = head\\n cur = head.next\\n\\n while cur:\\n if cur.val == prev.val:\\n prev.next = cur.next\\n else:\\n prev = cur\\n \\n cur = cur.next\\n\\n return head\\n\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n current = head\\n if head:\\n while current and current.next:\\n while current.next and current.val == current.next.val:\\n current.next = current.next.next \\n current = current.next\\n return head\\n \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n cur = head \\n while cur:\\n if cur.next and cur.val == cur.next.val:\\n cur.next = cur.next.next\\n else:\\n cur = cur.next\\n \\n return head\\n \\n\\n \\n \\n \\n\\n\\n\\n \",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n cur = head\\n while cur:\\n if cur.next and cur.val == (cur.next).val:\\n cur.next = (cur.next).next\\n else:\\n cur = cur.next\\n return head\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n tail = head\\n\\n while tail and tail.next:\\n if tail.val == tail.next.val:\\n tail.next = tail.next.next\\n else:\\n tail = tail.next\\n\\n return head\\n\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return head\\n current = head\\n while current.next:\\n if current.val == current.next.val:\\n current.next = current.next.next\\n else:\\n current = current.next\\n return head\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n curr = head\\n while curr:\\n\\n while curr.next and curr.val==curr.next.val:\\n curr.next = curr.next.next\\n curr = curr.next\\n return head\\n\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n cur = head \\n while cur and cur.next:\\n if cur.val == cur.next.val:\\n cur.next = cur.next.next\\n else:\\n cur = cur.next\\n\\n return head\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head == None:\\n return None\\n root = ListNode(head.val)\\n root1 = root\\n pre_val = -200\\n while head is not None:\\n #print(head.val)\\n if pre_val == -200:\\n pre_val = head.val\\n head = head.next\\n continue\\n if head.val == pre_val:\\n head = head.next\\n continue\\n #print(\\\"B\\\",head.val)\\n root.next = ListNode(head.val)\\n root = root.next\\n pre_val = head.val\\n head = head.next\\n return root1\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n current = head\\n while (current != None):\\n if current.next == None:\\n break\\n else:\\n if current.next.val == current.val:\\n current.next = current.next.next\\n else:\\n current = current.next\\n return head\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head==None:\\n return None\\n m = set()\\n m.add(head.val)\\n current = head\\n next = current.next\\n while next:\\n if next.val in m:\\n next = next.next\\n current.next=None\\n continue\\n m.add(next.val)\\n current.next = next\\n current = next\\n return head\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n c = head\\n while c and c.next:\\n while c.next and c.val == c.next.val:\\n c.next = c.next.next\\n c = c.next\\n \\n return head\\n\\n \\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n current = head\\n while current is not None:\\n next_node = current.next\\n while next_node is not None and next_node.val == current.val:\\n next_node = next_node.next\\n current.next = next_node\\n current = current.next\\n return head\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n cur = head \\n while cur:\\n while cur.next and cur.next.val == cur.val:\\n cur.next = cur.next.next\\n cur = cur.next\\n return head\\n \\n\\n \\n \\n \\n\\n\\n\\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n if head == None or head.next == None:\\n return head\\n \\n prev = head\\n curr = head.next\\n \\n while curr != None:\\n if prev.val == curr.val:\\n prev.next= curr.next\\n curr = prev.next\\n else:\\n curr = curr.next\\n prev = prev.next\\n \\n return head\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n\\n cur = head\\n while cur.next:\\n if cur.val == cur.next.val:\\n cur.next = cur.next.next\\n else:\\n cur = cur.next\\n\\n return head\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: \\n return head\\n \\n current = head\\n while current.next:\\n if current.val == current.next.val:\\n current.next = current.next.next\\n else:\\n current = current.next\\n \\n return head\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n c = head\\n while c and c.next:\\n while c.next and c.val == c.next.val:\\n c.next = c.next.next\\n c = c.next\\n \\n return head\\n\\n \\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n prev, curr = head, head.next\\n while curr:\\n if prev.val == curr.val:\\n next_node = curr.next\\n prev.next = next_node\\n curr.next = None\\n curr = next_node\\n else:\\n prev = curr\\n curr = curr.next\\n return head\\n\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:return None\\n \\n tmp=head\\n tmp2=head.next\\n last=head.val\\n while tmp2:\\n if tmp2.val==last:\\n if not tmp2.next:\\n tmp.next=None\\n break\\n tmp2=tmp2.next\\n tmp.next=tmp2\\n else:\\n tmp=tmp2\\n last=tmp.val\\n tmp2=tmp2.next\\n return head\\n\\n \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode(object):\\n# def _init_(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution(object):\\n def deleteDuplicates(self, head):\\n cur = head\\n while cur and cur.next:\\n if cur.val == cur.next.val:\\n cur.next = cur.next.next\\n else:\\n cur = cur.next\\n return head\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return None\\n lastval = head.val\\n cur = head.next\\n last = head\\n while cur is not None:\\n if cur.val == lastval:\\n cur = cur.next\\n else:\\n last.next = cur\\n last = cur\\n lastval = cur.val\\n last.next = None\\n return head\\n\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n dummy = ListNode(None, head)\\n\\n prev, cur = dummy, head\\n\\n while cur:\\n if prev.val == cur.val:\\n prev.next = cur.next\\n else:\\n prev = cur\\n cur = cur.next\\n \\n return dummy.next\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def deleteDuplicates(self, head: ListNode) -> ListNode:\\n if not head:\\n return None\\n \\n temp = head\\n temp2 = head.next\\n last = head.val\\n \\n while temp2: # while end of Linked list\\n if temp2.val == last: # Current number same as last number\\n if not temp2.next: # If last element, just delete and break loop\\n temp.next = None\\n break\\n temp2 = temp2.next # Not last, then delete that element\\n temp.next = temp2 # and move to next element\\n else: # If not the same as last element, jump to next node\\n temp = temp2\\n last = temp.val\\n temp2 = temp2.next\\n \\n return head # return the head back\\n\\n\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n l = []\\n current = head\\n while(current):\\n l.append(current.val)\\n current = current.next\\n l1 = sorted(list(set(l)))\\n\\n ll = temp = ListNode(0)\\n for i in l1:\\n ll.next = ListNode(i)\\n ll = ll.next\\n return temp.next\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n currNode = head\\n while currNode and currNode.next:\\n if currNode.val == currNode.next.val:\\n currNode.next = currNode.next.next\\n else:\\n currNode = currNode.next \\n return head \\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n cur = head\\n if head is None:\\n return head\\n while cur.next !=None:\\n if cur.next.val == cur.val:\\n cur.next = cur.next.next\\n \\n else:\\n cur = cur.next\\n return head\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next: return head\\n new_head = head\\n prev, curr = head, head.next\\n while curr:\\n if curr.val == prev.val:\\n prev.next = curr.next\\n curr = curr.next\\n else:\\n temp = curr\\n curr = curr.next\\n prev = temp\\n \\n return new_head\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def deleteDuplicates(self, head: ListNode) -> ListNode:\\n current = head\\n while current is not None and current.next is not None:\\n if current.next.val == current.val:\\n current.next = current.next.next\\n else:\\n current = current.next\\n return head\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n current = head\\n while current and current.next:\\n if current.val == current.next.val:\\n current.next = current.next.next\\n else:\\n current = current.next\\n return head\\n\\n\\n \\n\\n\\n\\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n seen = set()\\n current = head\\n prev = None\\n\\n while current:\\n if current.val in seen:\\n prev.next = current.next\\n else:\\n seen.add(current.val)\\n prev = current\\n current = current.next\\n\\n return head\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n c = head\\n while c and c.next:\\n while c.next and c.val == c.next.val:\\n c.next = c.next.next\\n c = c.next\\n \\n return head\\n\\n \\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n c = head\\n while c and c.next:\\n while c.next and c.val == c.next.val:\\n c.next = c.next.next\\n c = c.next\\n \\n return head\\n\\n \\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def deleteDuplicates(self, head: ListNode) -> ListNode:\\n if not head:\\n return None\\n \\n temp = head\\n temp2 = head.next\\n last = head.val\\n \\n while temp2: \\n if temp2.val == last: \\n if not temp2.next: \\n temp.next = None\\n break\\n temp2 = temp2.next \\n temp.next = temp2 \\n else: \\n temp = temp2\\n last = temp.val\\n temp2 = temp2.next\\n \\n return head \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n cur = head \\n while cur:\\n if cur.next and cur.val == cur.next.val:\\n cur.next = cur.next.next\\n else:\\n cur = cur.next\\n \\n return head\\n \\n\\n \\n \\n \\n\\n\\n\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n # curr = head\\n # while curr and curr.next:\\n # if curr.val == curr.next.val:\\n # curr.next = curr.next.next\\n # else:\\n # curr = curr.next\\n \\n # return head\\n curr1=head\\n curr2=head.next\\n\\n while(curr2):\\n if curr1.val!=curr2.val:\\n curr1=curr1.next\\n curr2=curr2.next\\n else:\\n if curr2:\\n curr2=curr2.next\\n curr1.next=curr2\\n else:\\n curr2.next=None\\n return head\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def deleteDuplicates(self, head: ListNode) -> ListNode:\\n if not head:\\n return None\\n \\n temp = head\\n temp2 = head.next\\n last = head.val\\n \\n while temp2: # while end of Linked list\\n if temp2.val == last: # Current number same as last number\\n if not temp2.next: # If last element, just delete and break loop\\n temp.next = None\\n break\\n temp2 = temp2.next # Not last, then delete that element\\n temp.next = temp2 # and move to next element\\n else: # If not the same as last element, jump to next node\\n temp = temp2\\n last = temp.val\\n temp2 = temp2.next\\n \\n return head # return the head back\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n temp=head\\n while temp.next:\\n if temp.next.val==temp.val:\\n temp.next=temp.next.next\\n else:\\n temp=temp.next\\n return head\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n current = head\\n while current is not None and current.next is not None:\\n if current.next.val == current.val:\\n current.next = current.next.next\\n else:\\n current = current.next\\n return head\\n\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return None\\n curr = head\\n while curr.next:\\n if curr.val == curr.next.val:\\n curr.next = curr.next.next\\n else:\\n curr = curr.next\\n return head\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n c = head\\n while c and c.next:\\n if c.val == c.next.val:\\n c.next = c.next.next\\n else:\\n c = c.next\\n \\n return head\\n\\n \\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n c = head\\n while c and c.next:\\n if c.val == c.next.val:\\n c.next = c.next.next\\n else:\\n c = c.next\\n \\n return head\\n\\n \\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n cur = head\\n\\n while cur and cur.next:\\n if cur.val == cur.next.val:\\n cur.next = cur.next.next\\n else:\\n cur = cur.next\\n \\n return head\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n arr = []\\n prev = head\\n while head:\\n if head.val not in arr:\\n arr.append(head.val)\\n temp = head\\n else:\\n temp.next = head.next\\n head = head.next\\n return prev\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n res=head\\n while head and head.next:\\n if head.val==head.next.val:\\n head.next=head.next.next\\n else:\\n head=head.next\\n return res\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n cur = head\\n while cur and cur.next:\\n if cur.val == cur.next.val:\\n cur.next = cur.next.next\\n else:\\n cur = cur.next\\n return head\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n\\n cur = head\\n while cur.next:\\n if cur.val == cur.next.val:\\n cur.next = cur.next.next\\n else:\\n cur = cur.next\\n\\n return head\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(-200, head)\\n slow = dummy\\n fast = head\\n\\n while fast:\\n while fast and fast.val == slow.val:\\n fast = fast.next\\n slow.next = fast\\n slow = fast\\n if fast:\\n fast = fast.next\\n\\n return dummy.next\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n cur=head\\n while cur and cur.next:\\n if cur.val==cur.next.val:\\n cur.next=cur.next.next\\n else:\\n cur=cur.next\\n \\n return head\",\n \"runtime\": \"48\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":52,"string":"52"},"mm_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n current = head\n while current and current.next:\n if current.val == current.next.val: \n current.next = current.next.next \n else: \n current = current.next\n return head\n\n\n ","memory":"15600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head == None:\n return head\n curr = head\n # while(curr and curr.next):\n # if curr.val == curr.next.val:\n # curr.next = curr.next.next\n # else:\n # curr = curr.next\n while (curr and curr.next):\n if curr.val == curr.next.val:\n temp = curr.next.next\n curr.next = None\n curr.next = temp\n else:\n curr = curr.next\n if curr.val == head.val:\n head.next = None\n return head\n","memory":"16000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n a = head\n b = head.next\n\n while b:\n if a.val == b.val:\n if not b.next:\n a.next = None\n break\n else:\n b = b.next\n else:\n a.next = b\n a = b\n b = b.next\n\n return head","memory":"16100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n tail = head\n if head and head.next:\n while head and head.next:\n if head.val == head.next.val:\n head.next = head.next.next\n else:\n head = head.next\n return tail \n else:\n return head\n ","memory":"16200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n curr = head\n\n while curr is not None and curr.next is not None:\n next_node = curr.next\n \n if next_node.val == curr.val:\n # Bypass the node to remove it\n curr.next = next_node.next\n else:\n # Move to the next node\n curr = next_node\n\n return head","memory":"16200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n current = head\n \n while current and current.next:\n if current.val == current.next.val:\n current.next = current.next.next \n else:\n current = current.next\n \n return head\n ","memory":"16300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n current = head\n while current and current.next is not None:\n if current.val == current.next.val:\n current.next = current.next.next\n else:\n current = current.next\n return head \n \n\n\n\n\n\n ","memory":"16300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n last_node = head\n curr = head\n while curr is not None:\n if curr.val != last_node.val:\n last_node.next = curr\n last_node = curr\n curr = curr.next\n last_node.next = None\n return head\n \n ","memory":"16400"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n current = head\\n while current and current.next:\\n if current.val == current.next.val: \\n current.next = current.next.next \\n else: \\n current = current.next\\n return head\\n\\n\\n \",\n \"memory\": \"15600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head == None:\\n return head\\n curr = head\\n # while(curr and curr.next):\\n # if curr.val == curr.next.val:\\n # curr.next = curr.next.next\\n # else:\\n # curr = curr.next\\n while (curr and curr.next):\\n if curr.val == curr.next.val:\\n temp = curr.next.next\\n curr.next = None\\n curr.next = temp\\n else:\\n curr = curr.next\\n if curr.val == head.val:\\n head.next = None\\n return head\\n\",\n \"memory\": \"16000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n a = head\\n b = head.next\\n\\n while b:\\n if a.val == b.val:\\n if not b.next:\\n a.next = None\\n break\\n else:\\n b = b.next\\n else:\\n a.next = b\\n a = b\\n b = b.next\\n\\n return head\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n tail = head\\n if head and head.next:\\n while head and head.next:\\n if head.val == head.next.val:\\n head.next = head.next.next\\n else:\\n head = head.next\\n return tail \\n else:\\n return head\\n \",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n curr = head\\n\\n while curr is not None and curr.next is not None:\\n next_node = curr.next\\n \\n if next_node.val == curr.val:\\n # Bypass the node to remove it\\n curr.next = next_node.next\\n else:\\n # Move to the next node\\n curr = next_node\\n\\n return head\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n current = head\\n \\n while current and current.next:\\n if current.val == current.next.val:\\n current.next = current.next.next \\n else:\\n current = current.next\\n \\n return head\\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n current = head\\n while current and current.next is not None:\\n if current.val == current.next.val:\\n current.next = current.next.next\\n else:\\n current = current.next\\n return head \\n \\n\\n\\n\\n\\n\\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n last_node = head\\n curr = head\\n while curr is not None:\\n if curr.val != last_node.val:\\n last_node.next = curr\\n last_node = curr\\n curr = curr.next\\n last_node.next = None\\n return head\\n \\n \",\n \"memory\": \"16400\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":8,"string":"8"}}},{"rowIdx":38,"cells":{"question_id":{"kind":"number","value":84,"string":"84"},"name":{"kind":"string","value":"largest-rectangle-in-histogram"},"content":{"kind":"string","value":"<p>Given an array of integers <code>heights</code> representing the histogram's bar height where the width of each bar is <code>1</code>, return <em>the area of the largest rectangle in the histogram</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/01/04/histogram.jpg\" style=\"width: 522px; height: 242px;\" />\n<pre>\n<strong>Input:</strong> heights = [2,1,5,6,2,3]\n<strong>Output:</strong> 10\n<strong>Explanation:</strong> The above is a histogram where width of each bar is 1.\nThe largest rectangle is shown in the red area, which has an area = 10 units.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/01/04/histogram-1.jpg\" style=\"width: 202px; height: 362px;\" />\n<pre>\n<strong>Input:</strong> heights = [2,4]\n<strong>Output:</strong> 4\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= heights.length <= 10<sup>5</sup></code></li>\n\t<li><code>0 <= heights[i] <= 10<sup>4</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":45.4832066145857,"string":"45.483207"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","stack","monotonic-stack"],"string":"[\n \"array\",\n \"stack\",\n \"monotonic-stack\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"158\", 0.0492], [\"166\", 0.0082], [\"175\", 0.0082], [\"183\", 0.0082], [\"191\", 0.0164], [\"200\", 0.024600000000000004], [\"208\", 0.0082], [\"217\", 0.0082], [\"225\", 0.0082], [\"234\", 0.0082], [\"242\", 0.0082], [\"251\", 0.0082], [\"259\", 0.0082], [\"267\", 0.0164], [\"276\", 0.0082], [\"284\", 0.0082], [\"293\", 0.0082], [\"301\", 0.0164], [\"310\", 0.0082], [\"318\", 0.0082], [\"326\", 0.0082], [\"335\", 0.0164], [\"343\", 0.0246], [\"352\", 0.0246], [\"360\", 0.0164], [\"369\", 0.0082], [\"377\", 0.0082], [\"386\", 0.0164], [\"394\", 0.0246], [\"402\", 0.0246], [\"411\", 0.0082], [\"419\", 0.0164], [\"428\", 0.0082], [\"436\", 0.0164], [\"445\", 0.0246], [\"453\", 0.041], [\"461\", 0.0328], [\"470\", 0.0328], [\"478\", 0.041], [\"487\", 0.0082], [\"495\", 0.0246], [\"504\", 0.0164], [\"512\", 0.0657], [\"521\", 0.0246], [\"529\", 0.0657], [\"537\", 0.0246], [\"546\", 0.041], [\"554\", 0.0739], [\"563\", 0.0739], [\"571\", 0.0574], [\"580\", 0.0657], [\"588\", 0.0821], [\"596\", 0.0574], [\"605\", 0.0574], [\"613\", 0.0574], [\"622\", 0.4678], [\"630\", 1.2064], [\"639\", 3.5455], [\"647\", 7.7801], [\"656\", 14.6163], [\"664\", 15.4206], [\"672\", 12.417000000000002], [\"681\", 8.4202], [\"689\", 6.4588], [\"698\", 4.6615], [\"706\", 3.0366], [\"715\", 2.3472], [\"723\", 1.4688999999999997], [\"731\", 1.4607], [\"740\", 1.4444], [\"748\", 1.6907], [\"757\", 1.1572], [\"765\", 1.0176], [\"774\", 1.0013], [\"782\", 0.7715000000000001], [\"791\", 0.8454999999999999], [\"799\", 0.5909000000000001], [\"807\", 0.6975000000000001], [\"816\", 0.6155999999999999], [\"824\", 0.3938]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"25400\", 0.0164], [\"25500\", 0.0082], [\"25700\", 0.0164], [\"25800\", 0.0164], [\"25900\", 0.0164], [\"26000\", 0.0164], [\"27900\", 0.0082], [\"28100\", 0.0082], [\"28400\", 0.0082], [\"28700\", 0.0082], [\"28800\", 0.0082], [\"29000\", 0.0164], [\"29100\", 0.0082], [\"29200\", 0.0246], [\"29300\", 0.0328], [\"29400\", 0.0328], [\"29500\", 0.041], [\"29600\", 0.197], [\"29700\", 0.5827], [\"29800\", 0.6483], [\"29900\", 1.6085], [\"30000\", 4.1773], [\"30100\", 2.6672], [\"30200\", 2.897], [\"30300\", 3.4715], [\"30400\", 6.0484], [\"30500\", 3.6274], [\"30600\", 1.3295], [\"30700\", 1.1818], [\"30800\", 0.8699], [\"30900\", 1.0094], [\"31000\", 0.6976], [\"31100\", 0.6073], [\"31200\", 0.3939], [\"31300\", 1.1407], [\"31400\", 6.9183], [\"31500\", 7.1481], [\"31600\", 1.0094], [\"31700\", 0.3775], [\"31800\", 0.197], [\"31900\", 0.238], [\"32000\", 0.1395], [\"32100\", 0.1805], [\"32200\", 0.1313], [\"32299\", 0.279], [\"32400\", 0.5334], [\"32500\", 1.1982], [\"32600\", 0.517], [\"32700\", 0.1477], [\"32800\", 0.2052], [\"32900\", 0.1559], [\"33000\", 0.1723], [\"33100\", 0.476], [\"33200\", 1.5347], [\"33300\", 2.5769], [\"33400\", 5.9007], [\"33500\", 3.7998], [\"33600\", 12.2199], [\"33700\", 3.9146], [\"33800\", 0.4842], [\"33900\", 0.2872], [\"34000\", 0.7304], [\"34100\", 0.6812], [\"34200\", 0.2298], [\"34300\", 0.0985], [\"34400\", 0.0985], [\"34500\", 0.1149], [\"34600\", 0.0821], [\"34700\", 0.2216], [\"34800\", 0.8125], [\"34900\", 1.8137], [\"35000\", 1.8629], [\"35100\", 2.0845]]}"},"rt_list":{"kind":"list like","value":[{"code":"# class Solution:\ndef largestRectangleArea(heights: List[int]) -> int:\n n = len(heights)\n max_area = 0\n stack = []\n for j in range(n):\n h = heights[j]\n while stack and h < heights[stack[-1]]:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (j - left)\n if area > max_area:\n max_area = area\n stack.append(j)\n while stack:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (n - left)\n if area > max_area:\n max_area = area\n return max_area\nif __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads,stdin):\n print(largestRectangleArea(i), file=f)\n exit(0)\n \n # Failed\n # if len(heights)==1:\n # return heights[0]\n # l, r = 0, len(heights) - 1\n # max_tmp = 0\n\n # while l < r:\n # val_l = heights[l]\n # val_r = heights[r]\n\n # if val_l < val_r:\n # x = val_l * (r-l+1)\n # l += 1 \n # if val_l > heights[l] and l < r:\n # max_tmp = 0\n # x=0\n # max_tmp = max(max_tmp, x)\n # else:\n # x = val_r * (r-l+1)\n # r -= 1 \n # if val_r > heights[r] and l < r:\n # max_tmp = 0\n # x = 0\n # max_tmp = max(max_tmp, x)\n \n # lon = 0\n # for i in range(len(heights)):\n # if heights[i] == 0:\n # if heights[lon:i]:\n # max_tmp = max(min(heights[lon:i]) * (i - lon), max_tmp)\n # lon = i+1\n # elif i == len(heights)-1:\n # # print(min(heights[lon:i+1]) * (i+1 - lon))\n # max_tmp = max(min(heights[lon:i+1]) * (i+1 - lon), max_tmp)\n # return max(max_tmp, max(heights))","runtime":"158"},{"code":"def largestRectangleArea(heights: List[int]) -> int:\n n = len(heights)\n max_area = 0\n stack = []\n for j in range(n):\n h = heights[j]\n while stack and h < heights[stack[-1]]:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (j - left)\n if area > max_area:\n max_area = area\n stack.append(j)\n while stack:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (n - left)\n if area > max_area:\n max_area = area\n return max_area\n\nif __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads,stdin):\n print(largestRectangleArea(i), file=f)\n exit(0)","runtime":"158"},{"code":"def largestRectangleArea(heights: List[int]) -> int:\n heights.append(0)\n stack = []\n best = 0\n for idx, height in enumerate(heights):\n i = idx\n while stack and height < stack[-1][0]:\n h, i = stack.pop()\n if (area := h * (idx - i)) > best:\n best = area\n stack.append((height, i))\n return best\n\nf = open('user.out', 'w')\nfor i in map(loads, stdin):\n f.write(f'{largestRectangleArea(i)}\\n')\nf.flush()\nexit(0)","runtime":"166"},{"code":"from typing import List\n\ndef largestRectangleArea(heights: List[int]) -> int:\n n = len(heights)\n st = []\n ans = 0\n for i in range(n):\n h = heights[i]\n start = i\n while st and st[-1][1] > h:\n ind, ht = st.pop()\n ans = max(ans, ht * (i - ind))\n start = ind\n \n st.append((start, h))\n\n # Process the remaining elements in the stack\n for i, h in st:\n ans = max(ans, h * (n - i)) # Correct calculation for the remaining heights\n \n return ans\n\nif __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads,stdin):\n print(largestRectangleArea(i), file=f)\n exit(0)","runtime":"175"},{"code":"def largestRectangleArea(heights: List[int]) -> int:\n heights.append(0)\n stack = []\n best = 0\n for idx, height in enumerate(heights):\n i = idx\n while stack and height < stack[-1][0]:\n h, i = stack.pop()\n if (area := h * (idx - i)) > best:\n best = area\n stack.append((height, i))\n return best\n\nf = open('user.out', 'w')\nfor i in map(loads, stdin):\n print(largestRectangleArea(i), file=f)\nf.flush()\nexit(0)","runtime":"183"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n = len(heights)\n stack = []\n max_area = 0\n\n for i in range(n):\n while stack and heights[i] <= heights[stack[-1]]:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1 if stack else i\n max_area = max(max_area, height * width)\n stack.append(i)\n\n while stack:\n height = heights[stack.pop()]\n width = n - stack[-1] - 1 if stack else n\n max_area = max(max_area, height * width)\n\n return max_area\n\nwith open(\"user.out\", \"w\") as f:\n inputs = map(loads, stdin)\n for nums in inputs:\n print(Solution().largestRectangleArea(nums),file=f)\nexit(0)","runtime":"191"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights.append(0)\n stack = [-1]\n res = 0\n for i in range(len(heights)):\n while (heights[stack[-1]] > heights[i]):\n h = heights[stack.pop()]\n w = i - 1 - stack[-1]\n res = max(res, h*w)\n stack.append(i)\n return res\nif __name__ == '__main__': \n with open('user.out','w') as f:\n s = Solution()\n for i in map(loads,stdin):\n print(s.largestRectangleArea(i), file=f)\n exit(0)","runtime":"191"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights += [0]\n ans = 0\n stk = [-1]\n\n # Every height in heights can form a rectangle by expanding to the next smaller(or equal) element on its left and right\n # ans must be one of them\n\n # try to expand in increasing order to the right, until we encounter sth smaller, this will be the next smaller on the right; mono stack keeps track of next smaller on the left\n # the content of the stack\n # ---------------------------------|\n # -- idx of increasing elements --> top\n # ---------------------------------|\n\n # stack[-1]=left next smaller | h=stack.pop() | i=right next smaller \n\n # for each element at index i, if it's smaller than stack.top()\n # Then the rectangle with height of stack.top() can no longer expand right\n # we pop it this height {h} from the stack, stack.top() is the prev element that is smaller than {h}\n # the rectangle area = {h} * (i - 1 - stack.top())\n\n for i, h in enumerate(heights):\n while stk and heights[stk[-1]] > h:\n # The top of stack must be popped off, no more extension to the right\n height = heights[stk.pop()]\n\n # right next smaller of h is at index i\n # rectangle's right ends at i-1\n # left next smaller of h is at index stk[-1]\n \n width = i - 1 - stk[-1]\n\n ans = max(ans, height * width)\n # end while\n\n stk.append(i)\n # end for\n\n return ans\n\nsol = Solution()\nf = open('user.out', 'w')\nfor i in map(loads, stdin):\n f.write(f'{sol.largestRectangleArea(i)}\\n')\nf.flush()\nexit(0)","runtime":"200"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n ans=heights[0]\n stack=[[heights[0],0,0]]\n heights.append(0)\n for i in range(1,len(heights)):\n a=heights[i]\n c=i\n while stack and stack[-1][0]>=a:\n b,d,z=stack.pop()\n ans=max(ans,(i-1-d+1)*b)\n c=d \n stack.append([a,c,i])\n \n del stack, heights\n return ans\nf = open('user.out','w')\nfor i in map(loads,stdin):\n f.write(f'{Solution().largestRectangleArea(i)}\\n')\nf.flush()\nexit(0)","runtime":"200"},{"code":"# class Solution:\ndef largestRectangleArea(heights: List[int]) -> int:\n heights += [0]\n stack = []\n max_area = -sys.maxsize\n for i, height in enumerate(heights):\n if not stack or height > stack[-1][0]:\n stack.append((height,i))\n else:\n while stack and stack[-1][0] >= height:\n h2, i2 = stack.pop()\n area = (i - i2) * h2\n max_area = max(max_area, area)\n stack.append((height, i2))\n return max_area\n\nif __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads,stdin):\n print(largestRectangleArea(i), file=f)\n exit(0)","runtime":"208"},{"code":"class Solution:\n def largestRectangleArea(self, h: list[int]) -> int:\n n = len(h)\n l,r = [1]*n, [1]*n\n \n for i in range(1,n):\n j = i - 1\n while j>=0 and h[j] >= h[i]: j -= l[j]\n l[i] = i - j\n \n for i in reversed(range(n-1)):\n j = i+1\n while j < n and h[i] <= h[j]: j += r[j] \n r[i] = j - i\n \n return max((l[i]+r[i])*h[i] -h[i] for i in range(n))\n\n\n\n\n\n\n\n\n\nf = open('user.out','w')\nfor i in map(loads,stdin):\n f.write(f'{Solution().largestRectangleArea(i)}\\n')\nf.flush()\nexit(0) \n ","runtime":"217"},{"code":"class Solution:\n def largestRectangleArea(self, h: list[int]) -> int:\n n = len(h)\n l,r = [1]*n, [1]*n\n \n for i in range(1,n):\n j = i - 1\n while j>=0 and h[j] >= h[i]: j -= l[j]\n l[i] = i - j\n \n for i in reversed(range(n-1)):\n j = i+1\n while j < n and h[i] <= h[j]: j += r[j] \n r[i] = j - i\n \n return max((l[i]+r[i])*h[i] -h[i] for i in range(n))\n\nf = open('user.out','w')\nfor i in map(loads,stdin):\n f.write(f'{Solution().largestRectangleArea(i)}\\n')\nf.flush()\nexit(0) \n ","runtime":"225"},{"code":"def largestRectangleArea(heights: List[int]) -> int:\n stack = []\n ans = 0\n for i, h in enumerate(heights):\n idx = 1000000\n if len(stack):\n if h < stack[-1][0]:\n while len(stack) and h < stack[-1][0]:\n idx = min(stack[-1][1], idx)\n ans = max(ans, stack[-1][0] * (i - stack[-1][1]))\n stack.pop()\n if idx == 1000000:\n idx = i\n stack.append((h, idx))\n while len(stack):\n ans = max(ans, stack[-1][0] * (len(heights) - stack[-1][1]))\n stack.pop()\n return ans\nif __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads,stdin):\n print(largestRectangleArea(i), file=f)\n exit(0)\n","runtime":"234"},{"code":"def largestRectangleArea(heights: List[int]) -> int:\n stack = []\n ans = 0\n n = len(heights)\n\n for idx in range(n - 1, -1, -1):\n curr = heights[idx]\n possible_start = idx\n while stack and stack[-1][0] >= curr:\n x, y = stack.pop()\n possible_start = y\n stack.append((curr, possible_start))\n for el, idx1 in stack:\n ans = max(ans, curr, el * (idx1 - idx + 1))\n\n return ans\n\nif __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads,stdin):\n print(largestRectangleArea(i), file=f)\n exit(0)\n","runtime":"242"},{"code":"# class Solution:\n# def largestRectangleArea(self, heights: List[int]) -> int:\n# stack=[-1]\n# themax=0\n# heights.append(0)\n# for i in range(len(heights)):\n\n# while(heights[i]<heights[stack[-1]]):\n# width=i-1-stack[-2]\n# height=heights[stack[-1]]\n# themax=max(width*height,themax)\n# stack.pop()\n# stack.append(i)\n# return themax\n\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n lis=[-1]\n\n themax=0\n heights.append(-1)\n for i in range(len(heights)):\n if heights[i]!=heights[i-1]:\n lis.append(i-1)\n while heights[i]<heights[lis[-1]]:\n pop=lis.pop()\n if (i-lis[-1]-1)*heights[pop]>themax:\n themax=(i-lis[-1]-1)*heights[pop]\n \n\n return themax\n\n\n","runtime":"251"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n best=0\n head=[0, 1, None ] #:[ h,w ]\n\n W=1\n #print(head,best)\n for i,h in enumerate(heights):\n add=0\n while True:\n if h>head[0]:\n head=[ h,1+add, head ]\n break\n elif h==head[0]:\n head[1]+=1+add\n break\n else:\n if head[0]*(head[1]+add) > best:\n best=head[0]*(head[1]+add)\n add+=head[1] \n head=head[2] \n #print(head,best)\n add=0\n while head is not None:\n if head[0]*(head[1]+add) > best:\n best=head[0]*(head[1]+add)\n add+=head[1] \n head=head[2] \n\n return best \n\n\n","runtime":"259"},{"code":"# class Solution:\n# def largestRectangleArea(self, heights: List[int]) -> int:\n # stack=[-1]\n # themax=0\n # heights.append(0)\n # for i in range(len(heights)):\n\n # while(heights[i]<heights[stack[-1]]):\n # width=i-1-stack[-2]\n # height=heights[stack[-1]]\n # themax=max(width*height,themax)\n # stack.pop()\n # stack.append(i)\n # return themax\n\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n lis=[-1]\n\n themax=0\n heights.append(-1)\n for i in range(len(heights)):\n if heights[i]!=heights[i-1]:\n lis.append(i-1)\n while heights[i]<heights[lis[-1]]:\n pop=lis.pop()\n if (i-lis[-1]-1)*heights[pop]>themax:\n themax=(i-lis[-1]-1)*heights[pop]\n \n\n return themax\n","runtime":"267"},{"code":"# class Solution:\n# def largestRectangleArea(self, heights: List[int]) -> int:\n # stack=[-1]\n # themax=0\n # heights.append(0)\n # for i in range(len(heights)):\n\n # while(heights[i]<heights[stack[-1]]):\n # width=i-1-stack[-2]\n # height=heights[stack[-1]]\n # themax=max(width*height,themax)\n # stack.pop()\n # stack.append(i)\n # return themax\n\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n lis=[-1]\n\n themax=0\n heights.append(-1)\n for i in range(len(heights)):\n if heights[i]!=heights[i-1]:\n lis.append(i-1)\n while heights[i]<heights[lis[-1]]:\n pop=lis.pop()\n if (i-lis[-1]-1)*heights[pop]>themax:\n themax=(i-lis[-1]-1)*heights[pop]\n \n\n return themax\n\n\n","runtime":"267"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n best=0\n head=[0, 1, None ] #:[ h,w ]\n\n\n for h in heights:\n add=0\n while True:\n if h>head[0]:\n head=[ h,1+add, head ]\n break\n elif h==head[0]:\n head[1]+=1+add\n break\n else: \n if (A:= head[0]*(head[1]+add)) > best:\n best=A\n add+=head[1] \n head=head[2] \n add=0\n while head is not None:\n if (A:= head[0]*(head[1]+add)) > best:\n best=A\n add+=head[1] \n head=head[2] \n\n return best \n\n\n","runtime":"276"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n ls = len(heights)\n heights.append(0)\n a = []\n m = 0\n l = 0\n for i, v in enumerate(heights):\n if v > l:\n a.append((i, v))\n elif v < l:\n while a and a[-1][1] >= v:\n j, k = a.pop()\n m = max(m, (i - j) * k)\n a.append((j, v))\n l = v\n return m\n","runtime":"284"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n ls = len(heights)\n heights.append(0)\n a = []\n m = 0\n l = 0\n for i, v in enumerate(heights):\n if v > l:\n a.append((i, v))\n elif v < l:\n while a and a[-1][1] >= v:\n j, k = a.pop()\n m = max(m, (i - j) * k)\n a.append((j, v))\n l = v\n return m\n","runtime":"293"},{"code":"# class Solution:\n# def largestRectangleArea(self, heights: List[int]) -> int:\n# stack=[-1]\n# themax=0\n# heights.append(0)\n# for i in range(len(heights)):\n\n# while(heights[i]<heights[stack[-1]]):\n# width=i-1-stack[-2]\n# height=heights[stack[-1]]\n# themax=max(width*height,themax)\n# stack.pop()\n# stack.append(i)\n# return themax\n\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n lis=[-1]\n themax=0\n heights.append(-1)\n for i in range(len(heights)):\n if heights[i]!=heights[i-1]:\n lis.append(i-1)\n while heights[i]<heights[lis[-1]]:\n pop=lis.pop()\n if (i-lis[-1]-1)*heights[pop]>themax:\n themax=(i-lis[-1]-1)*heights[pop]\n \n return themax\n\n\n\n# class Solution:\n# def largestRectangleArea(self, heights: List[int]) -> int:\n# lis=[-1]\n\n# themax=0\n# heights.append(-1)\n# s=set()\n# for i in range(len(heights)):\n# if heights[i]!=heights[i-1] and heights[i-1] not in s:\n# lis.append(i-1)\n# s.add(heights[i-1])\n# while heights[i]<heights[lis[-1]]:\n# pop=lis.pop()\n# s.remove(heights[pop])\n# if (i-lis[-1]-1)*heights[pop]>themax:\n# themax=(i-lis[-1]-1)*heights[pop]\n \n\n# return themax\n\n\n","runtime":"301"},{"code":"from collections import deque\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n mq = deque()\n max_area = heights[0]\n heights.append(0)\n l = 0\n for i, h in enumerate(heights):\n if h > l:\n mq.append((i, h))\n elif h < l:\n start = i\n while len(mq) > 0 and h <= mq[-1][1]:\n start, height = mq.pop()\n area = (i - start) * height\n max_area = max(max_area, area)\n mq.append((start, h))\n l = h\n return max_area\n","runtime":"310"},{"code":"# class Solution:\n# def largestRectangleArea(self, heights: List[int]) -> int:\n # stack=[-1]\n # themax=0\n # heights.append(0)\n # for i in range(len(heights)):\n\n # while(heights[i]<heights[stack[-1]]):\n # width=i-1-stack[-2]\n # height=heights[stack[-1]]\n # themax=max(width*height,themax)\n # stack.pop()\n # stack.append(i)\n # return themax\n\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n lis=[-1]\n # temp=heights[0]\n themax=0\n heights.append(-1)\n for i in range(len(heights)):\n if heights[i]!=heights[i-1]:\n lis.append(i-1)\n while heights[i]<heights[lis[-1]]:\n pop=lis.pop() \n themax=max(themax,(i-lis[-1]-1)*heights[pop])\n # temp=heights[i]\n return themax\n","runtime":"318"},{"code":"# Time complexity: O(n)\n# Space complexity: O(n)\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [] # strictly increasing, currently viable heights\n max_area = 0\n \n for i, height in enumerate(heights):\n # Empty stack => add current\n if not stack:\n stack.append((i, height))\n continue\n\n # Same height as before => skip\n if stack[-1][1] == height:\n continue\n\n # Current bar preserves previous bar\n if stack[-1][1] < height:\n stack.append((i, height))\n continue\n\n # Current bar breaks one or more previous bars\n starting_index = i\n while stack and stack[-1][1] >= height:\n # Pop and compute obtained area\n eliminated_bar = stack.pop()\n starting_index = eliminated_bar[0]\n max_area = max(max_area, (i - eliminated_bar[0]) * eliminated_bar[1])\n \n stack.append((starting_index, height))\n \n for bar in stack:\n max_area = max(max_area, (len(heights) - bar[0]) * bar[1])\n\n return max_area\n","runtime":"326"},{"code":"# class Solution:\n# def largestRectangleArea(self, heights: List[int]) -> int:\n # stack=[-1]\n # themax=0\n # heights.append(0)\n # for i in range(len(heights)):\n\n # while(heights[i]<heights[stack[-1]]):\n # width=i-1-stack[-2]\n # height=heights[stack[-1]]\n # themax=max(width*height,themax)\n # stack.pop()\n # stack.append(i)\n # return themax\n\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n lis=[-1]\n temp=heights[0]\n themax=0\n heights.append(-1)\n for i in range(len(heights)):\n if heights[i]!=temp:\n lis.append(i-1)\n while heights[i]<heights[lis[-1]]:\n pop=lis.pop() \n themax=max(themax,(i-lis[-1]-1)*heights[pop])\n # print(i,themax,lis)\n temp=heights[i]\n return themax\n","runtime":"335"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n best=0\n head=[0, 1, None ] #:[ h,w ]\n\n W=1\n #print(head,best)\n for i,h in enumerate(heights):\n add=0\n while True:\n if h>head[0]:\n head=[ h,1+add, head ]\n break\n elif h==head[0]:\n head[1]+=1+add\n break\n else:\n if head[0]*(head[1]+add) > best:\n best=head[0]*(head[1]+add)\n add+=head[1] \n head=head[2] \n #print(head,best)\n add=0\n while head is not None:\n if head[0]*(head[1]+add) > best:\n best=head[0]*(head[1]+add)\n add+=head[1] \n head=head[2] \n\n return best \n\n\n","runtime":"343"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n if len(heights) ==0:\n return 0\n\n if len(heights) == 1:\n return heights[0]\n\n\n stack = []\n\n i = 1\n stack.append((0, heights[0]))\n max_area = 0\n\n for i in range(len(heights)):\n if stack:\n if heights[i]< stack[-1][1]:\n popped_index = i\n while stack and heights[i]< stack[-1][1]:\n popped_index, popped_element = stack.pop()\n max_area = max(max_area, popped_element * (i-popped_index))\n stack.append((popped_index, heights[i]))\n elif heights[i] == stack[-1][1]:\n\n continue\n else:\n stack.append((i, heights[i]))\n else:\n stack.append((i, heights[i]))\n\n N = len(heights)\n for index, element in stack:\n max_area = max( (N-index)*element, max_area)\n\n return max_area\n\n ","runtime":"352"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n begin_h = [(0, heights[0])]\n max_rec = 0\n n = len(heights)\n for i in range(1, n):\n top_i, top_h = begin_h[-1]\n cur_h = heights[i]\n\n if cur_h < top_h:\n while begin_h and cur_h < begin_h[-1][1]:\n top_i, top_h = begin_h.pop()\n length = i - top_i\n max_rec = max(length * top_h, max_rec)\n \n begin_h.append((top_i, cur_h))\n\n if cur_h > top_h:\n begin_h.append((i, cur_h))\n \n\n while(begin_h):\n top_i, top_h = begin_h.pop()\n length = n - top_i\n max_rec = max(length * top_h, max_rec)\n \n return max_rec","runtime":"360"},{"code":"class Solution:\n def largestRectangleArea(self, h: List[int]) -> int:\n st=[]\n h.append(0) #so all eles in h will be processed also end ones if they are in asce.\n max_area=0\n prev=0\n\n for i,v in enumerate(h):\n if v>prev: st.append((i,v))\n elif v<prev:\n while st and st[-1][1]>v:\n j,v_prev=st.pop()\n max_area=max(max_area,(i-j)*v_prev)\n st.append((j,v))\n prev=v\n return max_area\n\n ","runtime":"369"},{"code":"class Solution:\n def largestRectangleArea(self,heights: List[int]) -> int:\n n = len(heights)\n max_area = 0\n stack = []\n for j in range(n):\n h = heights[j]\n while stack and h < heights[stack[-1]]:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (j - left)\n if area > max_area:\n max_area = area\n stack.append(j)\n while stack:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (n - left)\n if area > max_area:\n max_area = area\n return max_area","runtime":"377"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n maxRect = 0\n stack = [] # (start index, height)\n for i, val in enumerate(heights):\n if not stack:\n stack.append((i, val))\n elif stack[-1][1] < val:\n stack.append((i, val))\n elif stack[-1][1] == val:\n continue\n else:\n ind, height = 0,0\n while stack and stack[-1][1] > val:\n ind, height = stack.pop()\n if height * ((i) - ind) > maxRect:\n maxRect = height * ((i) - ind)\n\n stack.append((ind, val))\n # print(stack)\n\n while stack:\n ind, height = stack.pop()\n if height * ((len(heights)) - ind) > maxRect:\n maxRect = height * ((len(heights)) - ind)\n return maxRect\n\n","runtime":"386"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n maxSquare = 0\n\n for index, height in enumerate(heights):\n if not stack:\n stack.append([height, index])\n continue\n\n stackHeight, stackIndex = stack[-1]\n\n if height == stackHeight:\n continue\n elif height > stackHeight:\n stack.append([height, index])\n else:\n while stack and height < stack[-1][0]:\n stackHeight, stackIndex = stack.pop()\n maxSquare = max(maxSquare, stackHeight * (index - stackIndex))\n stack.append([height, stackIndex])\n\n for height in stack:\n maxSquare = max(maxSquare, height[0] * (len(heights) - height[1]))\n\n return maxSquare\n","runtime":"394"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [[0, heights[0]]]\n lens = 1\n maxa = heights[0]\n n = len(heights)\n for i in range(1, n):\n ind = i\n if heights[i] == stack[-1][1]:\n # area = stack[-1][1]*(i - stack[-1][0])\n # if area > maxa:\n # maxa = area\n continue\n while heights[i] < stack[-1][1]:\n p = stack.pop()\n ind = p[0]\n lens-=1\n area = p[1]*(i - p[0])\n if area > maxa:\n maxa = area\n if lens==0:\n break\n stack.append([ind, heights[i]])\n lens+=1\n for i in stack:\n area = i[1]*(n - i[0])\n if area > maxa:\n maxa = area\n return maxa","runtime":"402"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack, n, res = [-1], len(heights), 0\n heights.append(-1)\n for i,h in enumerate(heights):\n while heights[stack[-1]] > h:\n j = stack.pop()\n cur = heights[j] * (i-stack[-1]-1)\n if res < cur: res = cur\n stack.append(i)\n return res","runtime":"411"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n n = len(heights)\n if n == 0:\n return 0\n if n == 1:\n return heights[0]\n left = 0\n height = heights[0]\n maxVal = 0\n for right in range(1, n):\n if heights[right-1] > heights[right]:\n maxVal = max(maxVal, (right - left) * height)\n height = heights[right]\n while stack and stack[-1][0] >= height:\n left = stack[-1][1]\n maxVal = max(maxVal, (right - stack[-1][1]) * stack[-1][0])\n stack.pop()\n if heights[right-1] < heights[right]:\n stack.append((height, left))\n left = right\n height = heights[right]\n maxVal = max(maxVal, (n - left) * height)\n while stack:\n maxVal = max(maxVal, (n - stack[-1][1]) * stack[-1][0])\n stack.pop()\n return maxVal\n ","runtime":"419"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n res = -inf\n\n hStack = []\n pStack = []\n\n for i in range(len(heights)):\n if not hStack or heights[i] > hStack[-1]:\n hStack.append(heights[i])\n pStack.append(i)\n elif heights[i] < hStack[-1]:\n while hStack and heights[i] < hStack[-1]:\n height = hStack.pop()\n idx = pStack.pop()\n area = height * (i-idx)\n res = max(res, area)\n hStack.append(heights[i])\n pStack.append(idx)\n \n while (hStack):\n pos = len(heights)\n h = hStack.pop()\n i = pStack.pop()\n\n area = h * (pos-i)\n res = max(res, area)\n return res","runtime":"428"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n if len(heights) == 1:\n return heights[0]\n s = [[heights[0], 1]]\n th, tw = s[-1]\n res = heights[0]\n\n for h in itertools.chain(itertools.islice(heights, 1, len(heights)), [0]):\n w = 1\n if s and h <= th:\n while s and h < th:\n ph, pw = s.pop()\n th, tw = s[-1] if s else (None, None)\n w += pw\n area = (w - 1) * ph\n if area > res:\n res = area\n if s and h == th:\n tw += w\n s[-1] = (h, tw)\n continue\n th, tw = h, w\n s.append((th, tw))\n return res","runtime":"436"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n rectangles = []\n max_area = 0\n\n for i, height in enumerate(heights):\n if not rectangles or rectangles[-1][1] < height:\n rectangles.append((i, height))\n elif rectangles[-1][1] == height:\n continue\n else:\n while rectangles: \n if not rectangles[-1][1] > height:\n break\n last_index, last_height = rectangles[-1]\n max_area = max(max_area, last_height * (i - last_index))\n rectangles.pop()\n rectangles.append((last_index, height))\n \n for index, height in rectangles:\n max_area = max(max_area, height * (len(heights) - index))\n \n return max_area\n \n \n\n \n","runtime":"445"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights.insert(0, 0)\n heights.append(0)\n\n st = [0]\n res = 0\n for i in range(1, len(heights)):\n if heights[i] >= heights[st[-1]]:\n st.append(i)\n else:\n while st and heights[i] < heights[st[-1]]:\n midIdx = st.pop()\n # If the heights are the same, it means it can extend further. \n # So we should pop it out and continue to find the shorter one.\n while st and heights[midIdx] == heights[st[-1]]:\n st.pop()\n # Stack still contains stuff, because we insert 0 at the front of the heights list.\n # So we can directly access st[-1]\n leftIdx = st[-1]\n w = i - leftIdx - 1\n res = max(res, w * heights[midIdx])\n st.append(i)\n return res\n \n ","runtime":"453"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights.append(0)\n stack = []\n res = 0\n\n for i in range(len(heights)):\n while stack and heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i if not stack else i - stack[-1] - 1\n area = h * w\n if area > res:\n res = area\n stack.append(i)\n \n return res","runtime":"461"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n maxArea = 0\n stack = [] # startIdx, height\n heights.append(0) # allows us to clear out stack without extra logic\n for curI, curH in enumerate(heights):\n # don't need to append if we already have the value with a lower startIdx\n if stack and curH == stack[-1][1]:\n continue\n minStartIdx = curI\n while stack and curH < stack[-1][1]:\n startIdx, lastHeight = stack.pop()\n minStartIdx = startIdx\n maxArea = max(maxArea, lastHeight * (curI - startIdx))\n stack.append((minStartIdx, curH))\n return maxArea","runtime":"470"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n pos = [-1]\n heights.append(0)\n area = 0\n for i in range(len(heights)):\n while heights[i] < heights[pos[-1]]:\n h = heights[pos.pop()]\n w = i - pos[-1] - 1\n curr = h * w\n if curr > area:\n area = curr\n pos.append(i)\n heights.pop()\n return area","runtime":"478"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [[0, heights[0]]]\n lens = 1\n # heights.append(0)\n # print(heights)\n maxa = heights[0]\n n = len(heights)\n for i in range(1, n):\n # print(stack)\n ind = i\n if heights[i] == stack[-1][1]:\n area = stack[-1][1]*(i - stack[-1][0])\n if area > maxa:\n maxa = area\n continue\n while heights[i] < stack[-1][1]:\n p = stack.pop()\n ind = p[0]\n lens-=1\n area = p[1]*(i - p[0])\n if area > maxa:\n maxa = area\n if lens==0:\n break\n # x = heights[i]\n # indt = ind\n # for j in range(ind-1, -1, -1):\n # print(i)\n # if heights[j] >= x:\n # indt = j\n # else:\n # break\n stack.append([ind, heights[i]])\n lens+=1\n for i in stack:\n area = i[1]*(n - i[0])\n if area > maxa:\n maxa = area\n return maxa","runtime":"487"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n a, st = 0, []\n\n for i, num in enumerate(heights):\n stidx = i\n while st and st[-1][1]>num:\n idx, val = st.pop()\n stidx = idx\n a = max(val*(i-idx), a)\n if not st or st[-1][1]<num:\n st.append((stidx, num))\n\n for idx, val in st:\n a = max(val*(len(heights)-idx), a)\n\n return a","runtime":"495"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n best=0\n head=[0, 1, None ] #:[ h,w ]\n\n W=1\n #print(head,best)\n for i,h in enumerate(heights):\n add=0\n while True:\n if h>head[0]:\n head=[ h,1+add, head ]\n break\n elif h==head[0]:\n head[1]+=1+add\n break\n else:\n \n if (A:= head[0]*(head[1]+add)) > best:\n best=A\n add+=head[1] \n head=head[2] \n #print(head,best)\n add=0\n while head is not None:\n if (A:= head[0]*(head[1]+add)) > best:\n best=A\n add+=head[1] \n head=head[2] \n\n return best \n\n\n","runtime":"504"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n ans: int = 0\n stack: list[tuple[int, int]] = [(0, heights[0])]\n for i in range(1, len(heights)):\n if heights[i] > stack[-1][1]:\n stack.append((i, heights[i]))\n elif heights[i] < stack[-1][1]:\n last_index = -1\n while stack and heights[i] < stack[-1][1]:\n last_index, last_height = stack.pop()\n ans = max(ans, last_height * (i-last_index))\n if not stack or heights[i] > stack[-1][1]:\n # meaning there is not exactly heights[i] at stack[-1]\n assert last_index != -1\n stack.append((last_index, heights[i]))\n while stack:\n last_index, last_height = stack.pop()\n ans = max(ans, last_height * (len(heights)-last_index))\n return ans\n","runtime":"512"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n '''\n for each bar, we extend both sides until lbar_h >= cbar_h or rbar_h >= cbar_h\n find area and compare against maxx\n TLE\n '''\n \"\"\"\n max_area = 0\n # cur_left_areas = [0]*len(heights)\n \n for cbar_i, cbar_h in enumerate(heights):\n lbar_i = cbar_i-1\n if lbar_i>0 and heights[lbar_i]==cbar_h:\n continue\n \n while True:\n if lbar_i < 0: break\n if heights[lbar_i]>=cbar_h:\n lbar_i-=1\n else:\n break\n\n cur_left_area = cbar_h*(cbar_i - lbar_i)\n # cur_left_areas[cbar_i] = cur_left_area\n \n rbar_i = cbar_i+1\n while True:\n if rbar_i >= len(heights): break\n if heights[rbar_i]>=cbar_h:\n rbar_i+=1\n else:\n break\n right_area = cbar_h*(rbar_i - cbar_i - 1)\n print(cur_left_area, right_area)\n cur_area = cur_left_area+right_area\n max_area = max(max_area, cur_area)\n return max_area\n \"\"\"\n \n # Attempt 2\n '''\n Use stack to hold the tuple of height and idx, keep adding until a lower height is encountered\n when lower is enc start popping, until it is no longer lower. \n add to stack last popped idx and new height\n '''\n\n maxx = 0\n n = len(heights)\n stack = []\n stack.append((heights[0], 0))\n i = 0\n for i, height in enumerate(heights):\n if height > stack[-1][0]:\n stack.append((height, i))\n elif height == stack[-1][0]:\n pass\n else:\n while stack and height < stack[-1][0]:\n popped_h, popped_i = stack.pop()\n area = popped_h*(i-popped_i)\n maxx = max(maxx, area)\n stack.append((height, popped_i))\n \n while stack:\n popped_h, popped_i = stack.pop()\n area = popped_h*(n-popped_i)\n maxx = max(maxx, area)\n \n return maxx\n","runtime":"521"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [0]\n heights.insert(0, 0)\n heights.append(0)\n result = 0\n for i in range(1, len(heights)):\n if heights[i] > heights[stack[-1]]:\n stack.append(i)\n elif heights[i] == heights[stack[-1]]:\n stack.pop()\n stack.append(i)\n else:\n while stack and heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i - stack[-1] - 1\n result = max(result, h * w)\n stack.append(i)\n return result","runtime":"529"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n # index, number Max: 10\n # \n #\n # \n # \n\n #monotonic increasing stack\n\n stack = []\n max_height = float(-inf)\n\n for i, num in enumerate(heights):\n if not stack: stack.append((i,num))\n else:\n if num > stack[-1][1]: stack.append((i,num))\n elif num < stack[-1][1]:\n while stack and num < stack[-1][1]:\n index, number = stack.pop()\n max_height = max(max_height, number * (i - index))\n stack.append((index,num))\n\n \n while stack:\n index,number = stack.pop()\n max_height = max(max_height, number * (len(heights) - index))\n \n return max_height\n","runtime":"537"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [] # (value, index)\n n = len(heights)\n maxArea = 0\n\n for i in range(n):\n if not len(stack) or stack[-1][0] < heights[i]:\n stack.append((heights[i], i))\n elif heights[i] < stack[-1][0]:\n ni = i\n while len(stack) and stack[-1][0] >= heights[i]:\n sv, ni = stack.pop()\n maxArea = max(maxArea, (i - ni) * sv)\n stack.append((heights[i], ni))\n\n while len(stack):\n v, i = stack.pop()\n maxArea = max(maxArea, (n - i) * v)\n\n return maxArea","runtime":"537"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n max_height = float(-inf)\n\n for i, num in enumerate(heights):\n if not stack: stack.append((i,num))\n else:\n if num > stack[-1][1]: stack.append((i,num))\n elif num < stack[-1][1]:\n while stack and num < stack[-1][1]:\n index, number = stack.pop()\n max_height = max(max_height, number * (i - index))\n stack.append((index,num))\n\n \n while stack:\n index,number = stack.pop()\n max_height = max(max_height, number * (len(heights) - index))\n \n return max_height\n","runtime":"546"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [] # (value, index)\n n = len(heights)\n maxArea = 0\n\n for i in range(n):\n if not len(stack) or stack[-1][0] < heights[i]:\n stack.append((heights[i], i))\n elif heights[i] < stack[-1][0]:\n ni = i\n while len(stack) and stack[-1][0] >= heights[i]:\n sv, ni = stack.pop()\n maxArea = max(maxArea, (i - ni) * sv)\n stack.append((heights[i], ni))\n\n while len(stack):\n v, i = stack.pop()\n maxArea = max(maxArea, (n - i) * v)\n\n return maxArea","runtime":"554"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n\n s = []\n ans = 0\n for i, height in enumerate(heights + [0]):\n while s and heights[s[-1]] > height:\n h = heights[s.pop()]\n w = i if not s else i - s[-1] - 1\n if ans < h * w:\n ans = h * w\n s.append(i)\n\n return ans\n","runtime":"563"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n = len(heights)\n max_area = 0\n stack = []\n for j in range(n):\n h = heights[j]\n while stack and h < heights[stack[-1]]:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (j - left)\n if area > max_area:\n max_area = area\n stack.append(j)\n while stack:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (n - left)\n if area > max_area:\n max_area = area\n return max_area","runtime":"571"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n = len(heights)\n stack = []\n ans = 0\n for i, height in enumerate(heights):\n if not stack or height > stack[-1][1]:\n stack.append((i, height))\n elif height < stack[-1][1]:\n curr_i = 0\n while stack and height <= stack[-1][1]:\n curr_i, curr_height = stack.pop()\n ans = max(ans, curr_height * (i - curr_i))\n stack.append((0 if not stack else curr_i, height))\n\n \n for (i, height) in stack:\n ans = max(ans, height * (n - i))\n return ans\n\n\n\n\n\n\n ","runtime":"580"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n # 输入数组首尾各补上一个0（与42.接雨水不同的是，本题原首尾的两个柱子可以作为核心柱进行最大面积尝试\n heights.insert(0, 0)\n heights.append(0)\n stack = [0]\n result = 0\n for i in range(1, len(heights)):\n # 情况一\n if heights[i] > heights[stack[-1]]:\n stack.append(i)\n # 情况二\n elif heights[i] == heights[stack[-1]]:\n stack.pop()\n stack.append(i)\n # 情况三\n else:\n # 抛出所有较高的柱子\n while stack and heights[i] < heights[stack[-1]]:\n # 栈顶就是中间的柱子，主心骨\n mid_index = stack[-1]\n stack.pop()\n if stack:\n left_index = stack[-1]\n right_index = i\n width = right_index - left_index - 1\n height = heights[mid_index]\n result = max(result, width * height)\n stack.append(i)\n return result\n\n","runtime":"588"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights.insert(0,0)\n heights.append(0)\n #print(heights)\n result = 0\n stack = []\n stack.append(0)\n for i in range(1, len(heights)):\n if heights[stack[-1]] < heights[i]:\n stack.append(i)\n elif heights[stack[-1]] == heights[i]:\n stack.pop()\n stack.append(i)\n else:\n while stack and heights[stack[-1]] > heights[i]:\n mid = stack[-1]\n stack.pop()\n if stack:\n left = stack[-1]\n right = i\n #h = [heights[left], heights[mid], heights[right], min(heights[left], heights[right])]\n #w = [right - left, right - left - 1, right - left, right - left + 1]\n \n #area = max(h[0]*w[0], h[1]*w[1],h[2]*w[2],h[3]*w[3])\n area = heights[mid] *(right - left - 1)\n\n\n\n #print(h[0]*w[0], h[1]*w[1],h[2]*w[2],h[3]*w[3])\n result = max(result, area)\n stack.append(i)\n return result\n\n\n\n ","runtime":"596"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n if not heights:\n return 0\n heights.insert(0, 0)\n heights.append(0)\n s = [0]\n ret = 0\n # maintain an ordered stack: decreasing\n # reason: once find smaller, left larger ones not important\n # in future areas\n for i in range(1, len(heights)):\n # check\n if heights[i] > heights[s[-1]]:\n s.append(i)\n elif heights[i] == heights[s[-1]]:\n s.pop()\n s.append(i)\n else:\n while s and heights[i] < heights[s[-1]]:\n mid = s[-1]\n s.pop()\n if s:\n l = s[-1]\n r = i\n w = r - l - 1\n h = heights[mid]\n ret = max(ret, w * h)\n s.append(i)\n return ret","runtime":"605"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n max_area = 0\n\n stack = []\n # while popping you know that every previously popped value was greater\n # so the max possible rectangle area with h as the height is h*(1+number popped already)\n # we pop and forget because once a smaller element is seen that becomes the cap for any rectangle\n\n for current_index, h in enumerate(heights):\n while stack and h <= heights[stack[-1]]:\n popped = stack.pop(-1)\n if not stack:\n local_area = heights[popped]*(current_index)\n else:\n local_area = heights[popped]*(current_index-stack[-1]-1)\n if local_area > max_area:\n max_area = local_area\n \n stack.append(current_index)\n\n current_index += 1\n while stack:\n popped = stack.pop(-1)\n if not stack:\n local_area = heights[popped]*(current_index)\n else:\n local_area = heights[popped]*(current_index-stack[-1]-1)\n if local_area > max_area:\n max_area = local_area\n return max_area\n","runtime":"622"},{"code":"\nclass Solution:\n def largestRectangleArea(self, hist: List[int]) -> int:\n stack = []\n result = 0\n for i, height in enumerate(hist):\n start = None\n while stack and stack[-1][-1] > height:\n start, h = stack.pop()\n result = max(result, h*(i-start))\n if not stack or height > stack[-1][-1]:\n start = start if start is not None else i\n stack.append((start,height))\n n = len(hist)\n while stack:\n i, height = stack.pop()\n result = max(result, height*(n-i))\n return result","runtime":"622"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n list_stack = list()\n\n max_area = 0 \n for i in range(len(heights)):\n if i == 0 or heights[i] > heights[i-1]:\n list_stack.append((heights[i], i))\n elif heights[i] < heights[i-1]:\n prev_index = i\n while len(list_stack) > 0 and list_stack[-1][0] >= heights[i]:\n stack_height, stack_index = list_stack.pop()\n max_area = max(max_area, (i - stack_index) * stack_height)\n prev_index = stack_index\n if heights[i] > 0:\n list_stack.append((heights[i], prev_index))\n while len(list_stack) > 0:\n stack_height, stack_index = list_stack.pop()\n max_area = max(max_area, (len(heights) - stack_index) * stack_height)\n\n return max_area\n ","runtime":"630"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n area = heights[0]\n for i, h in enumerate(heights):\n if not stack or heights[stack[-1]] <= h:\n stack.append(i)\n continue\n \n while stack and heights[stack[-1]] > h:\n pos = stack.pop()\n area = max(area, heights[pos] * (i - pos))\n \n stack.append(pos)\n heights[pos] = h\n \n i = len(heights)\n while stack:\n idx = stack.pop()\n area = max(area, heights[idx] * (i - idx))\n return area\n","runtime":"630"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n\n maxArea = max(heights)\n stack = []\n\n for i in range(len(heights)):\n\n\n while stack and heights[stack[-1]] > heights[i]:\n currIndex = stack.pop()\n nextSmaller = i\n prevSmaller = stack[-1] if stack else -1\n\n # dist between two smaller ele\n width = nextSmaller - prevSmaller -1 \n maxArea = max(maxArea, width * heights[currIndex])\n\n stack.append(i)\n\n\n # if stack still has ele\n n = len(heights)\n while stack:\n currIndex = stack.pop()\n nextSmaller = n\n prevSmaller = stack[-1] if stack else -1\n # dist between two smaller ele\n width = nextSmaller - prevSmaller -1\n maxArea = max(maxArea, width * heights[currIndex])\n \n return maxArea","runtime":"639"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n \n stack = [-1]\n area = 0\n\n for i in range(len(heights)):\n\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]: \n height = heights[stack.pop()]\n width = i - stack[-1] - 1 \n area = max(area, height * width)\n \n stack.append(i)\n \n while stack[-1] != -1:\n height = heights[stack.pop()]\n width = len(heights) - stack[-1] - 1 \n area = max(area, height * width)\n\n return area","runtime":"639"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n max_area = 0\n stack = [-1] # unified with empty case\n for i in range(len(heights)):\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1\n max_area = max(max_area, height * width)\n stack.append(i)\n while stack[-1] != -1:\n height = heights[stack.pop()]\n width = len(heights) - stack[-1] - 1\n max_area = max(max_area, height * width)\n return max_area","runtime":"647"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n max_area = 0\n\n for i, h in enumerate(heights):\n start = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n width = i - index\n max_area = max(max_area, height * width)\n start = index\n stack.append((start,h))\n\n \n\n for i, h in stack:\n width = (len(heights)- i)\n max_area = max(max_area, width * h)\n \n return max_area","runtime":"647"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stk = [-1]\n heights.append(0)\n ans = 0\n for i in range(len(heights)):\n curr_height = heights[i]\n while curr_height < heights[stk[-1]]:\n h = heights[stk.pop()]\n w = i - stk[-1] - 1\n ans = max(ans, h * w)\n stk.append(i)\n return ans","runtime":"656"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [-1]\n max_area = 0\n\n for i in range(len(heights)):\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1\n max_area = max(max_area, height * width)\n stack.append(i)\n \n while stack[-1] != -1:\n height = heights[stack.pop()]\n width = len(heights) - stack[-1] - 1\n max_area = max(max_area, height * width)\n \n return max_area","runtime":"656"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n # OK\n # stack = []\n # max_area = 0\n # heights = [0] + heights + [0] # Add dummy bars to simplify the code\n\n # for i in range(len(heights)):\n # # While the current bar is lower than the bar at the top of the stack\n # while stack and heights[stack[-1]] > heights[i]:\n # # Calculate the area of the rectangle with the bar at the top of the stack as the smallest bar\n # h = heights[stack.pop()]\n # w = i - stack[-1] - 1\n # max_area = max(max_area, h * w)\n # # Push the index of the current bar onto the stack\n # stack.append(i)\n\n # return max_area\n\n # Practice:\n st = []\n area = 0\n heights = [-1] + heights + [-1] # some low value (0 works)\n # ^ to reference left boundary\n # ^ to process as k the last, nth element from original list\n\n for i,a in enumerate(heights):\n while(st and heights[st[-1]] > a):\n rr = i\n k = st.pop() # pop first\n ll = st[-1] # stack maintains next smaller index to left (larger values already popped)\n h = heights[k]\n length = rr - ll - 1 \n area = max(area, heights[k] * length)\n\n st.append(i)\n\n return area","runtime":"664"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n maxArea = 0\n stack = [] # pairs of index,height\n for i,h in enumerate(heights):\n start = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n maxArea = max(maxArea, height * (i-index))\n start = index\n stack.append((start,h))\n\n for i,h in stack:\n maxArea = max(maxArea, h * (len(heights) - i))\n return maxArea","runtime":"664"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n # Naive Approach (TLE)\n # Time: O(N^2), Space: O(1)\n # n = len(heights)\n # max_area = 0\n # for i in range(n):\n # l = i\n # while l - 1 >= 0 and heights[l - 1] >= heights[i]:\n # l -= 1\n # r = i\n # while r + 1 < n and heights[r + 1] >= heights[i]:\n # r += 1\n # curr_rect_area = heights[i] * (r - l + 1)\n # max_area = max(max_area, curr_rect_area)\n # return max_area\n\n # Approach: Stack\n # Time: O(N), Space: O(N)\n max_area = 0\n stack = []\n\n for i, h in enumerate(heights):\n # print('idx', i, h)\n if not stack:\n stack.append((i, h))\n # print('one', stack)\n else:\n if h >= stack[-1][1]:\n stack.append((i, h))\n # print('two', stack)\n else:\n while stack and h < stack[-1][1]:\n # print('three', stack)\n i_, h_ = stack.pop()\n curr_rect_area = (i - i_) * h_\n max_area = max(max_area, curr_rect_area)\n if not stack:\n stack.append((0, h))\n # print('four', stack)\n else:\n # make left boundary same as that of last popped block\n stack.append((i_, h))\n # print('five', stack)\n \n while stack:\n # print('six', stack)\n i_, h_ = stack.pop()\n curr_rect_area = (len(heights) - i_) * h_\n max_area = max(max_area, curr_rect_area)\n\n return max_area","runtime":"672"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [-1]\n max_area = 0\n\n for i in range(len(heights)):\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1\n max_area = max(max_area, height * width)\n stack.append(i)\n \n while stack[-1] != -1:\n height = heights[stack.pop()]\n width = len(heights) - stack[-1] - 1\n max_area = max(max_area, height * width)\n \n return max_area","runtime":"672"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stk = [-1]\n heights.append(0)\n ans = 0\n for i in range(len(heights)):\n curr_height = heights[i]\n while curr_height < heights[stk[-1]]:\n h = heights[stk.pop()]\n w = i - stk[-1] - 1\n ans = max(ans, h * w)\n stk.append(i)\n return ans","runtime":"681"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stk = [] #(height,idex)\n maxarea = 0\n #Monotonic Increasing\n for i,h in enumerate(heights):\n start = i\n while stk and stk[-1][0] > h:\n height,index = stk.pop()\n area = (i - index)* (height)\n maxarea = max(maxarea,area)\n start = index \n stk.append((h,start))\n\n for h,i in stk:\n maxarea = max(maxarea,(len(heights)-i)*h)\n return maxarea","runtime":"681"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n ans = 0\n for i in range(len(heights)):\n start = i\n while stack and stack[-1][-1] > heights[i]:\n index ,h = stack.pop()\n ans = max(ans, h *(i-index))\n start = index\n stack.append([start,heights[i]])\n while stack:\n i,h = stack.pop()\n ans = max(ans,h *(len(heights)-i))\n return ans\n\n \n ","runtime":"689"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n max_area = 0\n heights.append(0) # Add a 0 at the end to pop all remaining heights\n \n for i, h in enumerate(heights):\n start = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n max_area = max(max_area, height * (i - index))\n start = index\n stack.append((start, h))\n \n return max_area","runtime":"689"},{"code":"from collections import deque\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n # building a monotonously increasing stack, then go thorugh it\n stack = [-1]\n max_area = 0\n for i in range(len(heights)):\n # first pop\n while stack[-1] != -1 and heights[stack[-1]] > heights[i]:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1\n max_area = max(max_area, width * height)\n # then insert\n stack.append(i)\n # keep popping, now right limit is len(heights)\n while stack[-1] != -1:\n height = heights[stack.pop()]\n width = len(heights) - stack[-1] - 1\n max_area = max(max_area, width * height)\n return max_area","runtime":"698"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n stack.append([0, heights[0]])\n curr = 1\n maxarea = max(heights)\n\n while curr<len(heights):\n start = curr\n while stack and heights[curr] < stack[-1][1]:\n index, height = stack.pop()\n maxarea = max(maxarea, (curr-index)*height)\n start = index\n stack.append([start, heights[curr]])\n curr +=1\n\n #can use a for loop instead\n #for index, height in enumerate(heights):\n # start = index\n # while stack and height < stack[-1][1]:\n # idx, hei = stack.pop()\n # maxarea = max(maxarea, (index-idx)*height)\n # start = idx\n # stack.append([start, height])\n\n #leftovers in the stack are the ones that can be extended to the end of the histogram\n for index, height in stack:\n maxarea = max(maxarea, height*(len(heights)-index))\n\n return maxarea\n\n ","runtime":"698"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n ans = 0\n for i, h in enumerate(heights):\n if not stack or heights[stack[-1]] < h:\n stack.append(i)\n continue\n \n while stack and h <= heights[stack[-1]]:\n idx = stack.pop()\n ans = max(ans, (i - idx) * heights[idx])\n \n heights[idx] = h\n stack.append(idx)\n \n end = len(heights)\n while stack:\n idx = stack.pop()\n ans = max(ans, (end - idx) * heights[idx])\n return ans","runtime":"706"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n maxArea = 0\n\n for i, h in enumerate(heights):\n start = i\n while stack and stack[-1][1] > h:\n idx, height = stack.pop()\n maxArea = max(maxArea, height * (i - idx))\n start = idx\n stack.append((start, h))\n \n for i, h in stack:\n maxArea = max(maxArea, h * (len(heights) - i))\n \n return maxArea","runtime":"706"},{"code":"# in: int[] heights\n# out: largest rectangle in histogram\n\n# can be combined from different bars\n# all ints\n# all positive\n\n# we could have a bar of width 1 that is so tall it is the biggest\n# at any given point, the max area is the smallest bar to the left/right times width\n# we could expand out from each bar and compare max area at each point\n# what if we tried pointers?\n# come in from left + right and at each point, we consider the best possible area\n# we can essentially shrink the taller nums to the left once we hit a smaller num\n# we could build a new array of increasing nums from left and right\n# at each num, we essentially need to know the left + right index that it can stretch to\n# since we want to account for the max we can go to the left, what if we use a stack?\n# do we need a second stack to the right? maybe\n# go across the array, then when we get to a num that is smaller than the last (or min so far?)\n# we should track indices of nums as well so we know how far to the left a height goes\n# ok so use a stack, then pop so we get back to something shorter than prev num\n# each time we hit a shorter num, we know the height to the left has reached its best chance\n# multiply the top num by the distance to the next top el in the stack\n# keep popping until we reach something shorter thasn right num\n# keep going to end of list\n\n# T: O(N), moving across array once and popping up to once (2N)\n# S: O(N) for stack\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n if not heights:\n return 0\n max_area = 0\n stack = []\n for i in range(len(heights)): # 0,9\n height = heights[i] # 9\n while stack and height < stack[-1][0]:\n comparison_height = stack.pop()[0]\n width = i\n if stack:\n width = i - stack[-1][1] - 1\n area = comparison_height * width\n max_area = max(max_area, area)\n stack.append((height, i)) #[0,0, 9,1]\n\n # last nums\n while stack:\n comparison_height = stack.pop()[0] # 9\n width = len(heights) #\n if stack:\n width = len(heights) - stack[-1][1] - 1 # 1\n area = comparison_height * width\n max_area = max(max_area, area)\n\n return max_area\n\n\n","runtime":"715"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [-1]\n maxArea = 0\n for i in range(len(heights)):\n while stack[-1] != -1 and heights[stack[-1]] >= heights[i]:\n h = heights[stack.pop()]\n w = i - stack[-1] - 1\n maxArea = max(maxArea, h * w)\n stack += [i]\n while stack[-1] != -1:\n h = heights[stack.pop()]\n w = len(heights) - stack[-1] - 1\n maxArea = max(maxArea, h * w)\n return maxArea\n","runtime":"715"},{"code":"# Append the stack with value and index when the value in list is bigger than the last element in stack\n# Else, pop the lst element and update the result\n# As well as update the index of the new value to be inserted\n# At last if there are elements in stack pop them one by one and update result\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n res = 0\n\n for ind, val in enumerate(heights):\n st_ind = ind\n while stack and stack[-1][0] > val:\n tmp_num = (ind-stack[-1][1])*stack[-1][0]\n res = max(res, tmp_num)\n st_ind = stack.pop()[1]\n \n stack.append([val, st_ind])\n \n while stack:\n tmp_num = (len(heights)-stack[-1][1])*stack[-1][0]\n res = max(res, tmp_num)\n stack.pop()\n \n return res\n","runtime":"723"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n = len(heights)\n\n right_low = [n] * n\n stack = []\n for i in range(n):\n while stack and heights[i] < heights[stack[-1]]:\n top = stack.pop()\n right_low[top] = i\n stack.append(i)\n\n left_low = [-1] * n\n stack = []\n for i in range(n - 1, -1, -1):\n while stack and heights[i] < heights[stack[-1]]:\n top = stack.pop()\n left_low[top] = i\n stack.append(i)\n\n ans = 0\n for i in range(n):\n left = left_low[i]\n right = right_low[i]\n area = (right - left - 1) * heights[i]\n ans = max(ans, area)\n\n return ans\n\n\n # Time complexity: O(n)\n # Space complexity: O(n)\n\n\n \n ","runtime":"723"},{"code":"from typing import List\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n = len(heights)\n \n # Arrays to store the nearest smaller bars to the left and right\n left = [-1] * n # Nearest smaller bar to the left\n right = [n] * n # Nearest smaller bar to the right\n \n # Precompute the left boundaries\n for i in range(1, n):\n p = i - 1\n while p >= 0 and heights[p] >= heights[i]:\n p = left[p] # Move left to find the nearest smaller bar\n left[i] = p\n \n # Precompute the right boundaries\n for i in range(n - 2, -1, -1):\n p = i + 1\n while p < n and heights[p] >= heights[i]:\n p = right[p] # Move right to find the nearest smaller bar\n right[i] = p\n \n # Compute the maximum area\n max_area = 0\n for i in range(n):\n # Width is the distance between right[i] and left[i] minus 1\n width = right[i] - left[i] - 1\n area = heights[i] * width\n max_area = max(max_area, area)\n \n return max_area\n","runtime":"731"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n res = 0\n stack = [(-1, -1)] \n for right, h in enumerate(heights + [-1]):\n while h < stack[-1][-1]:\n _, val = stack.pop()\n left = stack[-1][0]\n res = max(res, (right - left - 1) * val)\n stack.append((right, h))\n return res","runtime":"731"},{"code":"class Solution:\n\n # Time: O(n)\n # Space: O(n)\n def largestRectangleArea(self, heights: List[int]) -> int:\n # monotonically nondecreasing stack\n stack = []\n # constraint: can heights be negative? \n maxArea = 0\n for i in range(len(heights)):\n curr = heights[i]\n extendsFrom = i\n # pop elements to maintain non-decreasing property of stack\n # calculate max area including/ending at that element\n while stack and curr < stack[-1][1]:\n maxArea = max(maxArea, stack[-1][1] * (i-stack[-1][0]))\n extendsFrom = stack[-1][0]\n stack.pop()\n # add current element, making it start as leftmost as possible\n stack.append([extendsFrom, curr])\n\n # now process remaining stack\n while len(stack) > 0:\n maxArea = max(maxArea, stack[-1][1] * (len(heights) - stack[-1][0]))\n stack.pop()\n return maxArea\n \n\"\"\"\nIdea: create monotonically increasing stack of heights\n- The smallest value (stack[0]) * len(stack) is the array\n- keep on doing this as you iterate through heights array and when you find new element that is not monotonically\nincreasing, clear the stack and start it again -> keep track of max area\n\n- complication: it is not necessary to use the entirety of monotonically increasing part, \nsometimes you need to get rid of too-small elements\n\n\"\"\"","runtime":"740"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n # constraint: can heights be negative? \n maxArea = 0\n for i in range(len(heights)):\n curr = heights[i]\n extendsFrom = i\n while stack and curr < stack[-1][1]:\n maxArea = max(maxArea, stack[-1][1] * (i-stack[-1][0]))\n extendsFrom = stack[-1][0]\n stack.pop()\n stack.append([extendsFrom, curr])\n # now process remaining stack\n while len(stack) > 0:\n maxArea = max(maxArea, stack[-1][1] * (len(heights) - stack[-1][0]))\n stack.pop()\n return maxArea\n \n\"\"\"\nIdea: create monotonically increasing stack of heights\n- The smallest value (stack[0]) * len(stack) is the array\n- keep on doing this as you iterate through heights array and when you find new element that is not monotonically\nincreasing, clear the stack and start it again -> keep track of max area\n\n- complication: it is not necessary to use the entirety of monotonically increasing part, \nsometimes you need to get rid of too-small elements\n\n\"\"\"","runtime":"740"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack, res = [(-1, 0)], 0\n for i, h in enumerate(heights):\n while stack[-1][1] > h:\n top = stack.pop()\n res = max(res, (i - stack[-1][0] -1) * top[1])\n stack.append((i, h))\n\n print(stack, res)\n\n for i in range(1, len(stack)):\n res = max(res, (stack[-1][0] - stack[i-1][0]) * stack[i][1])\n return res\n","runtime":"748"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n '''12:08'''\n stack = []\n maxRectangle = 0\n\n for i, currHeight in enumerate(heights):\n if len(stack) == 0 or currHeight >= stack[-1][1]:\n stack.append((i, currHeight))\n else:\n prevIndex = -1\n while len(stack) > 0 and currHeight < stack[-1][1]:\n prevIndex = stack[-1][0]\n maxRectangle = max(maxRectangle, self.popFromStackAndGetRectangleSize(i, stack))\n \n if currHeight != 0:\n stack.append((prevIndex, currHeight))\n \n while len(stack) > 0:\n maxRectangle = max(maxRectangle, self.popFromStackAndGetRectangleSize(len(heights), stack))\n \n return maxRectangle\n \n def popFromStackAndGetRectangleSize(self, currIndex, stack):\n prevIndex, h = stack.pop()\n rectangle = h * (currIndex - prevIndex)\n return rectangle\n","runtime":"748"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n maxArea = 0\n for ind, height in enumerate(heights):\n i = ind\n h = height\n while stack and height < stack[-1][1]:\n i, h = stack.pop()\n maxArea = max(maxArea, h * (ind-i))\n \n stack.append([i, height])\n maxArea = max(maxArea, height)\n\n while stack:\n i, h = stack.pop()\n maxArea = max(maxArea, h * (len(heights)-i))\n return maxArea","runtime":"757"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n # A stack with elements [(num, start, end)]\n # When curr < stack[-1], pop from stop.\n\n stack = []\n maxNum = float('-inf')\n\n for i in range(len(heights)):\n if (len(stack) == 0):\n stack.append([heights[i], i, i])\n continue\n \n if (heights[i] >= stack[-1][0]):\n stack.append([heights[i], i, i])\n else: \n end = stack[-1][2]\n start = stack[-1][1]\n while (len(stack) > 0 and heights[i] < stack[-1][0]):\n prev = stack[-1]\n start = prev[1]\n area = prev[0] + prev[0] * (end-start)\n maxNum = max(maxNum, area)\n stack.pop()\n\n stack.append([heights[i], start, i])\n \n if (len(stack) > 0):\n end = stack[-1][2]\n while (len(stack) > 0):\n start = stack[-1][1]\n curr = stack[-1][0]\n area = curr + curr*(end-start)\n maxNum = max(maxNum, area)\n stack.pop()\n \n return maxNum\n\n \n","runtime":"757"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n nse=self.findNSE(heights)\n pse=self.findPSE(heights)\n area=0\n n=len(heights)\n for i in range(n):\n area=max(area,heights[i]*(nse[i]-pse[i]-1))\n return area\n\n \n\n def findNSE(self,arr):\n n=len(arr)\n nse=[n]*n\n st=[]\n for i in range(n-1,-1,-1):\n while st and arr[st[-1]]>=arr[i]:\n st.pop()\n if st:\n nse[i]=st[-1]\n st.append(i)\n return nse\n def findPSE(self,arr):\n n=len(arr)\n pse=[-1]*n\n st=[]\n for i in range(n):\n while st and arr[st[-1]]>=arr[i]:\n st.pop()\n if st:\n pse[i]=st[-1]\n st.append(i)\n return pse\n\n\n ","runtime":"765"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n\n if len(heights) == 0:\n return 0\n \n stack = []\n max_area = 0\n\n for index,value in enumerate(heights):\n if len(stack) == 0 or stack[-1][1] <= value:\n stack.append([index, value])\n else:\n top = []\n while len(stack) >0 and value < stack[-1][1]:\n top, max_area = self.calculateArea(stack,index,max_area)\n \n stack.append([top[0],value])\n \n index+=1\n top =[]\n while len(stack) >0:\n top, max_area = self.calculateArea(stack,index,max_area)\n\n return max_area\n \n def calculateArea(self, stack,index, max_area):\n top = stack.pop()\n width = index - top[0]\n height = top[1]\n area = height * width\n\n max_area = max(max_area, area)\n \n return [top,max_area]\n ","runtime":"765"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n minLeft = [-1 for _ in range(len(heights))]\n minRight = [len(heights) for _ in range(len(heights))]\n for i in range(1, len(heights)):\n j = i-1\n while (j > -1):\n if heights[j] < heights[i]:\n minLeft[i] = j\n break\n j = minLeft[j]\n for i in range(len(heights) - 2, -1, -1):\n j = i+1\n while (j < len(heights)):\n if heights[j] < heights[i]:\n minRight[i] = j\n break\n j = minRight[j]\n result = 0\n\n for i in range(0, len(heights)):\n h = heights[i]\n w = minRight[i] - minLeft[i] - 1\n result = max(result, h * w)\n return result","runtime":"774"},{"code":"from collections import deque \nclass Solution:\n # calculate left \n def left(self,arr,n):\n res = [-1]*n \n stack = deque() \n stack.append(0)\n for i in range (1,n):\n val = arr[i] \n if stack and arr[stack[-1]]<val:\n res[i] = stack[-1]\n else:\n while stack and arr[stack[-1]]>=val:\n stack.pop()\n if stack:\n res[i] = stack[-1] \n stack.append(i)\n return res \n \n # calculate right\n def right(self,arr,n):\n res=[n]*n \n stack = deque()\n stack.append(n-1)\n for i in range(n-2,-1,-1):\n val = arr[i]\n if stack and arr[stack[-1]]<val:\n res[i] = stack[-1] \n else:\n while stack and arr[stack[-1]]>=val:\n stack.pop() \n if stack:\n res[i] = stack[-1] \n stack.append(i)\n return res \n \n def largestRectangleArea(self,height):\n n = len(height)\n left = self.left(height,n)\n right = self.right(height,n)\n maxArea = 0 \n for i in range(n):\n newArea = ((right[i]-left[i])-1)*(height[i])\n maxArea = max(maxArea,newArea)\n return maxArea \n ","runtime":"774"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n=len(heights)\n leftmin=[]\n s=[]\n for i in range(len(heights)):\n while s and heights[s[-1]]>=heights[i]:\n s.pop()\n if s:\n leftmin.append(i-s[-1])\n else:\n leftmin.append(i+1)\n s.append(i) \n rightmin=[0]*n\n s=[]\n for i in range(len(heights)-1,-1,-1):\n while s and heights[s[-1]]>=heights[i]:\n s.pop()\n if s:\n rightmin[i]=(s[-1]-i) \n else:\n rightmin[i]=n-i\n s.append(i) \n ans=0\n for i in range(n):\n t=heights[i]*(leftmin[i]+rightmin[i]-1)\n #print(t)\n ans=max(ans,t) \n return ans \n\n\n \n ","runtime":"782"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n = len(heights)\n stack = []\n left = [-1] * n\n right = [n] * n\n \n # Calculate left and right bounds using a single stack\n for i in range(n):\n while stack and heights[stack[-1]] >= heights[i]:\n stack.pop()\n if stack:\n left[i] = stack[-1]\n stack.append(i)\n\n stack.clear() # Clear the stack for right bounds\n \n for i in range(n-1, -1, -1):\n while stack and heights[stack[-1]] >= heights[i]:\n stack.pop()\n if stack:\n right[i] = stack[-1]\n stack.append(i)\n \n max_area = 0\n for i in range(n):\n width = right[i] - left[i] - 1\n max_area = max(max_area, width * heights[i])\n \n return max_area\n","runtime":"782"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n q = deque()\n result = 0\n for i, x in enumerate(heights):\n left_v = 0\n while q and q[-1][1] >= x:\n j, y, plv = q.pop()\n result = max(result, (i-j)*y + plv)\n\n if q:\n s = q[-1][0] + 1\n else:\n s = 0\n left_v = max(left_v, (i - s) * x)\n if not q:\n result = max(result, (i+1)*x)\n q.append((i, x, left_v))\n while q:\n result = max(result, (q[-1][0] - q[0][0] + 1) * q[0][1] + q[0][2])\n q.popleft()\n return result\n","runtime":"791"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n L = len(heights)\n leftLadder = []\n leftSmaller = [0]*L\n for i,h in enumerate(heights):\n while leftLadder and heights[leftLadder[-1]]>=h:\n leftLadder.pop()\n leftSmaller[i] = (leftLadder[-1] if leftLadder else -1)\n leftLadder.append(i)\n #print(leftSmaller)\n rightLadder = []\n rightSmaller = [0]*L\n for i,h in reversed(list(enumerate(heights))):\n while rightLadder and heights[rightLadder[-1]]>=h:\n rightLadder.pop()\n rightSmaller[i] = (rightLadder[-1] if rightLadder else L)\n rightLadder.append(i)\n #print(rightSmaller)\n\n best = 0\n for i,h in enumerate(heights):\n w=rightSmaller[i]-leftSmaller[i]-1\n area = w*h\n #print (i,leftSmaller[i],rightSmaller[i],h,area)\n best = max(best,area)\n return best","runtime":"791"},{"code":"def previous_smaller_index(arr):\n ans = [-1]\n st = [0]\n\n for i in range(1, len(arr)):\n\n while st and arr[i] <= arr[st[-1]]:\n st.pop()\n\n if len(st) == 0:\n ans.append(-1)\n\n else:\n ans.append(st[-1])\n\n st.append(i)\n\n return ans\n \ndef next_smaller_index(arr):\n ans = [len(arr)]\n st = [len(arr) - 1]\n\n for i in range(len(arr) - 2, -1, -1):\n\n while st and arr[i] <= arr[st[-1]]:\n st.pop()\n\n if len(st) == 0:\n ans.append(len(arr))\n\n else:\n ans.append(st[-1])\n\n st.append(i)\n\n return ans[::-1]\n \ndef max_area_histogram(arr):\n psi = previous_smaller_index(arr)\n nsi = next_smaller_index(arr)\n ans = 0\n print(psi, nsi)\n for i in range(len(arr)):\n ans = max(ans, ((nsi[i] - psi[i] - 1) * arr[i]))\n \n return ans\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n return max_area_histogram(heights)\n ","runtime":"799"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights_new = [0] + heights + [0]\n stack = []\n area = 0\n for i in range(len(heights_new)):\n while stack and heights_new[stack[-1]] > heights_new[i]:\n mid = stack.pop()\n if not stack: continue\n left = stack[-1]\n h = heights_new[mid]\n w = i-left-1\n area = max(h*w, area)\n\n stack.append(i)\n if heights_new[stack[-1]] <= heights_new[i]:\n stack.append(i)\n return area","runtime":"799"},{"code":"from dataclasses import dataclass\n\nclass Solution:\n\n def largestRectangleArea(self, heights: List[int]) -> int:\n @dataclass\n class StackElement:\n pos: int\n val: int\n\n length = len(heights)\n stack: list[StackElement] = []\n max_area = heights[0]\n for i in range(length):\n if not stack or heights[i] >= stack[-1].val:\n stack.append(StackElement(i, heights[i]))\n continue\n\n max_ext = stack[-1].pos\n while stack and stack[-1].val > heights[i]:\n max_area = max(max_area, (i - stack[-1].pos) * stack[-1].val)\n max_ext = stack[-1].pos\n stack.pop()\n\n stack.append(StackElement(max_ext, heights[i]))\n\n while stack:\n max_area = max(max_area, (length - stack[-1].pos) * stack[-1].val)\n stack.pop()\n\n return max_area\n","runtime":"807"},{"code":"from collections import deque\n\nclass Solution:\n\n def fillPrevSmaller(self):\n st = deque()\n \n for idx in (range(self.n)):\n height = self.heights[idx]\n if len(st) == 0:\n st.append(idx)\n else:\n while len(st) > 0 and height <= self.heights[st[-1]]:\n st.pop()\n if len(st) > 0:\n self.pge[idx] = st[-1]\n st.append(idx)\n\n def fillNextSmaller(self):\n st = deque()\n \n for idx in reversed(range(self.n)):\n height = self.heights[idx]\n if len(st) == 0:\n st.append(idx)\n else:\n while len(st) > 0 and height <= self.heights[st[-1]]:\n st.pop()\n if len(st) > 0:\n self.nge[idx] = st[-1]\n st.append(idx)\n\n\n\n def largestRectangleArea(self, heights: List[int]) -> int:\n self.n = len(heights)\n self.pge = [-1]*self.n\n self.nge = [self.n]*self.n\n self.heights = heights\n self.fillPrevSmaller()\n self.fillNextSmaller()\n ans = 0\n for i in range(self.n):\n ans = max(ans,heights[i]*(self.nge[i]-self.pge[i]-1),)\n return ans","runtime":"807"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n def PSE():\n stack = []\n res = []\n for i in range(len(heights)):\n while stack and stack[-1][0]>=heights[i]:\n stack.pop()\n if not stack:\n res.append(-1)\n else:\n res.append(stack[-1][1])\n stack.append([heights[i], i])\n return res\n def NSE():\n stack = []\n res = [len(heights) for _ in range(len(heights))]\n for i in range(len(heights)-1, -1, -1):\n while stack and stack[-1][0]>=heights[i]:\n stack.pop()\n if stack:\n res[i] = stack[-1][1]\n stack.append([heights[i], i])\n return res\n pse = PSE()\n nse = NSE()\n mx = 0\n l = len(heights)\n for i in range(len(heights)):\n mx = max(mx, heights[i]*(nse[i]-pse[i]-1))\n return mx","runtime":"816"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n hl = len(heights)\n right, left = [-1] * hl, [-1] * hl\n stack = []\n for i in range(hl):\n while stack and stack[-1][0] >= heights[i]:\n stack.pop()\n firstSmallIndx = -1\n if stack:\n firstSmallIndx = stack[-1][1]\n left[i] = firstSmallIndx + 1\n stack.append([heights[i], i])\n\n stack = []\n for i in range(hl-1, -1, -1):\n while stack and stack[-1][0] >= heights[i]:\n stack.pop()\n firstSmallIndx = hl\n if stack:\n firstSmallIndx = stack[-1][1]\n right[i] = firstSmallIndx - 1\n stack.append([heights[i], i])\n #print(left)\n #print(right)\n \n ans = 0\n for i in range(hl):\n rect = heights[i] * (right[i] - left[i] + 1)\n ans = max(ans, rect)\n return ans","runtime":"816"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n smallestRight = [len(heights)] * len(heights)\n smallestLeft = [-1] * len(heights)\n stack = []\n for index, height in enumerate(heights):\n while len(stack) > 0 and height < stack[-1][1]:\n biggerIndex, biggerHeight = stack[-1]\n smallestRight[biggerIndex] = index\n stack.pop()\n stack.append((index, height))\n\n stack = []\n for index in range(len(heights) - 1, -1, -1):\n height = heights[index]\n while len(stack) > 0 and height < stack[-1][1]:\n biggerIndex, biggerHeight = stack[-1]\n smallestLeft[biggerIndex] = index\n stack.pop()\n stack.append((index, height))\n \n best = 0\n for index, height in enumerate(heights):\n bestWidth = smallestRight[index] - smallestLeft[index] - 1\n bestArea = height * bestWidth\n best = max(best, bestArea)\n return best","runtime":"824"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n n = len(heights)\n left = [-1] * n\n for i in range(0,n):\n while len(stack)!= 0 and heights[stack[len(stack)-1]] >= heights[i]:\n stack.pop() \n if len(stack)!=0:\n left[i] = stack[len(stack)-1]\n stack.append(i)\n\n stack = []\n n = len(heights)\n right = [n] * n\n for i in range(n-1,-1,-1):\n while len(stack)!= 0 and heights[stack[len(stack)-1]] >= heights[i]:\n stack.pop()\n if len(stack)!=0:\n right[i] = stack[len(stack)-1]\n stack.append(i)\n\n maxArea = -1\n for i in range(n):\n area = (right[i]-left[i]-1) * heights[i]\n maxArea = max(area,maxArea)\n \n return maxArea\n\n","runtime":"824"}],"string":"[\n {\n \"code\": \"# class Solution:\\ndef largestRectangleArea(heights: List[int]) -> int:\\n n = len(heights)\\n max_area = 0\\n stack = []\\n for j in range(n):\\n h = heights[j]\\n while stack and h < heights[stack[-1]]:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (j - left)\\n if area > max_area:\\n max_area = area\\n stack.append(j)\\n while stack:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (n - left)\\n if area > max_area:\\n max_area = area\\n return max_area\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads,stdin):\\n print(largestRectangleArea(i), file=f)\\n exit(0)\\n \\n # Failed\\n # if len(heights)==1:\\n # return heights[0]\\n # l, r = 0, len(heights) - 1\\n # max_tmp = 0\\n\\n # while l < r:\\n # val_l = heights[l]\\n # val_r = heights[r]\\n\\n # if val_l < val_r:\\n # x = val_l * (r-l+1)\\n # l += 1 \\n # if val_l > heights[l] and l < r:\\n # max_tmp = 0\\n # x=0\\n # max_tmp = max(max_tmp, x)\\n # else:\\n # x = val_r * (r-l+1)\\n # r -= 1 \\n # if val_r > heights[r] and l < r:\\n # max_tmp = 0\\n # x = 0\\n # max_tmp = max(max_tmp, x)\\n \\n # lon = 0\\n # for i in range(len(heights)):\\n # if heights[i] == 0:\\n # if heights[lon:i]:\\n # max_tmp = max(min(heights[lon:i]) * (i - lon), max_tmp)\\n # lon = i+1\\n # elif i == len(heights)-1:\\n # # print(min(heights[lon:i+1]) * (i+1 - lon))\\n # max_tmp = max(min(heights[lon:i+1]) * (i+1 - lon), max_tmp)\\n # return max(max_tmp, max(heights))\",\n \"runtime\": \"158\"\n },\n {\n \"code\": \"def largestRectangleArea(heights: List[int]) -> int:\\n n = len(heights)\\n max_area = 0\\n stack = []\\n for j in range(n):\\n h = heights[j]\\n while stack and h < heights[stack[-1]]:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (j - left)\\n if area > max_area:\\n max_area = area\\n stack.append(j)\\n while stack:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (n - left)\\n if area > max_area:\\n max_area = area\\n return max_area\\n\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads,stdin):\\n print(largestRectangleArea(i), file=f)\\n exit(0)\",\n \"runtime\": \"158\"\n },\n {\n \"code\": \"def largestRectangleArea(heights: List[int]) -> int:\\n heights.append(0)\\n stack = []\\n best = 0\\n for idx, height in enumerate(heights):\\n i = idx\\n while stack and height < stack[-1][0]:\\n h, i = stack.pop()\\n if (area := h * (idx - i)) > best:\\n best = area\\n stack.append((height, i))\\n return best\\n\\nf = open('user.out', 'w')\\nfor i in map(loads, stdin):\\n f.write(f'{largestRectangleArea(i)}\\\\n')\\nf.flush()\\nexit(0)\",\n \"runtime\": \"166\"\n },\n {\n \"code\": \"from typing import List\\n\\ndef largestRectangleArea(heights: List[int]) -> int:\\n n = len(heights)\\n st = []\\n ans = 0\\n for i in range(n):\\n h = heights[i]\\n start = i\\n while st and st[-1][1] > h:\\n ind, ht = st.pop()\\n ans = max(ans, ht * (i - ind))\\n start = ind\\n \\n st.append((start, h))\\n\\n # Process the remaining elements in the stack\\n for i, h in st:\\n ans = max(ans, h * (n - i)) # Correct calculation for the remaining heights\\n \\n return ans\\n\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads,stdin):\\n print(largestRectangleArea(i), file=f)\\n exit(0)\",\n \"runtime\": \"175\"\n },\n {\n \"code\": \"def largestRectangleArea(heights: List[int]) -> int:\\n heights.append(0)\\n stack = []\\n best = 0\\n for idx, height in enumerate(heights):\\n i = idx\\n while stack and height < stack[-1][0]:\\n h, i = stack.pop()\\n if (area := h * (idx - i)) > best:\\n best = area\\n stack.append((height, i))\\n return best\\n\\nf = open('user.out', 'w')\\nfor i in map(loads, stdin):\\n print(largestRectangleArea(i), file=f)\\nf.flush()\\nexit(0)\",\n \"runtime\": \"183\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n = len(heights)\\n stack = []\\n max_area = 0\\n\\n for i in range(n):\\n while stack and heights[i] <= heights[stack[-1]]:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1 if stack else i\\n max_area = max(max_area, height * width)\\n stack.append(i)\\n\\n while stack:\\n height = heights[stack.pop()]\\n width = n - stack[-1] - 1 if stack else n\\n max_area = max(max_area, height * width)\\n\\n return max_area\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n inputs = map(loads, stdin)\\n for nums in inputs:\\n print(Solution().largestRectangleArea(nums),file=f)\\nexit(0)\",\n \"runtime\": \"191\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights.append(0)\\n stack = [-1]\\n res = 0\\n for i in range(len(heights)):\\n while (heights[stack[-1]] > heights[i]):\\n h = heights[stack.pop()]\\n w = i - 1 - stack[-1]\\n res = max(res, h*w)\\n stack.append(i)\\n return res\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n s = Solution()\\n for i in map(loads,stdin):\\n print(s.largestRectangleArea(i), file=f)\\n exit(0)\",\n \"runtime\": \"191\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights += [0]\\n ans = 0\\n stk = [-1]\\n\\n # Every height in heights can form a rectangle by expanding to the next smaller(or equal) element on its left and right\\n # ans must be one of them\\n\\n # try to expand in increasing order to the right, until we encounter sth smaller, this will be the next smaller on the right; mono stack keeps track of next smaller on the left\\n # the content of the stack\\n # ---------------------------------|\\n # -- idx of increasing elements --> top\\n # ---------------------------------|\\n\\n # stack[-1]=left next smaller | h=stack.pop() | i=right next smaller \\n\\n # for each element at index i, if it's smaller than stack.top()\\n # Then the rectangle with height of stack.top() can no longer expand right\\n # we pop it this height {h} from the stack, stack.top() is the prev element that is smaller than {h}\\n # the rectangle area = {h} * (i - 1 - stack.top())\\n\\n for i, h in enumerate(heights):\\n while stk and heights[stk[-1]] > h:\\n # The top of stack must be popped off, no more extension to the right\\n height = heights[stk.pop()]\\n\\n # right next smaller of h is at index i\\n # rectangle's right ends at i-1\\n # left next smaller of h is at index stk[-1]\\n \\n width = i - 1 - stk[-1]\\n\\n ans = max(ans, height * width)\\n # end while\\n\\n stk.append(i)\\n # end for\\n\\n return ans\\n\\nsol = Solution()\\nf = open('user.out', 'w')\\nfor i in map(loads, stdin):\\n f.write(f'{sol.largestRectangleArea(i)}\\\\n')\\nf.flush()\\nexit(0)\",\n \"runtime\": \"200\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n ans=heights[0]\\n stack=[[heights[0],0,0]]\\n heights.append(0)\\n for i in range(1,len(heights)):\\n a=heights[i]\\n c=i\\n while stack and stack[-1][0]>=a:\\n b,d,z=stack.pop()\\n ans=max(ans,(i-1-d+1)*b)\\n c=d \\n stack.append([a,c,i])\\n \\n del stack, heights\\n return ans\\nf = open('user.out','w')\\nfor i in map(loads,stdin):\\n f.write(f'{Solution().largestRectangleArea(i)}\\\\n')\\nf.flush()\\nexit(0)\",\n \"runtime\": \"200\"\n },\n {\n \"code\": \"# class Solution:\\ndef largestRectangleArea(heights: List[int]) -> int:\\n heights += [0]\\n stack = []\\n max_area = -sys.maxsize\\n for i, height in enumerate(heights):\\n if not stack or height > stack[-1][0]:\\n stack.append((height,i))\\n else:\\n while stack and stack[-1][0] >= height:\\n h2, i2 = stack.pop()\\n area = (i - i2) * h2\\n max_area = max(max_area, area)\\n stack.append((height, i2))\\n return max_area\\n\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads,stdin):\\n print(largestRectangleArea(i), file=f)\\n exit(0)\",\n \"runtime\": \"208\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, h: list[int]) -> int:\\n n = len(h)\\n l,r = [1]*n, [1]*n\\n \\n for i in range(1,n):\\n j = i - 1\\n while j>=0 and h[j] >= h[i]: j -= l[j]\\n l[i] = i - j\\n \\n for i in reversed(range(n-1)):\\n j = i+1\\n while j < n and h[i] <= h[j]: j += r[j] \\n r[i] = j - i\\n \\n return max((l[i]+r[i])*h[i] -h[i] for i in range(n))\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nf = open('user.out','w')\\nfor i in map(loads,stdin):\\n f.write(f'{Solution().largestRectangleArea(i)}\\\\n')\\nf.flush()\\nexit(0) \\n \",\n \"runtime\": \"217\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, h: list[int]) -> int:\\n n = len(h)\\n l,r = [1]*n, [1]*n\\n \\n for i in range(1,n):\\n j = i - 1\\n while j>=0 and h[j] >= h[i]: j -= l[j]\\n l[i] = i - j\\n \\n for i in reversed(range(n-1)):\\n j = i+1\\n while j < n and h[i] <= h[j]: j += r[j] \\n r[i] = j - i\\n \\n return max((l[i]+r[i])*h[i] -h[i] for i in range(n))\\n\\nf = open('user.out','w')\\nfor i in map(loads,stdin):\\n f.write(f'{Solution().largestRectangleArea(i)}\\\\n')\\nf.flush()\\nexit(0) \\n \",\n \"runtime\": \"225\"\n },\n {\n \"code\": \"def largestRectangleArea(heights: List[int]) -> int:\\n stack = []\\n ans = 0\\n for i, h in enumerate(heights):\\n idx = 1000000\\n if len(stack):\\n if h < stack[-1][0]:\\n while len(stack) and h < stack[-1][0]:\\n idx = min(stack[-1][1], idx)\\n ans = max(ans, stack[-1][0] * (i - stack[-1][1]))\\n stack.pop()\\n if idx == 1000000:\\n idx = i\\n stack.append((h, idx))\\n while len(stack):\\n ans = max(ans, stack[-1][0] * (len(heights) - stack[-1][1]))\\n stack.pop()\\n return ans\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads,stdin):\\n print(largestRectangleArea(i), file=f)\\n exit(0)\\n\",\n \"runtime\": \"234\"\n },\n {\n \"code\": \"def largestRectangleArea(heights: List[int]) -> int:\\n stack = []\\n ans = 0\\n n = len(heights)\\n\\n for idx in range(n - 1, -1, -1):\\n curr = heights[idx]\\n possible_start = idx\\n while stack and stack[-1][0] >= curr:\\n x, y = stack.pop()\\n possible_start = y\\n stack.append((curr, possible_start))\\n for el, idx1 in stack:\\n ans = max(ans, curr, el * (idx1 - idx + 1))\\n\\n return ans\\n\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads,stdin):\\n print(largestRectangleArea(i), file=f)\\n exit(0)\\n\",\n \"runtime\": \"242\"\n },\n {\n \"code\": \"# class Solution:\\n# def largestRectangleArea(self, heights: List[int]) -> int:\\n# stack=[-1]\\n# themax=0\\n# heights.append(0)\\n# for i in range(len(heights)):\\n\\n# while(heights[i]<heights[stack[-1]]):\\n# width=i-1-stack[-2]\\n# height=heights[stack[-1]]\\n# themax=max(width*height,themax)\\n# stack.pop()\\n# stack.append(i)\\n# return themax\\n\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n lis=[-1]\\n\\n themax=0\\n heights.append(-1)\\n for i in range(len(heights)):\\n if heights[i]!=heights[i-1]:\\n lis.append(i-1)\\n while heights[i]<heights[lis[-1]]:\\n pop=lis.pop()\\n if (i-lis[-1]-1)*heights[pop]>themax:\\n themax=(i-lis[-1]-1)*heights[pop]\\n \\n\\n return themax\\n\\n\\n\",\n \"runtime\": \"251\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n best=0\\n head=[0, 1, None ] #:[ h,w ]\\n\\n W=1\\n #print(head,best)\\n for i,h in enumerate(heights):\\n add=0\\n while True:\\n if h>head[0]:\\n head=[ h,1+add, head ]\\n break\\n elif h==head[0]:\\n head[1]+=1+add\\n break\\n else:\\n if head[0]*(head[1]+add) > best:\\n best=head[0]*(head[1]+add)\\n add+=head[1] \\n head=head[2] \\n #print(head,best)\\n add=0\\n while head is not None:\\n if head[0]*(head[1]+add) > best:\\n best=head[0]*(head[1]+add)\\n add+=head[1] \\n head=head[2] \\n\\n return best \\n\\n\\n\",\n \"runtime\": \"259\"\n },\n {\n \"code\": \"# class Solution:\\n# def largestRectangleArea(self, heights: List[int]) -> int:\\n # stack=[-1]\\n # themax=0\\n # heights.append(0)\\n # for i in range(len(heights)):\\n\\n # while(heights[i]<heights[stack[-1]]):\\n # width=i-1-stack[-2]\\n # height=heights[stack[-1]]\\n # themax=max(width*height,themax)\\n # stack.pop()\\n # stack.append(i)\\n # return themax\\n\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n lis=[-1]\\n\\n themax=0\\n heights.append(-1)\\n for i in range(len(heights)):\\n if heights[i]!=heights[i-1]:\\n lis.append(i-1)\\n while heights[i]<heights[lis[-1]]:\\n pop=lis.pop()\\n if (i-lis[-1]-1)*heights[pop]>themax:\\n themax=(i-lis[-1]-1)*heights[pop]\\n \\n\\n return themax\\n\",\n \"runtime\": \"267\"\n },\n {\n \"code\": \"# class Solution:\\n# def largestRectangleArea(self, heights: List[int]) -> int:\\n # stack=[-1]\\n # themax=0\\n # heights.append(0)\\n # for i in range(len(heights)):\\n\\n # while(heights[i]<heights[stack[-1]]):\\n # width=i-1-stack[-2]\\n # height=heights[stack[-1]]\\n # themax=max(width*height,themax)\\n # stack.pop()\\n # stack.append(i)\\n # return themax\\n\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n lis=[-1]\\n\\n themax=0\\n heights.append(-1)\\n for i in range(len(heights)):\\n if heights[i]!=heights[i-1]:\\n lis.append(i-1)\\n while heights[i]<heights[lis[-1]]:\\n pop=lis.pop()\\n if (i-lis[-1]-1)*heights[pop]>themax:\\n themax=(i-lis[-1]-1)*heights[pop]\\n \\n\\n return themax\\n\\n\\n\",\n \"runtime\": \"267\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n best=0\\n head=[0, 1, None ] #:[ h,w ]\\n\\n\\n for h in heights:\\n add=0\\n while True:\\n if h>head[0]:\\n head=[ h,1+add, head ]\\n break\\n elif h==head[0]:\\n head[1]+=1+add\\n break\\n else: \\n if (A:= head[0]*(head[1]+add)) > best:\\n best=A\\n add+=head[1] \\n head=head[2] \\n add=0\\n while head is not None:\\n if (A:= head[0]*(head[1]+add)) > best:\\n best=A\\n add+=head[1] \\n head=head[2] \\n\\n return best \\n\\n\\n\",\n \"runtime\": \"276\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n ls = len(heights)\\n heights.append(0)\\n a = []\\n m = 0\\n l = 0\\n for i, v in enumerate(heights):\\n if v > l:\\n a.append((i, v))\\n elif v < l:\\n while a and a[-1][1] >= v:\\n j, k = a.pop()\\n m = max(m, (i - j) * k)\\n a.append((j, v))\\n l = v\\n return m\\n\",\n \"runtime\": \"284\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n ls = len(heights)\\n heights.append(0)\\n a = []\\n m = 0\\n l = 0\\n for i, v in enumerate(heights):\\n if v > l:\\n a.append((i, v))\\n elif v < l:\\n while a and a[-1][1] >= v:\\n j, k = a.pop()\\n m = max(m, (i - j) * k)\\n a.append((j, v))\\n l = v\\n return m\\n\",\n \"runtime\": \"293\"\n },\n {\n \"code\": \"# class Solution:\\n# def largestRectangleArea(self, heights: List[int]) -> int:\\n# stack=[-1]\\n# themax=0\\n# heights.append(0)\\n# for i in range(len(heights)):\\n\\n# while(heights[i]<heights[stack[-1]]):\\n# width=i-1-stack[-2]\\n# height=heights[stack[-1]]\\n# themax=max(width*height,themax)\\n# stack.pop()\\n# stack.append(i)\\n# return themax\\n\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n lis=[-1]\\n themax=0\\n heights.append(-1)\\n for i in range(len(heights)):\\n if heights[i]!=heights[i-1]:\\n lis.append(i-1)\\n while heights[i]<heights[lis[-1]]:\\n pop=lis.pop()\\n if (i-lis[-1]-1)*heights[pop]>themax:\\n themax=(i-lis[-1]-1)*heights[pop]\\n \\n return themax\\n\\n\\n\\n# class Solution:\\n# def largestRectangleArea(self, heights: List[int]) -> int:\\n# lis=[-1]\\n\\n# themax=0\\n# heights.append(-1)\\n# s=set()\\n# for i in range(len(heights)):\\n# if heights[i]!=heights[i-1] and heights[i-1] not in s:\\n# lis.append(i-1)\\n# s.add(heights[i-1])\\n# while heights[i]<heights[lis[-1]]:\\n# pop=lis.pop()\\n# s.remove(heights[pop])\\n# if (i-lis[-1]-1)*heights[pop]>themax:\\n# themax=(i-lis[-1]-1)*heights[pop]\\n \\n\\n# return themax\\n\\n\\n\",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n mq = deque()\\n max_area = heights[0]\\n heights.append(0)\\n l = 0\\n for i, h in enumerate(heights):\\n if h > l:\\n mq.append((i, h))\\n elif h < l:\\n start = i\\n while len(mq) > 0 and h <= mq[-1][1]:\\n start, height = mq.pop()\\n area = (i - start) * height\\n max_area = max(max_area, area)\\n mq.append((start, h))\\n l = h\\n return max_area\\n\",\n \"runtime\": \"310\"\n },\n {\n \"code\": \"# class Solution:\\n# def largestRectangleArea(self, heights: List[int]) -> int:\\n # stack=[-1]\\n # themax=0\\n # heights.append(0)\\n # for i in range(len(heights)):\\n\\n # while(heights[i]<heights[stack[-1]]):\\n # width=i-1-stack[-2]\\n # height=heights[stack[-1]]\\n # themax=max(width*height,themax)\\n # stack.pop()\\n # stack.append(i)\\n # return themax\\n\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n lis=[-1]\\n # temp=heights[0]\\n themax=0\\n heights.append(-1)\\n for i in range(len(heights)):\\n if heights[i]!=heights[i-1]:\\n lis.append(i-1)\\n while heights[i]<heights[lis[-1]]:\\n pop=lis.pop() \\n themax=max(themax,(i-lis[-1]-1)*heights[pop])\\n # temp=heights[i]\\n return themax\\n\",\n \"runtime\": \"318\"\n },\n {\n \"code\": \"# Time complexity: O(n)\\n# Space complexity: O(n)\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [] # strictly increasing, currently viable heights\\n max_area = 0\\n \\n for i, height in enumerate(heights):\\n # Empty stack => add current\\n if not stack:\\n stack.append((i, height))\\n continue\\n\\n # Same height as before => skip\\n if stack[-1][1] == height:\\n continue\\n\\n # Current bar preserves previous bar\\n if stack[-1][1] < height:\\n stack.append((i, height))\\n continue\\n\\n # Current bar breaks one or more previous bars\\n starting_index = i\\n while stack and stack[-1][1] >= height:\\n # Pop and compute obtained area\\n eliminated_bar = stack.pop()\\n starting_index = eliminated_bar[0]\\n max_area = max(max_area, (i - eliminated_bar[0]) * eliminated_bar[1])\\n \\n stack.append((starting_index, height))\\n \\n for bar in stack:\\n max_area = max(max_area, (len(heights) - bar[0]) * bar[1])\\n\\n return max_area\\n\",\n \"runtime\": \"326\"\n },\n {\n \"code\": \"# class Solution:\\n# def largestRectangleArea(self, heights: List[int]) -> int:\\n # stack=[-1]\\n # themax=0\\n # heights.append(0)\\n # for i in range(len(heights)):\\n\\n # while(heights[i]<heights[stack[-1]]):\\n # width=i-1-stack[-2]\\n # height=heights[stack[-1]]\\n # themax=max(width*height,themax)\\n # stack.pop()\\n # stack.append(i)\\n # return themax\\n\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n lis=[-1]\\n temp=heights[0]\\n themax=0\\n heights.append(-1)\\n for i in range(len(heights)):\\n if heights[i]!=temp:\\n lis.append(i-1)\\n while heights[i]<heights[lis[-1]]:\\n pop=lis.pop() \\n themax=max(themax,(i-lis[-1]-1)*heights[pop])\\n # print(i,themax,lis)\\n temp=heights[i]\\n return themax\\n\",\n \"runtime\": \"335\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n best=0\\n head=[0, 1, None ] #:[ h,w ]\\n\\n W=1\\n #print(head,best)\\n for i,h in enumerate(heights):\\n add=0\\n while True:\\n if h>head[0]:\\n head=[ h,1+add, head ]\\n break\\n elif h==head[0]:\\n head[1]+=1+add\\n break\\n else:\\n if head[0]*(head[1]+add) > best:\\n best=head[0]*(head[1]+add)\\n add+=head[1] \\n head=head[2] \\n #print(head,best)\\n add=0\\n while head is not None:\\n if head[0]*(head[1]+add) > best:\\n best=head[0]*(head[1]+add)\\n add+=head[1] \\n head=head[2] \\n\\n return best \\n\\n\\n\",\n \"runtime\": \"343\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n if len(heights) ==0:\\n return 0\\n\\n if len(heights) == 1:\\n return heights[0]\\n\\n\\n stack = []\\n\\n i = 1\\n stack.append((0, heights[0]))\\n max_area = 0\\n\\n for i in range(len(heights)):\\n if stack:\\n if heights[i]< stack[-1][1]:\\n popped_index = i\\n while stack and heights[i]< stack[-1][1]:\\n popped_index, popped_element = stack.pop()\\n max_area = max(max_area, popped_element * (i-popped_index))\\n stack.append((popped_index, heights[i]))\\n elif heights[i] == stack[-1][1]:\\n\\n continue\\n else:\\n stack.append((i, heights[i]))\\n else:\\n stack.append((i, heights[i]))\\n\\n N = len(heights)\\n for index, element in stack:\\n max_area = max( (N-index)*element, max_area)\\n\\n return max_area\\n\\n \",\n \"runtime\": \"352\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n begin_h = [(0, heights[0])]\\n max_rec = 0\\n n = len(heights)\\n for i in range(1, n):\\n top_i, top_h = begin_h[-1]\\n cur_h = heights[i]\\n\\n if cur_h < top_h:\\n while begin_h and cur_h < begin_h[-1][1]:\\n top_i, top_h = begin_h.pop()\\n length = i - top_i\\n max_rec = max(length * top_h, max_rec)\\n \\n begin_h.append((top_i, cur_h))\\n\\n if cur_h > top_h:\\n begin_h.append((i, cur_h))\\n \\n\\n while(begin_h):\\n top_i, top_h = begin_h.pop()\\n length = n - top_i\\n max_rec = max(length * top_h, max_rec)\\n \\n return max_rec\",\n \"runtime\": \"360\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, h: List[int]) -> int:\\n st=[]\\n h.append(0) #so all eles in h will be processed also end ones if they are in asce.\\n max_area=0\\n prev=0\\n\\n for i,v in enumerate(h):\\n if v>prev: st.append((i,v))\\n elif v<prev:\\n while st and st[-1][1]>v:\\n j,v_prev=st.pop()\\n max_area=max(max_area,(i-j)*v_prev)\\n st.append((j,v))\\n prev=v\\n return max_area\\n\\n \",\n \"runtime\": \"369\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self,heights: List[int]) -> int:\\n n = len(heights)\\n max_area = 0\\n stack = []\\n for j in range(n):\\n h = heights[j]\\n while stack and h < heights[stack[-1]]:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (j - left)\\n if area > max_area:\\n max_area = area\\n stack.append(j)\\n while stack:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (n - left)\\n if area > max_area:\\n max_area = area\\n return max_area\",\n \"runtime\": \"377\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n maxRect = 0\\n stack = [] # (start index, height)\\n for i, val in enumerate(heights):\\n if not stack:\\n stack.append((i, val))\\n elif stack[-1][1] < val:\\n stack.append((i, val))\\n elif stack[-1][1] == val:\\n continue\\n else:\\n ind, height = 0,0\\n while stack and stack[-1][1] > val:\\n ind, height = stack.pop()\\n if height * ((i) - ind) > maxRect:\\n maxRect = height * ((i) - ind)\\n\\n stack.append((ind, val))\\n # print(stack)\\n\\n while stack:\\n ind, height = stack.pop()\\n if height * ((len(heights)) - ind) > maxRect:\\n maxRect = height * ((len(heights)) - ind)\\n return maxRect\\n\\n\",\n \"runtime\": \"386\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n maxSquare = 0\\n\\n for index, height in enumerate(heights):\\n if not stack:\\n stack.append([height, index])\\n continue\\n\\n stackHeight, stackIndex = stack[-1]\\n\\n if height == stackHeight:\\n continue\\n elif height > stackHeight:\\n stack.append([height, index])\\n else:\\n while stack and height < stack[-1][0]:\\n stackHeight, stackIndex = stack.pop()\\n maxSquare = max(maxSquare, stackHeight * (index - stackIndex))\\n stack.append([height, stackIndex])\\n\\n for height in stack:\\n maxSquare = max(maxSquare, height[0] * (len(heights) - height[1]))\\n\\n return maxSquare\\n\",\n \"runtime\": \"394\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [[0, heights[0]]]\\n lens = 1\\n maxa = heights[0]\\n n = len(heights)\\n for i in range(1, n):\\n ind = i\\n if heights[i] == stack[-1][1]:\\n # area = stack[-1][1]*(i - stack[-1][0])\\n # if area > maxa:\\n # maxa = area\\n continue\\n while heights[i] < stack[-1][1]:\\n p = stack.pop()\\n ind = p[0]\\n lens-=1\\n area = p[1]*(i - p[0])\\n if area > maxa:\\n maxa = area\\n if lens==0:\\n break\\n stack.append([ind, heights[i]])\\n lens+=1\\n for i in stack:\\n area = i[1]*(n - i[0])\\n if area > maxa:\\n maxa = area\\n return maxa\",\n \"runtime\": \"402\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack, n, res = [-1], len(heights), 0\\n heights.append(-1)\\n for i,h in enumerate(heights):\\n while heights[stack[-1]] > h:\\n j = stack.pop()\\n cur = heights[j] * (i-stack[-1]-1)\\n if res < cur: res = cur\\n stack.append(i)\\n return res\",\n \"runtime\": \"411\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n n = len(heights)\\n if n == 0:\\n return 0\\n if n == 1:\\n return heights[0]\\n left = 0\\n height = heights[0]\\n maxVal = 0\\n for right in range(1, n):\\n if heights[right-1] > heights[right]:\\n maxVal = max(maxVal, (right - left) * height)\\n height = heights[right]\\n while stack and stack[-1][0] >= height:\\n left = stack[-1][1]\\n maxVal = max(maxVal, (right - stack[-1][1]) * stack[-1][0])\\n stack.pop()\\n if heights[right-1] < heights[right]:\\n stack.append((height, left))\\n left = right\\n height = heights[right]\\n maxVal = max(maxVal, (n - left) * height)\\n while stack:\\n maxVal = max(maxVal, (n - stack[-1][1]) * stack[-1][0])\\n stack.pop()\\n return maxVal\\n \",\n \"runtime\": \"419\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n res = -inf\\n\\n hStack = []\\n pStack = []\\n\\n for i in range(len(heights)):\\n if not hStack or heights[i] > hStack[-1]:\\n hStack.append(heights[i])\\n pStack.append(i)\\n elif heights[i] < hStack[-1]:\\n while hStack and heights[i] < hStack[-1]:\\n height = hStack.pop()\\n idx = pStack.pop()\\n area = height * (i-idx)\\n res = max(res, area)\\n hStack.append(heights[i])\\n pStack.append(idx)\\n \\n while (hStack):\\n pos = len(heights)\\n h = hStack.pop()\\n i = pStack.pop()\\n\\n area = h * (pos-i)\\n res = max(res, area)\\n return res\",\n \"runtime\": \"428\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n if len(heights) == 1:\\n return heights[0]\\n s = [[heights[0], 1]]\\n th, tw = s[-1]\\n res = heights[0]\\n\\n for h in itertools.chain(itertools.islice(heights, 1, len(heights)), [0]):\\n w = 1\\n if s and h <= th:\\n while s and h < th:\\n ph, pw = s.pop()\\n th, tw = s[-1] if s else (None, None)\\n w += pw\\n area = (w - 1) * ph\\n if area > res:\\n res = area\\n if s and h == th:\\n tw += w\\n s[-1] = (h, tw)\\n continue\\n th, tw = h, w\\n s.append((th, tw))\\n return res\",\n \"runtime\": \"436\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n rectangles = []\\n max_area = 0\\n\\n for i, height in enumerate(heights):\\n if not rectangles or rectangles[-1][1] < height:\\n rectangles.append((i, height))\\n elif rectangles[-1][1] == height:\\n continue\\n else:\\n while rectangles: \\n if not rectangles[-1][1] > height:\\n break\\n last_index, last_height = rectangles[-1]\\n max_area = max(max_area, last_height * (i - last_index))\\n rectangles.pop()\\n rectangles.append((last_index, height))\\n \\n for index, height in rectangles:\\n max_area = max(max_area, height * (len(heights) - index))\\n \\n return max_area\\n \\n \\n\\n \\n\",\n \"runtime\": \"445\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights.insert(0, 0)\\n heights.append(0)\\n\\n st = [0]\\n res = 0\\n for i in range(1, len(heights)):\\n if heights[i] >= heights[st[-1]]:\\n st.append(i)\\n else:\\n while st and heights[i] < heights[st[-1]]:\\n midIdx = st.pop()\\n # If the heights are the same, it means it can extend further. \\n # So we should pop it out and continue to find the shorter one.\\n while st and heights[midIdx] == heights[st[-1]]:\\n st.pop()\\n # Stack still contains stuff, because we insert 0 at the front of the heights list.\\n # So we can directly access st[-1]\\n leftIdx = st[-1]\\n w = i - leftIdx - 1\\n res = max(res, w * heights[midIdx])\\n st.append(i)\\n return res\\n \\n \",\n \"runtime\": \"453\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights.append(0)\\n stack = []\\n res = 0\\n\\n for i in range(len(heights)):\\n while stack and heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i if not stack else i - stack[-1] - 1\\n area = h * w\\n if area > res:\\n res = area\\n stack.append(i)\\n \\n return res\",\n \"runtime\": \"461\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n maxArea = 0\\n stack = [] # startIdx, height\\n heights.append(0) # allows us to clear out stack without extra logic\\n for curI, curH in enumerate(heights):\\n # don't need to append if we already have the value with a lower startIdx\\n if stack and curH == stack[-1][1]:\\n continue\\n minStartIdx = curI\\n while stack and curH < stack[-1][1]:\\n startIdx, lastHeight = stack.pop()\\n minStartIdx = startIdx\\n maxArea = max(maxArea, lastHeight * (curI - startIdx))\\n stack.append((minStartIdx, curH))\\n return maxArea\",\n \"runtime\": \"470\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n pos = [-1]\\n heights.append(0)\\n area = 0\\n for i in range(len(heights)):\\n while heights[i] < heights[pos[-1]]:\\n h = heights[pos.pop()]\\n w = i - pos[-1] - 1\\n curr = h * w\\n if curr > area:\\n area = curr\\n pos.append(i)\\n heights.pop()\\n return area\",\n \"runtime\": \"478\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [[0, heights[0]]]\\n lens = 1\\n # heights.append(0)\\n # print(heights)\\n maxa = heights[0]\\n n = len(heights)\\n for i in range(1, n):\\n # print(stack)\\n ind = i\\n if heights[i] == stack[-1][1]:\\n area = stack[-1][1]*(i - stack[-1][0])\\n if area > maxa:\\n maxa = area\\n continue\\n while heights[i] < stack[-1][1]:\\n p = stack.pop()\\n ind = p[0]\\n lens-=1\\n area = p[1]*(i - p[0])\\n if area > maxa:\\n maxa = area\\n if lens==0:\\n break\\n # x = heights[i]\\n # indt = ind\\n # for j in range(ind-1, -1, -1):\\n # print(i)\\n # if heights[j] >= x:\\n # indt = j\\n # else:\\n # break\\n stack.append([ind, heights[i]])\\n lens+=1\\n for i in stack:\\n area = i[1]*(n - i[0])\\n if area > maxa:\\n maxa = area\\n return maxa\",\n \"runtime\": \"487\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n a, st = 0, []\\n\\n for i, num in enumerate(heights):\\n stidx = i\\n while st and st[-1][1]>num:\\n idx, val = st.pop()\\n stidx = idx\\n a = max(val*(i-idx), a)\\n if not st or st[-1][1]<num:\\n st.append((stidx, num))\\n\\n for idx, val in st:\\n a = max(val*(len(heights)-idx), a)\\n\\n return a\",\n \"runtime\": \"495\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n best=0\\n head=[0, 1, None ] #:[ h,w ]\\n\\n W=1\\n #print(head,best)\\n for i,h in enumerate(heights):\\n add=0\\n while True:\\n if h>head[0]:\\n head=[ h,1+add, head ]\\n break\\n elif h==head[0]:\\n head[1]+=1+add\\n break\\n else:\\n \\n if (A:= head[0]*(head[1]+add)) > best:\\n best=A\\n add+=head[1] \\n head=head[2] \\n #print(head,best)\\n add=0\\n while head is not None:\\n if (A:= head[0]*(head[1]+add)) > best:\\n best=A\\n add+=head[1] \\n head=head[2] \\n\\n return best \\n\\n\\n\",\n \"runtime\": \"504\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n ans: int = 0\\n stack: list[tuple[int, int]] = [(0, heights[0])]\\n for i in range(1, len(heights)):\\n if heights[i] > stack[-1][1]:\\n stack.append((i, heights[i]))\\n elif heights[i] < stack[-1][1]:\\n last_index = -1\\n while stack and heights[i] < stack[-1][1]:\\n last_index, last_height = stack.pop()\\n ans = max(ans, last_height * (i-last_index))\\n if not stack or heights[i] > stack[-1][1]:\\n # meaning there is not exactly heights[i] at stack[-1]\\n assert last_index != -1\\n stack.append((last_index, heights[i]))\\n while stack:\\n last_index, last_height = stack.pop()\\n ans = max(ans, last_height * (len(heights)-last_index))\\n return ans\\n\",\n \"runtime\": \"512\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n '''\\n for each bar, we extend both sides until lbar_h >= cbar_h or rbar_h >= cbar_h\\n find area and compare against maxx\\n TLE\\n '''\\n \\\"\\\"\\\"\\n max_area = 0\\n # cur_left_areas = [0]*len(heights)\\n \\n for cbar_i, cbar_h in enumerate(heights):\\n lbar_i = cbar_i-1\\n if lbar_i>0 and heights[lbar_i]==cbar_h:\\n continue\\n \\n while True:\\n if lbar_i < 0: break\\n if heights[lbar_i]>=cbar_h:\\n lbar_i-=1\\n else:\\n break\\n\\n cur_left_area = cbar_h*(cbar_i - lbar_i)\\n # cur_left_areas[cbar_i] = cur_left_area\\n \\n rbar_i = cbar_i+1\\n while True:\\n if rbar_i >= len(heights): break\\n if heights[rbar_i]>=cbar_h:\\n rbar_i+=1\\n else:\\n break\\n right_area = cbar_h*(rbar_i - cbar_i - 1)\\n print(cur_left_area, right_area)\\n cur_area = cur_left_area+right_area\\n max_area = max(max_area, cur_area)\\n return max_area\\n \\\"\\\"\\\"\\n \\n # Attempt 2\\n '''\\n Use stack to hold the tuple of height and idx, keep adding until a lower height is encountered\\n when lower is enc start popping, until it is no longer lower. \\n add to stack last popped idx and new height\\n '''\\n\\n maxx = 0\\n n = len(heights)\\n stack = []\\n stack.append((heights[0], 0))\\n i = 0\\n for i, height in enumerate(heights):\\n if height > stack[-1][0]:\\n stack.append((height, i))\\n elif height == stack[-1][0]:\\n pass\\n else:\\n while stack and height < stack[-1][0]:\\n popped_h, popped_i = stack.pop()\\n area = popped_h*(i-popped_i)\\n maxx = max(maxx, area)\\n stack.append((height, popped_i))\\n \\n while stack:\\n popped_h, popped_i = stack.pop()\\n area = popped_h*(n-popped_i)\\n maxx = max(maxx, area)\\n \\n return maxx\\n\",\n \"runtime\": \"521\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [0]\\n heights.insert(0, 0)\\n heights.append(0)\\n result = 0\\n for i in range(1, len(heights)):\\n if heights[i] > heights[stack[-1]]:\\n stack.append(i)\\n elif heights[i] == heights[stack[-1]]:\\n stack.pop()\\n stack.append(i)\\n else:\\n while stack and heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i - stack[-1] - 1\\n result = max(result, h * w)\\n stack.append(i)\\n return result\",\n \"runtime\": \"529\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # index, number Max: 10\\n # \\n #\\n # \\n # \\n\\n #monotonic increasing stack\\n\\n stack = []\\n max_height = float(-inf)\\n\\n for i, num in enumerate(heights):\\n if not stack: stack.append((i,num))\\n else:\\n if num > stack[-1][1]: stack.append((i,num))\\n elif num < stack[-1][1]:\\n while stack and num < stack[-1][1]:\\n index, number = stack.pop()\\n max_height = max(max_height, number * (i - index))\\n stack.append((index,num))\\n\\n \\n while stack:\\n index,number = stack.pop()\\n max_height = max(max_height, number * (len(heights) - index))\\n \\n return max_height\\n\",\n \"runtime\": \"537\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [] # (value, index)\\n n = len(heights)\\n maxArea = 0\\n\\n for i in range(n):\\n if not len(stack) or stack[-1][0] < heights[i]:\\n stack.append((heights[i], i))\\n elif heights[i] < stack[-1][0]:\\n ni = i\\n while len(stack) and stack[-1][0] >= heights[i]:\\n sv, ni = stack.pop()\\n maxArea = max(maxArea, (i - ni) * sv)\\n stack.append((heights[i], ni))\\n\\n while len(stack):\\n v, i = stack.pop()\\n maxArea = max(maxArea, (n - i) * v)\\n\\n return maxArea\",\n \"runtime\": \"537\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n max_height = float(-inf)\\n\\n for i, num in enumerate(heights):\\n if not stack: stack.append((i,num))\\n else:\\n if num > stack[-1][1]: stack.append((i,num))\\n elif num < stack[-1][1]:\\n while stack and num < stack[-1][1]:\\n index, number = stack.pop()\\n max_height = max(max_height, number * (i - index))\\n stack.append((index,num))\\n\\n \\n while stack:\\n index,number = stack.pop()\\n max_height = max(max_height, number * (len(heights) - index))\\n \\n return max_height\\n\",\n \"runtime\": \"546\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [] # (value, index)\\n n = len(heights)\\n maxArea = 0\\n\\n for i in range(n):\\n if not len(stack) or stack[-1][0] < heights[i]:\\n stack.append((heights[i], i))\\n elif heights[i] < stack[-1][0]:\\n ni = i\\n while len(stack) and stack[-1][0] >= heights[i]:\\n sv, ni = stack.pop()\\n maxArea = max(maxArea, (i - ni) * sv)\\n stack.append((heights[i], ni))\\n\\n while len(stack):\\n v, i = stack.pop()\\n maxArea = max(maxArea, (n - i) * v)\\n\\n return maxArea\",\n \"runtime\": \"554\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n\\n s = []\\n ans = 0\\n for i, height in enumerate(heights + [0]):\\n while s and heights[s[-1]] > height:\\n h = heights[s.pop()]\\n w = i if not s else i - s[-1] - 1\\n if ans < h * w:\\n ans = h * w\\n s.append(i)\\n\\n return ans\\n\",\n \"runtime\": \"563\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n = len(heights)\\n max_area = 0\\n stack = []\\n for j in range(n):\\n h = heights[j]\\n while stack and h < heights[stack[-1]]:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (j - left)\\n if area > max_area:\\n max_area = area\\n stack.append(j)\\n while stack:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (n - left)\\n if area > max_area:\\n max_area = area\\n return max_area\",\n \"runtime\": \"571\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n = len(heights)\\n stack = []\\n ans = 0\\n for i, height in enumerate(heights):\\n if not stack or height > stack[-1][1]:\\n stack.append((i, height))\\n elif height < stack[-1][1]:\\n curr_i = 0\\n while stack and height <= stack[-1][1]:\\n curr_i, curr_height = stack.pop()\\n ans = max(ans, curr_height * (i - curr_i))\\n stack.append((0 if not stack else curr_i, height))\\n\\n \\n for (i, height) in stack:\\n ans = max(ans, height * (n - i))\\n return ans\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"580\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # 输入数组首尾各补上一个0（与42.接雨水不同的是，本题原首尾的两个柱子可以作为核心柱进行最大面积尝试\\n heights.insert(0, 0)\\n heights.append(0)\\n stack = [0]\\n result = 0\\n for i in range(1, len(heights)):\\n # 情况一\\n if heights[i] > heights[stack[-1]]:\\n stack.append(i)\\n # 情况二\\n elif heights[i] == heights[stack[-1]]:\\n stack.pop()\\n stack.append(i)\\n # 情况三\\n else:\\n # 抛出所有较高的柱子\\n while stack and heights[i] < heights[stack[-1]]:\\n # 栈顶就是中间的柱子，主心骨\\n mid_index = stack[-1]\\n stack.pop()\\n if stack:\\n left_index = stack[-1]\\n right_index = i\\n width = right_index - left_index - 1\\n height = heights[mid_index]\\n result = max(result, width * height)\\n stack.append(i)\\n return result\\n\\n\",\n \"runtime\": \"588\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights.insert(0,0)\\n heights.append(0)\\n #print(heights)\\n result = 0\\n stack = []\\n stack.append(0)\\n for i in range(1, len(heights)):\\n if heights[stack[-1]] < heights[i]:\\n stack.append(i)\\n elif heights[stack[-1]] == heights[i]:\\n stack.pop()\\n stack.append(i)\\n else:\\n while stack and heights[stack[-1]] > heights[i]:\\n mid = stack[-1]\\n stack.pop()\\n if stack:\\n left = stack[-1]\\n right = i\\n #h = [heights[left], heights[mid], heights[right], min(heights[left], heights[right])]\\n #w = [right - left, right - left - 1, right - left, right - left + 1]\\n \\n #area = max(h[0]*w[0], h[1]*w[1],h[2]*w[2],h[3]*w[3])\\n area = heights[mid] *(right - left - 1)\\n\\n\\n\\n #print(h[0]*w[0], h[1]*w[1],h[2]*w[2],h[3]*w[3])\\n result = max(result, area)\\n stack.append(i)\\n return result\\n\\n\\n\\n \",\n \"runtime\": \"596\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n if not heights:\\n return 0\\n heights.insert(0, 0)\\n heights.append(0)\\n s = [0]\\n ret = 0\\n # maintain an ordered stack: decreasing\\n # reason: once find smaller, left larger ones not important\\n # in future areas\\n for i in range(1, len(heights)):\\n # check\\n if heights[i] > heights[s[-1]]:\\n s.append(i)\\n elif heights[i] == heights[s[-1]]:\\n s.pop()\\n s.append(i)\\n else:\\n while s and heights[i] < heights[s[-1]]:\\n mid = s[-1]\\n s.pop()\\n if s:\\n l = s[-1]\\n r = i\\n w = r - l - 1\\n h = heights[mid]\\n ret = max(ret, w * h)\\n s.append(i)\\n return ret\",\n \"runtime\": \"605\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n max_area = 0\\n\\n stack = []\\n # while popping you know that every previously popped value was greater\\n # so the max possible rectangle area with h as the height is h*(1+number popped already)\\n # we pop and forget because once a smaller element is seen that becomes the cap for any rectangle\\n\\n for current_index, h in enumerate(heights):\\n while stack and h <= heights[stack[-1]]:\\n popped = stack.pop(-1)\\n if not stack:\\n local_area = heights[popped]*(current_index)\\n else:\\n local_area = heights[popped]*(current_index-stack[-1]-1)\\n if local_area > max_area:\\n max_area = local_area\\n \\n stack.append(current_index)\\n\\n current_index += 1\\n while stack:\\n popped = stack.pop(-1)\\n if not stack:\\n local_area = heights[popped]*(current_index)\\n else:\\n local_area = heights[popped]*(current_index-stack[-1]-1)\\n if local_area > max_area:\\n max_area = local_area\\n return max_area\\n\",\n \"runtime\": \"622\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def largestRectangleArea(self, hist: List[int]) -> int:\\n stack = []\\n result = 0\\n for i, height in enumerate(hist):\\n start = None\\n while stack and stack[-1][-1] > height:\\n start, h = stack.pop()\\n result = max(result, h*(i-start))\\n if not stack or height > stack[-1][-1]:\\n start = start if start is not None else i\\n stack.append((start,height))\\n n = len(hist)\\n while stack:\\n i, height = stack.pop()\\n result = max(result, height*(n-i))\\n return result\",\n \"runtime\": \"622\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n list_stack = list()\\n\\n max_area = 0 \\n for i in range(len(heights)):\\n if i == 0 or heights[i] > heights[i-1]:\\n list_stack.append((heights[i], i))\\n elif heights[i] < heights[i-1]:\\n prev_index = i\\n while len(list_stack) > 0 and list_stack[-1][0] >= heights[i]:\\n stack_height, stack_index = list_stack.pop()\\n max_area = max(max_area, (i - stack_index) * stack_height)\\n prev_index = stack_index\\n if heights[i] > 0:\\n list_stack.append((heights[i], prev_index))\\n while len(list_stack) > 0:\\n stack_height, stack_index = list_stack.pop()\\n max_area = max(max_area, (len(heights) - stack_index) * stack_height)\\n\\n return max_area\\n \",\n \"runtime\": \"630\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n area = heights[0]\\n for i, h in enumerate(heights):\\n if not stack or heights[stack[-1]] <= h:\\n stack.append(i)\\n continue\\n \\n while stack and heights[stack[-1]] > h:\\n pos = stack.pop()\\n area = max(area, heights[pos] * (i - pos))\\n \\n stack.append(pos)\\n heights[pos] = h\\n \\n i = len(heights)\\n while stack:\\n idx = stack.pop()\\n area = max(area, heights[idx] * (i - idx))\\n return area\\n\",\n \"runtime\": \"630\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n\\n maxArea = max(heights)\\n stack = []\\n\\n for i in range(len(heights)):\\n\\n\\n while stack and heights[stack[-1]] > heights[i]:\\n currIndex = stack.pop()\\n nextSmaller = i\\n prevSmaller = stack[-1] if stack else -1\\n\\n # dist between two smaller ele\\n width = nextSmaller - prevSmaller -1 \\n maxArea = max(maxArea, width * heights[currIndex])\\n\\n stack.append(i)\\n\\n\\n # if stack still has ele\\n n = len(heights)\\n while stack:\\n currIndex = stack.pop()\\n nextSmaller = n\\n prevSmaller = stack[-1] if stack else -1\\n # dist between two smaller ele\\n width = nextSmaller - prevSmaller -1\\n maxArea = max(maxArea, width * heights[currIndex])\\n \\n return maxArea\",\n \"runtime\": \"639\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n \\n stack = [-1]\\n area = 0\\n\\n for i in range(len(heights)):\\n\\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]: \\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1 \\n area = max(area, height * width)\\n \\n stack.append(i)\\n \\n while stack[-1] != -1:\\n height = heights[stack.pop()]\\n width = len(heights) - stack[-1] - 1 \\n area = max(area, height * width)\\n\\n return area\",\n \"runtime\": \"639\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n max_area = 0\\n stack = [-1] # unified with empty case\\n for i in range(len(heights)):\\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n stack.append(i)\\n while stack[-1] != -1:\\n height = heights[stack.pop()]\\n width = len(heights) - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n return max_area\",\n \"runtime\": \"647\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n max_area = 0\\n\\n for i, h in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n width = i - index\\n max_area = max(max_area, height * width)\\n start = index\\n stack.append((start,h))\\n\\n \\n\\n for i, h in stack:\\n width = (len(heights)- i)\\n max_area = max(max_area, width * h)\\n \\n return max_area\",\n \"runtime\": \"647\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stk = [-1]\\n heights.append(0)\\n ans = 0\\n for i in range(len(heights)):\\n curr_height = heights[i]\\n while curr_height < heights[stk[-1]]:\\n h = heights[stk.pop()]\\n w = i - stk[-1] - 1\\n ans = max(ans, h * w)\\n stk.append(i)\\n return ans\",\n \"runtime\": \"656\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [-1]\\n max_area = 0\\n\\n for i in range(len(heights)):\\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n stack.append(i)\\n \\n while stack[-1] != -1:\\n height = heights[stack.pop()]\\n width = len(heights) - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n \\n return max_area\",\n \"runtime\": \"656\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # OK\\n # stack = []\\n # max_area = 0\\n # heights = [0] + heights + [0] # Add dummy bars to simplify the code\\n\\n # for i in range(len(heights)):\\n # # While the current bar is lower than the bar at the top of the stack\\n # while stack and heights[stack[-1]] > heights[i]:\\n # # Calculate the area of the rectangle with the bar at the top of the stack as the smallest bar\\n # h = heights[stack.pop()]\\n # w = i - stack[-1] - 1\\n # max_area = max(max_area, h * w)\\n # # Push the index of the current bar onto the stack\\n # stack.append(i)\\n\\n # return max_area\\n\\n # Practice:\\n st = []\\n area = 0\\n heights = [-1] + heights + [-1] # some low value (0 works)\\n # ^ to reference left boundary\\n # ^ to process as k the last, nth element from original list\\n\\n for i,a in enumerate(heights):\\n while(st and heights[st[-1]] > a):\\n rr = i\\n k = st.pop() # pop first\\n ll = st[-1] # stack maintains next smaller index to left (larger values already popped)\\n h = heights[k]\\n length = rr - ll - 1 \\n area = max(area, heights[k] * length)\\n\\n st.append(i)\\n\\n return area\",\n \"runtime\": \"664\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n maxArea = 0\\n stack = [] # pairs of index,height\\n for i,h in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n maxArea = max(maxArea, height * (i-index))\\n start = index\\n stack.append((start,h))\\n\\n for i,h in stack:\\n maxArea = max(maxArea, h * (len(heights) - i))\\n return maxArea\",\n \"runtime\": \"664\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # Naive Approach (TLE)\\n # Time: O(N^2), Space: O(1)\\n # n = len(heights)\\n # max_area = 0\\n # for i in range(n):\\n # l = i\\n # while l - 1 >= 0 and heights[l - 1] >= heights[i]:\\n # l -= 1\\n # r = i\\n # while r + 1 < n and heights[r + 1] >= heights[i]:\\n # r += 1\\n # curr_rect_area = heights[i] * (r - l + 1)\\n # max_area = max(max_area, curr_rect_area)\\n # return max_area\\n\\n # Approach: Stack\\n # Time: O(N), Space: O(N)\\n max_area = 0\\n stack = []\\n\\n for i, h in enumerate(heights):\\n # print('idx', i, h)\\n if not stack:\\n stack.append((i, h))\\n # print('one', stack)\\n else:\\n if h >= stack[-1][1]:\\n stack.append((i, h))\\n # print('two', stack)\\n else:\\n while stack and h < stack[-1][1]:\\n # print('three', stack)\\n i_, h_ = stack.pop()\\n curr_rect_area = (i - i_) * h_\\n max_area = max(max_area, curr_rect_area)\\n if not stack:\\n stack.append((0, h))\\n # print('four', stack)\\n else:\\n # make left boundary same as that of last popped block\\n stack.append((i_, h))\\n # print('five', stack)\\n \\n while stack:\\n # print('six', stack)\\n i_, h_ = stack.pop()\\n curr_rect_area = (len(heights) - i_) * h_\\n max_area = max(max_area, curr_rect_area)\\n\\n return max_area\",\n \"runtime\": \"672\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [-1]\\n max_area = 0\\n\\n for i in range(len(heights)):\\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n stack.append(i)\\n \\n while stack[-1] != -1:\\n height = heights[stack.pop()]\\n width = len(heights) - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n \\n return max_area\",\n \"runtime\": \"672\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stk = [-1]\\n heights.append(0)\\n ans = 0\\n for i in range(len(heights)):\\n curr_height = heights[i]\\n while curr_height < heights[stk[-1]]:\\n h = heights[stk.pop()]\\n w = i - stk[-1] - 1\\n ans = max(ans, h * w)\\n stk.append(i)\\n return ans\",\n \"runtime\": \"681\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stk = [] #(height,idex)\\n maxarea = 0\\n #Monotonic Increasing\\n for i,h in enumerate(heights):\\n start = i\\n while stk and stk[-1][0] > h:\\n height,index = stk.pop()\\n area = (i - index)* (height)\\n maxarea = max(maxarea,area)\\n start = index \\n stk.append((h,start))\\n\\n for h,i in stk:\\n maxarea = max(maxarea,(len(heights)-i)*h)\\n return maxarea\",\n \"runtime\": \"681\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n ans = 0\\n for i in range(len(heights)):\\n start = i\\n while stack and stack[-1][-1] > heights[i]:\\n index ,h = stack.pop()\\n ans = max(ans, h *(i-index))\\n start = index\\n stack.append([start,heights[i]])\\n while stack:\\n i,h = stack.pop()\\n ans = max(ans,h *(len(heights)-i))\\n return ans\\n\\n \\n \",\n \"runtime\": \"689\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n max_area = 0\\n heights.append(0) # Add a 0 at the end to pop all remaining heights\\n \\n for i, h in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n max_area = max(max_area, height * (i - index))\\n start = index\\n stack.append((start, h))\\n \\n return max_area\",\n \"runtime\": \"689\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # building a monotonously increasing stack, then go thorugh it\\n stack = [-1]\\n max_area = 0\\n for i in range(len(heights)):\\n # first pop\\n while stack[-1] != -1 and heights[stack[-1]] > heights[i]:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1\\n max_area = max(max_area, width * height)\\n # then insert\\n stack.append(i)\\n # keep popping, now right limit is len(heights)\\n while stack[-1] != -1:\\n height = heights[stack.pop()]\\n width = len(heights) - stack[-1] - 1\\n max_area = max(max_area, width * height)\\n return max_area\",\n \"runtime\": \"698\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n stack.append([0, heights[0]])\\n curr = 1\\n maxarea = max(heights)\\n\\n while curr<len(heights):\\n start = curr\\n while stack and heights[curr] < stack[-1][1]:\\n index, height = stack.pop()\\n maxarea = max(maxarea, (curr-index)*height)\\n start = index\\n stack.append([start, heights[curr]])\\n curr +=1\\n\\n #can use a for loop instead\\n #for index, height in enumerate(heights):\\n # start = index\\n # while stack and height < stack[-1][1]:\\n # idx, hei = stack.pop()\\n # maxarea = max(maxarea, (index-idx)*height)\\n # start = idx\\n # stack.append([start, height])\\n\\n #leftovers in the stack are the ones that can be extended to the end of the histogram\\n for index, height in stack:\\n maxarea = max(maxarea, height*(len(heights)-index))\\n\\n return maxarea\\n\\n \",\n \"runtime\": \"698\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n ans = 0\\n for i, h in enumerate(heights):\\n if not stack or heights[stack[-1]] < h:\\n stack.append(i)\\n continue\\n \\n while stack and h <= heights[stack[-1]]:\\n idx = stack.pop()\\n ans = max(ans, (i - idx) * heights[idx])\\n \\n heights[idx] = h\\n stack.append(idx)\\n \\n end = len(heights)\\n while stack:\\n idx = stack.pop()\\n ans = max(ans, (end - idx) * heights[idx])\\n return ans\",\n \"runtime\": \"706\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n maxArea = 0\\n\\n for i, h in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > h:\\n idx, height = stack.pop()\\n maxArea = max(maxArea, height * (i - idx))\\n start = idx\\n stack.append((start, h))\\n \\n for i, h in stack:\\n maxArea = max(maxArea, h * (len(heights) - i))\\n \\n return maxArea\",\n \"runtime\": \"706\"\n },\n {\n \"code\": \"# in: int[] heights\\n# out: largest rectangle in histogram\\n\\n# can be combined from different bars\\n# all ints\\n# all positive\\n\\n# we could have a bar of width 1 that is so tall it is the biggest\\n# at any given point, the max area is the smallest bar to the left/right times width\\n# we could expand out from each bar and compare max area at each point\\n# what if we tried pointers?\\n# come in from left + right and at each point, we consider the best possible area\\n# we can essentially shrink the taller nums to the left once we hit a smaller num\\n# we could build a new array of increasing nums from left and right\\n# at each num, we essentially need to know the left + right index that it can stretch to\\n# since we want to account for the max we can go to the left, what if we use a stack?\\n# do we need a second stack to the right? maybe\\n# go across the array, then when we get to a num that is smaller than the last (or min so far?)\\n# we should track indices of nums as well so we know how far to the left a height goes\\n# ok so use a stack, then pop so we get back to something shorter than prev num\\n# each time we hit a shorter num, we know the height to the left has reached its best chance\\n# multiply the top num by the distance to the next top el in the stack\\n# keep popping until we reach something shorter thasn right num\\n# keep going to end of list\\n\\n# T: O(N), moving across array once and popping up to once (2N)\\n# S: O(N) for stack\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n if not heights:\\n return 0\\n max_area = 0\\n stack = []\\n for i in range(len(heights)): # 0,9\\n height = heights[i] # 9\\n while stack and height < stack[-1][0]:\\n comparison_height = stack.pop()[0]\\n width = i\\n if stack:\\n width = i - stack[-1][1] - 1\\n area = comparison_height * width\\n max_area = max(max_area, area)\\n stack.append((height, i)) #[0,0, 9,1]\\n\\n # last nums\\n while stack:\\n comparison_height = stack.pop()[0] # 9\\n width = len(heights) #\\n if stack:\\n width = len(heights) - stack[-1][1] - 1 # 1\\n area = comparison_height * width\\n max_area = max(max_area, area)\\n\\n return max_area\\n\\n\\n\",\n \"runtime\": \"715\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [-1]\\n maxArea = 0\\n for i in range(len(heights)):\\n while stack[-1] != -1 and heights[stack[-1]] >= heights[i]:\\n h = heights[stack.pop()]\\n w = i - stack[-1] - 1\\n maxArea = max(maxArea, h * w)\\n stack += [i]\\n while stack[-1] != -1:\\n h = heights[stack.pop()]\\n w = len(heights) - stack[-1] - 1\\n maxArea = max(maxArea, h * w)\\n return maxArea\\n\",\n \"runtime\": \"715\"\n },\n {\n \"code\": \"# Append the stack with value and index when the value in list is bigger than the last element in stack\\n# Else, pop the lst element and update the result\\n# As well as update the index of the new value to be inserted\\n# At last if there are elements in stack pop them one by one and update result\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n res = 0\\n\\n for ind, val in enumerate(heights):\\n st_ind = ind\\n while stack and stack[-1][0] > val:\\n tmp_num = (ind-stack[-1][1])*stack[-1][0]\\n res = max(res, tmp_num)\\n st_ind = stack.pop()[1]\\n \\n stack.append([val, st_ind])\\n \\n while stack:\\n tmp_num = (len(heights)-stack[-1][1])*stack[-1][0]\\n res = max(res, tmp_num)\\n stack.pop()\\n \\n return res\\n\",\n \"runtime\": \"723\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n = len(heights)\\n\\n right_low = [n] * n\\n stack = []\\n for i in range(n):\\n while stack and heights[i] < heights[stack[-1]]:\\n top = stack.pop()\\n right_low[top] = i\\n stack.append(i)\\n\\n left_low = [-1] * n\\n stack = []\\n for i in range(n - 1, -1, -1):\\n while stack and heights[i] < heights[stack[-1]]:\\n top = stack.pop()\\n left_low[top] = i\\n stack.append(i)\\n\\n ans = 0\\n for i in range(n):\\n left = left_low[i]\\n right = right_low[i]\\n area = (right - left - 1) * heights[i]\\n ans = max(ans, area)\\n\\n return ans\\n\\n\\n # Time complexity: O(n)\\n # Space complexity: O(n)\\n\\n\\n \\n \",\n \"runtime\": \"723\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n = len(heights)\\n \\n # Arrays to store the nearest smaller bars to the left and right\\n left = [-1] * n # Nearest smaller bar to the left\\n right = [n] * n # Nearest smaller bar to the right\\n \\n # Precompute the left boundaries\\n for i in range(1, n):\\n p = i - 1\\n while p >= 0 and heights[p] >= heights[i]:\\n p = left[p] # Move left to find the nearest smaller bar\\n left[i] = p\\n \\n # Precompute the right boundaries\\n for i in range(n - 2, -1, -1):\\n p = i + 1\\n while p < n and heights[p] >= heights[i]:\\n p = right[p] # Move right to find the nearest smaller bar\\n right[i] = p\\n \\n # Compute the maximum area\\n max_area = 0\\n for i in range(n):\\n # Width is the distance between right[i] and left[i] minus 1\\n width = right[i] - left[i] - 1\\n area = heights[i] * width\\n max_area = max(max_area, area)\\n \\n return max_area\\n\",\n \"runtime\": \"731\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n res = 0\\n stack = [(-1, -1)] \\n for right, h in enumerate(heights + [-1]):\\n while h < stack[-1][-1]:\\n _, val = stack.pop()\\n left = stack[-1][0]\\n res = max(res, (right - left - 1) * val)\\n stack.append((right, h))\\n return res\",\n \"runtime\": \"731\"\n },\n {\n \"code\": \"class Solution:\\n\\n # Time: O(n)\\n # Space: O(n)\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # monotonically nondecreasing stack\\n stack = []\\n # constraint: can heights be negative? \\n maxArea = 0\\n for i in range(len(heights)):\\n curr = heights[i]\\n extendsFrom = i\\n # pop elements to maintain non-decreasing property of stack\\n # calculate max area including/ending at that element\\n while stack and curr < stack[-1][1]:\\n maxArea = max(maxArea, stack[-1][1] * (i-stack[-1][0]))\\n extendsFrom = stack[-1][0]\\n stack.pop()\\n # add current element, making it start as leftmost as possible\\n stack.append([extendsFrom, curr])\\n\\n # now process remaining stack\\n while len(stack) > 0:\\n maxArea = max(maxArea, stack[-1][1] * (len(heights) - stack[-1][0]))\\n stack.pop()\\n return maxArea\\n \\n\\\"\\\"\\\"\\nIdea: create monotonically increasing stack of heights\\n- The smallest value (stack[0]) * len(stack) is the array\\n- keep on doing this as you iterate through heights array and when you find new element that is not monotonically\\nincreasing, clear the stack and start it again -> keep track of max area\\n\\n- complication: it is not necessary to use the entirety of monotonically increasing part, \\nsometimes you need to get rid of too-small elements\\n\\n\\\"\\\"\\\"\",\n \"runtime\": \"740\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n # constraint: can heights be negative? \\n maxArea = 0\\n for i in range(len(heights)):\\n curr = heights[i]\\n extendsFrom = i\\n while stack and curr < stack[-1][1]:\\n maxArea = max(maxArea, stack[-1][1] * (i-stack[-1][0]))\\n extendsFrom = stack[-1][0]\\n stack.pop()\\n stack.append([extendsFrom, curr])\\n # now process remaining stack\\n while len(stack) > 0:\\n maxArea = max(maxArea, stack[-1][1] * (len(heights) - stack[-1][0]))\\n stack.pop()\\n return maxArea\\n \\n\\\"\\\"\\\"\\nIdea: create monotonically increasing stack of heights\\n- The smallest value (stack[0]) * len(stack) is the array\\n- keep on doing this as you iterate through heights array and when you find new element that is not monotonically\\nincreasing, clear the stack and start it again -> keep track of max area\\n\\n- complication: it is not necessary to use the entirety of monotonically increasing part, \\nsometimes you need to get rid of too-small elements\\n\\n\\\"\\\"\\\"\",\n \"runtime\": \"740\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack, res = [(-1, 0)], 0\\n for i, h in enumerate(heights):\\n while stack[-1][1] > h:\\n top = stack.pop()\\n res = max(res, (i - stack[-1][0] -1) * top[1])\\n stack.append((i, h))\\n\\n print(stack, res)\\n\\n for i in range(1, len(stack)):\\n res = max(res, (stack[-1][0] - stack[i-1][0]) * stack[i][1])\\n return res\\n\",\n \"runtime\": \"748\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n '''12:08'''\\n stack = []\\n maxRectangle = 0\\n\\n for i, currHeight in enumerate(heights):\\n if len(stack) == 0 or currHeight >= stack[-1][1]:\\n stack.append((i, currHeight))\\n else:\\n prevIndex = -1\\n while len(stack) > 0 and currHeight < stack[-1][1]:\\n prevIndex = stack[-1][0]\\n maxRectangle = max(maxRectangle, self.popFromStackAndGetRectangleSize(i, stack))\\n \\n if currHeight != 0:\\n stack.append((prevIndex, currHeight))\\n \\n while len(stack) > 0:\\n maxRectangle = max(maxRectangle, self.popFromStackAndGetRectangleSize(len(heights), stack))\\n \\n return maxRectangle\\n \\n def popFromStackAndGetRectangleSize(self, currIndex, stack):\\n prevIndex, h = stack.pop()\\n rectangle = h * (currIndex - prevIndex)\\n return rectangle\\n\",\n \"runtime\": \"748\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n maxArea = 0\\n for ind, height in enumerate(heights):\\n i = ind\\n h = height\\n while stack and height < stack[-1][1]:\\n i, h = stack.pop()\\n maxArea = max(maxArea, h * (ind-i))\\n \\n stack.append([i, height])\\n maxArea = max(maxArea, height)\\n\\n while stack:\\n i, h = stack.pop()\\n maxArea = max(maxArea, h * (len(heights)-i))\\n return maxArea\",\n \"runtime\": \"757\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # A stack with elements [(num, start, end)]\\n # When curr < stack[-1], pop from stop.\\n\\n stack = []\\n maxNum = float('-inf')\\n\\n for i in range(len(heights)):\\n if (len(stack) == 0):\\n stack.append([heights[i], i, i])\\n continue\\n \\n if (heights[i] >= stack[-1][0]):\\n stack.append([heights[i], i, i])\\n else: \\n end = stack[-1][2]\\n start = stack[-1][1]\\n while (len(stack) > 0 and heights[i] < stack[-1][0]):\\n prev = stack[-1]\\n start = prev[1]\\n area = prev[0] + prev[0] * (end-start)\\n maxNum = max(maxNum, area)\\n stack.pop()\\n\\n stack.append([heights[i], start, i])\\n \\n if (len(stack) > 0):\\n end = stack[-1][2]\\n while (len(stack) > 0):\\n start = stack[-1][1]\\n curr = stack[-1][0]\\n area = curr + curr*(end-start)\\n maxNum = max(maxNum, area)\\n stack.pop()\\n \\n return maxNum\\n\\n \\n\",\n \"runtime\": \"757\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n nse=self.findNSE(heights)\\n pse=self.findPSE(heights)\\n area=0\\n n=len(heights)\\n for i in range(n):\\n area=max(area,heights[i]*(nse[i]-pse[i]-1))\\n return area\\n\\n \\n\\n def findNSE(self,arr):\\n n=len(arr)\\n nse=[n]*n\\n st=[]\\n for i in range(n-1,-1,-1):\\n while st and arr[st[-1]]>=arr[i]:\\n st.pop()\\n if st:\\n nse[i]=st[-1]\\n st.append(i)\\n return nse\\n def findPSE(self,arr):\\n n=len(arr)\\n pse=[-1]*n\\n st=[]\\n for i in range(n):\\n while st and arr[st[-1]]>=arr[i]:\\n st.pop()\\n if st:\\n pse[i]=st[-1]\\n st.append(i)\\n return pse\\n\\n\\n \",\n \"runtime\": \"765\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n\\n if len(heights) == 0:\\n return 0\\n \\n stack = []\\n max_area = 0\\n\\n for index,value in enumerate(heights):\\n if len(stack) == 0 or stack[-1][1] <= value:\\n stack.append([index, value])\\n else:\\n top = []\\n while len(stack) >0 and value < stack[-1][1]:\\n top, max_area = self.calculateArea(stack,index,max_area)\\n \\n stack.append([top[0],value])\\n \\n index+=1\\n top =[]\\n while len(stack) >0:\\n top, max_area = self.calculateArea(stack,index,max_area)\\n\\n return max_area\\n \\n def calculateArea(self, stack,index, max_area):\\n top = stack.pop()\\n width = index - top[0]\\n height = top[1]\\n area = height * width\\n\\n max_area = max(max_area, area)\\n \\n return [top,max_area]\\n \",\n \"runtime\": \"765\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n minLeft = [-1 for _ in range(len(heights))]\\n minRight = [len(heights) for _ in range(len(heights))]\\n for i in range(1, len(heights)):\\n j = i-1\\n while (j > -1):\\n if heights[j] < heights[i]:\\n minLeft[i] = j\\n break\\n j = minLeft[j]\\n for i in range(len(heights) - 2, -1, -1):\\n j = i+1\\n while (j < len(heights)):\\n if heights[j] < heights[i]:\\n minRight[i] = j\\n break\\n j = minRight[j]\\n result = 0\\n\\n for i in range(0, len(heights)):\\n h = heights[i]\\n w = minRight[i] - minLeft[i] - 1\\n result = max(result, h * w)\\n return result\",\n \"runtime\": \"774\"\n },\n {\n \"code\": \"from collections import deque \\nclass Solution:\\n # calculate left \\n def left(self,arr,n):\\n res = [-1]*n \\n stack = deque() \\n stack.append(0)\\n for i in range (1,n):\\n val = arr[i] \\n if stack and arr[stack[-1]]<val:\\n res[i] = stack[-1]\\n else:\\n while stack and arr[stack[-1]]>=val:\\n stack.pop()\\n if stack:\\n res[i] = stack[-1] \\n stack.append(i)\\n return res \\n \\n # calculate right\\n def right(self,arr,n):\\n res=[n]*n \\n stack = deque()\\n stack.append(n-1)\\n for i in range(n-2,-1,-1):\\n val = arr[i]\\n if stack and arr[stack[-1]]<val:\\n res[i] = stack[-1] \\n else:\\n while stack and arr[stack[-1]]>=val:\\n stack.pop() \\n if stack:\\n res[i] = stack[-1] \\n stack.append(i)\\n return res \\n \\n def largestRectangleArea(self,height):\\n n = len(height)\\n left = self.left(height,n)\\n right = self.right(height,n)\\n maxArea = 0 \\n for i in range(n):\\n newArea = ((right[i]-left[i])-1)*(height[i])\\n maxArea = max(maxArea,newArea)\\n return maxArea \\n \",\n \"runtime\": \"774\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n=len(heights)\\n leftmin=[]\\n s=[]\\n for i in range(len(heights)):\\n while s and heights[s[-1]]>=heights[i]:\\n s.pop()\\n if s:\\n leftmin.append(i-s[-1])\\n else:\\n leftmin.append(i+1)\\n s.append(i) \\n rightmin=[0]*n\\n s=[]\\n for i in range(len(heights)-1,-1,-1):\\n while s and heights[s[-1]]>=heights[i]:\\n s.pop()\\n if s:\\n rightmin[i]=(s[-1]-i) \\n else:\\n rightmin[i]=n-i\\n s.append(i) \\n ans=0\\n for i in range(n):\\n t=heights[i]*(leftmin[i]+rightmin[i]-1)\\n #print(t)\\n ans=max(ans,t) \\n return ans \\n\\n\\n \\n \",\n \"runtime\": \"782\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n = len(heights)\\n stack = []\\n left = [-1] * n\\n right = [n] * n\\n \\n # Calculate left and right bounds using a single stack\\n for i in range(n):\\n while stack and heights[stack[-1]] >= heights[i]:\\n stack.pop()\\n if stack:\\n left[i] = stack[-1]\\n stack.append(i)\\n\\n stack.clear() # Clear the stack for right bounds\\n \\n for i in range(n-1, -1, -1):\\n while stack and heights[stack[-1]] >= heights[i]:\\n stack.pop()\\n if stack:\\n right[i] = stack[-1]\\n stack.append(i)\\n \\n max_area = 0\\n for i in range(n):\\n width = right[i] - left[i] - 1\\n max_area = max(max_area, width * heights[i])\\n \\n return max_area\\n\",\n \"runtime\": \"782\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n q = deque()\\n result = 0\\n for i, x in enumerate(heights):\\n left_v = 0\\n while q and q[-1][1] >= x:\\n j, y, plv = q.pop()\\n result = max(result, (i-j)*y + plv)\\n\\n if q:\\n s = q[-1][0] + 1\\n else:\\n s = 0\\n left_v = max(left_v, (i - s) * x)\\n if not q:\\n result = max(result, (i+1)*x)\\n q.append((i, x, left_v))\\n while q:\\n result = max(result, (q[-1][0] - q[0][0] + 1) * q[0][1] + q[0][2])\\n q.popleft()\\n return result\\n\",\n \"runtime\": \"791\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n L = len(heights)\\n leftLadder = []\\n leftSmaller = [0]*L\\n for i,h in enumerate(heights):\\n while leftLadder and heights[leftLadder[-1]]>=h:\\n leftLadder.pop()\\n leftSmaller[i] = (leftLadder[-1] if leftLadder else -1)\\n leftLadder.append(i)\\n #print(leftSmaller)\\n rightLadder = []\\n rightSmaller = [0]*L\\n for i,h in reversed(list(enumerate(heights))):\\n while rightLadder and heights[rightLadder[-1]]>=h:\\n rightLadder.pop()\\n rightSmaller[i] = (rightLadder[-1] if rightLadder else L)\\n rightLadder.append(i)\\n #print(rightSmaller)\\n\\n best = 0\\n for i,h in enumerate(heights):\\n w=rightSmaller[i]-leftSmaller[i]-1\\n area = w*h\\n #print (i,leftSmaller[i],rightSmaller[i],h,area)\\n best = max(best,area)\\n return best\",\n \"runtime\": \"791\"\n },\n {\n \"code\": \"def previous_smaller_index(arr):\\n ans = [-1]\\n st = [0]\\n\\n for i in range(1, len(arr)):\\n\\n while st and arr[i] <= arr[st[-1]]:\\n st.pop()\\n\\n if len(st) == 0:\\n ans.append(-1)\\n\\n else:\\n ans.append(st[-1])\\n\\n st.append(i)\\n\\n return ans\\n \\ndef next_smaller_index(arr):\\n ans = [len(arr)]\\n st = [len(arr) - 1]\\n\\n for i in range(len(arr) - 2, -1, -1):\\n\\n while st and arr[i] <= arr[st[-1]]:\\n st.pop()\\n\\n if len(st) == 0:\\n ans.append(len(arr))\\n\\n else:\\n ans.append(st[-1])\\n\\n st.append(i)\\n\\n return ans[::-1]\\n \\ndef max_area_histogram(arr):\\n psi = previous_smaller_index(arr)\\n nsi = next_smaller_index(arr)\\n ans = 0\\n print(psi, nsi)\\n for i in range(len(arr)):\\n ans = max(ans, ((nsi[i] - psi[i] - 1) * arr[i]))\\n \\n return ans\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n return max_area_histogram(heights)\\n \",\n \"runtime\": \"799\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights_new = [0] + heights + [0]\\n stack = []\\n area = 0\\n for i in range(len(heights_new)):\\n while stack and heights_new[stack[-1]] > heights_new[i]:\\n mid = stack.pop()\\n if not stack: continue\\n left = stack[-1]\\n h = heights_new[mid]\\n w = i-left-1\\n area = max(h*w, area)\\n\\n stack.append(i)\\n if heights_new[stack[-1]] <= heights_new[i]:\\n stack.append(i)\\n return area\",\n \"runtime\": \"799\"\n },\n {\n \"code\": \"from dataclasses import dataclass\\n\\nclass Solution:\\n\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n @dataclass\\n class StackElement:\\n pos: int\\n val: int\\n\\n length = len(heights)\\n stack: list[StackElement] = []\\n max_area = heights[0]\\n for i in range(length):\\n if not stack or heights[i] >= stack[-1].val:\\n stack.append(StackElement(i, heights[i]))\\n continue\\n\\n max_ext = stack[-1].pos\\n while stack and stack[-1].val > heights[i]:\\n max_area = max(max_area, (i - stack[-1].pos) * stack[-1].val)\\n max_ext = stack[-1].pos\\n stack.pop()\\n\\n stack.append(StackElement(max_ext, heights[i]))\\n\\n while stack:\\n max_area = max(max_area, (length - stack[-1].pos) * stack[-1].val)\\n stack.pop()\\n\\n return max_area\\n\",\n \"runtime\": \"807\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n\\n def fillPrevSmaller(self):\\n st = deque()\\n \\n for idx in (range(self.n)):\\n height = self.heights[idx]\\n if len(st) == 0:\\n st.append(idx)\\n else:\\n while len(st) > 0 and height <= self.heights[st[-1]]:\\n st.pop()\\n if len(st) > 0:\\n self.pge[idx] = st[-1]\\n st.append(idx)\\n\\n def fillNextSmaller(self):\\n st = deque()\\n \\n for idx in reversed(range(self.n)):\\n height = self.heights[idx]\\n if len(st) == 0:\\n st.append(idx)\\n else:\\n while len(st) > 0 and height <= self.heights[st[-1]]:\\n st.pop()\\n if len(st) > 0:\\n self.nge[idx] = st[-1]\\n st.append(idx)\\n\\n\\n\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n self.n = len(heights)\\n self.pge = [-1]*self.n\\n self.nge = [self.n]*self.n\\n self.heights = heights\\n self.fillPrevSmaller()\\n self.fillNextSmaller()\\n ans = 0\\n for i in range(self.n):\\n ans = max(ans,heights[i]*(self.nge[i]-self.pge[i]-1),)\\n return ans\",\n \"runtime\": \"807\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n def PSE():\\n stack = []\\n res = []\\n for i in range(len(heights)):\\n while stack and stack[-1][0]>=heights[i]:\\n stack.pop()\\n if not stack:\\n res.append(-1)\\n else:\\n res.append(stack[-1][1])\\n stack.append([heights[i], i])\\n return res\\n def NSE():\\n stack = []\\n res = [len(heights) for _ in range(len(heights))]\\n for i in range(len(heights)-1, -1, -1):\\n while stack and stack[-1][0]>=heights[i]:\\n stack.pop()\\n if stack:\\n res[i] = stack[-1][1]\\n stack.append([heights[i], i])\\n return res\\n pse = PSE()\\n nse = NSE()\\n mx = 0\\n l = len(heights)\\n for i in range(len(heights)):\\n mx = max(mx, heights[i]*(nse[i]-pse[i]-1))\\n return mx\",\n \"runtime\": \"816\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n hl = len(heights)\\n right, left = [-1] * hl, [-1] * hl\\n stack = []\\n for i in range(hl):\\n while stack and stack[-1][0] >= heights[i]:\\n stack.pop()\\n firstSmallIndx = -1\\n if stack:\\n firstSmallIndx = stack[-1][1]\\n left[i] = firstSmallIndx + 1\\n stack.append([heights[i], i])\\n\\n stack = []\\n for i in range(hl-1, -1, -1):\\n while stack and stack[-1][0] >= heights[i]:\\n stack.pop()\\n firstSmallIndx = hl\\n if stack:\\n firstSmallIndx = stack[-1][1]\\n right[i] = firstSmallIndx - 1\\n stack.append([heights[i], i])\\n #print(left)\\n #print(right)\\n \\n ans = 0\\n for i in range(hl):\\n rect = heights[i] * (right[i] - left[i] + 1)\\n ans = max(ans, rect)\\n return ans\",\n \"runtime\": \"816\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n smallestRight = [len(heights)] * len(heights)\\n smallestLeft = [-1] * len(heights)\\n stack = []\\n for index, height in enumerate(heights):\\n while len(stack) > 0 and height < stack[-1][1]:\\n biggerIndex, biggerHeight = stack[-1]\\n smallestRight[biggerIndex] = index\\n stack.pop()\\n stack.append((index, height))\\n\\n stack = []\\n for index in range(len(heights) - 1, -1, -1):\\n height = heights[index]\\n while len(stack) > 0 and height < stack[-1][1]:\\n biggerIndex, biggerHeight = stack[-1]\\n smallestLeft[biggerIndex] = index\\n stack.pop()\\n stack.append((index, height))\\n \\n best = 0\\n for index, height in enumerate(heights):\\n bestWidth = smallestRight[index] - smallestLeft[index] - 1\\n bestArea = height * bestWidth\\n best = max(best, bestArea)\\n return best\",\n \"runtime\": \"824\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n n = len(heights)\\n left = [-1] * n\\n for i in range(0,n):\\n while len(stack)!= 0 and heights[stack[len(stack)-1]] >= heights[i]:\\n stack.pop() \\n if len(stack)!=0:\\n left[i] = stack[len(stack)-1]\\n stack.append(i)\\n\\n stack = []\\n n = len(heights)\\n right = [n] * n\\n for i in range(n-1,-1,-1):\\n while len(stack)!= 0 and heights[stack[len(stack)-1]] >= heights[i]:\\n stack.pop()\\n if len(stack)!=0:\\n right[i] = stack[len(stack)-1]\\n stack.append(i)\\n\\n maxArea = -1\\n for i in range(n):\\n area = (right[i]-left[i]-1) * heights[i]\\n maxArea = max(area,maxArea)\\n \\n return maxArea\\n\\n\",\n \"runtime\": \"824\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":109,"string":"109"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def largestRectangleArea(heights: List[int]) -> int:\n n = len(heights)\n max_area = 0\n stack = []\n for j in range(n):\n h = heights[j]\n while stack and h < heights[stack[-1]]:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (j - left)\n if area > max_area:\n max_area = area\n stack.append(j)\n while stack:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (n - left)\n if area > max_area:\n max_area = area\n return max_area\n if __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads,stdin):\n print(largestRectangleArea(i), file=f)\n exit(0)","memory":"25400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n = len(heights)\n stack = []\n max_area = 0\n\n for i in range(n):\n while stack and heights[i] <= heights[stack[-1]]:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1 if stack else i\n max_area = max(max_area, height * width)\n stack.append(i)\n\n while stack:\n height = heights[stack.pop()]\n width = n - stack[-1] - 1 if stack else n\n max_area = max(max_area, height * width)\n\n return max_area\n\nwith open(\"user.out\", \"w\") as f:\n inputs = map(loads, stdin)\n for nums in inputs:\n print(Solution().largestRectangleArea(nums),file=f)\nexit(0)","memory":"25500"},{"code":"def largestRectangleArea(heights: List[int]) -> int:\n n = len(heights)\n max_area = 0\n stack = []\n for j in range(n):\n h = heights[j]\n while stack and h < heights[stack[-1]]:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (j - left)\n if area > max_area:\n max_area = area\n stack.append(j)\n while stack:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (n - left)\n if area > max_area:\n max_area = area\n return max_area\n\nif __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads,stdin):\n print(largestRectangleArea(i), file=f)\n exit(0)","memory":"25700"},{"code":"# class Solution:\ndef largestRectangleArea(heights: List[int]) -> int:\n n = len(heights)\n max_area = 0\n stack = []\n for j in range(n):\n h = heights[j]\n while stack and h < heights[stack[-1]]:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (j - left)\n if area > max_area:\n max_area = area\n stack.append(j)\n while stack:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (n - left)\n if area > max_area:\n max_area = area\n return max_area\nif __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads,stdin):\n print(largestRectangleArea(i), file=f)\n exit(0)\n \n # Failed\n # if len(heights)==1:\n # return heights[0]\n # l, r = 0, len(heights) - 1\n # max_tmp = 0\n\n # while l < r:\n # val_l = heights[l]\n # val_r = heights[r]\n\n # if val_l < val_r:\n # x = val_l * (r-l+1)\n # l += 1 \n # if val_l > heights[l] and l < r:\n # max_tmp = 0\n # x=0\n # max_tmp = max(max_tmp, x)\n # else:\n # x = val_r * (r-l+1)\n # r -= 1 \n # if val_r > heights[r] and l < r:\n # max_tmp = 0\n # x = 0\n # max_tmp = max(max_tmp, x)\n \n # lon = 0\n # for i in range(len(heights)):\n # if heights[i] == 0:\n # if heights[lon:i]:\n # max_tmp = max(min(heights[lon:i]) * (i - lon), max_tmp)\n # lon = i+1\n # elif i == len(heights)-1:\n # # print(min(heights[lon:i+1]) * (i+1 - lon))\n # max_tmp = max(min(heights[lon:i+1]) * (i+1 - lon), max_tmp)\n # return max(max_tmp, max(heights))","memory":"25800"},{"code":"# class Solution:\ndef largestRectangleArea(heights: List[int]) -> int:\n heights += [0]\n stack = []\n max_area = -sys.maxsize\n for i, height in enumerate(heights):\n if not stack or height > stack[-1][0]:\n stack.append((height,i))\n else:\n while stack and stack[-1][0] >= height:\n h2, i2 = stack.pop()\n area = (i - i2) * h2\n max_area = max(max_area, area)\n stack.append((height, i2))\n return max_area\n\nif __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads,stdin):\n print(largestRectangleArea(i), file=f)\n exit(0)","memory":"25900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights += [0]\n ans = 0\n stk = [-1]\n\n # Every height in heights can form a rectangle by expanding to the next smaller(or equal) element on its left and right\n # ans must be one of them\n\n # try to expand in increasing order to the right, until we encounter sth smaller, this will be the next smaller on the right; mono stack keeps track of next smaller on the left\n # the content of the stack\n # ---------------------------------|\n # -- idx of increasing elements --> top\n # ---------------------------------|\n\n # stack[-1]=left next smaller | h=stack.pop() | i=right next smaller \n\n # for each element at index i, if it's smaller than stack.top()\n # Then the rectangle with height of stack.top() can no longer expand right\n # we pop it this height {h} from the stack, stack.top() is the prev element that is smaller than {h}\n # the rectangle area = {h} * (i - 1 - stack.top())\n\n for i, h in enumerate(heights):\n while stk and heights[stk[-1]] > h:\n # The top of stack must be popped off, no more extension to the right\n height = heights[stk.pop()]\n\n # right next smaller of h is at index i\n # rectangle's right ends at i-1\n # left next smaller of h is at index stk[-1]\n \n width = i - 1 - stk[-1]\n\n ans = max(ans, height * width)\n # end while\n\n stk.append(i)\n # end for\n\n return ans\n\nsol = Solution()\nf = open('user.out', 'w')\nfor i in map(loads, stdin):\n f.write(f'{sol.largestRectangleArea(i)}\\n')\nf.flush()\nexit(0)","memory":"26000"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n st = []\n n = len(heights)\n prevSm = [-1 for _ in range(n)]\n for i in range(n):\n while len(st) and st[-1][0] >= heights[i]:\n st.pop()\n if len(st):\n prevSm[i] = st[-1][1]\n st.append([heights[i], i])\n \n st = []\n nextSm = [n for _ in range(n)]\n for i in range(n-1, -1, -1):\n while len(st) and st[-1][0] >= heights[i]:\n st.pop()\n if len(st):\n nextSm[i] = st[-1][1]\n st.append([heights[i], i])\n \n maxA = 0\n for i in range(n):\n maxA = max(maxA, heights[i] * (nextSm[i] - prevSm[i] - 1))\n return maxA\n\n\n\n ","memory":"27900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [-1]\n max_area = 0\n\n for i in range(len(heights)):\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1\n max_area = max(max_area, height * width)\n stack.append(i)\n \n while stack[-1] != -1:\n height = heights[stack.pop()]\n width = len(heights) - stack[-1] - 1\n max_area = max(max_area, height * width)\n \n return max_area ","memory":"28100"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n=len(heights)\n stk=[-1]\n max_=0\n for i in range(n):\n while stk[-1]!=-1 and heights[stk[-1]]>=heights[i]:\n max_=max(max_,heights[stk.pop()]*(i-stk[-1]-1))\n stk.append(i)\n while stk[-1]!=-1:\n max_=max(max_,heights[stk.pop()]*(len(heights)-stk[-1]-1))\n return max_\n","memory":"28400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights.append(0)\n ans = 0\n stk = deque() # stores the indices of potential left bounds of the rectangle\n for i, x in enumerate(heights):\n if len(stk) == 0 or x > heights[stk[-1]]:\n stk.append(i)\n else:\n leftmost = i\n while len(stk) > 0 and x < heights[stk[-1]]:\n ans = max(ans, (i - stk[-1]) * heights[stk[-1]])\n heights[stk[-1]] = x\n leftmost = stk[-1]\n stk.pop()\n stk.append(leftmost)\n return ans\n","memory":"28700"},{"code":"from typing import List\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n # Stack to keep indices of the bars in the histogram\n stack = []\n max_area = 0\n index = 0\n \n while index < len(heights):\n # Push the current index if the current bar is taller than the bar at the stack's top\n if not stack or heights[stack[-1]] <= heights[index]:\n stack.append(index)\n index += 1\n else:\n # Calculate the area with the bar at the top of the stack as the shortest bar\n top_of_stack = stack.pop()\n height = heights[top_of_stack]\n width = index if not stack else index - stack[-1] - 1\n max_area = max(max_area, height * width)\n \n # Now pop the remaining bars in the stack and calculate the area\n while stack:\n top_of_stack = stack.pop()\n height = heights[top_of_stack]\n width = index if not stack else index - stack[-1] - 1\n max_area = max(max_area, height * width)\n \n return max_area","memory":"29100"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n \n '''\n 1) Use left and right pointers\n 2) keep moving right unless the rectangle area is decreased, or current index is greater than the current area\n in that case shift left pointer to the right one\n\n [3 1 2 4 2]\n\n '''\n\n stack, ans = [], 0\n for i, h in enumerate(heights + [0]):\n while stack and heights[stack[-1]] >= h:\n H = heights[stack.pop()]\n W = i if not stack else i-stack[-1]-1\n ans = max(ans, H*W)\n stack.append(i)\n return ans\n\n ","memory":"29200"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights = [-inf] + heights + [-inf]\n stack = []\n max_area = 0\n for i, height in enumerate(heights):\n while stack and heights[stack[-1]] > height:\n curr_idx = stack.pop()\n left = stack[-1] + 1\n right = i - 1\n width = right - left + 1\n curr_height = heights[curr_idx]\n max_area = max(max_area, curr_height * width)\n stack.append(i)\n return max_area","memory":"29300"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n heights = [0] + heights + [0]\n largestrect = 0\n \n for i in range(len(heights)):\n while stack and heights[i] < heights[stack[-1]]:\n popped = stack.pop()\n largestrect = max(largestrect, (i - 1 - stack[-1]) * heights[popped])\n stack.append(i)\n \n return largestrect\n\n# Time complexity = O(n)\n# Space complexity = O(n)","memory":"29400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n\n stack = []\n\n N = len(heights)\n\n max_val = 0\n\n for i in range(N):\n \n h = heights[i]\n index = i\n\n while stack and stack[-1][0] >= h:\n old = stack.pop()\n index = old[2]\n val = old[0] * ((i - old[2]))\n print(old)\n print(val)\n max_val = max(max_val, val)\n \n stack.append([h, i, index])\n\n\n print('==============')\n print(stack)\n print('==============')\n\n while stack:\n old = stack.pop()\n val = old[0] * (N - old[2])\n print(old)\n print(val)\n max_val = max(max_val, val)\n\n return max_val\n\n \n\n \n\n \n","memory":"29500"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights_new = [0] + heights + [0]\n stack = []\n area = 0\n for i in range(len(heights_new)):\n while stack and heights_new[stack[-1]] > heights_new[i]:\n mid = stack.pop()\n if not stack: continue\n left = stack[-1]\n h = heights_new[mid]\n w = i-left-1\n area = max(h*w, area)\n\n stack.append(i)\n if heights_new[stack[-1]] <= heights_new[i]:\n stack.append(i)\n return area","memory":"29600"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n ans = 0\n for i, h in enumerate(heights):\n if not stack or heights[stack[-1]] < h:\n stack.append(i)\n continue\n \n while stack and h <= heights[stack[-1]]:\n idx = stack.pop()\n ans = max(ans, (i - idx) * heights[idx])\n \n heights[idx] = h\n stack.append(idx)\n \n end = len(heights)\n while stack:\n idx = stack.pop()\n ans = max(ans, (end - idx) * heights[idx])\n return ans","memory":"29700"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n \n if len(heights) == 0:\n return 0\n \n smallerLeft = [0] * len(heights)\n smallerRight = [0] * len(heights)\n \n for i in range(len(heights)):\n pos = i-1\n while pos >= 0 and heights[i] <= heights[pos]:\n pos = smallerLeft[pos]\n smallerLeft[i] = pos\n \n for i in range(len(heights)-1,-1,-1):\n pos = i+1\n while pos <= len(heights)-1 and heights[i] <= heights[pos]:\n pos = smallerRight[pos]\n smallerRight[i] = pos\n \n maxArea = 0\n for i, h in enumerate(heights):\n maxArea = max(maxArea, (smallerRight[i]-smallerLeft[i]-1) * heights[i])\n \n return maxArea\n ","memory":"29800"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights = [0] + heights + [0]\n stack = []\n max_area = 0\n i = 0\n while i < len(heights):\n if len(stack) == 0 or heights[i] >= heights[stack[-1]]:\n stack.append(i)\n i += 1\n elif heights[i] < heights[stack[-1]]:\n popped = stack.pop()\n width = i - stack[-1] - 1\n max_area = max(max_area, width * heights[popped])\n else:\n i += 1\n\n return max_area","memory":"29900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n=len(heights)\n def findprevsmall():\n result=[-1]*n\n stack=[]\n for i in range(n):\n while stack and heights[stack[-1]]>=heights[i]:\n stack.pop()\n if stack:\n result[i]=stack[-1]\n stack.append(i)\n return result\n def findnextsmall():\n result=[n]*n\n stack=[]\n for i in range(n-1,-1,-1):\n while stack and heights[stack[-1]]>=heights[i]:\n stack.pop()\n if stack:\n result[i]=stack[-1]\n stack.append(i)\n return result\n result=0\n left=findprevsmall()\n right=findnextsmall()\n for i in range(n):\n height=heights[i]\n breadth=right[i]-left[i]-1\n area=height*breadth\n result=max(result,area)\n return result\n\n ","memory":"29900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n curr_max = heights[0]\n stack = [(curr_max, 0)] # height (>= current height), start index\n N = len(heights)\n\n for i in range(1,N):\n curr_h = heights[i]\n ind_append = i #\n while stack and stack[-1][0] >= curr_h:\n prev_h, ind_append = stack.pop() # ind_append = prev_i\n curr_max = max(curr_max, prev_h*(i-ind_append))\n stack.append((curr_h, ind_append))\n\n for h,i in stack:\n curr_max = max(curr_max, h*(N-i))\n\n return curr_max","memory":"30000"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n maxR = 0\n recStack = [[0,0]]\n heights.append(0)\n # Pad left and right of histogram with 0s to ensure algorithm has the right stopping bounds\n for x in heights:\n width = 0\n # Keep popping off stack elements until stack is empty or bar smaller than current is found\n while recStack and x <= recStack[-1][1]:\n w,h = recStack.pop()\n width += w # Expanding width of peak section\n maxR = max(maxR,width*h) # Popped h value will always be smaller or equal to current h due to nature of while loop\n recStack.append([width+1,x]) # Add current bar to stack, extended as far left as possible\n return maxR","memory":"30000"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n maxR = 0\n recStack = [[0,0]]\n heights.append(0)\n for x in heights:\n width = 0\n while recStack and x <= recStack[-1][1]:\n h = recStack.pop()\n width += h[0]\n maxR = max(maxR,width*h[1])\n recStack.append([width+1,x])\n return maxR","memory":"30100"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n if not heights:\n return 0\n stack = [] # maintains the index, an strictly increasing stack\n maxArea = 0\n for i in range(len(heights)+1): # last height is 0;\n curH = 0 if i == len(heights) else heights[i] # current height at location i; \n # last one is 0 for cases like [1,2,3] so that we have a chance to pop all in the stack\n\n while stack and curH <= heights[stack[-1]]: # we saw a smaller height, time to pop and calculate area; Need to use <=, because it is a strictly increasing stack (we need to find the strictly smaller element on the left;) so that when we quit, we can append.\n h = heights[stack.pop()]\n start = stack[-1] if stack else -1 # if stack is empty, start = -1 (for cases like [1])\n # start location, index of the first smaller height in the left of the poped height; \n # i is the first samller height in the right of the poped height\n # |__________|........|___________________|___________|\n # stack[-1] stack.pop() i\n width = i - start - 1\n # print([\"stack containing index\", stack, \"curH\", curH, \"i\", i, \"start\", start, \"width\", width, \"h\", h, \"area\", width*h])\n maxArea = max(maxArea, width * h)\n\n # currH > heights[stack[-1]]\n # print(stack)\n stack.append(i) # curH is higher then top of stack or stack is empty, push to increasing stack\n\n return maxArea","memory":"30100"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n #use monotonic stack to store the index of number\n st,res=[],0\n for height in heights +[-1]:\n step=0\n while st and st[-1][1]>=height:\n w,h=st.pop()\n step+=w\n res=max(res,step*h)\n st.append((step+1,height))\n return res\n \n\n \n ","memory":"30200"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights.append(0)\n monotonic_stack = []\n ans = 0\n for idx, height in enumerate(heights):\n while monotonic_stack and height < heights[monotonic_stack[-1]]:\n popped_idx = monotonic_stack.pop()\n left_idx = monotonic_stack[-1] + 1 if monotonic_stack else 0\n right_idx = idx - 1\n width = right_idx - left_idx + 1\n cur_height = heights[popped_idx]\n area = width * cur_height\n ans = max(ans, area)\n monotonic_stack.append(idx)\n return ans","memory":"30200"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n \n n = len(heights)\n \n # Arrays to store the Nearest Smaller to Left and Right\n NSL = [-1] * n\n NSR = [n] * n\n \n # Stack to compute Nearest Smaller to Left (NSL)\n stack = []\n for i in range(n):\n while stack and heights[stack[-1]] >= heights[i]:\n stack.pop()\n NSL[i] = stack[-1] if stack else -1\n stack.append(i)\n \n # Clear stack and compute Nearest Smaller to Right (NSR)\n stack = []\n for i in range(n-1, -1, -1):\n while stack and heights[stack[-1]] >= heights[i]:\n stack.pop()\n NSR[i] = stack[-1] if stack else n\n stack.append(i)\n \n # Compute the maximum area\n max_area = 0\n for i in range(n):\n width = NSR[i] - NSL[i] - 1\n max_area = max(max_area, heights[i] * width)\n \n return max_area","memory":"30300"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack, largest = [], 0\n for h in heights + [-1]:\n step = 0\n while stack and stack[-1][1] >= h:\n wid, hei = stack.pop()\n step += wid\n largest = max(largest, step * hei)\n stack.append((step + 1, h))\n return largest","memory":"30300"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [-1]\n max_area = 0\n\n for i in range(len(heights)):\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1\n max_area = max(max_area, height * width)\n stack.append(i)\n \n while stack[-1] != -1:\n height = heights[stack.pop()]\n width = len(heights) - stack[-1] - 1\n max_area = max(max_area, height * width)\n \n return max_area","memory":"30400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n = len(heights)\n right = [n]*n\n left = [-1]*n\n \n stack = []\n for i in range(n):\n while stack and heights[stack[-1]]>heights[i]:\n right[stack[-1]] = i\n stack.pop()\n print(i)\n if stack:\n left[i] = stack[-1]\n stack.append(i)\n print(left, right)\n res = 0\n for i in range(n):\n l = left[i]\n r = right[i]\n res = max(res, heights[i]*(r-l-1))\n return res\n","memory":"30400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [-1]\n max_area = 0\n\n for i in range(len(heights)):\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1\n max_area = max(max_area, height * width)\n stack.append(i)\n \n while stack[-1] != -1:\n height = heights[stack.pop()]\n width = len(heights) - stack[-1] - 1\n max_area = max(max_area, height * width)\n \n return max_area","memory":"30500"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n \n stack = [-1]\n area = 0\n\n for i in range(len(heights)):\n\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]: \n height = heights[stack.pop()]\n width = i - stack[-1] - 1 \n area = max(area, height * width)\n \n stack.append(i)\n \n while stack[-1] != -1:\n height = heights[stack.pop()]\n width = len(heights) - stack[-1] - 1 \n area = max(area, height * width)\n\n return area","memory":"30500"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n largest_area = 0\n\n for height in heights:\n width = 1\n while stack and stack[-1] > height:\n top = stack.pop()\n area = width * top\n\n largest_area = max(largest_area, area)\n width += 1\n\n for i in range(width):\n stack.append(height)\n\n width = 1\n while stack:\n top = stack.pop()\n area = width * top\n\n largest_area = max(largest_area, area)\n width += 1\n \n return largest_area","memory":"30600"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n beeg = 0\n heights.append(0)\n s = deque([-1])\n for i, h in enumerate(heights):\n while h < heights[s[-1]]:\n index = s.pop()\n height = heights[index]\n beeg = max(beeg, (i - 1 - s[-1]) * height)\n s.append(i)\n return beeg","memory":"30600"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n area = heights[0]\n for i, h in enumerate(heights):\n if not stack or heights[stack[-1]] <= h:\n stack.append(i)\n continue\n \n while stack and heights[stack[-1]] > h:\n pos = stack.pop()\n area = max(area, heights[pos] * (i - pos))\n \n stack.append(pos)\n heights[pos] = h\n \n i = len(heights)\n while stack:\n idx = stack.pop()\n area = max(area, heights[idx] * (i - idx))\n return area\n","memory":"30700"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n ans = 0\n for i, h in enumerate(heights):\n if not stack or heights[stack[-1]] <= h:\n stack.append(i)\n continue\n \n while stack and h < heights[stack[-1]]:\n idx = stack.pop()\n ans = max(ans, (i - idx) * heights[idx])\n \n heights[idx] = h\n stack.append(idx)\n \n end = len(heights)\n while stack:\n idx = stack.pop()\n ans = max(ans, (end - idx) * heights[idx])\n return ans","memory":"30700"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n\n \n # prev small val index\n def pse(arr):\n\n stack = []\n res = [-1] * len(arr)\n\n for i in range(len(arr)):\n \n # prev eq is impl, we dont want to calc double \n while stack and arr[stack[-1]] >= arr[i]:\n stack.pop()\n \n if stack:\n res[i] = stack[-1]\n\n stack.append(i)\n return res\n\n # next small val index\n def nse(arr):\n stack = []\n res = [len(arr)] * len(arr)\n\n for i in range(len(arr)-1,-1,-1):\n\n while stack and arr[stack[-1]] > arr[i]:\n stack.pop()\n\n if stack:\n res[i] = stack[-1]\n\n stack.append(i)\n return res\n\n pseArr = pse(heights)\n nseArr = nse(heights)\n maxArea = 0\n for i in range(len(heights)):\n \n # dist between two smaller ele\n width = nseArr[i] - pseArr[i]-1\n maxArea = max(maxArea, width * heights[i])\n \n return maxArea","memory":"30800"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n maxArea = 0\n stack = []\n for i, h in enumerate(heights):\n while stack:\n if heights[stack[-1][0]] >= h:\n maxArea = max(maxArea, heights[stack[-1][0]] * (i - stack[-1][1] - 1))\n stack.pop()\n else:\n stack.append((i, stack[-1][0]))\n break\n if not stack:\n stack.append((i, -1))\n for i, l in stack:\n maxArea = max(maxArea, heights[i] * (len(heights) - l - 1))\n return maxArea","memory":"30900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n #height, index #How far back does it go\n\n res = 0\n stack = []\n\n #Append [height,index]\n for i in range(len(heights)):\n height = heights[i]\n index = i\n while stack and stack[-1][0] >= height:\n oldheight, oldIndex = stack.pop()\n res = max(res,oldheight * (i - oldIndex))\n index = oldIndex\n stack.append([height,index])\n\n for height, index in stack:\n res = max(res, height * (len(heights) - index))\n\n return res","memory":"30900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n def prev_smallest(height):\n n=len(height)\n stack=[]\n prev_small=[0]*n\n\n for i in range(n):\n while stack and height[stack[-1]]>=height[i]:\n stack.pop()\n \n if not stack:\n prev_small[i]=-1\n else:\n prev_small[i]=stack[-1]\n \n stack.append(i)\n \n return prev_small\n\n def next_smallest(height):\n n=len(height)\n stack=[]\n next_small=[0]*n\n\n for i in range(n-1,-1,-1):\n while stack and height[stack[-1]]>=height[i]:\n stack.pop()\n \n if not stack:\n next_small[i]=n\n else:\n next_small[i]=stack[-1]\n \n stack.append(i)\n \n return next_small\n\n prev_small=prev_smallest(heights)\n next_small=next_smallest(heights)\n # next_small.reverse()\n print(prev_small,next_small)\n\n max_area=0\n for i in range(len(heights)):\n\n max_area=max(max_area,(next_small[i]-prev_small[i]-1)*heights[i])\n\n return max_area\n\n","memory":"31000"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n = len(heights)\n left = [-1]*n\n right = [n]*n\n stack = []\n for i, v in enumerate(heights):\n while stack and heights[stack[-1]] >= v:\n right[stack[-1]] = i\n stack.pop()\n if stack:\n left[i] = stack[-1]\n stack.append(i)\n\n return max([(right[i] - left[i] -1)*v for i, v in enumerate(heights)])\n ","memory":"31100"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n right_index = [len(heights) for _ in heights]\n s = []\n for i in range(len(heights)):\n if not s or heights[i] >= heights[s[-1]]:\n s.append(i)\n else:\n while s and heights[i] < heights[s[-1]]:\n right_index[s[-1]] = i\n s.pop()\n s.append(i)\n\n left_index = [-1 for _ in heights] # [-1, -1, -1, -1, -1, 4]\n s = [] # [5, ]\n for i in reversed(range(len(heights))): # 4\n if not s or heights[i] >= heights[s[-1]]: # 4 >= 5\n s.append(i)\n else:\n while s and heights[i] < heights[s[-1]]:\n left_index[s[-1]] = i\n s.pop()\n s.append(i)\n\n ret = 0\n for i in range(len(heights)):\n ret = max(ret, heights[i] * (right_index[i] - left_index[i] - 1))\n return ret\n","memory":"31100"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [] # index, val\n res = 0\n for r, cur in enumerate(heights):\n l = r\n while stack and stack[-1][-1] >= cur:\n l, prev = stack.pop()\n res = max(res, prev * (r - l))\n r = l\n stack.append([r, cur])\n \n for i, v in stack:\n res = max(res, v * (len(heights) - i ))\n return res","memory":"31200"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n max_area = 0\n stack = [] # pair of elements : (index, height)\n heights.append(0)\n for i, h in enumerate(heights):\n # Process the stack when the current height is less than the top of the stack\n while stack and heights[stack[-1]] > h:\n height = heights[stack.pop()]\n width = i if not stack else i - stack[-1] - 1\n max_area = max(max_area, height * width)\n stack.append(i)\n \n return max_area","memory":"31300"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n st=[]\n maxi=0\n n=len(heights)\n for i in range(n):\n while st and heights[st[-1]] > heights[i] :\n ele = st[-1]\n st.pop()\n nse=i\n pse = st[-1] if st else -1\n maxi= max(maxi, (nse-pse-1)*heights[ele])\n st.append(i)\n while st:\n ele = st[-1]\n st.pop()\n nse=n\n pse = st[-1] if st else -1\n maxi= max(maxi, (nse-pse-1)*heights[ele])\n return maxi","memory":"31300"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights.append(-1)\n n = len(heights)\n result = 0\n stack = [-1]\n for i in range(n):\n while stack and heights[stack[-1]] > heights[i]:\n h = heights[stack.pop()]\n w = i - stack[-1] - 1\n result = max(result, h * w)\n stack.append(i)\n return result\n\n\n","memory":"31400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [] # стек для хранения индексов\n max_area = 0 # максимальная площадь\n index = 0 # текущий индекс\n\n while index < len(heights):\n # Если текущий бар выше или равен предыдущему, добавляем индекс в стек\n if not stack or heights[index] >= heights[stack[-1]]:\n stack.append(index)\n index += 1\n else:\n # Вытаскиваем последний индекс из стека\n top_of_stack = stack.pop()\n # Рассчитываем площадь с heights[top_of_stack] как наименьшей высотой\n area = (heights[top_of_stack] *\n ((index - stack[-1] - 1) if stack else index))\n # Обновляем максимальную площадь\n max_area = max(max_area, area)\n\n # Рассчитываем площадь для оставшихся индексов в стеке\n while stack:\n top_of_stack = stack.pop()\n area = (heights[top_of_stack] *\n ((index - stack[-1] - 1) if stack else index))\n max_area = max(max_area, area)\n\n return max_area","memory":"31400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n curMax = -float('inf')\n heights.append(-1)\n\n for h in heights:\n curWidth = 0\n while stack and stack[-1][0] > h:\n popH, popW = stack.pop()\n curWidth += popW\n curArea = curWidth * popH\n if curArea > curMax: curMax = curArea\n stack.append((h, curWidth + 1))\n \n return curMax\n \n\n","memory":"31500"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights.insert(0, 0)\n heights.append(0)\n stack = [0]\n result = 0\n for i in range(1, len(heights)):\n while stack and heights[i] < heights[stack[-1]]:\n mid_height = heights[stack[-1]]\n stack.pop()\n if stack:\n # area = width * height\n area = (i - stack[-1] - 1) * mid_height\n result = max(area, result)\n stack.append(i)\n return result","memory":"31500"},{"code":"# in: int[] heights\n# out: largest rectangle in histogram\n\n# can be combined from different bars\n# all ints\n# all positive\n\n# we could have a bar of width 1 that is so tall it is the biggest\n# at any given point, the max area is the smallest bar to the left/right times width\n# we could expand out from each bar and compare max area at each point\n# what if we tried pointers?\n# come in from left + right and at each point, we consider the best possible area\n# we can essentially shrink the taller nums to the left once we hit a smaller num\n# we could build a new array of increasing nums from left and right\n# at each num, we essentially need to know the left + right index that it can stretch to\n# since we want to account for the max we can go to the left, what if we use a stack?\n# do we need a second stack to the right? maybe\n# go across the array, then when we get to a num that is smaller than the last (or min so far?)\n# we should track indices of nums as well so we know how far to the left a height goes\n# ok so use a stack, then pop so we get back to something shorter than prev num\n# each time we hit a shorter num, we know the height to the left has reached its best chance\n# multiply the top num by the distance to the next top el in the stack\n# keep popping until we reach something shorter thasn right num\n# keep going to end of list\n\n# T: O(N), moving across array once and popping up to once (2N)\n# S: O(N) for stack\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n # Initialize variables\n max_area = 0\n stack = [] # Stack to store indices\n \n # Iterate through each bar in the histogram\n for i in range(len(heights)):\n # While the current bar is smaller than the bar at the stack's top, pop from the stack and calculate area\n while stack and heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()] # The height of the rectangle\n # If the stack is empty, it means we can extend all the way back to the beginning\n w = i if not stack else i - stack[-1] - 1 # The width of the rectangle\n max_area = max(max_area, h * w)\n # Push current bar index to the stack\n stack.append(i)\n \n # After we finish iterating through the heights array, we need to process the remaining bars in the stack\n while stack:\n h = heights[stack.pop()]\n w = len(heights) if not stack else len(heights) - stack[-1] - 1\n max_area = max(max_area, h * w)\n \n return max_area\n if not heights:\n return 0\n max_area = 0\n stack = []\n for i in range(len(heights)): # 0,9\n height = heights[i] # 9\n while stack and height < heights[stack[-1]]:\n comparison_height = heights[stack.pop()]\n width = i\n if stack:\n width = i - stack[-1] - 1\n area = comparison_height * width\n max_area = max(max_area, area)\n stack.append(i) #[0,0, 9,1]\n\n # last nums\n while stack:\n comparison_height = heights[stack.pop()] # 9\n width = len(heights) #\n if stack:\n width = len(heights) - stack[-1] - 1 # 1\n area = comparison_height * width\n max_area = max(max_area, area)\n\n return max_area\n\n\n","memory":"31600"},{"code":"# in: int[] heights\n# out: largest rectangle in histogram\n\n# can be combined from different bars\n# all ints\n# all positive\n\n# we could have a bar of width 1 that is so tall it is the biggest\n# at any given point, the max area is the smallest bar to the left/right times width\n# we could expand out from each bar and compare max area at each point\n# what if we tried pointers?\n# come in from left + right and at each point, we consider the best possible area\n# we can essentially shrink the taller nums to the left once we hit a smaller num\n# we could build a new array of increasing nums from left and right\n# at each num, we essentially need to know the left + right index that it can stretch to\n# since we want to account for the max we can go to the left, what if we use a stack?\n# do we need a second stack to the right? maybe\n# go across the array, then when we get to a num that is smaller than the last (or min so far?)\n# we should track indices of nums as well so we know how far to the left a height goes\n# ok so use a stack, then pop so we get back to something shorter than prev num\n# each time we hit a shorter num, we know the height to the left has reached its best chance\n# multiply the top num by the distance to the next top el in the stack\n# keep popping until we reach something shorter thasn right num\n# keep going to end of list\n\n# T: O(N), moving across array once and popping up to once (2N)\n# S: O(N) for stack\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n if not heights:\n return 0\n max_area = 0\n stack = []\n for i in range(len(heights)): # 0,9\n height = heights[i] # 9\n while stack and height < heights[stack[-1]]:\n comparison_height = heights[stack.pop()]\n width = i\n if stack:\n width = i - stack[-1] - 1\n area = comparison_height * width\n max_area = max(max_area, area)\n stack.append(i) #[0,0, 9,1]\n\n # last nums\n while stack:\n comparison_height = heights[stack.pop()] # 9\n width = len(heights) #\n if stack:\n width = len(heights) - stack[-1] - 1 # 1\n area = comparison_height * width\n max_area = max(max_area, area)\n\n return max_area\n\n\n","memory":"31600"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n\n def ngl(nums):\n n=len(nums)\n stack=[]\n res=[]\n\n for i in range(n):\n \n if len(stack)==0:\n res.append(-1)\n elif len(stack)>0 and stack[-1][1]<nums[i]:\n res.append(stack[-1][0])\n elif len(stack)>0 and stack[-1][1]>=nums[i]:\n while len(stack)>0 and stack[-1][1]>=nums[i]:\n stack.pop()\n if len(stack)==0:\n res.append(-1)\n else:\n res.append(stack[-1][0])\n stack.append([i,nums[i]])\n return(res)\n\n def ngr(nums):\n nums.append(-1)\n n=len(nums)\n stack=[]\n res=[]\n\n for i in range(n-1,-1,-1):\n\n if len(stack)==0:\n res.append(-1)\n elif len(stack)>0 and stack[-1][1]<nums[i]:\n res.append(stack[-1][0])\n elif len(stack)>0 and stack[-1][1]>=nums[i]:\n while len(stack)>0 and stack[-1][1]>=nums[i]:\n stack.pop()\n if len(stack)==0:\n res.append(-1)\n else:\n res.append(stack[-1][0])\n stack.append([i,nums[i]])\n return(res[::-1])\n\n a=(ngl(heights))\n b=(ngr(heights))\n c=[]\n n=len(a)\n for i in range(n):\n c.append((b[i]-a[i]-1)*heights[i])\n return(max(c))\n\n \n ","memory":"31700"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n\n def ngl(nums):\n n=len(nums)\n stack=[]\n res=[]\n\n for i in range(n):\n \n if len(stack)==0:\n res.append(-1)\n elif len(stack)>0 and stack[-1][1]<nums[i]:\n res.append(stack[-1][0])\n elif len(stack)>0 and stack[-1][1]>=nums[i]:\n while len(stack)>0 and stack[-1][1]>=nums[i]:\n stack.pop()\n if len(stack)==0:\n res.append(-1)\n else:\n res.append(stack[-1][0])\n stack.append([i,nums[i]])\n return(res)\n\n def ngr(nums):\n nums.append(-1)\n n=len(nums)\n stack=[]\n res=[]\n\n for i in range(n-1,-1,-1):\n\n if len(stack)==0:\n res.append(-1)\n elif len(stack)>0 and stack[-1][1]<nums[i]:\n res.append(stack[-1][0])\n elif len(stack)>0 and stack[-1][1]>=nums[i]:\n while len(stack)>0 and stack[-1][1]>=nums[i]:\n stack.pop()\n if len(stack)==0:\n res.append(-1)\n else:\n res.append(stack[-1][0])\n stack.append([i,nums[i]])\n return(res[::-1])\n\n a=(ngl(heights))\n b=(ngr(heights))\n c=[]\n n=len(a)\n for i in range(n):\n c.append((b[i]-a[i]-1)*heights[i])\n return(max(c))\n\n \n ","memory":"31700"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n st, ans = [(-1, -1)], 0\n for i, height in enumerate(heights):\n past = i\n while st[-1][0] > height:\n h, ind = st.pop()\n past = ind\n ans = max(ans, h*(i - ind))\n st += [(height, past)]\n \n for h, i in st:\n ans = max(ans, h*(len(heights) - i))\n return ans","memory":"31800"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n max_area = 0\n stack = []\n\n for i, h in enumerate(heights):\n start = i\n while stack and h < stack[-1][1]:\n index, height = stack.pop()\n width = i - index\n max_area = max(max_area, height * width)\n start = index #extending back the new height replacing the popped\n \n stack.append((start, h))\n \n for i, h in stack:\n max_area = max(max_area, h * (len(heights) - i)) #checking the area of items remaing in stack\n # from i to end of list\n\n return max_area","memory":"31900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n max_area = 0\n nsr , nsl = [] , []\n stack_nsr , stack_nsl = [], []\n for i in range(len(heights)):\n while stack_nsl and heights[stack_nsl[-1]] >= heights[i]:\n stack_nsl.pop()\n if stack_nsl:\n nsl.append(i-stack_nsl[-1])\n else:\n nsl.append(i+1)\n stack_nsl.append(i)\n\n for i in range(len(heights)-1 , -1 , -1):\n while stack_nsr and heights[stack_nsr[-1]] >= heights[i]:\n stack_nsr.pop()\n if stack_nsr:\n nsr.append(stack_nsr[-1]-i)\n else:\n nsr.append(len(heights)-i)\n stack_nsr.append(i)\n\n nsr = nsr[::-1]\n \n\n for i in range(len(heights)):\n width = nsr[i] + nsl[i] -1 \n area = width * heights[i]\n if area > max_area:\n max_area = area\n\n return max_area\n\n","memory":"32000"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n res = 0\n for i, h in enumerate(heights + [0]):\n while stack and h < heights[stack[-1]]:\n index = stack.pop()\n if stack:\n res = max(res, (i - stack[-1] - 1) * heights[index])\n else:\n res = max(res, (i) * heights[index])\n stack.append(i)\n return res","memory":"32100"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = [(-1, -1)]\n ans = 0\n for i, height in enumerate(heights):\n last = i\n while stack[-1][0] > height:\n h, ind = stack.pop()\n ans = max(ans, h*(i - ind))\n last = ind\n stack.append((height, last))\n \n for h, i in stack:\n ans = max(ans, h*(len(heights) - i))\n \n return ans","memory":"32200"},{"code":"from collections import deque\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n height_starts = deque()\n ans = 0\n for i, h in enumerate(heights):\n start = i\n while len(height_starts) > 0 and height_starts[-1][0] > h:\n oh, os = height_starts.pop()\n # print(oh, os, i - os)\n ans = max(ans, oh * (i - os))\n start = os\n if not (len(height_starts) > 0 and height_starts[0][0] == h):\n height_starts.append((h, start))\n while len(height_starts) > 0:\n oh, os = height_starts.pop()\n # print(oh, os, len(heights) - os)\n ans = max(ans, oh * (len(heights) - os))\n return ans\n","memory":"32299"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n # n = len(heights)\n # res = 0\n # for l in range(n):\n # for r in range(l, n):\n # area = (r-l+1) * min(heights[l], heights[r])\n # if heights[r] < heights[l]:\n # break\n # res = max(res, area)\n # return res\n\n stack = []\n res = 0\n n = len(heights)\n\n for idx, h in enumerate(heights):\n start = idx\n while stack and stack[-1][1] > h:\n stack_idx, stack_h = stack.pop()\n area = (idx-stack_idx) * stack_h\n res = max(res, area)\n start = stack_idx\n stack.append((start, h))\n \n for idx, h in stack:\n area = (n - idx) * h\n res = max(res, area)\n return res","memory":"32400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n result = 0\n\n stack = []\n\n for index, value in enumerate(heights):\n left_index = index\n while stack and stack[-1][1] > value:\n left_index, left_val = stack.pop()\n rectangle_area = (index - left_index) * left_val\n if rectangle_area > result:\n result = rectangle_area\n stack.append((left_index, value))\n\n for index, value in enumerate(stack):\n rect_area = (len(heights) - value[0]) * value[1]\n if rect_area > result:\n result = rect_area\n return result","memory":"32500"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n result = 0\n\n stack = []\n\n for index, value in enumerate(heights):\n left_index = index\n while stack and stack[-1][1] > value:\n left_index, left_val = stack.pop()\n rectangle_area = (index - left_index) * left_val\n if rectangle_area > result:\n result = rectangle_area\n stack.append((left_index, value))\n\n for index, value in enumerate(stack):\n rect_area = (len(heights) - value[0]) * value[1]\n if rect_area > result:\n result = rect_area\n return result","memory":"32500"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n largest = 0\n stack = []\n\n for idx, curr_height in enumerate(heights):\n \n # The new starting index for the height with value v. Defaults to its original index.\n curr_width_idx = idx\n \n\n # if prev height > curr height\n while stack and stack[-1][1] > curr_height:\n old_idx, prev_height = stack.pop()\n \n # previous is larger, so see if we can make a larger rectangle using our now larger width (update curr width idx to use prev heights idx)\n new_width = idx - old_idx\n curr_width_idx = old_idx\n\n largest = max(largest, new_width * prev_height)\n\n\n\n stack.append((curr_width_idx, curr_height))\n\n # check all heights remaining in the stack (An item will remain in the stack if a smaller height hasn't been encountered) Since these rectangles can now extend to the end of the histogram.\n\n for (old_idx, curr_height) in stack:\n width = len(heights) - old_idx\n largest = max(largest, width * curr_height)\n\n return largest","memory":"32600"},{"code":"class Solution:\n '''\n the factor that is going to limit us in terms of area is going to be the fact that we are going to be bounded by \n the smallest recrangle in our array\n \n either get rid of that rectangle or we keep it \n if we keep it then we will bound the rest of the rectangles to that height until we encounter a smaller rectangle then it will be bounded by that \n '''\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack=[]\n maxarea = 0\n for i,h in enumerate(heights):\n startindex=i\n while stack and stack[-1][1]>h:\n index,height=stack.pop()\n print(height)\n maxarea=max(maxarea,height*(i-index))\n startindex=index\n stack.append((startindex,h))\n for i, h in stack:\n maxarea=max(maxarea,h*(len(heights)-i))\n return maxarea\n \n\n ","memory":"32600"},{"code":"class Solution:\n '''\n the factor that is going to limit us in terms of area is going to be the fact that we are going to be bounded by \n the smallest recrangle in our array\n \n either get rid of that rectangle or we keep it \n if we keep it then we will bound the rest of the rectangles to that height until we encounter a smaller rectangle then it will be bounded by that \n '''\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack=[]\n maxarea = 0\n for i,h in enumerate(heights):\n startindex=i\n while stack and stack[-1][1]>h:\n index,height=stack.pop()\n maxarea=max(maxarea,height*(i-index))\n startindex=index\n stack.append((startindex,h))\n for i, h in stack:\n maxarea=max(maxarea,h*(len(heights)-i))\n return maxarea\n \n\n ","memory":"32700"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n # give is list of heights\n # need to return biggest area possible\n maxArea = 0\n stack = [] # pair: (index, height)\n\n for i, h in enumerate(heights):\n start = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n maxArea = max(maxArea, height * (i - index))\n start = index\n stack.append((start, h))\n\n for i, h in stack:\n maxArea = max(maxArea, h * (len(heights) - i))\n return maxArea\n","memory":"32800"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = deque()\n result = 0\n for i, h in enumerate(heights):\n idx = i\n while stack and h < stack[-1][1]:\n idx, height = stack.pop()\n width = i - idx\n result = max(result, height * width)\n \n stack.append((idx, h))\n \n while stack:\n idx, height = stack.pop()\n width = len(heights) - idx\n result = max(result, height * width)\n\n return result","memory":"32900"},{"code":"\"\"\" Watch this solution: https://www.youtube.com/watch?v=zx5Sw9130L0\n\"\"\"\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n area = 0\n \n for i, height in enumerate(heights):\n start = i\n while stack and stack[-1][1] > height:\n prev_index, prev_height = stack.pop()\n area = max(area, (i - prev_index) * prev_height)\n start = prev_index\n \n stack.append((start, height))\n \n while stack:\n start, height = stack.pop()\n area = max(area, (len(heights) - start) * height)\n \n return area","memory":"33000"},{"code":"class Solution:\n # the idea is that all the rectangles in the histogram must be able to extend to the end\n # if you are smaller than the previous value then the previous value cannot extend to the end\n # maintain a monotonically increasing stack\n # when you need to pop a value off calculate it's max possible value\n # do h * (curr - idx)\n # stretch back the current index to the idx and append it to the stack\n # process the values left in the stack\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n _max = [0]\n for i, h in enumerate(heights):\n next_i = i\n while len(stack) != 0 and stack[-1][1] > h:\n pidx, ph = stack.pop()\n _max[0] = max(_max[0], (i - pidx) * ph)\n next_i = pidx\n stack.append((next_i, h))\n\n while len(stack) != 0:\n pidx, ph = stack.pop()\n _max[0] = max(_max[0], (len(heights) - pidx) * ph)\n \n return _max[0]\n ","memory":"33100"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n=len(heights)\n stk=[]\n max_area=0\n\n for i , height in enumerate(heights):\n start = i\n while stk and height < stk[-1][0]:\n h,j=stk.pop()\n w =i - j\n a=h*w\n max_area= max(max_area,a)\n start = j\n stk.append((height,start))\n\n while stk:\n h,j = stk.pop()\n w = n-j\n max_area= max(max_area,h*w)\n return max_area\n\n ","memory":"33200"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n output = 0\n\n for i in range(len(heights)):\n min_index = i\n\n while len(stack) and stack[-1][1] > heights[i]:\n curr = stack.pop()\n output = max(output, (i - curr[0]) * curr[1])\n min_index = curr[0]\n\n stack.append((min_index, heights[i]))\n \n while len(stack):\n curr = stack.pop()\n output = max(output, (len(heights) - curr[0]) * curr[1])\n \n return output\n\n\n \n\n\n\n \n ","memory":"33300"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights_len = len(heights)\n stack = []\n maxH = 0\n\n for idx, h in enumerate(heights):\n start = idx\n while stack and stack[-1][-1] > h:\n index, height = stack.pop()\n maxH = max(maxH, height * (idx - index))\n start = index\n stack.append((start, h))\n \n\n while stack:\n index, height = stack.pop()\n maxH = max(maxH, height * (heights_len - index))\n \n return maxH\n ","memory":"33300"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n area = 0\n i = 0 \n stack = [] #(index, height)\n\n while i < len(heights):\n index = i\n\n while stack and stack[-1][1] > heights[i]:\n index, height = stack.pop()\n area = max(area, (height * (i - index)))\n \n stack.append((index, heights[i]))\n i += 1\n\n while stack:\n index, height = stack.pop()\n area = max(area, (height * (len(heights) - index)))\n\n return area","memory":"33400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n n=len(heights)\n stack=[]\n maxArea=0\n\n for i,height in enumerate(heights):\n start=i\n while stack and height < stack[-1][0]:\n h,j=stack.pop()\n w=i-j \n maxArea=max(maxArea,h*w)\n start=j\n stack.append((height,start))\n while stack:\n h,j = stack.pop()\n w=n-j\n maxArea=max(maxArea,h*w)\n return maxArea","memory":"33400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n max_area = 0\n for i in range(len(heights)):\n start = i\n while stack and stack[-1][1] > heights[i]:\n index, height = stack.pop()\n max_area = max(max_area, height * (i - index))\n start = index\n stack.append((start, heights[i]))\n \n length = len(heights)\n while stack:\n index, height = stack.pop()\n max_area = max(max_area, height * (length - index))\n\n return max_area\n","memory":"33500"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n maxArea = 0\n stack = []\n\n for i, h in enumerate(heights):\n start = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n maxArea = max(maxArea, height * (i - index))\n start = index\n stack.append((start, h))\n \n for i, h in stack:\n maxArea = max(maxArea, h * (len(heights) - i))\n \n return maxArea\n","memory":"33500"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n out=0\n stack=[]\n for i in range(len(heights)):\n temp_index=i\n while stack and stack[-1][-1]>heights[i]:\n temp_index,temp=stack.pop()\n out=max(out,temp*(i-temp_index))\n stack.append((temp_index,heights[i]))\n for i,h in stack:\n out=max(out,h*(len(heights)-i))\n return out","memory":"33600"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n maxArea = 0\n stack = []\n\n for i, h in enumerate(heights):\n start = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n maxArea = max(maxArea, height * (i - index))\n start = index\n stack.append((start, h))\n\n for i, h in stack:\n maxArea = max(maxArea, h * (len(heights) - i))\n\n return maxArea\n\n\n ","memory":"33600"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n maxArea = 0\n stack=[]\n for i,h in enumerate(heights):\n start = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n maxArea = max(maxArea, height*(i-index))\n start = index\n stack.append((start,h))\n \n for i,h in stack:\n maxArea = max(maxArea, h*(len(heights)-i))\n return maxArea","memory":"33700"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n res = 0\n stack = []\n\n for i, h in enumerate(heights):\n start = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n \n res = max(res, (i-index) *height)\n start = index\n stack.append((start, h))\n \n for i, h in stack:\n res = max(res, (len(heights)-i ) *h)\n return res\n","memory":"33700"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n left = [i for i in range(len(heights))]\n right = [i for i in range(len(heights))]\n\n increasing = deque()\n\n for i, height in enumerate(heights):\n while len(increasing) > 0 and heights[increasing[-1]] > height:\n right[increasing.pop()] = i\n \n increasing.append(i)\n \n for i in increasing:\n right[i] = len(heights)\n\n increasing = deque()\n\n for i in range(len(heights) - 1, -1, -1):\n height = heights[i]\n while len(increasing) > 0 and heights[increasing[-1]] > height:\n left[increasing.pop()] = i\n \n increasing.append(i)\n\n for i in increasing:\n left[i] = -1\n \n res = 0\n for i, (l, r) in enumerate(zip(left, right)):\n res = max(res, heights[i] * (r - l - 1))\n\n return res\n","memory":"33800"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n curr_max = heights[0]\n stack = [(curr_max, 0)] # height (>= current height), start index\n N = len(heights)\n\n for i in range(1,N):\n curr_h = heights[i]\n ind_append = i #\n while stack and stack[-1][0] > curr_h:\n prev_h, ind_append = stack.pop() # ind_append = prev_i\n curr_max = max(curr_max, prev_h*(i-ind_append))\n stack.append((curr_h, ind_append))\n\n for h,i in stack:\n curr_max = max(curr_max, h*(N-i))\n\n return curr_max","memory":"33900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = collections.deque([])\n max_area = float('-inf')\n\n for i in range(len(heights)):\n back_index = i\n while len(stack) > 0 and stack[-1][1] > heights[i]:\n index, height = stack.pop()\n max_area = max(max_area, height * (i - index))\n back_index = index\n \n stack.append((back_index, heights[i]))\n while stack:\n index, height = stack.pop()\n max_area = max(max_area, height * (len(heights) - index))\n \n return max_area\n\n ","memory":"33900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n max_area = 0\n\n for w,h in enumerate(heights):\n start = w\n while stack and stack[-1][1] > h:\n width, height = stack.pop()\n max_area = max(max_area, height * (w - width))\n print(max_area)\n start = width\n stack.append((start,h))\n \n for w,h in stack:\n max_area = max(max_area, h * (len(heights) - w))\n print(\"Second\" , max_area)\n return max_area\n \n","memory":"34000"},{"code":"class Solution:\n def largestRectangleArea(self, heights: list[int]) -> int:\n \n max_area: int = 0 # 7 \n stack: list[(int, int)] = [] # (1, 0), (3, 1)\n\n for i, height in enumerate(heights): # 0, 1 | 1, 3 | 3, 2\n if not stack: # the stack is empty\n stack.append((height, i))\n continue\n\n start = i\n while stack and height < stack[-1][0]:\n rect_height, start = stack.pop()\n rect_area = rect_height * (i - start)\n max_area = max(max_area, rect_area)\n \n stack.append((height, start))\n \n while stack: # [1, 0 | 2, 3]\n rect_height, start = stack.pop()\n rect_area = rect_height * (len(heights) - start)\n print(rect_height, start, rect_area)\n max_area = max(max_area, rect_area)\n\n return max_area\n ","memory":"34100"},{"code":"class Solution:\n def largestRectangleArea(self, heights: list[int]) -> int:\n \n max_area: int = 0 # 7 \n stack: list[(int, int)] = [] # (1, 0), (3, 1)\n\n for i, height in enumerate(heights): # 0, 1 | 1, 3 | 3, 2\n if not stack: # the stack is empty\n stack.append((height, i))\n continue\n\n start = i\n while stack and height < stack[-1][0]:\n rect_height, start = stack.pop()\n rect_area = rect_height * (i - start)\n max_area = max(max_area, rect_area)\n \n stack.append((height, start))\n \n while stack: # [1, 0 | 2, 3]\n rect_height, start = stack.pop()\n rect_area = rect_height * (len(heights) - start)\n print(rect_height, start, rect_area)\n max_area = max(max_area, rect_area)\n\n return max_area\n ","memory":"34200"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n '''\n Monotonic Stack\n T: O(n)\n S: O(n)\n stack = [[index, height]]\n If a int is less than both of its left and right neighobors,\n then the largest rectangle with width greater than 2 is no longer\n able to consider this int as its height, we can just pop it\n Likewise, whenever the height of the last int in the stack is\n greater than the cur int, we drop it and calculate the area from\n it till current, since the int cannot extend anymore when it encounter\n some smaller int after it\n '''\n res = 0\n stack = []\n for i, h in enumerate(heights):\n start = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n res = max(res, height * (i - index))\n start = index\n \n stack.append([start, h])\n \n for i, h in stack:\n res = max(res, h * (len(heights) - i))\n\n return res","memory":"34300"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n largest = 0\n for i, h in enumerate(heights):\n count = 0\n while stack and stack[-1][0] > h:\n height, idx = stack.pop()\n largest = max(largest, height * (i - idx))\n count += 1\n for j in range(count, -1, -1):\n stack.append((h, i - j))\n while stack:\n height, idx = stack.pop()\n largest = max(largest, height * (len(heights) - idx))\n return largest","memory":"34400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n largest = 0\n for i, h in enumerate(heights):\n count = 0\n while stack and stack[-1][0] > h:\n height, idx = stack.pop()\n largest = max(largest, height * (i - idx))\n count += 1\n for j in range(count, -1, -1):\n stack.append((h, i - j))\n while stack:\n height, idx = stack.pop()\n largest = max(largest, height * (len(heights) - idx))\n return largest","memory":"34400"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n heights.append(0)\n s = deque()\n maxArea = 0\n for i in range(0, len(heights)):\n height = heights[i]\n # only append if height is greater than to keep the stack monotonic\n if not s or height > s[-1][0]:\n s.append([height, i])\n else:\n leftBoundary = i\n while s and height < s[-1][0]:\n sHeight, sPt = s.pop()\n maxArea = max(maxArea, sHeight * (i - sPt)) \n leftBoundary = sPt\n s.append([height, leftBoundary])\n return maxArea\n \n \n ","memory":"34500"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n res = 0\n for i,h in enumerate(heights):\n lastIndex = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n res = max(res, height * (i - index))\n lastIndex = index\n stack.append([lastIndex, h])\n\n for i, h in stack:\n res = max(res, h * (len(heights) - i))\n return res ","memory":"34600"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n max_area = 0\n stack = []\n for i , h in enumerate(heights):\n idx = i\n if not stack:\n stack.append([i , h])\n continue\n while stack and stack[-1][1] > h:\n idx , he = stack.pop()\n max_area = max(max_area , (i - idx ) * he)\n stack.append([idx , h])\n\n while stack:\n idx , he = stack.pop()\n max_area = max(max_area , (i - idx + 1) * he) \n return max_area","memory":"34700"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n max_area = 0\n my_stack = []\n for index, ele in enumerate(heights):\n if len(my_stack) == 0:\n my_stack.append([index, ele])\n elif ele >= my_stack[-1][1]:\n my_stack.append([index, ele])\n else:\n pair_to_add = [index, ele]\n while len(my_stack) > 0 and my_stack[-1][1] > ele:\n curr_pair = my_stack.pop()\n area = curr_pair[1] * (index - curr_pair[0])\n max_area = max(max_area, area)\n pair_to_add[0] = curr_pair[0]\n my_stack.append(pair_to_add)\n \n while len(my_stack) > 0:\n pair = my_stack.pop()\n max_area = max(max_area, (pair[1] * (len(heights) - pair[0])))\n \n return max_area ","memory":"34800"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n maxArea = 0\n for ind, height in enumerate(heights):\n i = ind\n h = height\n while stack and height < stack[-1][1]:\n i, h = stack.pop()\n maxArea = max(maxArea, h * (ind-i))\n \n stack.append([i, height])\n maxArea = max(maxArea, height)\n\n while stack:\n i, h = stack.pop()\n maxArea = max(maxArea, h * (len(heights)-i))\n return maxArea","memory":"34900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n maxArea = 0\n for ind, height in enumerate(heights):\n i = ind\n h = height\n while stack and height < stack[-1][1]:\n i, h = stack.pop()\n maxArea = max(maxArea, h * (ind-i))\n stack.append([i, height])\n\n while stack:\n i, h = stack.pop()\n maxArea = max(maxArea, h * (len(heights)-i))\n return maxArea","memory":"34900"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n ans = 0\n for i in range(len(heights)):\n start = i\n while stack and stack[-1][-1] > heights[i]:\n index ,h = stack.pop()\n ans = max(ans, h *(i-index))\n start = index\n stack.append([start,heights[i]])\n while stack:\n i,h = stack.pop()\n ans = max(ans,h *(len(heights)-i))\n return ans\n\n \n ","memory":"35000"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n maxArea = 0\n numOfRectangles = len(heights)\n for ind, height in enumerate(heights):\n i = ind\n while stack and height < stack[-1][1]:\n i, h = stack.pop()\n maxArea = max(maxArea, h * (ind-i))\n stack.append([i, height])\n while stack:\n i, h = stack.pop()\n maxArea = max(maxArea, h * (numOfRectangles-i))\n return maxArea","memory":"35000"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n stack = []\n max_area = float('-inf')\n\n for index, height in enumerate(heights):\n while stack and stack[-1][1] > height:\n sIndex, sHeight = stack.pop()\n\n length = index if not stack else index - stack[-1][0] - 1\n area = length * sHeight\n\n max_area = max(max_area, area)\n stack.append([index, height])\n\n while stack:\n sIndex, sHeight = stack.pop()\n\n length = len(heights) if not stack else len(heights) - stack[-1][0] - 1\n area = length * sHeight\n\n max_area = max(max_area, area)\n\n return max_area","memory":"35100"},{"code":"class Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n max_area = 0\n my_stack = []\n for index, ele in enumerate(heights):\n if len(my_stack) == 0 or ele >= my_stack[-1][1]:\n my_stack.append([index, ele])\n else:\n pair_to_add = [index, ele]\n while len(my_stack) > 0 and my_stack[-1][1] > ele:\n curr_pair = my_stack.pop()\n area = curr_pair[1] * (index - curr_pair[0])\n max_area = max(max_area, area)\n pair_to_add[0] = curr_pair[0]\n my_stack.append(pair_to_add)\n \n while len(my_stack) > 0:\n pair = my_stack.pop()\n max_area = max(max_area, (pair[1] * (len(heights) - pair[0])))\n \n return max_area ","memory":"35100"}],"string":"[\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(heights: List[int]) -> int:\\n n = len(heights)\\n max_area = 0\\n stack = []\\n for j in range(n):\\n h = heights[j]\\n while stack and h < heights[stack[-1]]:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (j - left)\\n if area > max_area:\\n max_area = area\\n stack.append(j)\\n while stack:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (n - left)\\n if area > max_area:\\n max_area = area\\n return max_area\\n if __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads,stdin):\\n print(largestRectangleArea(i), file=f)\\n exit(0)\",\n \"memory\": \"25400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n = len(heights)\\n stack = []\\n max_area = 0\\n\\n for i in range(n):\\n while stack and heights[i] <= heights[stack[-1]]:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1 if stack else i\\n max_area = max(max_area, height * width)\\n stack.append(i)\\n\\n while stack:\\n height = heights[stack.pop()]\\n width = n - stack[-1] - 1 if stack else n\\n max_area = max(max_area, height * width)\\n\\n return max_area\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n inputs = map(loads, stdin)\\n for nums in inputs:\\n print(Solution().largestRectangleArea(nums),file=f)\\nexit(0)\",\n \"memory\": \"25500\"\n },\n {\n \"code\": \"def largestRectangleArea(heights: List[int]) -> int:\\n n = len(heights)\\n max_area = 0\\n stack = []\\n for j in range(n):\\n h = heights[j]\\n while stack and h < heights[stack[-1]]:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (j - left)\\n if area > max_area:\\n max_area = area\\n stack.append(j)\\n while stack:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (n - left)\\n if area > max_area:\\n max_area = area\\n return max_area\\n\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads,stdin):\\n print(largestRectangleArea(i), file=f)\\n exit(0)\",\n \"memory\": \"25700\"\n },\n {\n \"code\": \"# class Solution:\\ndef largestRectangleArea(heights: List[int]) -> int:\\n n = len(heights)\\n max_area = 0\\n stack = []\\n for j in range(n):\\n h = heights[j]\\n while stack and h < heights[stack[-1]]:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (j - left)\\n if area > max_area:\\n max_area = area\\n stack.append(j)\\n while stack:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (n - left)\\n if area > max_area:\\n max_area = area\\n return max_area\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads,stdin):\\n print(largestRectangleArea(i), file=f)\\n exit(0)\\n \\n # Failed\\n # if len(heights)==1:\\n # return heights[0]\\n # l, r = 0, len(heights) - 1\\n # max_tmp = 0\\n\\n # while l < r:\\n # val_l = heights[l]\\n # val_r = heights[r]\\n\\n # if val_l < val_r:\\n # x = val_l * (r-l+1)\\n # l += 1 \\n # if val_l > heights[l] and l < r:\\n # max_tmp = 0\\n # x=0\\n # max_tmp = max(max_tmp, x)\\n # else:\\n # x = val_r * (r-l+1)\\n # r -= 1 \\n # if val_r > heights[r] and l < r:\\n # max_tmp = 0\\n # x = 0\\n # max_tmp = max(max_tmp, x)\\n \\n # lon = 0\\n # for i in range(len(heights)):\\n # if heights[i] == 0:\\n # if heights[lon:i]:\\n # max_tmp = max(min(heights[lon:i]) * (i - lon), max_tmp)\\n # lon = i+1\\n # elif i == len(heights)-1:\\n # # print(min(heights[lon:i+1]) * (i+1 - lon))\\n # max_tmp = max(min(heights[lon:i+1]) * (i+1 - lon), max_tmp)\\n # return max(max_tmp, max(heights))\",\n \"memory\": \"25800\"\n },\n {\n \"code\": \"# class Solution:\\ndef largestRectangleArea(heights: List[int]) -> int:\\n heights += [0]\\n stack = []\\n max_area = -sys.maxsize\\n for i, height in enumerate(heights):\\n if not stack or height > stack[-1][0]:\\n stack.append((height,i))\\n else:\\n while stack and stack[-1][0] >= height:\\n h2, i2 = stack.pop()\\n area = (i - i2) * h2\\n max_area = max(max_area, area)\\n stack.append((height, i2))\\n return max_area\\n\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads,stdin):\\n print(largestRectangleArea(i), file=f)\\n exit(0)\",\n \"memory\": \"25900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights += [0]\\n ans = 0\\n stk = [-1]\\n\\n # Every height in heights can form a rectangle by expanding to the next smaller(or equal) element on its left and right\\n # ans must be one of them\\n\\n # try to expand in increasing order to the right, until we encounter sth smaller, this will be the next smaller on the right; mono stack keeps track of next smaller on the left\\n # the content of the stack\\n # ---------------------------------|\\n # -- idx of increasing elements --> top\\n # ---------------------------------|\\n\\n # stack[-1]=left next smaller | h=stack.pop() | i=right next smaller \\n\\n # for each element at index i, if it's smaller than stack.top()\\n # Then the rectangle with height of stack.top() can no longer expand right\\n # we pop it this height {h} from the stack, stack.top() is the prev element that is smaller than {h}\\n # the rectangle area = {h} * (i - 1 - stack.top())\\n\\n for i, h in enumerate(heights):\\n while stk and heights[stk[-1]] > h:\\n # The top of stack must be popped off, no more extension to the right\\n height = heights[stk.pop()]\\n\\n # right next smaller of h is at index i\\n # rectangle's right ends at i-1\\n # left next smaller of h is at index stk[-1]\\n \\n width = i - 1 - stk[-1]\\n\\n ans = max(ans, height * width)\\n # end while\\n\\n stk.append(i)\\n # end for\\n\\n return ans\\n\\nsol = Solution()\\nf = open('user.out', 'w')\\nfor i in map(loads, stdin):\\n f.write(f'{sol.largestRectangleArea(i)}\\\\n')\\nf.flush()\\nexit(0)\",\n \"memory\": \"26000\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n st = []\\n n = len(heights)\\n prevSm = [-1 for _ in range(n)]\\n for i in range(n):\\n while len(st) and st[-1][0] >= heights[i]:\\n st.pop()\\n if len(st):\\n prevSm[i] = st[-1][1]\\n st.append([heights[i], i])\\n \\n st = []\\n nextSm = [n for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n while len(st) and st[-1][0] >= heights[i]:\\n st.pop()\\n if len(st):\\n nextSm[i] = st[-1][1]\\n st.append([heights[i], i])\\n \\n maxA = 0\\n for i in range(n):\\n maxA = max(maxA, heights[i] * (nextSm[i] - prevSm[i] - 1))\\n return maxA\\n\\n\\n\\n \",\n \"memory\": \"27900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [-1]\\n max_area = 0\\n\\n for i in range(len(heights)):\\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n stack.append(i)\\n \\n while stack[-1] != -1:\\n height = heights[stack.pop()]\\n width = len(heights) - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n \\n return max_area \",\n \"memory\": \"28100\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n=len(heights)\\n stk=[-1]\\n max_=0\\n for i in range(n):\\n while stk[-1]!=-1 and heights[stk[-1]]>=heights[i]:\\n max_=max(max_,heights[stk.pop()]*(i-stk[-1]-1))\\n stk.append(i)\\n while stk[-1]!=-1:\\n max_=max(max_,heights[stk.pop()]*(len(heights)-stk[-1]-1))\\n return max_\\n\",\n \"memory\": \"28400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights.append(0)\\n ans = 0\\n stk = deque() # stores the indices of potential left bounds of the rectangle\\n for i, x in enumerate(heights):\\n if len(stk) == 0 or x > heights[stk[-1]]:\\n stk.append(i)\\n else:\\n leftmost = i\\n while len(stk) > 0 and x < heights[stk[-1]]:\\n ans = max(ans, (i - stk[-1]) * heights[stk[-1]])\\n heights[stk[-1]] = x\\n leftmost = stk[-1]\\n stk.pop()\\n stk.append(leftmost)\\n return ans\\n\",\n \"memory\": \"28700\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # Stack to keep indices of the bars in the histogram\\n stack = []\\n max_area = 0\\n index = 0\\n \\n while index < len(heights):\\n # Push the current index if the current bar is taller than the bar at the stack's top\\n if not stack or heights[stack[-1]] <= heights[index]:\\n stack.append(index)\\n index += 1\\n else:\\n # Calculate the area with the bar at the top of the stack as the shortest bar\\n top_of_stack = stack.pop()\\n height = heights[top_of_stack]\\n width = index if not stack else index - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n \\n # Now pop the remaining bars in the stack and calculate the area\\n while stack:\\n top_of_stack = stack.pop()\\n height = heights[top_of_stack]\\n width = index if not stack else index - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n \\n return max_area\",\n \"memory\": \"29100\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n \\n '''\\n 1) Use left and right pointers\\n 2) keep moving right unless the rectangle area is decreased, or current index is greater than the current area\\n in that case shift left pointer to the right one\\n\\n [3 1 2 4 2]\\n\\n '''\\n\\n stack, ans = [], 0\\n for i, h in enumerate(heights + [0]):\\n while stack and heights[stack[-1]] >= h:\\n H = heights[stack.pop()]\\n W = i if not stack else i-stack[-1]-1\\n ans = max(ans, H*W)\\n stack.append(i)\\n return ans\\n\\n \",\n \"memory\": \"29200\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights = [-inf] + heights + [-inf]\\n stack = []\\n max_area = 0\\n for i, height in enumerate(heights):\\n while stack and heights[stack[-1]] > height:\\n curr_idx = stack.pop()\\n left = stack[-1] + 1\\n right = i - 1\\n width = right - left + 1\\n curr_height = heights[curr_idx]\\n max_area = max(max_area, curr_height * width)\\n stack.append(i)\\n return max_area\",\n \"memory\": \"29300\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n heights = [0] + heights + [0]\\n largestrect = 0\\n \\n for i in range(len(heights)):\\n while stack and heights[i] < heights[stack[-1]]:\\n popped = stack.pop()\\n largestrect = max(largestrect, (i - 1 - stack[-1]) * heights[popped])\\n stack.append(i)\\n \\n return largestrect\\n\\n# Time complexity = O(n)\\n# Space complexity = O(n)\",\n \"memory\": \"29400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n\\n stack = []\\n\\n N = len(heights)\\n\\n max_val = 0\\n\\n for i in range(N):\\n \\n h = heights[i]\\n index = i\\n\\n while stack and stack[-1][0] >= h:\\n old = stack.pop()\\n index = old[2]\\n val = old[0] * ((i - old[2]))\\n print(old)\\n print(val)\\n max_val = max(max_val, val)\\n \\n stack.append([h, i, index])\\n\\n\\n print('==============')\\n print(stack)\\n print('==============')\\n\\n while stack:\\n old = stack.pop()\\n val = old[0] * (N - old[2])\\n print(old)\\n print(val)\\n max_val = max(max_val, val)\\n\\n return max_val\\n\\n \\n\\n \\n\\n \\n\",\n \"memory\": \"29500\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights_new = [0] + heights + [0]\\n stack = []\\n area = 0\\n for i in range(len(heights_new)):\\n while stack and heights_new[stack[-1]] > heights_new[i]:\\n mid = stack.pop()\\n if not stack: continue\\n left = stack[-1]\\n h = heights_new[mid]\\n w = i-left-1\\n area = max(h*w, area)\\n\\n stack.append(i)\\n if heights_new[stack[-1]] <= heights_new[i]:\\n stack.append(i)\\n return area\",\n \"memory\": \"29600\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n ans = 0\\n for i, h in enumerate(heights):\\n if not stack or heights[stack[-1]] < h:\\n stack.append(i)\\n continue\\n \\n while stack and h <= heights[stack[-1]]:\\n idx = stack.pop()\\n ans = max(ans, (i - idx) * heights[idx])\\n \\n heights[idx] = h\\n stack.append(idx)\\n \\n end = len(heights)\\n while stack:\\n idx = stack.pop()\\n ans = max(ans, (end - idx) * heights[idx])\\n return ans\",\n \"memory\": \"29700\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n \\n if len(heights) == 0:\\n return 0\\n \\n smallerLeft = [0] * len(heights)\\n smallerRight = [0] * len(heights)\\n \\n for i in range(len(heights)):\\n pos = i-1\\n while pos >= 0 and heights[i] <= heights[pos]:\\n pos = smallerLeft[pos]\\n smallerLeft[i] = pos\\n \\n for i in range(len(heights)-1,-1,-1):\\n pos = i+1\\n while pos <= len(heights)-1 and heights[i] <= heights[pos]:\\n pos = smallerRight[pos]\\n smallerRight[i] = pos\\n \\n maxArea = 0\\n for i, h in enumerate(heights):\\n maxArea = max(maxArea, (smallerRight[i]-smallerLeft[i]-1) * heights[i])\\n \\n return maxArea\\n \",\n \"memory\": \"29800\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights = [0] + heights + [0]\\n stack = []\\n max_area = 0\\n i = 0\\n while i < len(heights):\\n if len(stack) == 0 or heights[i] >= heights[stack[-1]]:\\n stack.append(i)\\n i += 1\\n elif heights[i] < heights[stack[-1]]:\\n popped = stack.pop()\\n width = i - stack[-1] - 1\\n max_area = max(max_area, width * heights[popped])\\n else:\\n i += 1\\n\\n return max_area\",\n \"memory\": \"29900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n=len(heights)\\n def findprevsmall():\\n result=[-1]*n\\n stack=[]\\n for i in range(n):\\n while stack and heights[stack[-1]]>=heights[i]:\\n stack.pop()\\n if stack:\\n result[i]=stack[-1]\\n stack.append(i)\\n return result\\n def findnextsmall():\\n result=[n]*n\\n stack=[]\\n for i in range(n-1,-1,-1):\\n while stack and heights[stack[-1]]>=heights[i]:\\n stack.pop()\\n if stack:\\n result[i]=stack[-1]\\n stack.append(i)\\n return result\\n result=0\\n left=findprevsmall()\\n right=findnextsmall()\\n for i in range(n):\\n height=heights[i]\\n breadth=right[i]-left[i]-1\\n area=height*breadth\\n result=max(result,area)\\n return result\\n\\n \",\n \"memory\": \"29900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n curr_max = heights[0]\\n stack = [(curr_max, 0)] # height (>= current height), start index\\n N = len(heights)\\n\\n for i in range(1,N):\\n curr_h = heights[i]\\n ind_append = i #\\n while stack and stack[-1][0] >= curr_h:\\n prev_h, ind_append = stack.pop() # ind_append = prev_i\\n curr_max = max(curr_max, prev_h*(i-ind_append))\\n stack.append((curr_h, ind_append))\\n\\n for h,i in stack:\\n curr_max = max(curr_max, h*(N-i))\\n\\n return curr_max\",\n \"memory\": \"30000\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n maxR = 0\\n recStack = [[0,0]]\\n heights.append(0)\\n # Pad left and right of histogram with 0s to ensure algorithm has the right stopping bounds\\n for x in heights:\\n width = 0\\n # Keep popping off stack elements until stack is empty or bar smaller than current is found\\n while recStack and x <= recStack[-1][1]:\\n w,h = recStack.pop()\\n width += w # Expanding width of peak section\\n maxR = max(maxR,width*h) # Popped h value will always be smaller or equal to current h due to nature of while loop\\n recStack.append([width+1,x]) # Add current bar to stack, extended as far left as possible\\n return maxR\",\n \"memory\": \"30000\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n maxR = 0\\n recStack = [[0,0]]\\n heights.append(0)\\n for x in heights:\\n width = 0\\n while recStack and x <= recStack[-1][1]:\\n h = recStack.pop()\\n width += h[0]\\n maxR = max(maxR,width*h[1])\\n recStack.append([width+1,x])\\n return maxR\",\n \"memory\": \"30100\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n if not heights:\\n return 0\\n stack = [] # maintains the index, an strictly increasing stack\\n maxArea = 0\\n for i in range(len(heights)+1): # last height is 0;\\n curH = 0 if i == len(heights) else heights[i] # current height at location i; \\n # last one is 0 for cases like [1,2,3] so that we have a chance to pop all in the stack\\n\\n while stack and curH <= heights[stack[-1]]: # we saw a smaller height, time to pop and calculate area; Need to use <=, because it is a strictly increasing stack (we need to find the strictly smaller element on the left;) so that when we quit, we can append.\\n h = heights[stack.pop()]\\n start = stack[-1] if stack else -1 # if stack is empty, start = -1 (for cases like [1])\\n # start location, index of the first smaller height in the left of the poped height; \\n # i is the first samller height in the right of the poped height\\n # |__________|........|___________________|___________|\\n # stack[-1] stack.pop() i\\n width = i - start - 1\\n # print([\\\"stack containing index\\\", stack, \\\"curH\\\", curH, \\\"i\\\", i, \\\"start\\\", start, \\\"width\\\", width, \\\"h\\\", h, \\\"area\\\", width*h])\\n maxArea = max(maxArea, width * h)\\n\\n # currH > heights[stack[-1]]\\n # print(stack)\\n stack.append(i) # curH is higher then top of stack or stack is empty, push to increasing stack\\n\\n return maxArea\",\n \"memory\": \"30100\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n #use monotonic stack to store the index of number\\n st,res=[],0\\n for height in heights +[-1]:\\n step=0\\n while st and st[-1][1]>=height:\\n w,h=st.pop()\\n step+=w\\n res=max(res,step*h)\\n st.append((step+1,height))\\n return res\\n \\n\\n \\n \",\n \"memory\": \"30200\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights.append(0)\\n monotonic_stack = []\\n ans = 0\\n for idx, height in enumerate(heights):\\n while monotonic_stack and height < heights[monotonic_stack[-1]]:\\n popped_idx = monotonic_stack.pop()\\n left_idx = monotonic_stack[-1] + 1 if monotonic_stack else 0\\n right_idx = idx - 1\\n width = right_idx - left_idx + 1\\n cur_height = heights[popped_idx]\\n area = width * cur_height\\n ans = max(ans, area)\\n monotonic_stack.append(idx)\\n return ans\",\n \"memory\": \"30200\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n \\n n = len(heights)\\n \\n # Arrays to store the Nearest Smaller to Left and Right\\n NSL = [-1] * n\\n NSR = [n] * n\\n \\n # Stack to compute Nearest Smaller to Left (NSL)\\n stack = []\\n for i in range(n):\\n while stack and heights[stack[-1]] >= heights[i]:\\n stack.pop()\\n NSL[i] = stack[-1] if stack else -1\\n stack.append(i)\\n \\n # Clear stack and compute Nearest Smaller to Right (NSR)\\n stack = []\\n for i in range(n-1, -1, -1):\\n while stack and heights[stack[-1]] >= heights[i]:\\n stack.pop()\\n NSR[i] = stack[-1] if stack else n\\n stack.append(i)\\n \\n # Compute the maximum area\\n max_area = 0\\n for i in range(n):\\n width = NSR[i] - NSL[i] - 1\\n max_area = max(max_area, heights[i] * width)\\n \\n return max_area\",\n \"memory\": \"30300\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack, largest = [], 0\\n for h in heights + [-1]:\\n step = 0\\n while stack and stack[-1][1] >= h:\\n wid, hei = stack.pop()\\n step += wid\\n largest = max(largest, step * hei)\\n stack.append((step + 1, h))\\n return largest\",\n \"memory\": \"30300\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [-1]\\n max_area = 0\\n\\n for i in range(len(heights)):\\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n stack.append(i)\\n \\n while stack[-1] != -1:\\n height = heights[stack.pop()]\\n width = len(heights) - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n \\n return max_area\",\n \"memory\": \"30400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n = len(heights)\\n right = [n]*n\\n left = [-1]*n\\n \\n stack = []\\n for i in range(n):\\n while stack and heights[stack[-1]]>heights[i]:\\n right[stack[-1]] = i\\n stack.pop()\\n print(i)\\n if stack:\\n left[i] = stack[-1]\\n stack.append(i)\\n print(left, right)\\n res = 0\\n for i in range(n):\\n l = left[i]\\n r = right[i]\\n res = max(res, heights[i]*(r-l-1))\\n return res\\n\",\n \"memory\": \"30400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [-1]\\n max_area = 0\\n\\n for i in range(len(heights)):\\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n stack.append(i)\\n \\n while stack[-1] != -1:\\n height = heights[stack.pop()]\\n width = len(heights) - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n \\n return max_area\",\n \"memory\": \"30500\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n \\n stack = [-1]\\n area = 0\\n\\n for i in range(len(heights)):\\n\\n while stack[-1] != -1 and heights[i] <= heights[stack[-1]]: \\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1 \\n area = max(area, height * width)\\n \\n stack.append(i)\\n \\n while stack[-1] != -1:\\n height = heights[stack.pop()]\\n width = len(heights) - stack[-1] - 1 \\n area = max(area, height * width)\\n\\n return area\",\n \"memory\": \"30500\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n largest_area = 0\\n\\n for height in heights:\\n width = 1\\n while stack and stack[-1] > height:\\n top = stack.pop()\\n area = width * top\\n\\n largest_area = max(largest_area, area)\\n width += 1\\n\\n for i in range(width):\\n stack.append(height)\\n\\n width = 1\\n while stack:\\n top = stack.pop()\\n area = width * top\\n\\n largest_area = max(largest_area, area)\\n width += 1\\n \\n return largest_area\",\n \"memory\": \"30600\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n beeg = 0\\n heights.append(0)\\n s = deque([-1])\\n for i, h in enumerate(heights):\\n while h < heights[s[-1]]:\\n index = s.pop()\\n height = heights[index]\\n beeg = max(beeg, (i - 1 - s[-1]) * height)\\n s.append(i)\\n return beeg\",\n \"memory\": \"30600\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n area = heights[0]\\n for i, h in enumerate(heights):\\n if not stack or heights[stack[-1]] <= h:\\n stack.append(i)\\n continue\\n \\n while stack and heights[stack[-1]] > h:\\n pos = stack.pop()\\n area = max(area, heights[pos] * (i - pos))\\n \\n stack.append(pos)\\n heights[pos] = h\\n \\n i = len(heights)\\n while stack:\\n idx = stack.pop()\\n area = max(area, heights[idx] * (i - idx))\\n return area\\n\",\n \"memory\": \"30700\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n ans = 0\\n for i, h in enumerate(heights):\\n if not stack or heights[stack[-1]] <= h:\\n stack.append(i)\\n continue\\n \\n while stack and h < heights[stack[-1]]:\\n idx = stack.pop()\\n ans = max(ans, (i - idx) * heights[idx])\\n \\n heights[idx] = h\\n stack.append(idx)\\n \\n end = len(heights)\\n while stack:\\n idx = stack.pop()\\n ans = max(ans, (end - idx) * heights[idx])\\n return ans\",\n \"memory\": \"30700\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n\\n \\n # prev small val index\\n def pse(arr):\\n\\n stack = []\\n res = [-1] * len(arr)\\n\\n for i in range(len(arr)):\\n \\n # prev eq is impl, we dont want to calc double \\n while stack and arr[stack[-1]] >= arr[i]:\\n stack.pop()\\n \\n if stack:\\n res[i] = stack[-1]\\n\\n stack.append(i)\\n return res\\n\\n # next small val index\\n def nse(arr):\\n stack = []\\n res = [len(arr)] * len(arr)\\n\\n for i in range(len(arr)-1,-1,-1):\\n\\n while stack and arr[stack[-1]] > arr[i]:\\n stack.pop()\\n\\n if stack:\\n res[i] = stack[-1]\\n\\n stack.append(i)\\n return res\\n\\n pseArr = pse(heights)\\n nseArr = nse(heights)\\n maxArea = 0\\n for i in range(len(heights)):\\n \\n # dist between two smaller ele\\n width = nseArr[i] - pseArr[i]-1\\n maxArea = max(maxArea, width * heights[i])\\n \\n return maxArea\",\n \"memory\": \"30800\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n maxArea = 0\\n stack = []\\n for i, h in enumerate(heights):\\n while stack:\\n if heights[stack[-1][0]] >= h:\\n maxArea = max(maxArea, heights[stack[-1][0]] * (i - stack[-1][1] - 1))\\n stack.pop()\\n else:\\n stack.append((i, stack[-1][0]))\\n break\\n if not stack:\\n stack.append((i, -1))\\n for i, l in stack:\\n maxArea = max(maxArea, heights[i] * (len(heights) - l - 1))\\n return maxArea\",\n \"memory\": \"30900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n #height, index #How far back does it go\\n\\n res = 0\\n stack = []\\n\\n #Append [height,index]\\n for i in range(len(heights)):\\n height = heights[i]\\n index = i\\n while stack and stack[-1][0] >= height:\\n oldheight, oldIndex = stack.pop()\\n res = max(res,oldheight * (i - oldIndex))\\n index = oldIndex\\n stack.append([height,index])\\n\\n for height, index in stack:\\n res = max(res, height * (len(heights) - index))\\n\\n return res\",\n \"memory\": \"30900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n def prev_smallest(height):\\n n=len(height)\\n stack=[]\\n prev_small=[0]*n\\n\\n for i in range(n):\\n while stack and height[stack[-1]]>=height[i]:\\n stack.pop()\\n \\n if not stack:\\n prev_small[i]=-1\\n else:\\n prev_small[i]=stack[-1]\\n \\n stack.append(i)\\n \\n return prev_small\\n\\n def next_smallest(height):\\n n=len(height)\\n stack=[]\\n next_small=[0]*n\\n\\n for i in range(n-1,-1,-1):\\n while stack and height[stack[-1]]>=height[i]:\\n stack.pop()\\n \\n if not stack:\\n next_small[i]=n\\n else:\\n next_small[i]=stack[-1]\\n \\n stack.append(i)\\n \\n return next_small\\n\\n prev_small=prev_smallest(heights)\\n next_small=next_smallest(heights)\\n # next_small.reverse()\\n print(prev_small,next_small)\\n\\n max_area=0\\n for i in range(len(heights)):\\n\\n max_area=max(max_area,(next_small[i]-prev_small[i]-1)*heights[i])\\n\\n return max_area\\n\\n\",\n \"memory\": \"31000\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n = len(heights)\\n left = [-1]*n\\n right = [n]*n\\n stack = []\\n for i, v in enumerate(heights):\\n while stack and heights[stack[-1]] >= v:\\n right[stack[-1]] = i\\n stack.pop()\\n if stack:\\n left[i] = stack[-1]\\n stack.append(i)\\n\\n return max([(right[i] - left[i] -1)*v for i, v in enumerate(heights)])\\n \",\n \"memory\": \"31100\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n right_index = [len(heights) for _ in heights]\\n s = []\\n for i in range(len(heights)):\\n if not s or heights[i] >= heights[s[-1]]:\\n s.append(i)\\n else:\\n while s and heights[i] < heights[s[-1]]:\\n right_index[s[-1]] = i\\n s.pop()\\n s.append(i)\\n\\n left_index = [-1 for _ in heights] # [-1, -1, -1, -1, -1, 4]\\n s = [] # [5, ]\\n for i in reversed(range(len(heights))): # 4\\n if not s or heights[i] >= heights[s[-1]]: # 4 >= 5\\n s.append(i)\\n else:\\n while s and heights[i] < heights[s[-1]]:\\n left_index[s[-1]] = i\\n s.pop()\\n s.append(i)\\n\\n ret = 0\\n for i in range(len(heights)):\\n ret = max(ret, heights[i] * (right_index[i] - left_index[i] - 1))\\n return ret\\n\",\n \"memory\": \"31100\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [] # index, val\\n res = 0\\n for r, cur in enumerate(heights):\\n l = r\\n while stack and stack[-1][-1] >= cur:\\n l, prev = stack.pop()\\n res = max(res, prev * (r - l))\\n r = l\\n stack.append([r, cur])\\n \\n for i, v in stack:\\n res = max(res, v * (len(heights) - i ))\\n return res\",\n \"memory\": \"31200\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n max_area = 0\\n stack = [] # pair of elements : (index, height)\\n heights.append(0)\\n for i, h in enumerate(heights):\\n # Process the stack when the current height is less than the top of the stack\\n while stack and heights[stack[-1]] > h:\\n height = heights[stack.pop()]\\n width = i if not stack else i - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n stack.append(i)\\n \\n return max_area\",\n \"memory\": \"31300\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n st=[]\\n maxi=0\\n n=len(heights)\\n for i in range(n):\\n while st and heights[st[-1]] > heights[i] :\\n ele = st[-1]\\n st.pop()\\n nse=i\\n pse = st[-1] if st else -1\\n maxi= max(maxi, (nse-pse-1)*heights[ele])\\n st.append(i)\\n while st:\\n ele = st[-1]\\n st.pop()\\n nse=n\\n pse = st[-1] if st else -1\\n maxi= max(maxi, (nse-pse-1)*heights[ele])\\n return maxi\",\n \"memory\": \"31300\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights.append(-1)\\n n = len(heights)\\n result = 0\\n stack = [-1]\\n for i in range(n):\\n while stack and heights[stack[-1]] > heights[i]:\\n h = heights[stack.pop()]\\n w = i - stack[-1] - 1\\n result = max(result, h * w)\\n stack.append(i)\\n return result\\n\\n\\n\",\n \"memory\": \"31400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [] # стек для хранения индексов\\n max_area = 0 # максимальная площадь\\n index = 0 # текущий индекс\\n\\n while index < len(heights):\\n # Если текущий бар выше или равен предыдущему, добавляем индекс в стек\\n if not stack or heights[index] >= heights[stack[-1]]:\\n stack.append(index)\\n index += 1\\n else:\\n # Вытаскиваем последний индекс из стека\\n top_of_stack = stack.pop()\\n # Рассчитываем площадь с heights[top_of_stack] как наименьшей высотой\\n area = (heights[top_of_stack] *\\n ((index - stack[-1] - 1) if stack else index))\\n # Обновляем максимальную площадь\\n max_area = max(max_area, area)\\n\\n # Рассчитываем площадь для оставшихся индексов в стеке\\n while stack:\\n top_of_stack = stack.pop()\\n area = (heights[top_of_stack] *\\n ((index - stack[-1] - 1) if stack else index))\\n max_area = max(max_area, area)\\n\\n return max_area\",\n \"memory\": \"31400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n curMax = -float('inf')\\n heights.append(-1)\\n\\n for h in heights:\\n curWidth = 0\\n while stack and stack[-1][0] > h:\\n popH, popW = stack.pop()\\n curWidth += popW\\n curArea = curWidth * popH\\n if curArea > curMax: curMax = curArea\\n stack.append((h, curWidth + 1))\\n \\n return curMax\\n \\n\\n\",\n \"memory\": \"31500\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights.insert(0, 0)\\n heights.append(0)\\n stack = [0]\\n result = 0\\n for i in range(1, len(heights)):\\n while stack and heights[i] < heights[stack[-1]]:\\n mid_height = heights[stack[-1]]\\n stack.pop()\\n if stack:\\n # area = width * height\\n area = (i - stack[-1] - 1) * mid_height\\n result = max(area, result)\\n stack.append(i)\\n return result\",\n \"memory\": \"31500\"\n },\n {\n \"code\": \"# in: int[] heights\\n# out: largest rectangle in histogram\\n\\n# can be combined from different bars\\n# all ints\\n# all positive\\n\\n# we could have a bar of width 1 that is so tall it is the biggest\\n# at any given point, the max area is the smallest bar to the left/right times width\\n# we could expand out from each bar and compare max area at each point\\n# what if we tried pointers?\\n# come in from left + right and at each point, we consider the best possible area\\n# we can essentially shrink the taller nums to the left once we hit a smaller num\\n# we could build a new array of increasing nums from left and right\\n# at each num, we essentially need to know the left + right index that it can stretch to\\n# since we want to account for the max we can go to the left, what if we use a stack?\\n# do we need a second stack to the right? maybe\\n# go across the array, then when we get to a num that is smaller than the last (or min so far?)\\n# we should track indices of nums as well so we know how far to the left a height goes\\n# ok so use a stack, then pop so we get back to something shorter than prev num\\n# each time we hit a shorter num, we know the height to the left has reached its best chance\\n# multiply the top num by the distance to the next top el in the stack\\n# keep popping until we reach something shorter thasn right num\\n# keep going to end of list\\n\\n# T: O(N), moving across array once and popping up to once (2N)\\n# S: O(N) for stack\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # Initialize variables\\n max_area = 0\\n stack = [] # Stack to store indices\\n \\n # Iterate through each bar in the histogram\\n for i in range(len(heights)):\\n # While the current bar is smaller than the bar at the stack's top, pop from the stack and calculate area\\n while stack and heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()] # The height of the rectangle\\n # If the stack is empty, it means we can extend all the way back to the beginning\\n w = i if not stack else i - stack[-1] - 1 # The width of the rectangle\\n max_area = max(max_area, h * w)\\n # Push current bar index to the stack\\n stack.append(i)\\n \\n # After we finish iterating through the heights array, we need to process the remaining bars in the stack\\n while stack:\\n h = heights[stack.pop()]\\n w = len(heights) if not stack else len(heights) - stack[-1] - 1\\n max_area = max(max_area, h * w)\\n \\n return max_area\\n if not heights:\\n return 0\\n max_area = 0\\n stack = []\\n for i in range(len(heights)): # 0,9\\n height = heights[i] # 9\\n while stack and height < heights[stack[-1]]:\\n comparison_height = heights[stack.pop()]\\n width = i\\n if stack:\\n width = i - stack[-1] - 1\\n area = comparison_height * width\\n max_area = max(max_area, area)\\n stack.append(i) #[0,0, 9,1]\\n\\n # last nums\\n while stack:\\n comparison_height = heights[stack.pop()] # 9\\n width = len(heights) #\\n if stack:\\n width = len(heights) - stack[-1] - 1 # 1\\n area = comparison_height * width\\n max_area = max(max_area, area)\\n\\n return max_area\\n\\n\\n\",\n \"memory\": \"31600\"\n },\n {\n \"code\": \"# in: int[] heights\\n# out: largest rectangle in histogram\\n\\n# can be combined from different bars\\n# all ints\\n# all positive\\n\\n# we could have a bar of width 1 that is so tall it is the biggest\\n# at any given point, the max area is the smallest bar to the left/right times width\\n# we could expand out from each bar and compare max area at each point\\n# what if we tried pointers?\\n# come in from left + right and at each point, we consider the best possible area\\n# we can essentially shrink the taller nums to the left once we hit a smaller num\\n# we could build a new array of increasing nums from left and right\\n# at each num, we essentially need to know the left + right index that it can stretch to\\n# since we want to account for the max we can go to the left, what if we use a stack?\\n# do we need a second stack to the right? maybe\\n# go across the array, then when we get to a num that is smaller than the last (or min so far?)\\n# we should track indices of nums as well so we know how far to the left a height goes\\n# ok so use a stack, then pop so we get back to something shorter than prev num\\n# each time we hit a shorter num, we know the height to the left has reached its best chance\\n# multiply the top num by the distance to the next top el in the stack\\n# keep popping until we reach something shorter thasn right num\\n# keep going to end of list\\n\\n# T: O(N), moving across array once and popping up to once (2N)\\n# S: O(N) for stack\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n if not heights:\\n return 0\\n max_area = 0\\n stack = []\\n for i in range(len(heights)): # 0,9\\n height = heights[i] # 9\\n while stack and height < heights[stack[-1]]:\\n comparison_height = heights[stack.pop()]\\n width = i\\n if stack:\\n width = i - stack[-1] - 1\\n area = comparison_height * width\\n max_area = max(max_area, area)\\n stack.append(i) #[0,0, 9,1]\\n\\n # last nums\\n while stack:\\n comparison_height = heights[stack.pop()] # 9\\n width = len(heights) #\\n if stack:\\n width = len(heights) - stack[-1] - 1 # 1\\n area = comparison_height * width\\n max_area = max(max_area, area)\\n\\n return max_area\\n\\n\\n\",\n \"memory\": \"31600\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n\\n def ngl(nums):\\n n=len(nums)\\n stack=[]\\n res=[]\\n\\n for i in range(n):\\n \\n if len(stack)==0:\\n res.append(-1)\\n elif len(stack)>0 and stack[-1][1]<nums[i]:\\n res.append(stack[-1][0])\\n elif len(stack)>0 and stack[-1][1]>=nums[i]:\\n while len(stack)>0 and stack[-1][1]>=nums[i]:\\n stack.pop()\\n if len(stack)==0:\\n res.append(-1)\\n else:\\n res.append(stack[-1][0])\\n stack.append([i,nums[i]])\\n return(res)\\n\\n def ngr(nums):\\n nums.append(-1)\\n n=len(nums)\\n stack=[]\\n res=[]\\n\\n for i in range(n-1,-1,-1):\\n\\n if len(stack)==0:\\n res.append(-1)\\n elif len(stack)>0 and stack[-1][1]<nums[i]:\\n res.append(stack[-1][0])\\n elif len(stack)>0 and stack[-1][1]>=nums[i]:\\n while len(stack)>0 and stack[-1][1]>=nums[i]:\\n stack.pop()\\n if len(stack)==0:\\n res.append(-1)\\n else:\\n res.append(stack[-1][0])\\n stack.append([i,nums[i]])\\n return(res[::-1])\\n\\n a=(ngl(heights))\\n b=(ngr(heights))\\n c=[]\\n n=len(a)\\n for i in range(n):\\n c.append((b[i]-a[i]-1)*heights[i])\\n return(max(c))\\n\\n \\n \",\n \"memory\": \"31700\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n\\n def ngl(nums):\\n n=len(nums)\\n stack=[]\\n res=[]\\n\\n for i in range(n):\\n \\n if len(stack)==0:\\n res.append(-1)\\n elif len(stack)>0 and stack[-1][1]<nums[i]:\\n res.append(stack[-1][0])\\n elif len(stack)>0 and stack[-1][1]>=nums[i]:\\n while len(stack)>0 and stack[-1][1]>=nums[i]:\\n stack.pop()\\n if len(stack)==0:\\n res.append(-1)\\n else:\\n res.append(stack[-1][0])\\n stack.append([i,nums[i]])\\n return(res)\\n\\n def ngr(nums):\\n nums.append(-1)\\n n=len(nums)\\n stack=[]\\n res=[]\\n\\n for i in range(n-1,-1,-1):\\n\\n if len(stack)==0:\\n res.append(-1)\\n elif len(stack)>0 and stack[-1][1]<nums[i]:\\n res.append(stack[-1][0])\\n elif len(stack)>0 and stack[-1][1]>=nums[i]:\\n while len(stack)>0 and stack[-1][1]>=nums[i]:\\n stack.pop()\\n if len(stack)==0:\\n res.append(-1)\\n else:\\n res.append(stack[-1][0])\\n stack.append([i,nums[i]])\\n return(res[::-1])\\n\\n a=(ngl(heights))\\n b=(ngr(heights))\\n c=[]\\n n=len(a)\\n for i in range(n):\\n c.append((b[i]-a[i]-1)*heights[i])\\n return(max(c))\\n\\n \\n \",\n \"memory\": \"31700\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n st, ans = [(-1, -1)], 0\\n for i, height in enumerate(heights):\\n past = i\\n while st[-1][0] > height:\\n h, ind = st.pop()\\n past = ind\\n ans = max(ans, h*(i - ind))\\n st += [(height, past)]\\n \\n for h, i in st:\\n ans = max(ans, h*(len(heights) - i))\\n return ans\",\n \"memory\": \"31800\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n max_area = 0\\n stack = []\\n\\n for i, h in enumerate(heights):\\n start = i\\n while stack and h < stack[-1][1]:\\n index, height = stack.pop()\\n width = i - index\\n max_area = max(max_area, height * width)\\n start = index #extending back the new height replacing the popped\\n \\n stack.append((start, h))\\n \\n for i, h in stack:\\n max_area = max(max_area, h * (len(heights) - i)) #checking the area of items remaing in stack\\n # from i to end of list\\n\\n return max_area\",\n \"memory\": \"31900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n max_area = 0\\n nsr , nsl = [] , []\\n stack_nsr , stack_nsl = [], []\\n for i in range(len(heights)):\\n while stack_nsl and heights[stack_nsl[-1]] >= heights[i]:\\n stack_nsl.pop()\\n if stack_nsl:\\n nsl.append(i-stack_nsl[-1])\\n else:\\n nsl.append(i+1)\\n stack_nsl.append(i)\\n\\n for i in range(len(heights)-1 , -1 , -1):\\n while stack_nsr and heights[stack_nsr[-1]] >= heights[i]:\\n stack_nsr.pop()\\n if stack_nsr:\\n nsr.append(stack_nsr[-1]-i)\\n else:\\n nsr.append(len(heights)-i)\\n stack_nsr.append(i)\\n\\n nsr = nsr[::-1]\\n \\n\\n for i in range(len(heights)):\\n width = nsr[i] + nsl[i] -1 \\n area = width * heights[i]\\n if area > max_area:\\n max_area = area\\n\\n return max_area\\n\\n\",\n \"memory\": \"32000\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n res = 0\\n for i, h in enumerate(heights + [0]):\\n while stack and h < heights[stack[-1]]:\\n index = stack.pop()\\n if stack:\\n res = max(res, (i - stack[-1] - 1) * heights[index])\\n else:\\n res = max(res, (i) * heights[index])\\n stack.append(i)\\n return res\",\n \"memory\": \"32100\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = [(-1, -1)]\\n ans = 0\\n for i, height in enumerate(heights):\\n last = i\\n while stack[-1][0] > height:\\n h, ind = stack.pop()\\n ans = max(ans, h*(i - ind))\\n last = ind\\n stack.append((height, last))\\n \\n for h, i in stack:\\n ans = max(ans, h*(len(heights) - i))\\n \\n return ans\",\n \"memory\": \"32200\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n height_starts = deque()\\n ans = 0\\n for i, h in enumerate(heights):\\n start = i\\n while len(height_starts) > 0 and height_starts[-1][0] > h:\\n oh, os = height_starts.pop()\\n # print(oh, os, i - os)\\n ans = max(ans, oh * (i - os))\\n start = os\\n if not (len(height_starts) > 0 and height_starts[0][0] == h):\\n height_starts.append((h, start))\\n while len(height_starts) > 0:\\n oh, os = height_starts.pop()\\n # print(oh, os, len(heights) - os)\\n ans = max(ans, oh * (len(heights) - os))\\n return ans\\n\",\n \"memory\": \"32299\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # n = len(heights)\\n # res = 0\\n # for l in range(n):\\n # for r in range(l, n):\\n # area = (r-l+1) * min(heights[l], heights[r])\\n # if heights[r] < heights[l]:\\n # break\\n # res = max(res, area)\\n # return res\\n\\n stack = []\\n res = 0\\n n = len(heights)\\n\\n for idx, h in enumerate(heights):\\n start = idx\\n while stack and stack[-1][1] > h:\\n stack_idx, stack_h = stack.pop()\\n area = (idx-stack_idx) * stack_h\\n res = max(res, area)\\n start = stack_idx\\n stack.append((start, h))\\n \\n for idx, h in stack:\\n area = (n - idx) * h\\n res = max(res, area)\\n return res\",\n \"memory\": \"32400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n result = 0\\n\\n stack = []\\n\\n for index, value in enumerate(heights):\\n left_index = index\\n while stack and stack[-1][1] > value:\\n left_index, left_val = stack.pop()\\n rectangle_area = (index - left_index) * left_val\\n if rectangle_area > result:\\n result = rectangle_area\\n stack.append((left_index, value))\\n\\n for index, value in enumerate(stack):\\n rect_area = (len(heights) - value[0]) * value[1]\\n if rect_area > result:\\n result = rect_area\\n return result\",\n \"memory\": \"32500\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n result = 0\\n\\n stack = []\\n\\n for index, value in enumerate(heights):\\n left_index = index\\n while stack and stack[-1][1] > value:\\n left_index, left_val = stack.pop()\\n rectangle_area = (index - left_index) * left_val\\n if rectangle_area > result:\\n result = rectangle_area\\n stack.append((left_index, value))\\n\\n for index, value in enumerate(stack):\\n rect_area = (len(heights) - value[0]) * value[1]\\n if rect_area > result:\\n result = rect_area\\n return result\",\n \"memory\": \"32500\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n largest = 0\\n stack = []\\n\\n for idx, curr_height in enumerate(heights):\\n \\n # The new starting index for the height with value v. Defaults to its original index.\\n curr_width_idx = idx\\n \\n\\n # if prev height > curr height\\n while stack and stack[-1][1] > curr_height:\\n old_idx, prev_height = stack.pop()\\n \\n # previous is larger, so see if we can make a larger rectangle using our now larger width (update curr width idx to use prev heights idx)\\n new_width = idx - old_idx\\n curr_width_idx = old_idx\\n\\n largest = max(largest, new_width * prev_height)\\n\\n\\n\\n stack.append((curr_width_idx, curr_height))\\n\\n # check all heights remaining in the stack (An item will remain in the stack if a smaller height hasn't been encountered) Since these rectangles can now extend to the end of the histogram.\\n\\n for (old_idx, curr_height) in stack:\\n width = len(heights) - old_idx\\n largest = max(largest, width * curr_height)\\n\\n return largest\",\n \"memory\": \"32600\"\n },\n {\n \"code\": \"class Solution:\\n '''\\n the factor that is going to limit us in terms of area is going to be the fact that we are going to be bounded by \\n the smallest recrangle in our array\\n \\n either get rid of that rectangle or we keep it \\n if we keep it then we will bound the rest of the rectangles to that height until we encounter a smaller rectangle then it will be bounded by that \\n '''\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack=[]\\n maxarea = 0\\n for i,h in enumerate(heights):\\n startindex=i\\n while stack and stack[-1][1]>h:\\n index,height=stack.pop()\\n print(height)\\n maxarea=max(maxarea,height*(i-index))\\n startindex=index\\n stack.append((startindex,h))\\n for i, h in stack:\\n maxarea=max(maxarea,h*(len(heights)-i))\\n return maxarea\\n \\n\\n \",\n \"memory\": \"32600\"\n },\n {\n \"code\": \"class Solution:\\n '''\\n the factor that is going to limit us in terms of area is going to be the fact that we are going to be bounded by \\n the smallest recrangle in our array\\n \\n either get rid of that rectangle or we keep it \\n if we keep it then we will bound the rest of the rectangles to that height until we encounter a smaller rectangle then it will be bounded by that \\n '''\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack=[]\\n maxarea = 0\\n for i,h in enumerate(heights):\\n startindex=i\\n while stack and stack[-1][1]>h:\\n index,height=stack.pop()\\n maxarea=max(maxarea,height*(i-index))\\n startindex=index\\n stack.append((startindex,h))\\n for i, h in stack:\\n maxarea=max(maxarea,h*(len(heights)-i))\\n return maxarea\\n \\n\\n \",\n \"memory\": \"32700\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n # give is list of heights\\n # need to return biggest area possible\\n maxArea = 0\\n stack = [] # pair: (index, height)\\n\\n for i, h in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n maxArea = max(maxArea, height * (i - index))\\n start = index\\n stack.append((start, h))\\n\\n for i, h in stack:\\n maxArea = max(maxArea, h * (len(heights) - i))\\n return maxArea\\n\",\n \"memory\": \"32800\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = deque()\\n result = 0\\n for i, h in enumerate(heights):\\n idx = i\\n while stack and h < stack[-1][1]:\\n idx, height = stack.pop()\\n width = i - idx\\n result = max(result, height * width)\\n \\n stack.append((idx, h))\\n \\n while stack:\\n idx, height = stack.pop()\\n width = len(heights) - idx\\n result = max(result, height * width)\\n\\n return result\",\n \"memory\": \"32900\"\n },\n {\n \"code\": \"\\\"\\\"\\\" Watch this solution: https://www.youtube.com/watch?v=zx5Sw9130L0\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n area = 0\\n \\n for i, height in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > height:\\n prev_index, prev_height = stack.pop()\\n area = max(area, (i - prev_index) * prev_height)\\n start = prev_index\\n \\n stack.append((start, height))\\n \\n while stack:\\n start, height = stack.pop()\\n area = max(area, (len(heights) - start) * height)\\n \\n return area\",\n \"memory\": \"33000\"\n },\n {\n \"code\": \"class Solution:\\n # the idea is that all the rectangles in the histogram must be able to extend to the end\\n # if you are smaller than the previous value then the previous value cannot extend to the end\\n # maintain a monotonically increasing stack\\n # when you need to pop a value off calculate it's max possible value\\n # do h * (curr - idx)\\n # stretch back the current index to the idx and append it to the stack\\n # process the values left in the stack\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n _max = [0]\\n for i, h in enumerate(heights):\\n next_i = i\\n while len(stack) != 0 and stack[-1][1] > h:\\n pidx, ph = stack.pop()\\n _max[0] = max(_max[0], (i - pidx) * ph)\\n next_i = pidx\\n stack.append((next_i, h))\\n\\n while len(stack) != 0:\\n pidx, ph = stack.pop()\\n _max[0] = max(_max[0], (len(heights) - pidx) * ph)\\n \\n return _max[0]\\n \",\n \"memory\": \"33100\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n=len(heights)\\n stk=[]\\n max_area=0\\n\\n for i , height in enumerate(heights):\\n start = i\\n while stk and height < stk[-1][0]:\\n h,j=stk.pop()\\n w =i - j\\n a=h*w\\n max_area= max(max_area,a)\\n start = j\\n stk.append((height,start))\\n\\n while stk:\\n h,j = stk.pop()\\n w = n-j\\n max_area= max(max_area,h*w)\\n return max_area\\n\\n \",\n \"memory\": \"33200\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n output = 0\\n\\n for i in range(len(heights)):\\n min_index = i\\n\\n while len(stack) and stack[-1][1] > heights[i]:\\n curr = stack.pop()\\n output = max(output, (i - curr[0]) * curr[1])\\n min_index = curr[0]\\n\\n stack.append((min_index, heights[i]))\\n \\n while len(stack):\\n curr = stack.pop()\\n output = max(output, (len(heights) - curr[0]) * curr[1])\\n \\n return output\\n\\n\\n \\n\\n\\n\\n \\n \",\n \"memory\": \"33300\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights_len = len(heights)\\n stack = []\\n maxH = 0\\n\\n for idx, h in enumerate(heights):\\n start = idx\\n while stack and stack[-1][-1] > h:\\n index, height = stack.pop()\\n maxH = max(maxH, height * (idx - index))\\n start = index\\n stack.append((start, h))\\n \\n\\n while stack:\\n index, height = stack.pop()\\n maxH = max(maxH, height * (heights_len - index))\\n \\n return maxH\\n \",\n \"memory\": \"33300\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n area = 0\\n i = 0 \\n stack = [] #(index, height)\\n\\n while i < len(heights):\\n index = i\\n\\n while stack and stack[-1][1] > heights[i]:\\n index, height = stack.pop()\\n area = max(area, (height * (i - index)))\\n \\n stack.append((index, heights[i]))\\n i += 1\\n\\n while stack:\\n index, height = stack.pop()\\n area = max(area, (height * (len(heights) - index)))\\n\\n return area\",\n \"memory\": \"33400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n=len(heights)\\n stack=[]\\n maxArea=0\\n\\n for i,height in enumerate(heights):\\n start=i\\n while stack and height < stack[-1][0]:\\n h,j=stack.pop()\\n w=i-j \\n maxArea=max(maxArea,h*w)\\n start=j\\n stack.append((height,start))\\n while stack:\\n h,j = stack.pop()\\n w=n-j\\n maxArea=max(maxArea,h*w)\\n return maxArea\",\n \"memory\": \"33400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n max_area = 0\\n for i in range(len(heights)):\\n start = i\\n while stack and stack[-1][1] > heights[i]:\\n index, height = stack.pop()\\n max_area = max(max_area, height * (i - index))\\n start = index\\n stack.append((start, heights[i]))\\n \\n length = len(heights)\\n while stack:\\n index, height = stack.pop()\\n max_area = max(max_area, height * (length - index))\\n\\n return max_area\\n\",\n \"memory\": \"33500\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n maxArea = 0\\n stack = []\\n\\n for i, h in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n maxArea = max(maxArea, height * (i - index))\\n start = index\\n stack.append((start, h))\\n \\n for i, h in stack:\\n maxArea = max(maxArea, h * (len(heights) - i))\\n \\n return maxArea\\n\",\n \"memory\": \"33500\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n out=0\\n stack=[]\\n for i in range(len(heights)):\\n temp_index=i\\n while stack and stack[-1][-1]>heights[i]:\\n temp_index,temp=stack.pop()\\n out=max(out,temp*(i-temp_index))\\n stack.append((temp_index,heights[i]))\\n for i,h in stack:\\n out=max(out,h*(len(heights)-i))\\n return out\",\n \"memory\": \"33600\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n maxArea = 0\\n stack = []\\n\\n for i, h in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n maxArea = max(maxArea, height * (i - index))\\n start = index\\n stack.append((start, h))\\n\\n for i, h in stack:\\n maxArea = max(maxArea, h * (len(heights) - i))\\n\\n return maxArea\\n\\n\\n \",\n \"memory\": \"33600\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n maxArea = 0\\n stack=[]\\n for i,h in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n maxArea = max(maxArea, height*(i-index))\\n start = index\\n stack.append((start,h))\\n \\n for i,h in stack:\\n maxArea = max(maxArea, h*(len(heights)-i))\\n return maxArea\",\n \"memory\": \"33700\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n res = 0\\n stack = []\\n\\n for i, h in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n \\n res = max(res, (i-index) *height)\\n start = index\\n stack.append((start, h))\\n \\n for i, h in stack:\\n res = max(res, (len(heights)-i ) *h)\\n return res\\n\",\n \"memory\": \"33700\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n left = [i for i in range(len(heights))]\\n right = [i for i in range(len(heights))]\\n\\n increasing = deque()\\n\\n for i, height in enumerate(heights):\\n while len(increasing) > 0 and heights[increasing[-1]] > height:\\n right[increasing.pop()] = i\\n \\n increasing.append(i)\\n \\n for i in increasing:\\n right[i] = len(heights)\\n\\n increasing = deque()\\n\\n for i in range(len(heights) - 1, -1, -1):\\n height = heights[i]\\n while len(increasing) > 0 and heights[increasing[-1]] > height:\\n left[increasing.pop()] = i\\n \\n increasing.append(i)\\n\\n for i in increasing:\\n left[i] = -1\\n \\n res = 0\\n for i, (l, r) in enumerate(zip(left, right)):\\n res = max(res, heights[i] * (r - l - 1))\\n\\n return res\\n\",\n \"memory\": \"33800\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n curr_max = heights[0]\\n stack = [(curr_max, 0)] # height (>= current height), start index\\n N = len(heights)\\n\\n for i in range(1,N):\\n curr_h = heights[i]\\n ind_append = i #\\n while stack and stack[-1][0] > curr_h:\\n prev_h, ind_append = stack.pop() # ind_append = prev_i\\n curr_max = max(curr_max, prev_h*(i-ind_append))\\n stack.append((curr_h, ind_append))\\n\\n for h,i in stack:\\n curr_max = max(curr_max, h*(N-i))\\n\\n return curr_max\",\n \"memory\": \"33900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = collections.deque([])\\n max_area = float('-inf')\\n\\n for i in range(len(heights)):\\n back_index = i\\n while len(stack) > 0 and stack[-1][1] > heights[i]:\\n index, height = stack.pop()\\n max_area = max(max_area, height * (i - index))\\n back_index = index\\n \\n stack.append((back_index, heights[i]))\\n while stack:\\n index, height = stack.pop()\\n max_area = max(max_area, height * (len(heights) - index))\\n \\n return max_area\\n\\n \",\n \"memory\": \"33900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n max_area = 0\\n\\n for w,h in enumerate(heights):\\n start = w\\n while stack and stack[-1][1] > h:\\n width, height = stack.pop()\\n max_area = max(max_area, height * (w - width))\\n print(max_area)\\n start = width\\n stack.append((start,h))\\n \\n for w,h in stack:\\n max_area = max(max_area, h * (len(heights) - w))\\n print(\\\"Second\\\" , max_area)\\n return max_area\\n \\n\",\n \"memory\": \"34000\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: list[int]) -> int:\\n \\n max_area: int = 0 # 7 \\n stack: list[(int, int)] = [] # (1, 0), (3, 1)\\n\\n for i, height in enumerate(heights): # 0, 1 | 1, 3 | 3, 2\\n if not stack: # the stack is empty\\n stack.append((height, i))\\n continue\\n\\n start = i\\n while stack and height < stack[-1][0]:\\n rect_height, start = stack.pop()\\n rect_area = rect_height * (i - start)\\n max_area = max(max_area, rect_area)\\n \\n stack.append((height, start))\\n \\n while stack: # [1, 0 | 2, 3]\\n rect_height, start = stack.pop()\\n rect_area = rect_height * (len(heights) - start)\\n print(rect_height, start, rect_area)\\n max_area = max(max_area, rect_area)\\n\\n return max_area\\n \",\n \"memory\": \"34100\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: list[int]) -> int:\\n \\n max_area: int = 0 # 7 \\n stack: list[(int, int)] = [] # (1, 0), (3, 1)\\n\\n for i, height in enumerate(heights): # 0, 1 | 1, 3 | 3, 2\\n if not stack: # the stack is empty\\n stack.append((height, i))\\n continue\\n\\n start = i\\n while stack and height < stack[-1][0]:\\n rect_height, start = stack.pop()\\n rect_area = rect_height * (i - start)\\n max_area = max(max_area, rect_area)\\n \\n stack.append((height, start))\\n \\n while stack: # [1, 0 | 2, 3]\\n rect_height, start = stack.pop()\\n rect_area = rect_height * (len(heights) - start)\\n print(rect_height, start, rect_area)\\n max_area = max(max_area, rect_area)\\n\\n return max_area\\n \",\n \"memory\": \"34200\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n '''\\n Monotonic Stack\\n T: O(n)\\n S: O(n)\\n stack = [[index, height]]\\n If a int is less than both of its left and right neighobors,\\n then the largest rectangle with width greater than 2 is no longer\\n able to consider this int as its height, we can just pop it\\n Likewise, whenever the height of the last int in the stack is\\n greater than the cur int, we drop it and calculate the area from\\n it till current, since the int cannot extend anymore when it encounter\\n some smaller int after it\\n '''\\n res = 0\\n stack = []\\n for i, h in enumerate(heights):\\n start = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n res = max(res, height * (i - index))\\n start = index\\n \\n stack.append([start, h])\\n \\n for i, h in stack:\\n res = max(res, h * (len(heights) - i))\\n\\n return res\",\n \"memory\": \"34300\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n largest = 0\\n for i, h in enumerate(heights):\\n count = 0\\n while stack and stack[-1][0] > h:\\n height, idx = stack.pop()\\n largest = max(largest, height * (i - idx))\\n count += 1\\n for j in range(count, -1, -1):\\n stack.append((h, i - j))\\n while stack:\\n height, idx = stack.pop()\\n largest = max(largest, height * (len(heights) - idx))\\n return largest\",\n \"memory\": \"34400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n largest = 0\\n for i, h in enumerate(heights):\\n count = 0\\n while stack and stack[-1][0] > h:\\n height, idx = stack.pop()\\n largest = max(largest, height * (i - idx))\\n count += 1\\n for j in range(count, -1, -1):\\n stack.append((h, i - j))\\n while stack:\\n height, idx = stack.pop()\\n largest = max(largest, height * (len(heights) - idx))\\n return largest\",\n \"memory\": \"34400\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n heights.append(0)\\n s = deque()\\n maxArea = 0\\n for i in range(0, len(heights)):\\n height = heights[i]\\n # only append if height is greater than to keep the stack monotonic\\n if not s or height > s[-1][0]:\\n s.append([height, i])\\n else:\\n leftBoundary = i\\n while s and height < s[-1][0]:\\n sHeight, sPt = s.pop()\\n maxArea = max(maxArea, sHeight * (i - sPt)) \\n leftBoundary = sPt\\n s.append([height, leftBoundary])\\n return maxArea\\n \\n \\n \",\n \"memory\": \"34500\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n res = 0\\n for i,h in enumerate(heights):\\n lastIndex = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n res = max(res, height * (i - index))\\n lastIndex = index\\n stack.append([lastIndex, h])\\n\\n for i, h in stack:\\n res = max(res, h * (len(heights) - i))\\n return res \",\n \"memory\": \"34600\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n max_area = 0\\n stack = []\\n for i , h in enumerate(heights):\\n idx = i\\n if not stack:\\n stack.append([i , h])\\n continue\\n while stack and stack[-1][1] > h:\\n idx , he = stack.pop()\\n max_area = max(max_area , (i - idx ) * he)\\n stack.append([idx , h])\\n\\n while stack:\\n idx , he = stack.pop()\\n max_area = max(max_area , (i - idx + 1) * he) \\n return max_area\",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n max_area = 0\\n my_stack = []\\n for index, ele in enumerate(heights):\\n if len(my_stack) == 0:\\n my_stack.append([index, ele])\\n elif ele >= my_stack[-1][1]:\\n my_stack.append([index, ele])\\n else:\\n pair_to_add = [index, ele]\\n while len(my_stack) > 0 and my_stack[-1][1] > ele:\\n curr_pair = my_stack.pop()\\n area = curr_pair[1] * (index - curr_pair[0])\\n max_area = max(max_area, area)\\n pair_to_add[0] = curr_pair[0]\\n my_stack.append(pair_to_add)\\n \\n while len(my_stack) > 0:\\n pair = my_stack.pop()\\n max_area = max(max_area, (pair[1] * (len(heights) - pair[0])))\\n \\n return max_area \",\n \"memory\": \"34800\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n maxArea = 0\\n for ind, height in enumerate(heights):\\n i = ind\\n h = height\\n while stack and height < stack[-1][1]:\\n i, h = stack.pop()\\n maxArea = max(maxArea, h * (ind-i))\\n \\n stack.append([i, height])\\n maxArea = max(maxArea, height)\\n\\n while stack:\\n i, h = stack.pop()\\n maxArea = max(maxArea, h * (len(heights)-i))\\n return maxArea\",\n \"memory\": \"34900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n maxArea = 0\\n for ind, height in enumerate(heights):\\n i = ind\\n h = height\\n while stack and height < stack[-1][1]:\\n i, h = stack.pop()\\n maxArea = max(maxArea, h * (ind-i))\\n stack.append([i, height])\\n\\n while stack:\\n i, h = stack.pop()\\n maxArea = max(maxArea, h * (len(heights)-i))\\n return maxArea\",\n \"memory\": \"34900\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n ans = 0\\n for i in range(len(heights)):\\n start = i\\n while stack and stack[-1][-1] > heights[i]:\\n index ,h = stack.pop()\\n ans = max(ans, h *(i-index))\\n start = index\\n stack.append([start,heights[i]])\\n while stack:\\n i,h = stack.pop()\\n ans = max(ans,h *(len(heights)-i))\\n return ans\\n\\n \\n \",\n \"memory\": \"35000\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n maxArea = 0\\n numOfRectangles = len(heights)\\n for ind, height in enumerate(heights):\\n i = ind\\n while stack and height < stack[-1][1]:\\n i, h = stack.pop()\\n maxArea = max(maxArea, h * (ind-i))\\n stack.append([i, height])\\n while stack:\\n i, h = stack.pop()\\n maxArea = max(maxArea, h * (numOfRectangles-i))\\n return maxArea\",\n \"memory\": \"35000\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n stack = []\\n max_area = float('-inf')\\n\\n for index, height in enumerate(heights):\\n while stack and stack[-1][1] > height:\\n sIndex, sHeight = stack.pop()\\n\\n length = index if not stack else index - stack[-1][0] - 1\\n area = length * sHeight\\n\\n max_area = max(max_area, area)\\n stack.append([index, height])\\n\\n while stack:\\n sIndex, sHeight = stack.pop()\\n\\n length = len(heights) if not stack else len(heights) - stack[-1][0] - 1\\n area = length * sHeight\\n\\n max_area = max(max_area, area)\\n\\n return max_area\",\n \"memory\": \"35100\"\n },\n {\n \"code\": \"class Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n max_area = 0\\n my_stack = []\\n for index, ele in enumerate(heights):\\n if len(my_stack) == 0 or ele >= my_stack[-1][1]:\\n my_stack.append([index, ele])\\n else:\\n pair_to_add = [index, ele]\\n while len(my_stack) > 0 and my_stack[-1][1] > ele:\\n curr_pair = my_stack.pop()\\n area = curr_pair[1] * (index - curr_pair[0])\\n max_area = max(max_area, area)\\n pair_to_add[0] = curr_pair[0]\\n my_stack.append(pair_to_add)\\n \\n while len(my_stack) > 0:\\n pair = my_stack.pop()\\n max_area = max(max_area, (pair[1] * (len(heights) - pair[0])))\\n \\n return max_area \",\n \"memory\": \"35100\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":99,"string":"99"}}},{"rowIdx":39,"cells":{"question_id":{"kind":"number","value":85,"string":"85"},"name":{"kind":"string","value":"maximal-rectangle"},"content":{"kind":"string","value":"<p>Given a <code>rows x cols</code> binary <code>matrix</code> filled with <code>0</code>'s and <code>1</code>'s, find the largest rectangle containing only <code>1</code>'s and return <em>its area</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2020/09/14/maximal.jpg\" style=\"width: 402px; height: 322px;\" />\n<pre>\n<strong>Input:</strong> matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]\n<strong>Output:</strong> 6\n<strong>Explanation:</strong> The maximal rectangle is shown in the above picture.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> matrix = [["0"]]\n<strong>Output:</strong> 0\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> matrix = [["1"]]\n<strong>Output:</strong> 1\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>rows == matrix.length</code></li>\n\t<li><code>cols == matrix[i].length</code></li>\n\t<li><code>1 <= row, cols <= 200</code></li>\n\t<li><code>matrix[i][j]</code> is <code>'0'</code> or <code>'1'</code>.</li>\n</ul>\n"},"acRate":{"kind":"number","value":51.673839913664324,"string":"51.67384"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","dynamic-programming","stack","matrix","monotonic-stack"],"string":"[\n \"array\",\n \"dynamic-programming\",\n \"stack\",\n \"matrix\",\n \"monotonic-stack\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"82\", 0.1332], [\"107\", 0.0333], [\"133\", 0.0666], [\"158\", 0.0998], [\"183\", 0.0333], [\"208\", 45.82359999999999], [\"234\", 27.12130000000001], [\"259\", 5.3575], [\"284\", 1.1983000000000001], [\"309\", 0.6658], [\"335\", 0.1998], [\"360\", 0.09990000000000002], [\"385\", 0.9653999999999999], [\"411\", 0.6659], [\"436\", 0.1998], [\"461\", 0.6657], [\"486\", 0.1332], [\"512\", 0.3663], [\"537\", 0.1665], [\"562\", 0.09990000000000002], [\"587\", 0.1665], [\"613\", 0.2996], [\"638\", 0.333], [\"663\", 0.1665], [\"688\", 0.1665], [\"714\", 0.1332], [\"739\", 0.09990000000000002], [\"764\", 0.0333], [\"789\", 0.1998], [\"815\", 0.1998], [\"840\", 0.09990000000000002], [\"865\", 0.0333], [\"891\", 0.2664], [\"916\", 0.1332], [\"941\", 0.09990000000000002], [\"966\", 0.0333], [\"992\", 0.333], [\"1017\", 0.333], [\"1042\", 0.3663], [\"1067\", 0.4994], [\"1093\", 0.4662], [\"1118\", 0.4995], [\"1143\", 0.3663], [\"1168\", 0.2331], [\"1194\", 0.1332], [\"1219\", 0.19980000000000003], [\"1244\", 0.1998], [\"1269\", 0.1665], [\"1295\", 0.09990000000000002], [\"1320\", 0.1665], [\"1345\", 0.3996], [\"1371\", 0.49939999999999996], [\"1396\", 0.2331], [\"1421\", 0.1998], [\"1446\", 0.0666], [\"1472\", 0.09990000000000002], [\"1497\", 0.09990000000000002], [\"1522\", 0.0333], [\"1547\", 0.0333], [\"1573\", 0.0333], [\"1598\", 0.0333], [\"1623\", 0.0333], [\"1648\", 0.0666], [\"1674\", 0.0333], [\"1699\", 0.0666], [\"1724\", 0.0333], [\"1749\", 0.0333], [\"1775\", 0.0333], [\"1800\", 0.0333], [\"1825\", 0.0333], [\"1851\", 0.0333], [\"1876\", 0.0333], [\"1901\", 0.0333], [\"1926\", 0.0333], [\"1952\", 0.0333], [\"1977\", 0.0333], [\"2002\", 0.0666], [\"2027\", 0.3663], [\"2053\", 0.9322], [\"2078\", 0.6992]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"17200\", 0.1331], [\"17300\", 0.0333], [\"17400\", 0.0333], [\"17500\", 0.1997], [\"17600\", 1.3977], [\"17700\", 5.6572], [\"17800\", 20.2329], [\"17900\", 39.1015], [\"18000\", 22.1631], [\"18100\", 3.7937], [\"18200\", 0.6988], [\"18300\", 0.3328], [\"18400\", 0.2329], [\"18500\", 0.1331], [\"18600\", 0.0666], [\"18700\", 0.0998], [\"18800\", 0.0333], [\"18900\", 0.1997], [\"19000\", 0.2995]]}"},"rt_list":{"kind":"list like","value":[{"code":"def largestRectangleArea(heights: List[int]) -> int:\n stack = []\n max_area = 0\n heights.append(0) \n\n for i in range(len(heights)):\n while stack and heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i if not stack else i - stack[-1] - 1\n max_area = max(max_area, h * w)\n stack.append(i)\n \n heights.pop() \n return max_area\n\n\nclass Solution:\n def maximalRectangle(matrix: List[List[str]]) -> int:\n if not matrix or not matrix[0]:\n return 0\n \n n_cols = len(matrix[0])\n heights = [0] * n_cols\n max_area = 0\n\n for row in matrix:\n for i in range(n_cols):\n \n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n \n max_area = max(max_area, largestRectangleArea(heights))\n \n return max_area\n\n with open('user.out','w') as f:\n for i in map(loads, stdin):\n print(maximalRectangle(i), file=f)\n exit(0)","runtime":"82"},{"code":"def largestRectangleArea(heights: List[int]) -> int:\n print(f'heights: {heights}')\n n = len(heights)\n max_area = 0\n stack = []\n for j in range(n):\n h = heights[j]\n while stack and h < heights[stack[-1]]:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (j - left)\n if area > max_area:\n max_area = area\n stack.append(j)\n while stack:\n i = stack.pop()\n left = 0 if not stack else stack[-1] + 1\n area = heights[i] * (n - left)\n if area > max_area:\n max_area = area\n return max_area\n\n\ndef maximalRectangle(matrix: List[List[str]]) -> int:\n cols = len(matrix[0])\n heights = [0]*cols\n max_area = 0\n for row in matrix:\n for i, val in enumerate(row):\n if val == '0':\n heights[i] = 0\n else:\n heights[i] += 1\n area = largestRectangleArea(heights)\n if area > max_area:\n max_area = area\n return max_area\n\n\nif __name__ == '__main__': \n with open('user.out','w') as f:\n for i in map(loads, stdin):\n print(maximalRectangle(i), file=f)\n exit(0)","runtime":"82"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix or not matrix[0]:\n return 0\n \n # Initialize the histogram heights\n num_cols = len(matrix[0])\n heights = [0] * num_cols\n max_area = 0\n\n def largestRectangleArea(heights):\n max_area = 0\n stack = []\n\n for i, h in enumerate(heights):\n s = i\n while stack and stack[-1][1] > h:\n index, height = stack.pop()\n max_area = max(max_area, height * (i - index))\n s = index\n stack.append((s, h))\n\n for i, h in stack:\n max_area = max(max_area, h * (len(heights) - i))\n\n return max_area\n\n \n for row in matrix:\n for i in range(num_cols):\n if row[i] == '1':\n heights[i] += 1\n else:\n heights[i] = 0\n\n max_area = max(max_area, largestRectangleArea(heights))\n \n return max_area\n\n\n ","runtime":"107"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix:\n return 0\n \n rows, cols = len(matrix), len(matrix[0])\n heights = [0] * (cols + 1) # Include an extra element for easier calculation\n max_area = 0\n \n for row in matrix:\n for i in range(cols):\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n # Calculate max area using histogram method\n stack = []\n for i in range(len(heights)):\n while stack and heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i if not stack else i - stack[-1] - 1\n max_area = max(max_area, h * w)\n stack.append(i)\n \n return max_area ","runtime":"133"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix:\n return 0\n \n rows, cols = len(matrix), len(matrix[0])\n heights = [0] * (cols + 1) # Include an extra element for easier calculation\n max_area = 0\n \n for row in matrix:\n for i in range(cols):\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n # Calculate max area using histogram method\n stack = []\n for i in range(len(heights)):\n while stack and heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i if not stack else i - stack[-1] - 1\n max_area = max(max_area, h * w)\n stack.append(i)\n \n return max_area ","runtime":"158"},{"code":"class Solution:\n def maximalRectangle(self, matrix: list[list[str]], ans = 0) -> int:\n\n m, n = len(matrix), len(matrix[0])\n dp = [0]*(n+1)\n \n for i in range(m):\n stk = deque([-1])\n\n for j in range(n+1):\n if j < n and matrix[i][j] == '1': dp[j]+= 1\n else: dp[j] = 0\n\n while(dp[stk[0]] > dp[j]):\n ans = max(ans,dp[stk.popleft()]*(j-stk[0]-1))\n\n stk.appendleft(j)\n\n return ans","runtime":"183"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def largestRectangleArea(heights):\n stack = []\n max_area = 0\n heights.append(0) # Add a sentinel value to make sure we process all elements in the stack\n\n for i in range(len(heights)):\n while stack and heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i if not stack else i - stack[-1] - 1\n max_area = max(max_area, h * w)\n stack.append(i)\n \n heights.pop() # Remove the sentinel value\n return max_area\n\n if not matrix:\n return 0\n\n max_area = 0\n cols = len(matrix[0])\n heights = [0] * cols\n \n for row in matrix:\n for i in range(cols):\n if row[i] == '1':\n heights[i] += 1\n else:\n heights[i] = 0\n\n max_area = max(max_area, largestRectangleArea(heights))\n\n return max_area\n\n ","runtime":"208"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n grid = self.getHistGrid(matrix)\n return self.getMaxRectangle(grid)\n \n def getHistGrid(self, grid):\n m, n = len(grid), len(grid[0])\n dp = [[0]*n for _ in range(m)]\n for i in range(m):\n for j in range(n):\n if m == 0 and grid[i][j] == '1':\n dp[i][j] == 1\n elif grid[i][j] == '1':\n dp[i][j] = 1+dp[i-1][j]\n return dp\n\n def getMaxRectangle(self, grid):\n m,n = len(grid), len(grid[0])\n maxArea = 0\n for i in range(m):\n stack = [-1]\n for j in range(n):\n while stack[-1] != -1 and grid[i][stack[-1]] > grid[i][j]:\n height = grid[i][stack.pop()]\n width = j-stack[-1]-1\n maxArea = max(maxArea, height*width)\n stack.append(j)\n while stack[-1] != -1:\n height = grid[i][stack.pop()]\n width = n-stack[-1]-1\n maxArea = max(maxArea, height*width)\n return maxArea\n ","runtime":"208"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix:\n return 0\n\n n = len(matrix[0])\n heights = [0] * (n + 1)\n max_area = 0\n\n for row in matrix:\n \n for i in range(n):\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n \n stack = [-1]\n for i in range(n + 1):\n while heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i - 1 - stack[-1]\n max_area = max(max_area, h * w)\n stack.append(i)\n\n return max_area","runtime":"234"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def rowMaxRectangle(heights: List[int]) -> int:\n area = 0\n stack = [-1]\n for i in range(len(heights)):\n while stack[-1] != -1 and heights[stack[-1]] >= heights[i]:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1\n area = max(area, width * height)\n stack.append(i)\n while stack[-1] != -1:\n height = heights[stack.pop()]\n width = len(heights) - stack[-1] - 1\n area = max(area, width * height)\n return area\n\n max_area = 0\n dp = [0] * len(matrix[0])\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n dp[j] = dp[j] + 1 if matrix[i][j] == \"1\" else 0\n max_area = max(max_area, rowMaxRectangle(dp))\n return max_area","runtime":"234"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n def hist(arr):\n l=[0]*len(arr)\n r=[0]*len(arr)\n rs=[]\n for i in range(len(arr)):\n while len(rs)>0 and arr[i]<rs[-1][0]:\n top = rs.pop()\n r[top[1]] = i-top[1]-1\n rs.append((arr[i],i))\n while len(rs)>0:\n top = rs.pop()\n r[top[1]] = len(arr)-top[1]-1\n \n ls=[]\n for i in range(len(arr)-1,-1,-1):\n while len(ls)>0 and arr[i]<ls[-1][0]:\n top = ls.pop()\n l[top[1]] = top[1]-i-1\n ls.append((arr[i],i))\n while len(ls)>0:\n top = ls.pop()\n l[top[1]] = top[1]\n \n ans=0\n for i in range(len(arr)):\n ans=max(ans,(l[i]+r[i]+1)*arr[i])\n return ans\n \n count=[0]*len(matrix[0])\n ans=0\n for i in range(len(matrix)):\n for j in range(len(matrix[i])):\n if matrix[i][j]==\"0\":\n count[j]=0\n else:\n count[j]+=1\n # print(count)\n ans = max(ans,hist(count))\n return ans\n \n\n","runtime":"259"},{"code":"class Solution:\n def getnearSmallerLeft(self, arr):\n stack = []\n ans = []\n for i in range(len(arr)):\n while stack and arr[i] <= arr[stack[-1]]:\n stack.pop()\n if stack:\n ans.append(stack[-1])\n else:\n ans.append(-1)\n stack.append(i)\n return ans\n\n def getnearSmallerRight(self, arr):\n stack = []\n ans = [0] * len(arr)\n for i in range(len(arr) - 1, -1, -1):\n while stack and arr[i] <= arr[stack[-1]]:\n stack.pop()\n if stack:\n ans[i] = stack[-1]\n else:\n ans[i] = len(arr)\n stack.append(i)\n return ans\n\n def largetst_rect(self, arr):\n nseLeft = self.getnearSmallerLeft(arr)\n nseRight = self.getnearSmallerRight(arr)\n ans = 0\n for i in range(len(arr)):\n width = nseRight[i] - nseLeft[i] - 1\n ans = max(ans, width * arr[i])\n return ans\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix or not matrix[0]:\n return 0\n \n n, m = len(matrix), len(matrix[0])\n arr = [int(matrix[0][j]) for j in range(m)]\n ans = self.largetst_rect(arr)\n \n for i in range(1, n):\n arr = [arr[j] + int(matrix[i][j]) if matrix[i][j] == '1' else 0 for j in range(m)]\n ans = max(ans, self.largetst_rect(arr))\n\n return ans\n","runtime":"259"},{"code":"class Solution:\n def maximalRectangle(self, arr: List[List[str]]) -> int:\n def mah(arr):\n st = []\n left = [0] * len(arr)\n right = [0] * len(arr)\n i = 0\n \n while i < len(arr):\n if len(st) == 0:\n left[i] = -1\n elif arr[i] > arr[st[-1]]:\n left[i] = st[-1]\n else:\n while len(st) > 0 and arr[i] <= arr[st[-1]]:\n st.pop()\n if len(st) == 0:\n left[i] = -1\n else:\n left[i] = st[-1]\n st.append(i)\n i += 1\n \n i = len(arr) - 1\n st = []\n \n while i >= 0:\n if len(st) == 0:\n right[i] = len(arr)\n elif arr[i] > arr[st[-1]]:\n right[i] = st[-1]\n else:\n while len(st) > 0 and arr[i] <= arr[st[-1]]:\n st.pop()\n if len(st) == 0:\n right[i] = len(arr)\n else:\n right[i] = st[-1]\n st.append(i)\n i -= 1\n \n width = [0] * len(arr)\n for i in range(len(arr)):\n width[i] = right[i] - left[i] - 1\n \n area = [0] * len(arr)\n for i in range(len(arr)):\n area[i] = width[i] * arr[i]\n \n return max(area)\n m = len(arr[0])\n n = len(arr)\n for i in range(n):\n for j in range(m):\n arr[i][j] = int(arr[i][j])\n l=[]\n for j in range(m):\n l.append(int(arr[0][j]))\n mx=mah(l)\n \n if len(arr)<2:\n return mx\n for i in range(1,n):\n for j in range(m):\n if arr[i][j]==1:\n l[j]=l[j]+arr[i][j]\n\n else:\n l[j]=0\n print(l)\n mx=max(mx,mah(l))\n return mx\n \n\n \n ","runtime":"284"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # tranverse matrix row by row, each row means based on this row what is the maximum rectangle\n cur_height = [0 for _ in range(len(matrix[0]))]\n res = float('-inf')\n for row_index, cur_row in enumerate(matrix):\n for cur_col, cur_item in enumerate(cur_row):\n print(cur_col, cur_item)\n if cur_item == '1':\n cur_height[cur_col] = cur_height[cur_col] + 1 \n else:\n cur_height[cur_col] = 0\n res = max(res, self.calculate_max_rectangle(cur_height))\n return res\n \n def calculate_max_rectangle(self, heights):\n stack = [] # (cur_index, cur_height)\n ret = float('-inf')\n for cur_index, cur_height in enumerate(heights):\n while stack and cur_height <= stack[-1][1]:\n last_index, last_height = stack.pop()\n last_last_index = stack[-1][0] if stack else -1\n ret = max(ret, (cur_index-last_last_index-1) * last_height)\n stack.append((cur_index, cur_height))\n while stack:\n last_index, last_height = stack.pop()\n last_last_index = stack[-1][0] if stack else -1\n ret = max(ret, (len(heights)-last_last_index-1) * last_height)\n return ret","runtime":"284"},{"code":"class Solution:\n @staticmethod\n def mrec(matrix: List[List[str]], k, l, mms):\n # print(k, l)\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n pj = m\n i = k\n while i < n:\n if (n - k) * (pj - l) <= mms:\n break\n j = l\n # print('i', i, j, pj)\n while j < pj:\n # print(k, l, i, j, pj)\n if matrix[i][j] == '0':\n break\n j += 1\n s = (i - k + 1) * (j - l)\n # print('+', k, l, i, j, s)\n if s > ms:\n ms = s\n pj = j\n i += 1\n return ms\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # print(len(matrix), print(len(matrix[0])))\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n for i in range(n):\n for j in range(m):\n pms = (n - i) * (m - j)\n if pms < ms:\n break\n s = self.mrec(matrix, i, j, ms)\n if s > ms:\n ms = s\n i += 1\n return ms\n","runtime":"309"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def maxRectangle(arr):\n leftMin = [-1 for x in arr]\n rightMin = [len(arr) for x in arr]\n stack = []\n xarr=arr\n i=0\n for x in arr:\n while len(stack) and x<stack[-1][0]:\n top = stack.pop(-1)\n rightMin[top[1]] = i\n else:\n stack.append((x,i))\n i+=1\n i=len(arr)-1\n stack=[]\n for x in arr[::-1]:\n while len(stack) and x<stack[-1][0]:\n top = stack.pop(-1)\n print(top)\n leftMin[top[1]] = i\n else:\n stack.append((x,i))\n i-=1\n \n return [leftMin,rightMin]\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if matrix[i][j] == '1':\n matrix[i][j]=1\n if matrix[i][j] == '0':\n matrix[i][j]=0\n if i != len(matrix)-1:\n if matrix[i+1][j] == '1':\n matrix[i+1][j] = 1+matrix[i][j]\n maxx=0\n for arr in matrix:\n lm,rm=maxRectangle(arr)\n # print(arr,lm,rm)\n for i in range(len(lm)):\n tmp=arr[i]*(abs(lm[i]-rm[i])-1)\n if tmp>maxx:\n maxx=tmp\n return maxx\n\n \n","runtime":"309"},{"code":"class Solution:\n @staticmethod\n def mrec(matrix: List[List[str]], k, l, rx1, rx2, ry1, ry2, mms):\n # print(k, l)\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n mi = -1\n mj = -1\n pj = m\n i = k\n while i < n:\n if (n - k) * (pj - l) <= mms:\n break\n j = l\n # print('i', i, j, pj)\n if (i < ry1) or (i > ry2) or (pj <= rx1) or (l > rx2):\n while j < pj:\n # print(k, l, i, j, pj)\n if matrix[i][j] == '0':\n break\n j += 1\n s = (i - k + 1) * (j - l)\n # print('+', k, l, i, j, s)\n if s > ms:\n ms = s\n mi = i\n mj = j - 1\n else:\n # in_x = (i >= ry1) and (i <= ry2)\n while j < pj:\n # print(k, l, i, j, pj)\n if (j >= rx1) and (j <= rx2):\n j = rx2 if j < pj else pj - 1\n else:\n if matrix[i][j] == '0':\n break\n j += 1\n s = (i - k + 1) * (j - l)\n # print('+', k, l, i, j, s)\n if s > ms:\n ms = s\n mi = i\n mj = j - 1\n pj = j\n i += 1\n return ms, mi, mj\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # print(len(matrix), print(len(matrix[0])))\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n rs = 0\n rx1 = -1\n rx2 = -1\n ry1 = -1\n ry2 = -1\n for i in range(n):\n # pms = (n - i) * m\n # if pms < ms:\n # break\n for j in range(m):\n pms = (n - i) * (m - j)\n if pms < ms:\n break\n s, ir, jr = self.mrec(matrix, i, j, rx1, rx2, ry1, ry2, ms)\n if s > ms:\n ms = s\n if s > rs:\n rx1 = j\n rx2 = jr\n ry1 = i\n ry2 = ir\n rs = s\n i += 1\n ry1 += 1\n rs -= rx2 - rx1\n return ms\n","runtime":"335"},{"code":"class Stack:\n\n def __init__(self):\n self.arr = []\n\n def push(self, data):\n self.arr.append(data)\n\n def pop(self):\n if len(self.arr) == 0:\n return -1\n else:\n y = self.arr.pop()\n return y\n\n def len(self):\n return len(self.arr)\n\n def top(self):\n if len(self.arr) > 0:\n return self.arr[-1]\n else:\n return -1e9 - 1\n\n def show(self):\n return self.arr\n\n\ndef pse(n, a):\n # code here\n\n s = Stack()\n b = n * [0]\n\n for i in range(n):\n\n while s.len() > 0 and a[s.top()] > a[i]:\n s.pop()\n if s.len() == 0:\n b[i] = -1\n s.push(i)\n else:\n b[i] = s.top()\n s.push(i)\n return b\n\n\ndef nse(n, a):\n # code here\n\n s = Stack()\n b = n * [0]\n\n for i in range(n - 1, -1, -1):\n while s.len() > 0 and a[s.top()] >= a[i]:\n s.pop()\n if s.len() == 0:\n b[i] = n\n s.push(i)\n else:\n b[i] = s.top()\n s.push(i)\n\n return b\ndef largestRectangleArea(heights) -> int:\n\n n = len(heights)\n\n left = pse(n,heights)\n right = nse(n,heights)\n #print(left,right)\n ans = 0\n for i in range(n):\n if left[i] == -1:\n if right[i] == n:\n ans = max(ans,n*heights[i])\n else:\n ans = max(ans,(right[i]+1)*heights[right[i]],heights[i]*(right[i]))\n else:\n if right[i] == n:\n ans = max(ans,(n-left[i])*(heights[left[i]]),(n-left[i]-1)*(heights[i]))\n else:\n ans = max(ans,(right[i]-left[i])*max(heights[left[i]],heights[right[i]]),(right[i]-left[i]-1)*heights[i])\n return ans\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n \n prefixmatrix =[[0 for i in range(len(matrix[0]))] for j in range(len(matrix))]\n\n for i in range(len(matrix[0])):\n prefixmatrix[0][i] = int(matrix[0][i])\n for j in range(1,len(matrix)):\n if matrix[j][i] == \"0\":\n prefixmatrix[j][i] = 0\n else:\n prefixmatrix[j][i] = prefixmatrix[j-1][i] + int(matrix[j][i])\n ans = 0\n print(prefixmatrix)\n for i in prefixmatrix:\n ans = max(ans,largestRectangleArea(i))\n\n return ans\n\n\n","runtime":"335"},{"code":"class Solution:\n def find_max_vert_line(self, y, x):\n if self.distances_matrix[y][x][0]:\n return self.distances_matrix[y][x][0]\n y_copy = y\n val = 0\n while y_copy<self.height and self.matrix[y_copy][x] == \"1\" :\n val+=1\n y_copy+=1\n self.distances_matrix[y][x][0] = val\n return self.distances_matrix[y][x][0]\n\n def find_max_horz_line(self, y, x):\n if self.distances_matrix[y][x][1]:\n return self.distances_matrix[y][x][1]\n x_copy = x\n val = 0\n while x_copy<self.width and self.matrix[y][x_copy] == \"1\":\n val+=1\n x_copy+=1\n self.distances_matrix[y][x][1] = val\n return val\n \n def find_max_rect_in_local(self, y, x, current_max):\n max_width = self.find_max_horz_line(y,x)\n max_height = self.find_max_vert_line(y,x)\n if max_height * max_width < current_max:\n return current_max\n for current_width in range(max_width, 0, -1):\n if max_height * current_width < current_max:\n return current_max\n else:\n row_counter = 1\n for new_y in range(y+1, y+max_height):\n if self.find_max_horz_line(new_y,x)>=current_width:\n row_counter+=1\n else:\n break\n new_max = row_counter*current_width\n if new_max>current_max:\n current_max=new_max\n return current_max\n \n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n self.matrix = matrix\n current_max = 0\n self.width=len(self.matrix[0])\n self.height=len(self.matrix)\n self.distances_matrix = [[[None,None] for _ in range(self.width)] for _ in range(self.height)]\n # for y in range(0, len(self.matrix)):\n # print(\"\".join(self.matrix[y]))\n # print(self.find_max_rect_in_local(0,0))\n for y in range(0, self.height):\n for x in range(0, self.width):\n if (self.width-x)*(self.height-y) < current_max:\n break\n # print(\"y:%s, x:%s, val:%s \"% (y, x, self.find_max_rect_in_local(y,x)))\n current_max = self.find_max_rect_in_local(y,x, current_max)\n return current_max","runtime":"360"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m = len(matrix)\n n = len(matrix[0])\n def get_max_from_hist(heights):\n n = len(heights)\n left = [-1]*n\n right = [-1] * n\n \n s = []\n for i in range(n):\n v = heights[i]\n while s and heights[s[-1]]>v:\n right[s[-1]] = i\n s.pop()\n s.append(i)\n s = []\n for i in range(n-1,-1,-1):\n v = heights[i]\n while s and heights[s[-1]]>v:\n left[s[-1]] = i\n s.pop()\n s.append(i)\n print(left)\n print(right)\n res = 0\n for i in range(n):\n l = left[i]\n r = right[i]\n if l==-1:\n l = -1\n if r==-1:\n r = n\n ans = (r-l-1)*heights[i]\n if res<ans:\n res = ans\n print(l,r,i,heights[i],ans)\n return res\n # line\n ans = 0\n for k in range(m):\n heights = [0]*n\n for j in range(n):\n h = 0\n for i in range(k,m):\n if matrix[i][j]=='1':\n h+=1\n else:\n break\n heights[j] = h\n print(heights)\n ans = max(ans,get_max_from_hist(heights))\n return ans\n\n\n\n ","runtime":"360"},{"code":"class Solution:\n @staticmethod\n def mrec(matrix: List[List[str]], k, l, rx1, rx2, ry1, ry2, mms):\n # print(k, l)\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n mi = -1\n mj = -1\n pj = m\n i = k\n while i < n:\n if (n - k) * (pj - l) <= mms:\n break\n j = l\n in_x = (i >= ry1) and (i <= ry2)\n # print('i', i, j, pj)\n if (pj <= rx1) or (l > rx2):\n while j < pj:\n # print(k, l, i, j, pj)\n if matrix[i][j] == '0':\n break\n s = (i - k + 1) * (j - l + 1)\n # print('+', k, l, i, j, s)\n if s > ms:\n ms = s\n mi = i\n mj = j\n j += 1\n else:\n while j < pj:\n # print(k, l, i, j, pj)\n if in_x and (j >= rx1) and (j <= rx2):\n j = rx2 if j < pj else pj - 1\n s = (i - k + 1) * (j - l + 1)\n else:\n if matrix[i][j] == '0':\n break\n s = (i - k + 1) * (j - l + 1)\n # print('+', k, l, i, j, s)\n if s > ms:\n ms = s\n mi = i\n mj = j\n j += 1\n pj = j\n i += 1\n return ms, mi, mj\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # print(len(matrix), print(len(matrix[0])))\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n rs = 0\n rx1 = -1\n rx2 = -1\n ry1 = -1\n ry2 = -1\n for i in range(n):\n # pms = (n - i) * m\n # if pms < ms:\n # break\n for j in range(m):\n pms = (n - i) * (m - j)\n if pms < ms:\n break\n s, ir, jr = self.mrec(matrix, i, j, rx1, rx2, ry1, ry2, ms)\n if s > ms:\n ms = s\n if s > rs:\n rx1 = j\n rx2 = jr\n ry1 = i\n ry2 = ir\n rs = s\n i += 1\n ry1 += 1\n rs -= rx2 - rx1\n return ms\n","runtime":"385"},{"code":"import numpy as np\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n def width(i):\n arr = matrix[i]\n count = 0\n for k in range(len(arr)):\n if arr[k] == \"1\":\n count += 1\n else:\n count = 0 \n arr[k] = count\n \n for i in range(len(matrix)):\n width(i)\n \n matrix = np.array(matrix).T\n \n def leetcode88(i):\n arr = matrix[i]\n stack = []\n\n mx = 0 \n \n for k in range(len(arr)):\n j = k\n while stack and stack[-1][0] > arr[k]:\n h, j = stack.pop()\n mx = max(mx, h * (k - j))\n stack.append([arr[k], j])\n\n k = len(arr)\n while stack:\n h, j = stack.pop()\n mx = max(mx, h * (k - j))\n return mx\n \n return max([leetcode88(i) for i in range(len(matrix))])\n\n\n","runtime":"385"},{"code":"import numpy as np\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix or not matrix[0]:\n return 0\n \n # Convert matrix to numpy array for faster operations\n matrix = np.array([[int(cell) for cell in row] for row in matrix], dtype=np.int32)\n return self._maximal_rectangle_optimized(matrix)\n \n @staticmethod\n def _maximal_rectangle_optimized(matrix):\n rows, cols = matrix.shape\n heights = np.zeros(cols, dtype=np.int32)\n max_area = 0\n \n for row in range(rows):\n # Update heights\n heights = (heights + 1) * matrix[row]\n \n # Calculate max rectangle for current row\n stack = [-1]\n for i in range(cols + 1):\n h = heights[i] if i < cols else 0\n while stack[-1] != -1 and heights[stack[-1]] > h:\n height = heights[stack.pop()]\n width = i - stack[-1] - 1\n max_area = max(max_area, height * width)\n stack.append(i)\n \n return max_area\n","runtime":"411"},{"code":"class Solution:\n @staticmethod\n def mrec(matrix: List[List[str]], k, l, rx1, rx2, ry1, ry2, mms):\n # print(k, l)\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n mi = -1\n mj = -1\n pj = m\n i = k\n while i < n:\n if (n - k) * (pj - l) <= mms:\n break\n j = l\n in_x = (i >= ry1) and (i <= ry2)\n # print('i', i, j, pj)\n while j < pj:\n # print(k, l, i, j, pj)\n if in_x and (j >= rx1) and (j <= rx2):\n j = rx2\n if j >= pj:\n j = pj - 1\n s = (i - k + 1) * (j - l + 1)\n else:\n if matrix[i][j] == '0':\n break\n s = (i - k + 1) * (j - l + 1)\n # print('+', k, l, i, j, s)\n if s > ms:\n ms = s\n mi = i\n mj = j\n j += 1\n pj = j\n i += 1\n return ms, mi, mj\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # print(len(matrix), print(len(matrix[0])))\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n rs = 0\n rx1 = -1\n rx2 = -1\n ry1 = -1\n ry2 = -1\n for i in range(n):\n # pms = (n - i) * m\n # if pms < ms:\n # break\n for j in range(m):\n pms = (n - i) * (m - j)\n if pms < ms:\n break\n s, ir, jr = self.mrec(matrix, i, j, rx1, rx2, ry1, ry2, ms)\n if s > ms:\n ms = s\n if s > rs:\n rx1 = j\n rx2 = jr\n ry1 = i\n ry2 = ir\n rs = s\n i += 1\n ry1 += 1\n rs -= rx2 - rx1\n return ms\n","runtime":"411"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_area = 0\n matrix = [list(map(int, row)) for row in matrix]\n R, C = len(matrix), len(matrix[0])\n for r in range(len(matrix)):\n heights = []\n for c in range(C):\n if matrix[r][c] == 0:\n heights.append(0)\n continue\n r1 = r\n while r1 + 1 < R and matrix[r1+1][c] == 1:\n r1 += 1\n heights.append(r1 - r + 1)\n max_area = max(max_area, self.maxAreaInHistogram(heights))\n \n return max_area\n\n def maxAreaInHistogram(self, heights):\n stack, max_area = [], 0\n for height in heights + [-1]:\n width = 0\n while stack and stack[-1][0] >= height:\n prev_height, prev_width = stack.pop()\n width += prev_width\n max_area = max(max_area, width * prev_height)\n\n stack.append((height, width + 1)) \n \n return max_area\n\n\n'''\nhistogram from every height\ncalc prefix sums in n^2\ngenerate histogram problem in n, n histogram problems\n\noverall n^2\n'''","runtime":"436"},{"code":"class Solution:\n import sys\n\n def maxRectArea(self, ht):\n n = len(ht)\n\n if n==1:\n if ht[0] == 0:\n return 0\n elif ht[0] == 1:\n return 1\n\n \n ls = [-1]*n\n rs = [n]*n\n\n maxArea = -1\n\n for i in range(0, n):\n\n for j in range(i-1, -1, -1):\n if ht[j] < ht[i]:\n ls[i] = j\n break\n\n for k in range(i+1, n):\n if ht[i] > ht[k]:\n rs[i] = k\n break\n\n area = (rs[i] - ls[i] - 1)*ht[i]\n maxArea = max(maxArea, area)\n\n return maxArea\n \n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n n = len(matrix)\n m = len(matrix[0])\n\n if n==0:\n return None\n\n ht = [0]*m\n\n maxArea = 0\n\n for i in range(0,n):\n for j in range(0,m):\n if matrix[i][j] == \"1\":\n ht[j] += 1\n\n else: ht[j] = 0\n\n rowArea = self.maxRectArea(ht)\n maxArea = max(maxArea, rowArea)\n \n return maxArea","runtime":"436"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if matrix == []: return 0\n else:\n mat = [[0 for i in range(len(matrix[0]))] for j in range(len(matrix))]\n for i in range(len(matrix)):\n for j in range(len(matrix[i])):\n if matrix[i][j] == \"1\":\n hei = 0\n idx = i\n while idx < len(matrix):\n if matrix[idx][j] == \"1\":\n hei += 1\n else: break\n idx += 1\n mat[i][j] = hei\n result = 0\n for i in range(len(mat)):\n stack = [[0, mat[i][0]]]\n for j in range(1, len(mat[i])):\n idx = j\n while stack != [] and stack[-1][1] > mat[i][j]:\n val = stack[-1][1] * (j - stack[-1][0])\n if result < val: result = val\n idx = stack.pop()[0]\n stack.append([idx, mat[i][j]])\n while stack != []:\n val = stack[-1][1] * (len(mat[i]) - stack[-1][0])\n if result < val: result = val\n stack.pop()\n return result\n \n","runtime":"461"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n rows = len(matrix)\n cols = len(matrix[0])\n \n row_histogram = [0 for i in range(cols)]\n\n def get_max_rect_area(hist):\n l = len(hist)\n #prev less array\n prev_less = [-1 for i in range(l)]\n \n for i in range(1,l):\n for j in range(i-1,-1,-1):\n if hist[i]>hist[j]:\n prev_less[i]=j\n break\n #next less array\n next_less = [-1 for i in range(l)]\n \n for i in range(l-1,-1,-1):\n for j in range(i+1,l):\n if hist[i]>hist[j]:\n next_less[i]=j\n break\n \n\n\n '''\n counter = 0\n prev_less = [-1 for i in range(l)]\n while counter+1<l and hist[counter]>=hist[counter+1]:\n counter+=1\n\n if counter<l-1:\n min_ = hist[counter]\n min_index=counter\n for i in range(counter+1,l):\n if min_ >= hist[i]:\n prev_less[i] = -1\n min_ = hist[i]\n min_index = i\n else:\n prev_less[i] = min_index\n '''\n # next less array\n '''\n counter = l-1\n next_less = [-1 for i in range(l)]\n while counter-1>=0 and hist[counter-1]<=hist[counter]:\n counter-=1\n\n if counter>0:\n min_ = hist[counter]\n min_index=counter\n for i in range(counter-1,-1,-1):\n if min_ >= hist[i]:\n next_less[i] = -1\n min_ = hist[i]\n min_index = i\n else:\n next_less[i] = min_index\n '''\n \n area = -1\n for i in range(l):\n width_left = i-prev_less[i]-1\n ''' #above condition equivalent to below if else code\n if prev_less[i]==-1:\n width_left = i\n else:\n width_left = i-prev_less[i]-1\n '''\n width_right = 0\n if next_less[i]==-1:\n width_right = l-1-i\n else:\n width_right = next_less[i] - i -1\n area = max(area, (width_left+width_right+1)*hist[i])\n \n if False:\n print(\"\\n--------------------------------------\\nhistogram: \", end='')\n for i in hist:\n print(i, end= ' ')\n print(\"\\nprev less: \",end='')\n for i in prev_less:\n print(i, end= ' ')\n print(\"\\nnext less: \",end='')\n for i in next_less:\n print(i, end= ' ')\n return area\n\n area = -1\n\n for i in range(rows):\n for j in range(cols):\n if matrix[i][j]=='1':\n row_histogram[j]+=1\n else:\n row_histogram[j]=0\n \n area = max(area, get_max_rect_area(row_histogram))\n \n \n return area","runtime":"461"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n mat_1 = []\n for y in range(len(matrix)):\n temp = [0]*len(matrix[0])\n mat_1.append(temp)\n\n cur_big = 0\n for y in range(len(matrix)-1,-1,-1):\n\n\n for x in range(len(matrix[0])-1,-1,-1):\n\n\n if matrix[y][x] == \"1\":\n if cur_big < 1: cur_big = 1\n mat_1[y][x] += 1\n if (x+1) < len(matrix[0]):\n mat_1[y][x] += mat_1[y][x+1]\n if cur_big < mat_1[y][x]: cur_big = mat_1[y][x]\n \n \n #for x in mat_1:print(x)\n\n #for i in range(1,len(mat_1)):\n temp = [0]*(len(mat_1[0])+5)\n for x in range(len(mat_1[0])):\n for i in range(len(temp)):temp[i]=0\n for y in range(len(mat_1)):\n len_x = mat_1[y][x]\n for i in range(1,mat_1[y][x]+1):\n temp[i] += 1\n if temp[i]*i > cur_big: cur_big = temp[i]*i\n \n if (y+1) < len(mat_1) and mat_1[y+1][x] < len_x:\n for i in range(mat_1[y+1][x]+1,len_x+1):\n temp[i] = 0\n\n return cur_big","runtime":"486"},{"code":"class Solution:\n def f(self,array):\n n=len(array)\n result=[-1]*n\n stack=[]\n for i in range(n):\n next_element=array[i]\n while stack and array[stack[-1]]>next_element:\n index=stack.pop()\n result[index]=i\n stack.append(i)\n return result\n def g(self,array):\n n=len(array)\n result=[-1]*n\n stack=[]\n for i in range(n-1,-1,-1):\n next_element=array[i]\n while stack and array[stack[-1]]>next_element:\n index=stack.pop()\n result[index]=i\n stack.append(i)\n return result\n def largestRectangleArea(self, heights: List[int]) -> int:\n n=len(heights)\n x=self.f(heights)\n y=self.g(heights)\n d=[0]*n\n for i in range(n):\n if x[i]==-1 and y[i]==-1:\n d[i]=heights[i]*n\n elif x[i]==-1 and y[i]!=-1:\n d[i]=heights[i]*(n-y[i]-1)\n elif y[i]==-1 and x[i]!=-1:\n d[i]=heights[i]*(x[i])\n else: \n d[i]=heights[i]*(x[i]-y[i]-1) \n return max(d)\n \n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n \n m=len(matrix)\n n=len(matrix[0])\n s=0\n for i in range(m):\n heights=[0]*n\n for j in range(n):\n k=0\n while (k+i)<=m-1 and matrix[k+i][j]==\"1\":\n k+=1\n heights[j]=k\n s=max(s,self.largestRectangleArea(heights))\n return s\n \n\n","runtime":"486"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def largestRectangleArea(heights):\n if not heights:\n return 0\n stack = [heights[0]]\n maxi = 0\n for item in heights[1:]:\n if item >= stack[-1]:\n stack.append(item)\n else:\n for i in range(len(stack)-1, -1, -1):\n if stack[i] < item:\n break\n if i == 0:\n i = -1\n for j in range(i+1, len(stack)):\n cur = stack[j]*(len(stack)-j)\n if cur > maxi:\n maxi = cur\n for j in range(i+1, len(stack)):\n stack[j] = item\n stack.append(item)\n for i in range(0, len(stack)):\n cur = stack[i]*(len(stack)-i)\n if cur > maxi:\n maxi = cur\n return maxi\n \n if not matrix:\n return 0\n maxi_matrix = 0\n for i in range(0, len(matrix)):\n heights = [0 for _ in range(0, len(matrix[0]))]\n for j in range(0, len(matrix[0])):\n for k in range(i, -1, -1):\n if matrix[k][j] == '1':\n heights[j] += 1\n else:\n break\n maxi_line = largestRectangleArea(heights)\n if maxi_line > maxi_matrix:\n maxi_matrix = maxi_line\n return maxi_matrix","runtime":"537"},{"code":"import numpy as np \nclass Solution:\n \n def find_largest_rectangle(self, heights): \n\n n = len(heights)\n s = []\n l = [-1] * n \n r = [n] * n \n for i in range(n): \n while s and heights[s[-1]] >= heights[i]: \n r[s[-1]] = i \n s.pop()\n \n if s: \n l[i] = s[-1]\n s.append(i)\n\n return max([heights[i] * (r[i] - l[i]-1) for i in range(n)])\n\n def compute_heights(self, matrix, start_index=0):\n # hard problem \n m, n = len(matrix), len(matrix[0])\n\n heights = [0] * m\n for i in range(m): \n if matrix[i][start_index] == '0': \n continue\n for j in range(start_index, n): \n if matrix[i][j] == '1': \n heights[i] += 1\n else:\n break \n return heights\n\n \n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n m, n = len(matrix), len(matrix[0]) \n max_area = float('-inf')\n for start_index in range(n):\n heights = self.compute_heights(matrix, start_index)\n area = self.find_largest_rectangle(heights)\n max_area = max(max_area, area)\n \n return max_area\n\n ","runtime":"537"},{"code":"import numpy as np \nclass Solution:\n \n def find_largest_rectangle(self, heights): \n\n n = len(heights)\n s = []\n l = [-1] * n \n r = [n] * n \n for i in range(n): \n while s and heights[s[-1]] >= heights[i]: \n r[s[-1]] = i \n s.pop()\n \n if s: \n l[i] = s[-1]\n s.append(i)\n\n return max([heights[i] * (r[i] - l[i]-1) for i in range(n)])\n\n def compute_heights(self, matrix, start_index=0):\n # hard problem \n m, n = len(matrix), len(matrix[0])\n\n heights = [0] * m\n for i in range(m): \n if matrix[i][start_index] == '0': \n continue\n for j in range(start_index, n): \n if matrix[i][j] == '1': \n heights[i] += 1\n else:\n break \n return heights\n\n \n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n m, n = len(matrix), len(matrix[0]) \n max_area = float('-inf')\n for start_index in range(n):\n heights = self.compute_heights(matrix, start_index)\n area = self.find_largest_rectangle(heights)\n max_area = max(max_area, area)\n \n return max_area\n\n ","runtime":"562"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix:\n return 0\n\n m, n = len(matrix), len(matrix[0])\n ans = 0\n for i in range(m):\n # monotonic stk for each \"histogram\" max area\n stk = []\n h = [0]*n\n for j in range(n):\n # get height for (i, j)\n j_h = 0\n while i-j_h >= 0 and matrix[i-j_h][j] == '1':\n j_h += 1\n h[j] = j_h\n\n # check max area in stk\n for idx, h in enumerate([0]+h+[0]):\n print(stk)\n while stk and stk[-1][1] >= h:\n idx1, h1 = stk.pop()\n if stk:\n idx2, _ = stk[-1]\n ans = max(ans, (idx-idx2-1)*h1)\n stk.append((idx, h))\n\n return ans","runtime":"562"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n # worst O(n**3)\n \n length = len(matrix[0])\n width = len(matrix)\n\n for i in range(width):\n for j in range(length):\n matrix[i][j] = int(matrix[i][j])\n\n for row in range(width):\n for col in range(length):\n cur_cell = matrix[row][col]\n directions = [(-1,0), (-1,-1), (0,-1)]\n temp = []\n\n if cur_cell == 1:\n for dr, dc in directions:\n next_r = row + dr\n next_c = col + dc\n\n if next_r in range(width) and next_c in range(length):\n next_cell = matrix[next_r][next_c]\n temp.append(next_cell)\n else: temp.append(0)\n matrix[row][col] = matrix[row][col] + min(temp)\n \n max_ans = 0\n \n # expansion\n for i in range(width):\n for j in range(length):\n\n current = matrix[i][j]\n current_area_v = current * current\n current_area_h = current * current\n\n if current >= 1:\n # downward\n for down in range(i+1, width):\n if matrix[down][j] >= current:\n current_area_v += current\n else: break\n\n for right in range(j+1, length):\n if matrix[i][right] >= current:\n current_area_h += current\n else: break\n \n max_ans = max(max_ans, current_area_v, current_area_h)\n \n return max_ans","runtime":"587"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n # worst O(n**3)\n \n length = len(matrix[0])\n width = len(matrix)\n\n # 每个正方形的点向下或者向右扩张\n\n for i in range(width):\n for j in range(length):\n matrix[i][j] = int(matrix[i][j])\n\n for row in range(width):\n for col in range(length):\n cur_cell = matrix[row][col]\n directions = [(-1,0), (-1,-1), (0,-1)]\n temp = []\n\n if cur_cell == 1:\n for dr, dc in directions:\n next_r = row + dr\n next_c = col + dc\n\n if next_r in range(width) and next_c in range(length):\n next_cell = matrix[next_r][next_c]\n temp.append(next_cell)\n else: temp.append(0)\n matrix[row][col] = matrix[row][col] + min(temp)\n \n max_ans = 0\n \n # expansion\n for i in range(width):\n for j in range(length):\n\n current = matrix[i][j]\n current_area_v = current * current\n current_area_h = current * current\n\n if current >= 1:\n # downward\n for down in range(i+1, width):\n if matrix[down][j] >= current:\n current_area_v += current\n else: break\n\n for right in range(j+1, length):\n if matrix[i][right] >= current:\n current_area_h += current\n else: break\n \n max_ans = max(max_ans, current_area_v, current_area_h)\n \n return max_ans","runtime":"587"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n N, M = len(matrix), len(matrix[0])\n self.ans = 0\n\n def maxTriangleContaining(r, c):\n row = r\n min_width = float('inf')\n area = 0\n\n while row < N and matrix[row][c] == '1':\n width = 1\n\n for nc in range(c + 1, M):\n if matrix[row][nc] != '1':\n break\n \n width += 1\n \n min_width = min(min_width, width)\n row += 1\n\n if min_width * (N - r) < self.ans:\n break\n \n area = max(area, min_width * (row - r))\n\n return area\n \n for r in range(N):\n for c in range(M):\n if matrix[r][c] == '1':\n self.ans = max(self.ans, maxTriangleContaining(r, c))\n\n return self.ans","runtime":"613"},{"code":"class Solution:\n def maxHist(self, ls, n):\n ans = 0\n for p, val in enumerate(ls):\n w = 1\n temp = p-1\n while p != 0 and temp >= 0 and ls[temp] >= val:\n w += 1\n temp -= 1\n temp = p+1\n while temp < n and ls[temp] >= val:\n w += 1\n temp += 1\n ans = max(ans, val*w)\n return ans\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n matrix[0] = [int(i) for i in matrix[0]]\n ans = max(0, self.maxHist(matrix[0], n))\n for i in range(1, m):\n for j in range(n):\n matrix[i][j] = int(matrix[i][j])\n if matrix[i][j] > 0:\n matrix[i][j] += matrix[i-1][j]\n ans = max(ans, self.maxHist(matrix[i], n))\n # print(matrix)\n return ans","runtime":"613"},{"code":"class Solution:\n def maximalRectangle(self, arr: List[List[str]]) -> int:\n m=len(arr)\n n=len(arr[0])\n for j in range(n):\n arr[0][j]=eval(arr[0][j])\n for i in range(1,m):\n for j in range(n):\n arr[i][j]=eval(arr[i][j])\n if arr[i][j]==1:\n arr[i][j]+=arr[i-1][j]\n def largestRectangleArea(heights):\n n_s=[-1]*len(heights)\n p_s=[-1]*len(heights)\n def next_smaller(arr):\n s=[]\n top=-1\n for i in range(len(arr)):\n while top>-1:\n if arr[s[top]]>arr[i]:\n n_s[s.pop(top)]=i\n top-=1\n else:\n break\n if top!=-1:\n p_s[i]=s[top] \n s.append(i)\n top+=1\n \n m=0\n l=0\n r=0\n next_smaller(heights)\n for i in range(len(heights)):\n l=p_s[i]\n r=n_s[i]\n if r==-1:\n r=len(heights)\n if m < heights[i]*(r-(l+1)):\n m=heights[i]*(r-(l+1))\n return m\n mq=-1\n for x in arr:\n mq=max(mq,largestRectangleArea(x))\n return mq\n\n ","runtime":"638"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n # worst O(n**3)\n \n length = len(matrix[0])\n width = len(matrix)\n\n \n # find maximal square\n for i in range(width):\n for j in range(length):\n matrix[i][j] = int(matrix[i][j])\n\n for row in range(width):\n for col in range(length):\n cur_cell = matrix[row][col]\n directions = [(-1,0), (-1,-1), (0,-1)]\n temp = []\n\n if cur_cell == 1:\n for dr, dc in directions:\n next_r = row + dr\n next_c = col + dc\n\n if next_r in range(width) and next_c in range(length):\n next_cell = matrix[next_r][next_c]\n temp.append(next_cell)\n else: temp.append(0)\n matrix[row][col] = matrix[row][col] + min(temp)\n \n max_ans = 0\n \n # expansion\n # 每个正方形的点向下或者向右扩张\n for i in range(width):\n for j in range(length):\n\n current = matrix[i][j]\n current_area_v = current * current\n current_area_h = current * current\n\n if current >= 1:\n # downward\n for down in range(i+1, width):\n if matrix[down][j] >= current:\n current_area_v += current\n else: break\n\n for right in range(j+1, length):\n if matrix[i][right] >= current:\n current_area_h += current\n else: break\n \n max_ans = max(max_ans, current_area_v, current_area_h)\n \n return max_ans","runtime":"638"},{"code":"from typing import List\r\nimport time\r\nclass Solution:\r\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\r\n def find_continuous(row: List[int]) -> List[tuple]:\r\n res = []\r\n last = 0\r\n start = -1\r\n end = -1\r\n for idx, item in enumerate(row):\r\n item = int(item)\r\n if item == 1 and last == 0:\r\n start = idx\r\n end = idx\r\n elif item == 0 and last == 1:\r\n res.append((start, end))\r\n start = -1\r\n end = -1\r\n elif item == 1:\r\n end = idx\r\n last = item\r\n if end != -1:\r\n res.append((start, end))\r\n return res\r\n def get_hists(matrix, row_index, start, end) -> tuple[List[int], int]:\r\n res = []\r\n max_height = 0\r\n for i in range(start, end+1):\r\n height = 0\r\n for j in range(row_index, -1, -1):\r\n if int(matrix[j][i]) == 1:\r\n height += 1\r\n else:\r\n break\r\n if height > max_height:\r\n max_height = height\r\n res.append(height)\r\n return res, max_height\r\n def calc_largest(heights: List[int]) -> int:\r\n stack = [] # Stack to store indices\r\n max_area = 0 # Initialize max area\r\n index = 0 # Current index\r\n\r\n while index < len(heights):\r\n # If this bar is higher than the bar on top stack, push it to stack\r\n if not stack or heights[index] >= heights[stack[-1]]:\r\n stack.append(index)\r\n index += 1\r\n else:\r\n # Pop the top\r\n top_of_stack = stack.pop()\r\n # Calculate the area with heights[top_of_stack]\r\n # as the smallest bar\r\n width = index if not stack else index - stack[-1] - 1\r\n area = heights[top_of_stack] * width\r\n # Update max area, if needed\r\n max_area = max(max_area, area)\r\n\r\n # Now pop the remaining bars from stack and calculate area\r\n while stack:\r\n top_of_stack = stack.pop()\r\n width = index if not stack else index - stack[-1] - 1\r\n area = heights[top_of_stack] * width\r\n max_area = max(max_area, area)\r\n return max_area\r\n\r\n rows = len(matrix)\r\n cols = len(matrix[0])\r\n max_area = 0\r\n for i in range(rows):\r\n continuous_range = find_continuous(matrix[i])\r\n for item in continuous_range:\r\n start = item[0]\r\n end = item[1]\r\n hists, maxh = get_hists(matrix, i, start, end)\r\n width = end - start + 1\r\n if maxh * width <= max_area:\r\n continue\r\n area = calc_largest(hists)\r\n if area > max_area:\r\n max_area = area\r\n return max_area\r\n ","runtime":"663"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # Brute force.\n n_rows = len(matrix)\n n_cols = len(matrix[0])\n\n def maxAreaIJ(i, j):\n max_area = 0\n max_j = n_cols - 1\n for ii in range(i, n_rows):\n if matrix[ii][j] != \"1\": break\n for jj in range(j, n_cols+1):\n if jj == n_cols or matrix[ii][jj] == \"0\":\n max_j= min(jj-1, max_j)\n area = (max_j - j + 1) * (ii - i + 1)\n max_area = max(max_area, area)\n break\n \n return max_area\n \n res = 0\n for i in range(n_rows):\n for j in range(n_cols):\n # Stop early if res is already bigger than max possible.\n if res > (n_cols - j) * (n_rows - i):\n continue\n res = max(res, maxAreaIJ(i,j))\n \n return res\n \n\n\n\n ","runtime":"663"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n x=len(matrix[0]) # obtain dimensions of the matrix\n y=len(matrix)\n dict_x={} # dict for horizontal contiguous sequences a tile is in; key is xy coordinate of tile\n visited=[0 for i in range(x*y)] # dict of visited positions\n all_1=1\n\n \n\n for i in range(y): # traverse each row find all contiguous sequences of 1's\n start=0\n temp=[]\n for j in range(x):\n \n if matrix[i][j]==\"1\":\n temp.append(i*x + j)\n\n if j==x-1:\n for elem in temp:\n dict_x[elem]=[start,j]\n\n if matrix[i][j]=='0':\n for elem in temp:\n dict_x[elem]=[start,j-1]\n temp=[]\n start=j+1\n all_1=0\n if(all_1):\n return x*y\n \n\n\n \n \n current=0 # current position \n curr_size=0\n greatest=0\n\n \n \n while(current < x*y): \n curr_y=current//x # current x-coordinate\n curr_x=current - curr_y*x # current y-coordinate\n \n position=curr_x + x*curr_y # position of tile as integer\n \n if(matrix[curr_y][curr_x]!=\"1\"):\n current+=1\n continue\n \n endpoint1=dict_x[position][0] # endpoints for the horizontal band of 1's\n endpoint2=x\n\n for i in range(curr_y,y):\n\n position=i*x + curr_x\n \n if(position in dict_x.keys()):\n endpoint1=max(endpoint1,dict_x[position][0])\n endpoint2=min(endpoint2,dict_x[position][1])\n length=1+i-curr_y\n height=1 + endpoint2-endpoint1\n curr_size = length*height\n\n\n if curr_size>greatest:\n greatest=curr_size\n\n for z in range(endpoint1,endpoint2+1):\n visited[i*x + z]=1 # visited\n \n else:\n visited[i*x + curr_x]=1 \n break\n \n\n current+=1\n\n \n return greatest","runtime":"688"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n for i in range(len(matrix)):\n for j in range(len(matrix[i])):\n matrix[i][j] = int(matrix[i][j])\n # if matrix[i][j] == 1 and j-1 >= 0:\n # matrix[i][j] = matrix[i][j] + matrix[i][j-1]\n # print(matrix[i])\n # print(\"__________________\")\n\n max_rect = 0\n # print(matrix[0])\n for i in range(len(matrix)):\n base = 0\n heigth = []\n for j in range(len(matrix[0])):\n if matrix[i][j] == 1:\n if i-1 >= 0:\n matrix[i][j] += matrix[i-1][j]\n count = 0\n while heigth and heigth[-1] > matrix[i][j]:\n count += 1\n heigth.pop()\n while count > 0:\n heigth.append(matrix[i][j])\n count -= 1\n heigth.append(matrix[i][j])\n base += 1\n else:\n heigth = []\n base = 0\n for k in range(len(heigth)):\n # print(i, j, max_rect)\n max_rect = max(max_rect, heigth[k] * (len(heigth) - k) )\n # print(matrix[i])\n return max_rect","runtime":"688"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n rows = len(matrix)\n cols = len(matrix[0])\n dp = matrix.copy()\n\n dp[0] = list(map(int, dp[0]))\n for r in range(1, rows):\n for c in range(cols):\n if int(dp[r][c]) > 0:\n dp[r][c] = 1 + int(dp[r-1][c])\n for row in dp:\n print(row)\n best_rec = 0\n for r in range(rows):\n for c in range(cols):\n if int(dp[r][c]) == 0:\n continue\n current_val = int(dp[r][c])\n\n i,j = c, c \n while i >= 0 and int(dp[r][i]) >= current_val:\n i -= 1\n while j < cols and int(dp[r][j]) >= current_val:\n j += 1\n i += 1\n j -= 1\n best_rec = max( (j - i + 1) * current_val , best_rec)\n\n return best_rec\n \n\n","runtime":"714"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n rows = len(matrix)\n cols = len(matrix[0])\n dp = matrix.copy()\n\n dp[0] = list(map(int, dp[0]))\n for r in range(1, rows):\n for c in range(cols):\n if int(dp[r][c]) > 0:\n dp[r][c] = 1 + int(dp[r-1][c])\n for row in dp:\n print(row)\n best_rec = 0\n for r in range(rows):\n for c in range(cols):\n if int(dp[r][c]) == 0:\n continue\n current_val = int(dp[r][c])\n\n i,j = c, c \n while i >= 0 and int(dp[r][i]) >= current_val:\n i -= 1\n while j < cols and int(dp[r][j]) >= current_val:\n j += 1\n i += 1\n j -= 1\n best_rec = max( (j - i + 1) * current_val , best_rec)\n\n return best_rec\n \n\n","runtime":"714"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n ## Set intersection and memoization (first solution)\n ## 23 LOC in 1:23:40 at 3:42 pm\n ## 397 ms 17.23%, 21.58 MB 5.01%\n ans, m, n = 0, len(matrix), len(matrix[0])\n matrix = [[int(v) for v in row] for row in matrix]\n mat = [set(j for j,v in enumerate(row) if v) for row in matrix]\n # @cache\n def widest(s):\n ans, wid, prev = 0, 1, -5\n for i in s:\n if i == prev+1:\n wid += 1\n else:\n wid = 1\n ans = max(ans, wid)\n prev = i\n return ans\n for i in range(m):\n setter = mat[i]\n w = widest(tuple(setter))\n ans = max(ans, w)\n for u in range(i+1, m):\n setter &= mat[u]\n w = widest(tuple(setter))\n ans = max(ans, (u-i+1)*w)\n return ans\n\n\n\n # ## WIP DP\n # @cache\n # def contig(i,j):\n # if i==0 and j==0:\n # return matrix[i][j]\n \n # if not i or not contig(i-1,j):\n # return \n\n\n\n\n # ## WIP - TLE 72/74 cases passed\n # ## 14 LOC in 56:00\n # ans, m, n = 0, len(matrix), len(matrix[0])\n # matrix = [[int(v) for v in row] for row in matrix]\n # for i,j in product(range(m), range(n)):\n # if matrix[i][j]:\n # maxv = n\n # for u in range(i, m):\n # for v in range(j, maxv):\n # # area = (u-i+1)*(v-j+1)\n # # print('i,j,u,v,a = ', i, j, u, v, area)\n # if not matrix[u][v]:\n # maxv = v\n # break\n # # elif area > ans:\n # elif (area := (u-i+1)*(v-j+1)) > ans:\n # ans = area\n # return ans\n\n\n\n\n # ## Still TLE\n # ans, m, n = 0, len(matrix), len(matrix[0])\n # matrix = [[int(v) for v in row] for row in matrix]\n # # acc = [list(accumulate([0] + row)) for row in matrix]\n # acc = [[0]*(n+1) for _ in range(m+1)]\n # for i in range(m):\n # for j in range(n):\n # acc[i+1][j+1] = matrix[i][j] + acc[i+1][j]\n # for j in range(n):\n # for i in range(m):\n # acc[i+1][j+1] += acc[i][j+1]\n # # print('acc = ', acc)\n # # print('len(acc) = ', len(acc))\n # # print('len(acc[0]) = ', len(acc[0]))\n # def area(i,j,u,v):\n # # print(' area(', i, j, u, v, ') = ')\n # return acc[u+1][v+1] + acc[i][j] - acc[i][v+1] - acc[u+1][j]\n # # print('area = ', area(0, 0, 0, 0))\n # # if m > 3 and n > 4:\n # # print('area = ', area(1, 2, 3, 4))\n # # for i,j in product(range(m), range(n)):\n # # if matrix[i][j]:\n # # for w,h in\n # # if w*h >= ans and \n # ans, m, n = 0, len(matrix), len(matrix[0])\n # for i,j in product(range(m), range(n)):\n # if matrix[i][j]:\n # for h,w in product(range(1, m-i+1), range(1,n-j+1)):\n # # print('testing i,j,h,w = ', i, j, h, w)\n # if w*h >= ans and area(i,j,i+h-1,j+w-1) == h*w:\n # ans = h*w\n # return ans\n\n\n # ## WIP BF - TLE 68/74 cases passed\n # ## 13 LOC in 41:00 at 2:58 pm\n # matrix = [[int(v) for v in row] for row in matrix]\n # ans, m, n = 0, len(matrix), len(matrix[0])\n # for i,j in product(range(m), range(n)):\n # if matrix[i][j]:\n # for h,w in product(range(1, m-i+1), range(1,n-j+1)):\n # # print('testing i,j,h,w = ', i, j, h, w)\n # if w*h >= ans:\n # # Whole with early break\n # whole = True\n # for u,v in product(range(i,i+h), range(j,j+w)):\n # # print(' u,v,m = ', u,v,matrix[u][v])\n # # if matrix[u][v] == '0':\n # if not matrix[u][v]:\n # whole = False\n # break\n # if whole:\n # # print(' WINNER i,j,h,w = ', i, j, h, w)\n # ans = w*h\n # # sumo = 0\n # # for u,v in product(range(i,i+h), range(j,j+w)):\n # # sumo += int(matrix[u][v])\n # # if sumo == w*h:\n # # ans = sumo\n # # assert(area(i,j,u,v) == sumo)\n # return ans\n\n\n ## start 2024.07.30 Tue 1:58 pm","runtime":"739"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # dp[i][j] 表示在第i行，以j-th 结尾的最长1子串的长度\n # max(min(dp[k: l + 1][j]) * (l - k + 1))\n # T: O(n * m^2)\n # S: O(m*n)\n if len(matrix) == 0 or len(matrix[0]) == 0:\n return 0\n \n m = len(matrix)\n n = len(matrix[0])\n dp = [[0 for _ in range(n)] for _ in range(m)]\n for i in range(m):\n for j in range(n):\n if i == 0 and j == 0:\n dp[i][j] = int(matrix[i][j])\n else:\n if matrix[i][j] == \"0\":\n dp[i][j] = 0\n else:\n dp[i][j] = dp[i][j - 1] + 1\n \n # print(dp)\n max_area = 0\n for j in range(n):\n for k in range(m):\n min_len = dp[k][j]\n if min_len == 0:\n continue\n if max_area < min_len:\n max_area = min_len\n\n for l in range(k + 1, m):\n if dp[l][j] < min_len:\n min_len = dp[l][j]\n if min_len == 0:\n break\n\n max_area = max(max_area, min_len * (l - k + 1))\n \n return max_area\n\n ","runtime":"739"},{"code":"class Solution:\n @staticmethod\n def mrec(matrix: List[List[str]], k, l, mms):\n # print(k, l)\n n = len(matrix)\n m = len(matrix[0])\n ms = 0\n pj = m\n i = k\n while i < n:\n # if (n - k) * (pj - l) <= mms:\n # break\n j = l\n # print('i', i, j, pj)\n while j < pj:\n # print(k, l, i, j, pj)\n if matrix[i][j] == '0':\n break\n j += 1\n s = (i - k + 1) * (j - l)\n # print('+', k, l, i, j, s)\n if s > ms:\n ms = s\n pj = j\n i += 1\n return ms\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # print(len(matrix), print(len(matrix[0])))\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n for i in range(n):\n for j in range(m):\n pms = (n - i) * (m - j)\n if pms < ms:\n break\n s = self.mrec(matrix, i, j, ms)\n if s > ms:\n ms = s\n i += 1\n return ms\n","runtime":"764"},{"code":"class Solution:\n def maximalRectangle(self, mat: List[List[str]]) -> int:\n n = len(mat)\n m = len(mat[0])\n prevR = [int(i) for i in mat[0]]\n maxAns = 0\n mat[0] = prevR.copy()\n for i in range(1,n):\n for j in range(m):\n mat[i][j] = int(mat[i][j])\n if mat[i][j] == 1:\n mat[i][j] = mat[i][j] + prevR[j]\n prevR[j] = mat[i][j]\n for i in range(n):\n for j in range(m):\n if mat[i][j] == 0:\n continue\n maxAns = max(maxAns , mat[i][j])\n mini = mat[i][j]\n for k in range(j+1,m):\n if mat[i][k] == 0:\n break\n else:\n if mat[i][k] < mini:\n mini = mat[i][k]\n maxAns = max(maxAns , (k-j+1)*mini)\n return maxAns\n ","runtime":"789"},{"code":"class Solution:\n @staticmethod\n def mrec(matrix: List[List[str]], k, l, mms):\n # print(k, l)\n n = len(matrix)\n m = len(matrix[0])\n ms = 0\n pj = m\n i = k\n while i < n:\n # if (n - k) * (pj - l) <= mms:\n # break\n j = l\n # print('i', i, j, pj)\n while j < pj:\n # print(k, l, i, j, pj)\n if matrix[i][j] == '0':\n break\n j += 1\n s = (i - k + 1) * (j - l)\n # print('+', k, l, i, j, s)\n if s > ms:\n ms = s\n pj = j\n i += 1\n return ms\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # print(len(matrix), print(len(matrix[0])))\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n for i in range(n):\n for j in range(m):\n pms = (n - i) * (m - j)\n if pms < ms:\n break\n s = self.mrec(matrix, i, j, ms)\n if s > ms:\n ms = s\n i += 1\n return ms\n","runtime":"789"},{"code":"class Solution:\n def mrec(self, matrix: List[List[str]], k, l, rx1, rx2, ry1, ry2):\n # print(k, l)\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n mi = -1\n mj = -1\n pj = m\n i = k\n while i < n:\n j = l\n in_x = (i >= ry1) and (i <= ry2)\n # print('i', i, j, pj)\n while j < pj:\n # print(k, l, i, j, pj)\n if in_x and (j >= rx1) and (j <= rx2):\n j = rx2\n if j >= pj:\n j = pj - 1\n s = (i - k + 1) * (j - l + 1)\n else:\n if matrix[i][j] == '0':\n break\n s = (i - k + 1) * (j - l + 1)\n # print('+', k, l, i, j, s)\n if s > ms:\n ms = s\n mi = i\n mj = j\n j += 1\n pj = j\n i += 1\n return ms, mi, mj\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n print(len(matrix), print(len(matrix[0])))\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n rs = 0\n rx1 = -1\n rx2 = -1\n ry1 = -1\n ry2 = -1\n for i in range(n):\n pms = (n - i) * m\n if pms < ms:\n break\n for j in range(m):\n pms = (n - i) * (m - j)\n if pms < ms:\n break\n s, ir, jr = self.mrec(matrix, i, j, rx1, rx2, ry1, ry2)\n if s > ms:\n ms = s\n if s > rs:\n rx1 = j\n rx2 = jr\n ry1 = i\n ry2 = ir\n rs = s\n i += 1\n ry1 += 1\n rs -= rx2 - rx1\n return ms\n","runtime":"815"},{"code":"from collections import defaultdict\nclass Solution:\n def helper(self, i, j, visited, matrix):\n m, n = len(matrix), len(matrix[0])\n if (i, j) in visited or i >= m or j >= n or matrix[i][j] == '0':\n return\n \n self.helper(i + 1, j + 1, visited, matrix)\n\n i_max = i + 1\n while True:\n if i_max >= m or matrix[i_max][j] == '0':\n break\n i_max += 1\n i_max -= 1\n\n if j == n - 1:\n visited[(i, j)].add((i_max, j))\n return\n\n j_max = j + 1\n while True:\n if j_max >= n or matrix[i][j_max] == '0':\n break\n j_max += 1\n j_max -= 1\n\n if i == m - 1:\n visited[(i, j)].add((i, j_max))\n return\n\n if i == i_max and j == j_max:\n visited[(i, j)].add((i, j))\n return \n \n i_sub_max = i\n j_sub_max = j\n for i_sub, j_sub in visited[(i+1, j+1)]:\n i_new = min(i_max, i_sub)\n j_new = min(j_max, j_sub)\n visited[(i, j)].add((i_new, j_new))\n i_sub_max = max(i_sub_max, i_new)\n j_sub_max = max(j_sub_max, j_new)\n\n if i_max > i_sub_max:\n visited[(i, j)].add((i_max, j))\n \n if j_max > j_sub_max:\n visited[(i, j)].add((i, j_max))\n \n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n visited = defaultdict(set)\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n self.helper(i, j, visited, matrix)\n\n area = 0\n for i, j in visited:\n for k, l in visited[(i, j)]:\n area = max(area, (k - i + 1) * (l - j + 1))\n return area\n\n\n ","runtime":"815"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_rect = 0\n cumulative_row = [0] * len(matrix[0])\n\n for row in range(len(matrix)):\n for column in range(len(matrix[0])):\n if matrix[row][column] == '1':\n cumulative_row[column] += 1\n else:\n cumulative_row[column] = 0\n\n # print(cumulative_row, self.get_max(cumulative_row))\n max_rect = max(max_rect, self.get_max(cumulative_row))\n \n return max_rect\n\n def get_max(self, row: list[int]) -> int:\n result = 0\n\n for limit in range(max(row) + 1):\n local = 0\n\n for a in row:\n local = (local + limit) if limit <= a else 0\n result = max(result, local)\n \n return result\n","runtime":"840"},{"code":"from collections import defaultdict\nclass Solution:\n def helper(self, i, j, visited, matrix):\n m, n = len(matrix), len(matrix[0])\n if (i, j) in visited or i >= m or j >= n or matrix[i][j] == '0':\n return\n \n self.helper(i + 1, j + 1, visited, matrix)\n\n i_max = i + 1\n while True:\n if i_max >= m or matrix[i_max][j] == '0':\n break\n i_max += 1\n i_max -= 1\n\n if j == n - 1:\n visited[(i, j)].add((i_max, j))\n return\n\n j_max = j + 1\n while True:\n if j_max >= n or matrix[i][j_max] == '0':\n break\n j_max += 1\n j_max -= 1\n\n if i == m - 1:\n visited[(i, j)].add((i, j_max))\n return\n\n if i == i_max and j == j_max:\n visited[(i, j)].add((i, j))\n return \n \n i_sub_max = i\n j_sub_max = j\n for i_sub, j_sub in visited[(i+1, j+1)]:\n i_new = min(i_max, i_sub)\n j_new = min(j_max, j_sub)\n visited[(i, j)].add((i_new, j_new))\n i_sub_max = max(i_sub_max, i_new)\n j_sub_max = max(j_sub_max, j_new)\n\n if i_max > i_sub_max:\n visited[(i, j)].add((i_max, j))\n \n if j_max > j_sub_max:\n visited[(i, j)].add((i, j_max))\n \n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n visited = defaultdict(set)\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n self.helper(i, j, visited, matrix)\n\n area = 0\n for i, j in visited:\n for k, l in visited[(i, j)]:\n area = max(area, (k - i + 1) * (l - j + 1))\n return area\n\n\n ","runtime":"840"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_rect = 0\n cumulative_row = [0] * len(matrix[0])\n\n for row in matrix:\n cumulative_row = [\n (cumulative_row[column] + 1) * (row[column] == '1')\n for column in range(len(row))\n ]\n max_rect = max(max_rect, self.get_max(cumulative_row))\n \n return max_rect\n\n def get_max(self, row: list[int]) -> int:\n result = 0\n\n for limit in row:\n local = 0\n\n for a in row:\n local = (local + limit) if limit <= a else 0\n if result < local: result = local\n \n return result\n","runtime":"865"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # height->length so far\n maxArea = 0\n dp = [[None for i in range(len(matrix[0]))] for j in range(len(matrix))]\n for row in range(len(matrix)):\n record = dict()\n for cal in range(len(matrix[0])):\n if matrix[row][cal] == \"0\":\n record = dict()\n dp[row][cal] = 0\n continue\n if row == 0:\n dp[row][cal] = 1\n else:\n dp[row][cal] = dp[row-1][cal] + 1 \n height = dp[row][cal]\n newRecord = dict()\n for i in range(1,height+1):\n if i not in record:\n newRecord[i] = 1\n maxArea = max(maxArea, i)\n else:\n \n newRecord[i] = record[i] + 1\n maxArea = max(maxArea, i * newRecord[i])\n record = newRecord\n return maxArea\n \n\n ","runtime":"891"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n best = 0\n largestRect = [[(0, 0)] for _ in range(len(matrix[0]) + 1)]\n for row in matrix:\n for j, entry in enumerate(row):\n if entry == '0':\n largestRect[j + 1] = [(0, 0)]\n continue\n maxWidth = largestRect[j][0][0] + 1\n a = largestRect[j + 1]\n res = [(maxWidth, 1)]\n best = max(maxWidth, best)\n for w, h in a:\n if w > maxWidth:\n res[0] = (maxWidth, h + 1)\n best = max(maxWidth * (h + 1), best)\n elif h + 1 > res[-1][1]:\n res.append((w, h + 1))\n best = max(w * (h + 1), best)\n largestRect[j + 1] = res\n \n return best","runtime":"891"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n dp = [[int(i) for i in row] for row in matrix]\n for j in range(len(matrix[0])):\n for i in range(len(matrix)-2,-1,-1):\n if(dp[i][j] != 0):\n dp[i][j] += dp[i+1][j]\n print(dp)\n best = 0\n for i in range(len(matrix)):\n for test_num in range(1, 201):\n curr_best = 0\n for j in range(len(matrix[0])):\n if(dp[i][j]>=test_num):\n curr_best += test_num\n if(curr_best>best):\n best= curr_best\n else:\n curr_best = 0\n return best\n \n \n \n \n \n\n ","runtime":"916"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_rect = 0\n cumulative_row = [0] * len(matrix[0])\n\n for row in range(len(matrix)):\n for column in range(len(matrix[0])):\n if matrix[row][column] == '1':\n cumulative_row[column] += 1\n else:\n cumulative_row[column] = 0\n\n # print(cumulative_row, self.get_max(cumulative_row))\n max_rect = max(max_rect, self.get_max(cumulative_row))\n \n return max_rect\n\n def get_max(self, row: list[int]) -> int:\n result = 0\n\n for limit in range(max(row) + 1):\n local = 0\n\n for a in row:\n local = (local + limit) * (limit <= a)\n result = max(result, local)\n \n return result\n","runtime":"916"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n row = len(matrix)\n col = len(matrix[0])\n x=[0]*col\n ans=0\n for i in range(row):\n y=[0]*(row+1)\n for j in range(col):\n if matrix[i][j]=='1':\n x[j]+=1\n for k in range(1,x[j]+1):\n y[k]+=1\n ans=max(ans,y[k]*k)\n for k in range(x[j]+1,row+1):\n y[k]=0\n else:\n x[j]=0\n y=[0]*(row+1)\n return ans","runtime":"941"},{"code":"class Solution:\r\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\r\n li = len(matrix)\r\n lj = len(matrix[0])\r\n dp = [0] * lj\r\n res = 0\r\n for i in range(li):\r\n kj = -1\r\n for j in range(lj):\r\n if matrix[i][j] == \"1\":\r\n dp[j] += 1\r\n # ans = 0\r\n ymin = float(\"inf\")\r\n for k in range(j, kj, -1):\r\n ymin = min(ymin, dp[k])\r\n res = max(res, ymin * (j - k + 1))\r\n # res = max(res, ans)\r\n\r\n else:\r\n dp[j] = 0\r\n kj = j\r\n\r\n return res\r\n\r\n","runtime":"941"},{"code":"class Solution:\r\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\r\n li = len(matrix)\r\n lj = len(matrix[0])\r\n dp = [0] * lj\r\n res = 0\r\n for i in range(li):\r\n kj = -1\r\n for j in range(lj):\r\n if matrix[i][j] == \"1\":\r\n dp[j] += 1\r\n ans = 0\r\n ymin = float(\"inf\")\r\n for k in range(j, kj, -1):\r\n ymin = min(ymin, dp[k])\r\n ans = max(ans, ymin * (j - k + 1))\r\n res = max(res, ans)\r\n\r\n else:\r\n dp[j] = 0\r\n kj = j\r\n\r\n return res\r\n\r\n","runtime":"966"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m = len(matrix)\n n = len(matrix[0])\n\n dp_right = [[0] * n for _ in range(m)]\n dp_below = [[0] * n for _ in range(m)]\n\n for i in range(m):\n if matrix[i][n-1] == \"1\":\n dp_right[i][n-1] = 1\n for i in range(m):\n for j in range(n-2, -1, -1):\n if matrix[i][j] == \"1\":\n dp_right[i][j] = 1 + dp_right[i][j+1]\n\n for j in range(n):\n if matrix[m-1][j] == \"1\":\n dp_below[m-1][j] = 1\n for j in range(n):\n for i in range(m-2, -1, -1):\n if matrix[i][j] == \"1\":\n dp_below[i][j] = 1 + dp_below[i+1][j]\n\n res = 0\n # Calculate maximal rectangle area\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == \"1\":\n width = dp_right[i][j]\n for k in range(dp_below[i][j]):\n width = min(width, dp_right[i+k][j])\n res = max(res, (k + 1) * width)\n return res\n\n ","runtime":"992"},{"code":"def helper(i, j, d, r):\n z = d[i][j]\n if z==0: return 0\n mn = 200\n res = c = 0\n for x in range(i, i+z):\n c += 1\n mn = min(mn, r[x][j])\n res = max(res, c*mn)\n return res\nclass Solution:\n def maximalRectangle(self, mat: List[List[str]]) -> int:\n n = len(mat)\n m = len(mat[0])\n down = [[0]*m for i in range(n)]\n right = [[0]*m for i in range(n)]\n for i in range(n):\n c = 0\n for j in range(m-1, -1, -1):\n if mat[i][j]==\"1\":\n c += 1\n else:\n c = 0\n right[i][j] = c\n for j in range(m):\n c = 0\n for i in range(n-1, -1, -1):\n if mat[i][j]==\"1\":\n c += 1\n else:\n c = 0\n down[i][j] = c\n ans = 0\n for i in range(n):\n for j in range(m):\n ans = max(ans, helper(i, j, down, right))\n #print(i, j, ans)\n return ans","runtime":"992"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n mat_1 = []\n for y in range(len(matrix)):\n temp = []\n for x in range(len(matrix[0])):\n temp.append([0]*len(matrix))\n mat_1.append(temp)\n\n print(len(matrix[0]),len(matrix))\n cur_big = 0\n for y in range(len(matrix)-1,-1,-1):\n for x in range(len(matrix[0])-1,-1,-1):\n if matrix[y][x] == \"1\":\n if cur_big < 1: cur_big = 1\n \n mat_1[y][x][0] += 1\n if (x+1) < len(matrix[0]):\n mat_1[y][x][0] += mat_1[y][x+1][0]\n if cur_big < mat_1[y][x][0]: cur_big = mat_1[y][x][0]\n\n if (y+1) < len(matrix):\n min_1 = mat_1[y][x][0]\n for i in range(1,len(matrix)):\n if mat_1[y+1][x][i-1] == 0: break\n mat_1[y][x][i] = mat_1[y+1][x][i-1]\n if min_1 > mat_1[y][x][i]: min_1 = mat_1[y][x][i]\n if cur_big < (i+1)*min_1: cur_big = (i+1)*min_1\n\n \n\n\n #[1,1,5,1][0,0,0,0][1,3,3,0][0,0,0,0][0,0,0,0]\n #[1,5,1] [0,0,0] [3,3,0] [2,2,1] [1,1,0]\n #[5,1] [4,0] [3,0] [2,1] [1,0]\n #[1] [0] [0] [1] [0]\n \n\n return cur_big","runtime":"1017"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_rect = 0\n cumulative_row = [0] * len(matrix[0])\n\n for row in range(len(matrix)):\n for column in range(len(matrix[0])):\n if matrix[row][column] == '1':\n cumulative_row[column] += 1\n else:\n cumulative_row[column] = 0\n\n # print(cumulative_row, self.get_max(cumulative_row))\n max_rect = max(max_rect, self.get_max(cumulative_row))\n \n return max_rect\n\n def get_max(self, row: list[int]) -> int:\n result = 0\n\n for limit in range(max(row) + 1):\n local = 0\n\n for a in row:\n local = (local + limit) * bool(limit <= a)\n result = max(result, local)\n \n return result\n","runtime":"1017"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n n = len(matrix)\n m = len(matrix[0])\n\n for j in range (m):\n for i in range (n):\n if i==0:\n matrix[i][j] = 1 if matrix[i][j]=='1' else 0\n elif matrix[i][j] == '1':\n matrix[i][j] = 1+matrix[i-1][j]\n else:\n matrix[i][j] = 0\n \n ans = 0\n for i in range (n):\n for j in range (m):\n if matrix[i][j]>0:\n k = j-1\n width = 1\n height = matrix[i][j]\n ans = max(ans, width*height)\n while k>=0 and matrix[i][k]>0:\n width+=1\n height = min(height, matrix[i][k])\n k-=1\n ans = max(ans, width*height)\n return ans","runtime":"1042"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n max_area = 0\n dp = [[0 for _ in range(len(matrix[0]))] for _ in range(len(matrix))]\n\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if j == 0:\n dp[i][j] = 1 if matrix[i][j] == \"1\" else 0\n continue\n dp[i][j] = 1 + dp[i][j-1] if matrix[i][j] == \"1\" else 0\n \n\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n\n min_width = dp[i][j]\n\n for h in range(i, -1, -1):\n min_width = min(min_width, dp[h][j])\n\n if min_width == 0:\n break\n \n max_area = max(max_area, min_width * (i - h + 1))\n\n return max_area\n ","runtime":"1042"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n n_r, n_c = len(matrix), len(matrix[0])\n\n dp = [[0 for x in range(n_c)] for _ in range(n_r)]\n\n result = 0\n \n for r in range(n_r):\n for c in range(n_c):\n if matrix[r][c] == \"1\":\n if c == 0:\n dp[r][c] = 1\n else:\n dp[r][c] = 1 + dp[r][c-1]\n\n minWidth = dp[r][c]\n for k in range (r, -1, -1):\n if dp[k][c] == 0:\n break\n minWidth = min(minWidth, dp[k][c])\n # print(f\"r, c, k: {r, c, k}\")\n # print(f\"minWidth: {minWidth}, len:{r-k+1}\")\n result = max(result, minWidth * (r-k+1))\n # print(f\"dp[r]: {r, dp[r]}, result: {result}\")\n\n print(f\"dp: {dp}\")\n return result","runtime":"1067"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m,n = len(matrix),len(matrix[0])\n ans = 0\n dp = [[(0,0) for i in range(n)] for j in range(m)]\n\n for i in range(m):\n for j in range(n):\n if matrix[i][j]=='1':\n x = dp[i][j-1][0]+1 if j>0 else 1\n y = dp[i-1][j][1]+1 if i>0 else 1\n dp[i][j] = [x,y]\n ans = max(x,y,ans)\n minWidth = x\n\n for r in range(i-1,i-y,-1):\n minWidth = min(minWidth,dp[r][j][0])\n ans = max(ans,minWidth*(i-r+1))\n\n return ans","runtime":"1067"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n n = len(matrix)\n m = len(matrix[0])\n\n for j in range (m):\n for i in range (n):\n if i==0:\n matrix[i][j] = 1 if matrix[i][j]=='1' else 0\n elif matrix[i][j] == '1':\n matrix[i][j] = 1+matrix[i-1][j]\n else:\n matrix[i][j] = 0\n \n ans = 0\n for i in range (n):\n for j in range (m):\n if matrix[i][j]>0:\n k = j-1\n width = 1\n height = matrix[i][j]\n ans = max(ans, width*height)\n while k>=0 and matrix[i][k]>0:\n width+=1\n height = min(height, matrix[i][k])\n k-=1\n ans = max(ans, width*height)\n return ans","runtime":"1093"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m,n = len(matrix),len(matrix[0])\n ans = 0\n dp = [[(0,0) for i in range(n)] for j in range(m)]\n\n for i in range(m):\n for j in range(n):\n if matrix[i][j]=='1':\n x = dp[i][j-1][0]+1 if j>0 else 1\n y = dp[i-1][j][1]+1 if i>0 else 1\n dp[i][j] = [x,y]\n ans = max(ans,x,y)\n minWidth = x\n\n for r in range(i-1,i-y,-1):\n minWidth = min(minWidth,dp[r][j][0])\n ans = max(ans,minWidth*(i-r+1))\n\n return ans","runtime":"1093"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n answer = 0\n\n m = len(matrix)\n n = len(matrix[0])\n\n successive_r = [[0] * n for _ in range(m)]\n successive_c = [[0] * n for _ in range(m)]\n\n for r in range(m):\n c = 0\n while c < n:\n if matrix[r][c] == \"1\":\n c_start, c_end = c, c\n while c_end < n and matrix[r][c_end] == \"1\":\n c_end += 1\n \n for c_temp in range(c_start, c_end):\n successive_c[r][c_temp] = c_end - c_temp\n \n c = c_end\n else:\n c += 1\n\n for c in range(n):\n r = 0\n while r < m:\n if matrix[r][c] == \"1\":\n r_start, r_end = r, r\n while r_end < m and matrix[r_end][c] == \"1\":\n r_end += 1\n \n for r_temp in range(r_start, r_end):\n successive_r[r_temp][c] = r_end - r_temp\n \n r = r_end\n else:\n r += 1\n\n for r in range(m):\n for c in range(n):\n r_len, c_len = inf, inf\n \n r_count = successive_r[r][c]\n for i in range(r_count):\n r_temp = r + i\n c_count = successive_c[r_temp][c]\n\n r_len = i + 1\n c_len = min(c_len, c_count)\n\n answer = max(answer, r_len * c_len)\n\n return answer\n\n\n \n \n\n\n ","runtime":"1118"},{"code":"class Solution:\n def mrec(self, matrix: List[List[str]], k, l, rx1, rx2, ry1, ry2):\n # print(k, l)\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n mi = -1\n mj = -1\n pj = m\n i = k\n while i < n:\n j = l\n # print('i', i, j, pj)\n while j < pj:\n # print(k, l, i, j, pj)\n if (i >= ry1) and (i <= ry2) and (j >= rx1) and (j <= rx2):\n j = rx2\n if j >= pj:\n j = pj - 1\n s = (i - k + 1) * (j - l + 1)\n else:\n if matrix[i][j] == '0':\n break\n s = (i - k + 1) * (j - l + 1)\n # print('+', k, l, i, j, s)\n if s > ms:\n ms = s\n mi = i\n mj = j\n j += 1\n pj = j\n i += 1\n return ms, mi, mj\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n rs = 0\n rx1 = -1\n rx2 = -1\n ry1 = -1\n ry2 = -1\n for i in range(n):\n for j in range(m):\n s, ir, jr = self.mrec(matrix, i, j, rx1, rx2, ry1, ry2)\n if s > ms:\n ms = s\n if s > rs:\n rx1 = j\n rx2 = jr\n ry1 = i\n ry2 = ir\n rs = s\n i += 1\n ry1 += 1\n rs -= rx2 - rx1\n return ms\n","runtime":"1118"},{"code":"from typing import List,Optional\nfrom collections import deque\nimport sys\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]):\n m,n = len(matrix),len(matrix[0])\n \n nseRow = [[0]*n for _ in range(m)]\n for i in range(m):\n stack = []\n for j in range(n-1,-1,-1):\n while(stack and int(matrix[i][stack[-1]])>=int(matrix[i][j])):stack.pop()\n if(stack==[]):nseRow[i][j] = n\n else:nseRow[i][j] = stack[-1]\n stack.append(j)\n \n nseCol = [[0]*n for _ in range(m)]\n for j in range(n):\n stack = []\n for i in range(m-1,-1,-1):\n while(stack and int(matrix[stack[-1]][j])>=int(matrix[i][j])):stack.pop()\n if(stack==[]):nseCol[i][j] = m\n else:nseCol[i][j] = stack[-1]\n stack.append(i)\n \n # print(nseRow)\n # print(nseCol)\n\n area = 0\n for i in range(m):\n for j in range(n):\n if(matrix[i][j]=='1'):\n index = nseRow[i][j]\n ans = m\n for k in range(j,index):\n ans = min(nseCol[i][k]-i,ans)\n area = max(area,ans*(k-j+1))\n return area\n \n# time complexity: O(m*n*m)\n# space complexity: O(m*n)","runtime":"1143"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n res, m, n = 0, len(matrix), len(matrix[0])\n dp = [[0 for _ in range(n)] for _ in range(m)]\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == '1':\n x = dp[i][j] = (dp[i][j - 1] if j > 0 else 0) + 1\n for y in range(i + 1):\n if dp[i - y][j] == 0:\n break\n x = min(x, dp[i - y][j])\n res = max(res, x * (y + 1))\n return res","runtime":"1143"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n #dp[i][j] = maximal rectangle that can be built from row i, column j (including the (i,j) element)\n ROWS, COLS = len(matrix), len(matrix[0])\n dp = [[0 for _ in range(COLS)] for _ in range(ROWS)]\n dp[0] = [1 if matrix[0][i] == \"1\" else 0 for i in range(COLS)]\n\n cnt = 0\n largest_area = 0\n for i in range(COLS):\n if matrix[0][i] == \"1\":\n cnt += 1\n largest_area = max(largest_area, cnt)\n else:\n cnt = 0\n\n for r in range(1, ROWS):\n if matrix[r][0] == \"1\":\n dp[r][0] = 1 + dp[r-1][0]\n largest_area = max(largest_area, dp[r][0])\n\n for c in range(1, COLS):\n curr_height = ROWS\n if matrix[r][c] == \"1\":\n dp[r][c] = 1 + dp[r-1][c]\n for cpt in range(c, -1, -1):\n if matrix[r][cpt] == \"0\":\n break\n curr_height = min(curr_height, dp[r][cpt])\n largest_area = max(largest_area, (c-cpt+1) * curr_height)\n if r == ROWS-1:\n print(cpt, curr_height)\n return largest_area\n \n ","runtime":"1168"},{"code":"class Solution:\n def maximalRectangle(self, mat: List[List[str]]) -> int:\n \n n=len(mat)\n m=len(mat[0])\n\n dp=[[0 for i in range(m)] for j in range(n)]\n ans=[[0 for i in range(m)] for j in range(n)]\n\n for j in range(m):\n dp[0][j]=int(mat[0][j])\n \n for i in range(1,n):\n for j in range(m):\n if mat[i][j]!='0':\n #print(dp[i-1][j])\n dp[i][j]=1+dp[i-1][j]\n \n for i in range(n):\n for j in range(m):\n mini=dp[i][j]\n cnt=1\n for k in range(j,-1,-1):\n mini=min(mini,dp[i][k])\n if mini==0:\n break\n ans[i][j]=max(ans[i][j],cnt*mini)\n cnt+=1\n\n # for i in dp:\n # print(i)\n # for i in ans:\n # print(i)\n return max([max(i) for i in ans])\n\n","runtime":"1168"},{"code":"import numpy as np\n\ndef largestRectangleArea(heights):\n if max(heights) == 0: return 0\n heights_unique = np.unique(heights).astype(int)\n height_to_unique_heights_idcs = np.zeros(np.max(heights)+1,dtype=int)\n for x in range(max(heights)+1):\n if x in heights_unique:\n height_to_unique_heights_idcs[x] = np.where(x==heights_unique)[0][0]\n buffer_height_unique_rolling_length = np.zeros(shape=len(heights_unique)).astype(int)\n largest_s = 0\n #heights_unique_idx_prev_best\n for idx, height in enumerate(heights):\n heights_unique_idx = height_to_unique_heights_idcs[height]\n buffer_height_unique_rolling_length[:heights_unique_idx+1] += 1 #heights_unique[:heights_unique_idx]\n buffer_height_unique_rolling_length[heights_unique_idx+1:] = 0\n \n curr_largest_s = np.max(buffer_height_unique_rolling_length[:heights_unique_idx+1] * \n heights_unique[:heights_unique_idx+1])\n \n \n largest_s = max(largest_s, curr_largest_s)\n \n\n return largest_s\n\n \n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]], verbose=False) -> int:\n matrix_rolling_sum_vertical = [[int(x) for x in matrix[0]]]\n for row in matrix[1:]:\n matrix_rolling_sum_vertical.append([(x+1) * int(v) for x, v in zip(matrix_rolling_sum_vertical[-1], row)])\n if verbose:\n print(\"matrix_rolling_sum_vertical:\\n\", np.array(matrix_rolling_sum_vertical))\n\n max_size = 0\n for row in matrix_rolling_sum_vertical:\n new_largest_rectangle = largestRectangleArea(row)\n if verbose: print(new_largest_rectangle)\n max_size = max(max_size, new_largest_rectangle)\n return max_size\n ","runtime":"1194"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n self.max = 0 \n self.row, self.col = len(matrix), len(matrix[0])\n self.compute(matrix)\n \n return(self.max)\n\n def compute(self, matrix):\n\n stack_ = []\n\n for i in range(self.row):\n row_query = matrix[i]\n for j in range(i):\n combined, area = self.compute_area(row_query, stack_[j],i ,j)\n stack_[j] = combined.copy()\n \n \n area_row = self.check(row_query)\n if area_row>self.max:\n self.max = area_row\n stack_ += [row_query]\n\n def check(self, row):\n\n temp = []\n area = 0 \n for i in range(self.col):\n\n if row[i]==\"1\" :\n area+=1 \n else:\n if area>0:\n if area>self.max:\n self.max = area\n area = 0 \n\n if area>0:\n if area>self.max:\n self.max = area \n return area\n\n def compute_area(self, query, base, index, indexs):\n\n temp = []\n area = 0 \n for i in range(self.col):\n\n if query[i]==\"1\" and base[i]==\"1\":\n temp+=[\"1\"]\n area+=index-indexs+1 \n else:\n if area>0:\n if area>self.max:\n self.max = area\n area = 0 \n temp+=[\"0\"]\n\n if area>0:\n if area>self.max:\n self.max = area \n return temp, area","runtime":"1194"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n left_store = [[1] * len(matrix[0]) for _ in range(len(matrix))]\n for i in range(len(matrix)):\n j = len(matrix[0])-1\n cnt = 0\n while j >=0:\n if matrix[i][j]==\"1\":\n cnt+=1\n else:\n cnt= 0\n left_store[i][j] = cnt\n j-=1\n print(left_store)\n res = 0\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n maxLen = left_store[i][j]\n maxArea = maxLen\n c = i\n while c+1 < len(matrix) and matrix[c+1][j] == \"1\":\n c += 1\n maxLen = min(maxLen, left_store[c][j])\n maxArea = max(maxArea, (c - i + 1)*maxLen)\n res = max(maxArea, res)\n return res\n\n","runtime":"1219"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def check_col(r,c):\n if r==len(matrix) or matrix[r][c]=='0':\n return 0\n matrix[r][c] = check_col(r+1,c) + 1\n return matrix[r][c]\n\n def check_row(r,c):\n global max_rec\n min_col = 1e9\n count = 0\n while not(c+count==len(matrix[0]) or matrix[r][c+count]=='0'):\n count+=1\n min_col = min(min_col, check_col(r,c+count-1))\n max_rec = max(max_rec, count*min_col)\n if (len(matrix[0])-c)*min_col<max_rec:\n return\n \n global max_rec\n max_rec = 0\n for c in range(len(matrix[0])):\n for r in range(len(matrix)):\n check_row(r,c)\n return max_rec","runtime":"1219"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_rect = 0\n cumulative_row = [0] * len(matrix[0])\n\n for row in range(len(matrix)):\n for column in range(len(matrix[0])):\n if matrix[row][column] == '1':\n cumulative_row[column] += 1\n else:\n cumulative_row[column] = 0\n\n # print(cumulative_row, self.get_max(cumulative_row))\n max_rect = max(max_rect, self.get_max(cumulative_row))\n \n return max_rect\n\n def get_max(self, row: list[int]) -> int:\n rows: list[list[int]] = []\n\n for number in range(max(row) + 1):\n rows.append([\n number if number <= a else 0\n for a in row\n ])\n\n return max(\n max(a) * self.get_max_same_nums(a)\n for a in rows\n )\n\n def get_max_same_nums(self, nums: list[int]) -> int:\n result = 1\n local = 1\n\n for index in range(1, len(nums)):\n local = local + 1 if nums[index] and nums[index] == nums[index - 1] else 1\n result = max(result, local)\n\n return result","runtime":"1244"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # 200*200*200*200\n self.precompute(matrix)\n print(self.down_matrix)\n largest = 0\n for i, row in enumerate(matrix):\n for j, num in enumerate(row):\n if matrix[i][j] == \"1\":\n count = self.find_rect(matrix, i, j)\n largest = max(largest, count)\n return largest\n\n def precompute(self, matrix):\n self.down_matrix = [[0 for j in range(len(matrix[0]))] for i in range(len(matrix))]\n for i in range(len(matrix)-1, -1, -1):\n for j in range(len(matrix[0])):\n if matrix[i][j] == \"1\":\n prev = 0\n if i+1 < len(matrix):\n prev = self.down_matrix[i+1][j]\n self.down_matrix[i][j] = prev + 1\n \n def find_rect(self, matrix, i, j):\n # O(200)\n depths = []\n for c in range(j, len(matrix[0])):\n if matrix[i][c] == \"0\":\n break\n depths.append(self.down_matrix[i][c])\n \n largest = 1\n smallest = depths[0]\n for count, depth in enumerate(depths):\n smallest = min(smallest, depth)\n area = (count+1) * smallest\n largest = max(largest, area)\n return largest\n\n # def go_down(self, matrix, row, columns):\n # count = 1\n # row += 1\n # break_flag = False\n # while row < len(matrix) and not break_flag:\n # for column in columns:\n # if matrix[row][column] == \"0\":\n # break_flag = True\n # break\n # row += 1\n # if not break_flag:\n # count += 1\n # return count","runtime":"1244"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def check_col(r,c):\n if r==len(matrix) or matrix[r][c]=='0':\n return 0\n matrix[r][c] = check_col(r+1,c) + 1\n return matrix[r][c]\n\n def check_row(r,c):\n global max_rec\n min_col = 1e9\n count = 0\n while not(c+count==len(matrix[0]) or matrix[r][c+count]=='0'):\n count+=1\n min_col = min(min_col, check_col(r,c+count-1))\n max_rec = max(max_rec, count*min_col)\n if (len(matrix[0])-c)*min_col<max_rec:\n return\n \n global max_rec\n max_rec = 0\n for c in range(len(matrix[0])):\n for r in range(len(matrix)):\n check_row(r,c)\n return max_rec","runtime":"1269"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n '''\n Review\n Given\n -matrix of 0s and 1s where there's at least 1 row and 1 col\n Want\n -Find the largest rectangle containing only 1s and return its area (or 0 if no such value exists)\n \n Analysis\n -What is a rectangle?\n -Starting from the top left 1, go straight down until end of matrix or 0, that is the first rectangle it's in\n -From there, move to the right and do the same, respecting the shortest height between each column of 1s\n -Repeat until you get to the right end of the matrix or get to 0\n -Repeat all that for every 1 in the matrix => O(nm*nm) in the worst case\n \n -Optimization: using next smaller than elements to avoid re-processing the size of the columns of 1s and just pick the smallest\n -Starting from the top left 1, find the location of its vertical next smaller, that height is the size of the first rectangle\n -Move to the right for as many 1s as there are to the right of the top left 1, determine the location of vertical next smaller\n -pick the shortest height and respect that in determining the size of the rectangle and save the shortest height and largest rectangle O(nm * m) in worst case \n \n Overall Optimized Flow\n Identify each vertical next smaller for all 1s\n For each 1, perform max rectangle calculation if it's top left in rectangle and save if the largest overall\n Return the largest rectangle\n '''\n verticalNextSmallers = self.getVerticalNextSmallers(matrix)\n maxRectangle = 0\n \n for r in range(len(matrix)):\n for c in range(len(matrix[0])):\n if matrix[r][c] == '1':\n curMaxRect = self.findMaxRectangleForElement(matrix, r, c, verticalNextSmallers)\n maxRectangle = max(maxRectangle, curMaxRect)\n \n return maxRectangle\n \n def getVerticalNextSmallers(self, matrix):\n # default value: row = beyond the last element of the matrix; col = current element index in row\n # set the row beyond the matrix so it can be used to define the vertical length correctly when there is no next smaller\n nextSmallerMatrix = [[(len(matrix), i) for i in range(len(row))] for row in matrix]\n \n stack = deque()\n \n for c in range(len(matrix[0])):\n for r in range(len(matrix)):\n while stack and matrix[r][c] == '0':\n elementWithNextSmaller = stack.pop()\n nextSmallerMatrix[elementWithNextSmaller[0]][elementWithNextSmaller[1]] = (r, c)\n \n # only care to process the 1s\n if matrix[r][c] == '1':\n stack.append((r, c))\n \n # looking into new column\n stack.clear()\n \n \n return nextSmallerMatrix\n \n def findMaxRectangleForElement(self, matrix, r, c, nextSmallers):\n curCol = c\n largestRectangle = 0\n shortestHeight = len(matrix)\n \n while curCol < len(matrix[0]) and matrix[r][curCol] == '1':\n nextSmallerLocation = nextSmallers[r][curCol]\n \n # vertical length is the distance between the index of the next smaller (or the length\n # of the matrix itself) and the current row\n verticalLength = nextSmallerLocation[0] - r\n \n # use the shortest height to determine the rectangle area\n shortestHeight = min(shortestHeight, verticalLength)\n \n # area is the shortest height * width of rectangle\n curRectangleArea = shortestHeight * (curCol - c + 1)\n \n # update the var for the loop\n curCol += 1\n \n # save the largest rectangle for the given (r, c) element\n largestRectangle = max(largestRectangle, curRectangleArea)\n \n return largestRectangle","runtime":"1269"},{"code":"from functools import cache\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n @cache\n def dp(i, j):\n # return largest square, largest rectangle\n # largest square, longest row, longest column, largest rect area\n if i == m or j == n or matrix[i][j] == \"0\":\n return 0, 0, 0, 0\n\n # largest square\n len_square = 1 + min(dp(i, j + 1)[0], dp(i + 1, j)[0], dp(i + 1, j + 1)[0])\n\n # longest row\n len_row = 1 + dp(i, j + 1)[1]\n\n # longest column\n len_col = 1 + dp(i + 1, j)[2]\n\n # find the area of the maximum rectangle\n bottom_len = len_square\n max_area = len_square ** 2\n k1 = i\n k2 = j + len_square\n val = dp(k1, k2)\n while k2 <= n and val[0]:\n bottom_len = min(bottom_len, val[2])\n max_area = max(max_area, bottom_len * (k2 - j + 1))\n k2 += 1\n val = dp(k1, k2)\n \n right_len = len_square\n k1 = i + len_square\n k2 = j\n val = dp(k1, k2)\n while k1 <=m and val[0]:\n right_len = min(right_len, val[1])\n max_area = max(max_area, right_len * (k1 - i + 1))\n k1 += 1\n val = dp(k1, k2)\n\n return len_square, len_row, len_col, max_area\n\n ans = 0\n m = len(matrix)\n n = len(matrix[0])\n for i in range(m):\n for j in range(n):\n ans = max(ans, dp(i, j)[3])\n \n return ans","runtime":"1295"},{"code":"from functools import cache\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n @cache\n def dp(i, j):\n # return largest square, largest rectangle\n # largest square, longest row, longest column, largest rect area\n if i == m or j == n or matrix[i][j] == \"0\":\n return 0, 0, 0, 0\n\n # largest square\n len_square = 1 + min(dp(i, j + 1)[0], dp(i + 1, j)[0], dp(i + 1, j + 1)[0])\n\n # longest row\n len_row = 1 + dp(i, j + 1)[1]\n\n # longest column\n len_col = 1 + dp(i + 1, j)[2]\n\n # find the area of the maximum rectangle\n bottom_len = len_square\n max_area = len_square ** 2\n k1 = i\n k2 = j + len_square\n val = dp(k1, k2)\n while k2 <= n and val[0]:\n bottom_len = min(bottom_len, val[2])\n max_area = max(max_area, bottom_len * (k2 - j + 1))\n k2 += 1\n val = dp(k1, k2)\n \n right_len = len_square\n k1 = i + len_square\n k2 = j\n val = dp(k1, k2)\n while k1 <=m and val[0]:\n right_len = min(right_len, val[1])\n max_area = max(max_area, right_len * (k1 - i + 1))\n k1 += 1\n val = dp(k1, k2)\n\n return len_square, len_row, len_col, max_area\n\n ans = 0\n m = len(matrix)\n n = len(matrix[0])\n for i in range(m):\n for j in range(n):\n ans = max(ans, dp(i, j)[3])\n \n return ans","runtime":"1295"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n n = len(matrix)\n m = len(matrix[0])\n ans = 0\n\n next_max_seen = {}\n max_seen = {}\n for i in range(n):\n if \"1\" not in matrix[i]:\n max_seen = {}\n continue\n last_one = -1\n for j in range(m):\n if matrix[i][j] == \"1\":\n for start_j in range(last_one, j):\n rect_area = j-start_j\n cand = (j,start_j)\n if cand in max_seen:\n rect_area += max_seen[cand]\n next_max_seen[cand] = rect_area\n ans = max(ans, rect_area)\n else:\n last_one = j\n \n max_seen = next_max_seen\n next_max_seen = {}\n \n return ans\n ","runtime":"1320"},{"code":"class Solution:\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n dp = [[[0] for cell in row] for row in matrix]\n max_area = 0\n\n for i, row in enumerate(matrix):\n for j, cell in enumerate(row):\n\n if cell == '0':\n continue\n\n h = 1 if i == 0 else 1 + dp[i - 1][j][0]\n dp[i][j][0] = h\n\n max_area = max(max_area, h)\n\n for k in range(1, j + 1):\n # print(i, j, k, i, j - k, k - 1)\n a = dp[i][j - 1][k - 1] if len(dp[i][j - 1]) >= k else 0\n\n if a == 0:\n break\n\n h = min(h, a)\n dp[i][j].append(h)\n\n max_area = max(max_area, h * (k + 1))\n\n # print(i, dp[i])\n # print('----')\n\n return max_area\n\n\n # def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n # dp = [[[set()] for cell in row] for row in matrix]\n # max_area = 0\n\n # for i, row in enumerate(matrix):\n # for j, cell in enumerate(row):\n\n # if cell == '0':\n # continue\n \n # left_rects = set() if i == 0 else dp[i - 1][j][0]\n # up_rects = set() if j == 0 else dp[i][j - 1][0]\n\n # if len(left_rects) == 0 and len(up_rects) == 0:\n # dp[i][j].add((1, 1))\n # continue\n\n # for l in left_rects:\n # for u in up_rects:\n # x = min(1 + l[0], u[0])\n # y = min(l[1], 1 + u[1])\n\n # max_area = max(max_area, x * y)\n \n # return max_area\n\n\n # def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n # dp = [[[(0, 0)] for cell in row] for row in matrix]\n\n # for i, row in enumerate(matrix):\n # for j, cell in enumerate(row):\n\n # if cell == '0':\n # dp[i][j] = (0, 0)\n # continue\n\n # dist_left = 1 if i == 0 else 1 + dp[i - 1][j][0]\n # dist_up = 1 if j == 0 else 1 + dp[i][j - 1][1]\n # dp[i][j] = (dist_left, dist_up)\n\n # max_area = 0\n\n # for i, row in enumerate(matrix):\n\n # rect1, rect2 = (0, 0), (0, 0)\n\n # for j, cell in enumerate(row):\n\n # if cell == '0':\n # rect1, rect2 = (0, 0), (0, 0)\n # continue\n \n # return max_area\n\n# 3 x 1\n# 2 x 1\n# 2 x 2\n ","runtime":"1371"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m,n = len(matrix),len(matrix[0])\n ans = 0\n dp = {}\n\n for i in range(m):\n for j in range(n):\n if matrix[i][j]=='0':\n dp[(i,j)]=(0,0)\n else:\n x = dp[(i,j-1)][0]+1 if j>0 else 1\n y = dp[(i-1,j)][1]+1 if i>0 else 1\n dp[(i,j)] = (x,y)\n ans = max(x,y,ans)\n minWidth = x\n # verical max possible\n for r in range(i-1,i-y,-1):\n minWidth = min(minWidth,dp[(r,j)][0])\n ans = max(ans,minWidth*(i-r+1))\n \n \n return ans","runtime":"1371"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m,n = len(matrix),len(matrix[0])\n ans = 0\n dp = {}\n\n for i in range(m):\n for j in range(n):\n if matrix[i][j]=='0':\n dp[(i,j)]=(0,0)\n else:\n x = dp[(i,j-1)][0]+1 if j>0 else 1\n y = dp[(i-1,j)][1]+1 if i>0 else 1\n dp[(i,j)] = (x,y)\n ans = max(x,y,ans)\n minWidth = x\n # verical max possible\n for r in range(i-1,i-y,-1):\n minWidth = min(minWidth,dp[(r,j)][0])\n ans = max(ans,minWidth*(i-r+1))\n \n \n return ans","runtime":"1396"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # Step 1: Define the problem in terms of DP\n # m: number of rows, n: number of columns in the matrix\n m, n = len(matrix), len(matrix[0])\n \n # Step 2: Initialize DP table\n # dp will store for each cell (i, j) a tuple (x, y)\n # where x is the width of the consecutive '1's in the current row\n # and y is the height of the consecutive '1's in the current column\n dp = {}\n\n # Variable to store the maximum area found so far\n ans = 0\n \n # Step 3: Iterate through each cell in the matrix (bottom-up approach)\n for i in range(m):\n for j in range(n):\n \n # Step 4: Base case - If the current cell is '0', it contributes no area\n if matrix[i][j] == '0':\n dp[(i, j)] = (0, 0) # No width, no height for this cell\n else:\n # If current cell is '1', calculate width and height\n # x = width of consecutive '1's in the current row ending at (i, j)\n # If we're at the first column, width is 1, otherwise extend from left\n x = dp[(i, j-1)][0] + 1 if j > 0 else 1\n \n # y = height of consecutive '1's in the current column ending at (i, j)\n # If we're at the first row, height is 1, otherwise extend from top\n y = dp[(i-1, j)][1] + 1 if i > 0 else 1\n \n # Store the width and height in dp for current cell (i, j)\n dp[(i, j)] = (x, y)\n\n # Update the maximum rectangle size that can be formed\n # Consider horizontal line from (i, j) and update answer with max(x, y)\n ans = max(x * 1, y * 1, ans)\n\n # Step 5: Check for possible rectangles with height > 1\n # Start at the current row (i), and go up row by row to check vertical rectangles\n minWidth = x # Set the current width as the minimum width\n for r in range(i-1, i-y, -1):\n # For every row above the current one, find the minimum width possible\n minWidth = min(minWidth, dp[(r, j)][0]) # Ensure rectangle width fits\n \n # Calculate area = minWidth * height (i - r + 1), update maximum\n ans = max(ans, minWidth * (i - r + 1))\n \n # Step 6: Return the final result, which is the maximum area found\n return ans","runtime":"1396"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n rows, cols = len(matrix), len(matrix[0])\n length = [[0]*cols for _ in range(rows)]\n for col in range(cols):\n for row in range(rows-1, -1, -1):\n if matrix[row][col] == \"1\":\n length[row][col] = 1 if row == rows-1 else 1+length[row+1][col]\n\n # print(length)\n res = 0\n for height in range(rows,0,-1):\n for i in range(rows-height+1):\n curr_wid = 0\n for j in range(cols):\n if length[i][j] >= height:\n curr_wid += 1\n else:\n curr_wid = 0\n res = max(res, height*curr_wid)\n return res\n\n\n ","runtime":"1421"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m,n = len(matrix), len(matrix[0])\n ans = 0\n dp = {}\n\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == '0':\n dp[(i,j)] = (0,0)\n else:\n x = dp[(i,j-1)][0]+1 if j>0 else 1\n y = dp[(i-1,j)][1]+1 if i>0 else 1\n dp[(i,j)] = (x,y)\n ans = max(x,y,ans)\n minWidth = x\n #vertical max possible\n for r in range(i-1,i-y,-1):\n minWidth = min(minWidth,dp[(r,j)][0])\n ans = max(ans,minWidth*(i-r+1))\n return ans","runtime":"1421"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m,n = len(matrix),len(matrix[0])\n ans = 0\n dp = {}\n\n for i in range(m):\n for j in range(n):\n if matrix[i][j]=='0':\n dp[(i,j)]=(0,0)\n else:\n x = dp[(i,j-1)][0]+1 if j>0 else 1\n y = dp[(i-1,j)][1]+1 if i>0 else 1\n dp[(i,j)] = (x,y)\n ans = max(x, y, ans)\n minWidth = x\n # verical max possible\n for r in range(i-1,i-y,-1):\n minWidth = min(minWidth,dp[(r,j)][0])\n ans = max(ans,minWidth*(i-r+1))\n \n \n return ans","runtime":"1446"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n rows, cols = len(matrix), len(matrix[0])\n rightBound = [[0 for _ in range(cols)] for _ in range(rows)]\n for r in range(rows):\n prevZero = -1\n for c in range(cols):\n if int(matrix[r][c]) == 0:\n for k in range(prevZero + 1, c):\n rightBound[r][k] = c - 1\n prevZero = c\n for k in range(prevZero + 1, cols):\n rightBound[r][k] = cols - 1\n ans = 0\n for r1 in range(rows):\n for c1 in range(cols):\n if int(matrix[r1][c1]) == 0:\n continue\n curMax = rightBound[r1][c1] - c1 + 1\n colWidth = rightBound[r1][c1] - c1 + 1\n for r2 in range(r1 + 1, rows):\n if int(matrix[r2][c1]) == 0:\n break\n colWidth = min(colWidth, rightBound[r2][c1] - c1 + 1)\n curMax = max(curMax, colWidth * (r2 - r1 + 1))\n ans = max(curMax, ans)\n return ans\n","runtime":"1446"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m,n = len(matrix),len(matrix[0])\n ans = 0\n dp = {}\n for i in range(m):\n for j in range(n):\n if matrix[i][j]=='0':\n dp[(i,j)]=(0,0)\n else:\n x = dp[(i,j-1)][0]+1 if j>0 else 1\n y = dp[(i-1,j)][1]+1 if i>0 else 1\n dp[(i,j)] = (x,y)\n ans = max(x,y,ans)\n minWidth = x\n for r in range(i-1,i-y,-1):\n minWidth = min(minWidth,dp[(r,j)][0])\n ans = max(ans,minWidth*(i-r+1))\n return ans","runtime":"1472"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m = len(matrix)\n n = len(matrix[0])\n maxarea = 0\n for a in range(m):\n ands = [1]*n\n maxstretch = 0\n for b in range(a,m):\n stretch = 0\n for col in range(n):\n ands[col] = ands[col] & (ord(matrix[b][col])-48)\n if ands[col] == 1:\n stretch += 1\n maxarea = max(maxarea,stretch*(b+1-a))\n else:\n stretch = 0\n# print(a,b,ands)\n return maxarea\n","runtime":"1472"},{"code":"class Solution:\n def compute_heights(self, matrix):\n heights = [len(matrix)]*len(matrix[0])\n for level in range(len(matrix)):\n for idx in range(len(matrix[0])):\n if matrix[level][idx] == 0:\n heights[idx] = min(heights[idx], level)\n return heights\n\n def get_largest_rect_from_heights(self, heights):\n largest_rect = 0\n for idx, val in enumerate(heights):\n if val == 0: continue\n i = idx\n height = 200\n while i >= 0:\n if heights[i] == 0:\n break\n width = idx-i + 1\n height = min(heights[i], height, val)\n area = width*height\n largest_rect = max(largest_rect, area)\n i -= 1\n return largest_rect\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n sub_matrices = [[int(y) for y in x] for x in matrix]\n sub_matrices = [sub_matrices[:i+1][::-1] for i in range(len(sub_matrices))]\n\n max_area = 0\n for matrix in sub_matrices:\n heights = self.compute_heights(matrix)\n largest_rect = self.get_largest_rect_from_heights(heights)\n if largest_rect > max_area:\n max_area = largest_rect\n return max_area","runtime":"1497"},{"code":"class Solution:\n def compute_heights(self, matrix):\n heights = [len(matrix)]*len(matrix[0])\n for level in range(len(matrix)):\n for idx in range(len(matrix[0])):\n if matrix[level][idx] == 0:\n heights[idx] = min(heights[idx], level)\n return heights\n\n def get_largest_rect_from_heights(self, heights):\n largest_rect = 0\n for idx, val in enumerate(heights):\n if val == 0: continue\n # print('f', idx, val)\n # largest_rect = max(largest_rect, val)\n i = idx\n height = 200\n while i >= 0:\n if heights[i] == 0:\n break\n width = idx-i + 1\n height = min(heights[i], height, val)\n area = width*height\n largest_rect = max(largest_rect, area)\n # print(f'i: {i}, idx: {idx}, ht: {height}, wd: {width}, ar: {area}, rect: {largest_rect}')\n i -= 1\n return largest_rect\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n sub_matrices = [[int(y) for y in x] for x in matrix]\n sub_matrices = [sub_matrices[:i+1][::-1] for i in range(len(sub_matrices))]\n\n max_area = 0\n for matrix in sub_matrices:\n heights = self.compute_heights(matrix)\n # print(heights)\n largest_rect = self.get_largest_rect_from_heights(heights)\n if largest_rect > max_area:\n max_area = largest_rect\n return max_area","runtime":"1497"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n res=0\n m,n=len(matrix),len(matrix[0])\n bruh=defaultdict(int)\n for c in range(n):\n for r in range(m):\n k=0\n while r+k < m and matrix[r+k][c]==\"1\": k+=1\n bruh[(r,c)]=k\n for r in range(m):\n for c in range(n):\n k=0\n cur=bruh[(r,c)]\n while cur and c+k<n:\n cur=min(cur,bruh[(r,c+k)])\n res=max(res,(k+1)*cur)\n k+=1\n return res\n\n","runtime":"1522"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n res = 0\n rows = len(matrix)\n cols = len(matrix[0])\n for r in range(rows):\n for c in range(cols):\n if matrix[r][c] == '0':\n continue\n if res >= (rows - r) * (cols - c):\n continue\n for w in range(cols - c):\n if matrix[r][c + w] == '0':\n break\n h = 0\n while h + r < rows:\n valid = True\n for k in range(w + 1):\n if matrix[r + h][c + k] == '0':\n valid = False\n if valid:\n res = max(res, (h + 1) * (w + 1))\n # print(\"res=\",res, \"=\", h + 1, \" x \", w + 1, \"from (\", r, \",\", c)\n h += 1\n else:\n break\n return res\n\n ","runtime":"1547"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n ans = 0\n m = len(matrix)\n n = len(matrix[0])\n long_m = [[0 for j in range(n)] for i in range(m)]\n long_n = [[0 for j in range(n)] for i in range(m)]\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == '1':\n if i == 0:\n long_m[i][j] = 1\n else:\n long_m[i][j] = long_m[i - 1][j] + 1\n if j == 0:\n long_n[i][j] = 1\n else:\n long_n[i][j] = long_n[i][j - 1] + 1\n rect = [[[0 for k in range(m + 1)] for j in range(n)] for i in range(m)]\n for k in range(1, m + 1):\n for i in range(k - 1, m):\n if long_m[i][0] >= k:\n rect[i][0][k] = 1\n ans = max(ans, k)\n for j in range(1, n):\n if long_m[i][j] >= k:\n rect[i][j][k] = rect[i][j - 1][k] + 1\n ans = max(ans, k * rect[i][j][k])\n return ans","runtime":"1573"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # dp[i][j] 表示在第i行，以j-th 结尾的最长1子串的长度\n # max(min(dp[k: l + 1][j]) * (l - k + 1))\n if len(matrix) == 0 or len(matrix[0]) == 0:\n return 0\n \n m = len(matrix)\n n = len(matrix[0])\n dp = [[0 for _ in range(n)] for _ in range(m)]\n for i in range(m):\n for j in range(n):\n if i == 0 and j == 0:\n dp[i][j] = int(matrix[i][j])\n else:\n if matrix[i][j] == \"0\":\n dp[i][j] = 0\n else:\n dp[i][j] = dp[i][j - 1] + 1\n \n # print(dp)\n max_area = 0\n for j in range(n):\n for k in range(m):\n min_len = dp[k][j]\n if max_area < min_len:\n max_area = min_len\n for l in range(k + 1, m):\n if dp[l][j] < min_len:\n min_len = dp[l][j]\n max_area = max(max_area, min_len * (l - k + 1))\n \n return max_area\n\n ","runtime":"1598"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n dp = [[[] for _ in range(n+1)] for _ in range(m+1)]\n MAX = 0\n for i in range(1, m+1):\n for j in range(1, n+1):\n if matrix[i-1][j-1] == '1':\n left, top = dp[i][j-1], dp[i-1][j]\n\n dp[i][j].append(left[0] + 1 if len(left) > 0 else 1)\n MAX = max(MAX, dp[i][j][0])\n k = 0\n while k < len(top):\n if k < len(left) - 1:\n temp = min(max(left[k+1] + 1, top[k]), dp[i][j][-1])\n else:\n temp = min(top[k], dp[i][j][-1])\n dp[i][j].append(temp)\n MAX = max(MAX, temp * (k+2)) ###\n k += 1\n return MAX","runtime":"1623"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n maxRec = 0\n r = 0\n while len(matrix) != 0:\n for c in range(len(matrix[r])):\n maxRec = self.search(maxRec, matrix, r, c)\n if maxRec == len(matrix)*len(matrix[0]): return maxRec\n matrix.pop(0)\n return maxRec\n def search(self, maxRec, matrix, r, c):\n startingCol = c\n while r < len(matrix) and matrix[r][c] == \"1\":\n r += 1\n if r == 0: return maxRec\n # print(\"row:\", r)\n selectedCol = list(range(r))\n while len(selectedCol) != 0 and c < len(matrix[0]):\n # print(\"col:\", c)\n # print(\"len:\", len(selectedCol))\n i = 0\n while i < len(selectedCol):\n selectedRow = selectedCol[i]\n if matrix[selectedRow][c] == \"0\":\n selectedCol.pop(i)\n continue\n i += 1\n carryRow, carry = -1, 0\n for selectedRow in selectedCol:\n # print(\"selectedRow:\", selectedRow)\n rec = c-startingCol + 1\n if selectedRow == carryRow:\n rec += carry\n carryRow, carry = selectedRow + 1, rec\n # print(\"rec:\",rec)\n maxRec = max(maxRec, rec)\n c += 1\n\n return maxRec","runtime":"1648"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n maxRec = 0\n r = 0\n while len(matrix) != 0:\n for c in range(len(matrix[r])):\n maxRec = self.search(maxRec, matrix, r, c)\n if maxRec == len(matrix)*len(matrix[0]): return maxRec\n matrix.pop(0)\n return maxRec\n def search(self, maxRec, matrix, r, c):\n startingCol = c\n while r < len(matrix) and matrix[r][c] == \"1\":\n r += 1\n if r == 0: return maxRec\n # print(\"row:\", r)\n selectedCol = list(range(r))\n while len(selectedCol) != 0 and c < len(matrix[0]):\n # print(\"col:\", c)\n # print(\"len:\", len(selectedCol))\n i = 0\n while i < len(selectedCol):\n selectedRow = selectedCol[i]\n if matrix[selectedRow][c] == \"0\":\n selectedCol.pop(i)\n continue\n i += 1\n carryRow, carry = -1, 0\n for selectedRow in selectedCol:\n # print(\"selectedRow:\", selectedRow)\n rec = c-startingCol + 1\n if selectedRow == carryRow:\n rec += carry\n carryRow, carry = selectedRow + 1, rec\n # print(\"rec:\",rec)\n maxRec = max(maxRec, rec)\n c += 1\n\n return maxRec","runtime":"1648"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n dp = [[[] for _ in range(n+1)] for _ in range(m+1)]\n MAX = 0\n for i in range(1, m+1):\n for j in range(1, n+1):\n if matrix[i-1][j-1] == '1':\n left, top = dp[i][j-1], dp[i-1][j]\n\n dp[i][j].append(left[0] + 1 if len(left) > 0 else 1)\n MAX = max(MAX, dp[i][j][0])\n k = 0\n while k < len(top):\n if k < len(left) - 1:\n temp = min(max(left[k+1] + 1, top[k]), dp[i][j][-1])\n else:\n temp = min(top[k], dp[i][j][-1])\n dp[i][j].append(temp)\n MAX = max(MAX, temp * (k+2)) ###\n k += 1\n return MAX","runtime":"1674"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n n_rows, n_cols = len(matrix), len(matrix[0])\n dp = [[0 for _ in range(n_cols)] for _ in range(n_rows)]\n dp[0][0] = 1 if matrix[0][0] == '1' else 0\n \n count = dp[0][0]\n for i in range(1, n_rows):\n count = count + 1 if matrix[i][0] == \"1\" else 0\n dp[i][0] = max(count, dp[i-1][0])\n \n count = dp[0][0]\n for i in range(1, n_cols):\n count = count + 1 if matrix[0][i] == \"1\" else 0\n dp[0][i] = max(count, dp[0][i-1])\n\n dp_cols = [[0 for _ in range(n_cols)] for _ in range(n_rows)]\n for i in range(0, n_rows):\n dp_cols[i][0] = int(matrix[i][0])\n for j in range(1, n_cols):\n dp_cols[i][j] = dp_cols[i][j-1] + 1 if int(matrix[i][j]) else 0\n \n\n \n for i in range(1, n_rows):\n for j in range(1, n_cols):\n dp[i][j] = max(dp[i-1][j], dp[i][j-1])\n if int(matrix[i][j]):\n rects = []\n for k in range(i, -1, -1):\n if int(matrix[k][j]) == 0:\n break\n rects.append(dp_cols[k][j])\n min_value = 1e8\n for k in range(len(rects)):\n min_value = min(min_value, rects[k])\n dp[i][j] = max(dp[i][j], (k+1)*min_value)\n # print(dp)\n # print(dp_cols)\n return dp[-1][-1] ","runtime":"1699"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def getWidth(str):\n subStr = str.split(\"0\")\n return len(max(subStr, key=lambda x: len(x)))\n\n def getStrAnd(str1, str2):\n newStr = \"\"\n for i in range(len(str1)):\n if str1[i] == str2[i] == \"1\": newStr = newStr+\"1\"\n else: newStr = newStr+\"0\"\n return newStr\n \n def convertToStr(row):\n st = \"\"\n for el in row: st = st + el\n return st\n\n longest = 0\n for rowStart in range(0, len(matrix)):\n resStr = convertToStr(matrix[rowStart])\n longest = max(longest, getWidth(resStr))\n for i in range(rowStart+1, len(matrix)):\n addStr = convertToStr(matrix[i])\n resStr = getStrAnd(resStr, addStr)\n longest = max(longest, getWidth(resStr)*(i-rowStart+1))\n\n return longest","runtime":"1699"},{"code":"def collectZeroRows(matrix):\n zeroRows = []\n for i in range(0, len(matrix)):\n zeros = []\n for j in range(0, len(matrix[i])):\n if matrix[i][j] == '0':\n zeros.append(j)\n zeroRows.append(zeros)\n return zeroRows\n\n# at matrix[i][j] == 1; find max k > j s.t. matrix[i][k] == '0'\ndef getLongHRun(matrix, zeroRows, i, j):\n idx = bisect.bisect_left( zeroRows[i], j )\n if idx == len(zeroRows[i]):\n return len(matrix[i]) - j\n if idx == 0 and zeroRows[i][idx] < j:\n return 1\n return zeroRows[i][idx] - j\n\ndef maxRect(matrix, i, j, zeroRows):\n result = 1\n v_len = 1\n h_len = getLongHRun(matrix, zeroRows, i + v_len - 1, j)\n while i + v_len - 1 < len(matrix) and matrix[i + v_len - 1][j] == '1':\n h_run = getLongHRun(matrix, zeroRows, i + v_len - 1, j)\n h_len = min(h_len, h_run )\n result = max(result, h_len * v_len)\n # print(i, j, h_run, zeroRows[i + v_len - 1], h_len, v_len, result)\n v_len += 1\n return result\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n zeroRows = collectZeroRows(matrix)\n result = 0\n for i in range(0, len(matrix)):\n for j in range(0, len(matrix[i])):\n if matrix[i][j] == '0':\n continue\n # matrix[i][j] == '1'\n temp_res = maxRect(matrix, i, j, zeroRows)\n result = max(result, temp_res)\n # print(i, j, temp_res)\n return result\n","runtime":"1724"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int: \n m = len(matrix)\n n = len(matrix[0])\n\n for j in range(n-1, -1, -1):\n for i in range(m-1, -1, -1):\n if matrix[i][j] == \"0\":\n matrix[i][j] = 0\n else:\n down = matrix[i+1][j] if i+1 != m else 0\n right = matrix[i][j+1] if j+1 != n else 0\n\n x = set()\n if down and right:\n x_down = {(a+1, b) for a, b in down}\n x_right = {(a, b+1) for a, b in right}\n for d in x_down:\n for r in x_right:\n x.add((min(d[0], r[0]), min(d[1], r[1])))\n x |= {(a, b) for a, b in (x_down | x_right) if a == 1 or b == 1}\n if (1, 1) in x:\n x.remove((1, 1))\n elif down:\n a = max(a for a, _ in down)\n x.add((a + 1, 1))\n elif right:\n b = max(b for _, b in right)\n x.add((1, b + 1))\n else:\n x.add((1, 1))\n matrix[i][j] = x\n\n for j in range(n-1, -1, -1):\n for i in range(m-1, -1, -1):\n if matrix[i][j]:\n matrix[i][j] = max(a*b for a, b in matrix[i][j])\n\n return max(max(row) for row in matrix)","runtime":"1749"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n ret = 0\n H = len(matrix)\n Y_arr = [[] for i in range(H)]\n for i in range(H):\n for j in range(len(matrix[0])):\n if matrix[i][j] == '0': Y_arr[i].append(j)\n Y_arr[i].append(len(matrix[0]))\n # print(Y_arr)\n\n can_t = []\n for i in range(H):\n can_t.clear()\n for j in range(len(Y_arr[i])):\n can_t.append(Y_arr[i][j])\n\n ret_t = 0\n count_t = 0\n for k in range(i, H):\n count_t += 1\n if k != i:\n for u in range(len(Y_arr[k])):\n if Y_arr[k][u] >= can_t[len(can_t) - 1]: break\n elif Y_arr[k][u] not in can_t:\n can_t.append(Y_arr[k][u])\n can_t.sort()\n # print(can_t)\n for u in range(len(can_t)):\n if u == 0: ret_t = max(ret_t, count_t * can_t[u])\n else: ret_t = max(ret_t, count_t * (can_t[u] - can_t[u - 1] - 1))\n ret = max(ret, ret_t)\n # print(ret)\n\n return ret\n","runtime":"1775"},{"code":"def get_max_right(i,j, matrix, memory):\n if (i,j) in memory:\n return memory[(i,j)]\n if j!=0 and (i,j-1) in memory and memory[(i,j-1)] != 0:\n memory[(i,j)] = memory[(i,j-1)]-1\n return memory[(i,j)]\n \n n = len(matrix[0])\n counter = 0\n p = j\n while p < n and matrix[i][p] == \"1\":\n counter += 1\n p+=1\n memory[(i,j)] = counter\n return memory[(i,j)]\n \n\n\ndef get_max_at_pos(i,j,matrix, memory):\n if matrix[i][j] == \"0\":\n memory[(i,j)] = 0\n return memory[(i,j)]\n flag = True\n p = i\n rec_max = 0\n right_max = float(\"Inf\")\n n = len(matrix)\n while flag:\n if p < n and matrix[p][j] == \"1\":\n t_right = get_max_right(p,j,matrix,memory)\n right_max = min(right_max, t_right)\n square_size = (p-i+1)*right_max\n rec_max = max(square_size, rec_max)\n p+=1\n else:\n flag = False\n return rec_max\n\n \n \n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n n = len(matrix)\n m = len(matrix[0])\n memory = {}\n rec_max = 0\n for i in range(n):\n for j in range(m):\n ij_max = get_max_at_pos(i,j,matrix,memory)\n rec_max = max(ij_max, rec_max)\n return rec_max\n\n ","runtime":"1800"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int: \n m = len(matrix)\n n = len(matrix[0])\n\n for j in range(n-1, -1, -1):\n for i in range(m-1, -1, -1):\n if matrix[i][j] == \"0\":\n matrix[i][j] = 0\n else:\n down = matrix[i+1][j] if i+1 != m else 0\n right = matrix[i][j+1] if j+1 != n else 0\n\n x = set()\n if down and right:\n x_down = {(a+1, b) for a, b in down}\n x_right = {(a, b+1) for a, b in right}\n for d in x_down:\n for r in x_right:\n x.add((min(d[0], r[0]), min(d[1], r[1])))\n x |= {(a, b) for a, b in (x_down | x_right) if a == 1 or b == 1}\n elif down:\n a = max(a for a, _ in down)\n x.add((a + 1, 1))\n elif right:\n b = max(b for _, b in right)\n x.add((1, b + 1))\n else:\n x.add((1, 1))\n matrix[i][j] = x\n\n for j in range(n-1, -1, -1):\n for i in range(m-1, -1, -1):\n if matrix[i][j]:\n matrix[i][j] = max(a*b for a, b in matrix[i][j])\n\n return max(max(row) for row in matrix)","runtime":"1825"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n d ={}\n d1 = {}\n m = 0\n for i in range(len(matrix)-1, -1, -1):\n for j in range(len(matrix[0])-1, -1, -1):\n if matrix[i][j] == \"0\":\n d[f\"{i},{j}\"] = 0\n else:\n if f\"{i},{j+1}\" not in d:\n d[f\"{i},{j}\"] = 1\n else:\n d[f\"{i},{j}\"] = 1 + d[f\"{i},{j+1}\"]\n \n \n for j in range(len(matrix[0])-1, -1, -1):\n for i in range(len(matrix)-1, -1, -1): \n if matrix[i][j] == \"0\":\n d1[f\"{i},{j}\"] = 0\n else:\n if f\"{i + 1},{j}\" not in d1:\n d1[f\"{i},{j}\"] = 1\n else:\n d1[f\"{i},{j}\"] = 1 + d1[f\"{i + 1},{j}\"]\n\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if d[f\"{i},{j}\"] == 0:\n continue\n v = d[f\"{i},{j}\"]\n while v > 0:\n temp = v\n c = i + 1\n while f\"{c},{j}\" in d and d[f\"{c},{j}\"] >= v:\n temp += v\n c += 1\n if temp > m:\n m = temp\n v -= 1\n if v*d1[f\"{i},{j}\"] < m:\n break\n \n \n return m\n\n","runtime":"1851"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # dp with histograms\n # dp[i][j] stores the max width for rectangel end with cell [i][j]\n m, n = len(matrix), len(matrix[0])\n dp = [[0 for i in range(n)] for j in range(m)]\n res = 0\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == \"0\": continue\n dp[i][j] = 1 if j == 0 else dp[i][j-1] + 1\n\n curr_width, height = dp[i][j], 0\n for k in range(i, -1, -1):\n curr_width = min(curr_width, dp[k][j])\n height += 1\n res = max(res, curr_width * height)\n\n return res\n ","runtime":"1876"},{"code":"def get_max_right(i,j, matrix, memory):\n if (i,j) in memory:\n return memory[(i,j)]\n n = len(matrix[0])\n counter = 0\n p = j\n while p < n and matrix[i][p] == \"1\":\n counter += 1\n p+=1\n memory[(i,j)] = counter\n return memory[(i,j)]\n \n\n\ndef get_max_at_pos(i,j,matrix, memory):\n if matrix[i][j] == \"0\":\n memory[(i,j)] = 0\n return memory[(i,j)]\n flag = True\n p = i\n rec_max = 0\n right_max = float(\"Inf\")\n n = len(matrix)\n while flag:\n if p < n and matrix[p][j] == \"1\":\n t_right = get_max_right(p,j,matrix,memory)\n right_max = min(right_max, t_right)\n square_size = (p-i+1)*right_max\n rec_max = max(square_size, rec_max)\n p+=1\n else:\n flag = False\n return rec_max\n\n \n \n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n n = len(matrix)\n m = len(matrix[0])\n memory = {}\n rec_max = 0\n for i in range(n):\n for j in range(m):\n ij_max = get_max_at_pos(i,j,matrix,memory)\n rec_max = max(ij_max, rec_max)\n return rec_max\n\n ","runtime":"1901"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n \n down = [ [ 0 ] * n for i in range(m) ]\n right = [ [0] * n for i in range(m) ]\n for i in range(m - 1, -1, -1):\n for j in range(n - 1, -1, -1):\n if j < n - 1:\n if matrix[i][j + 1] == \"1\":\n right[i][j] = right[i][j + 1] + 1\n if i < m - 1:\n if matrix[i + 1][j] == \"1\":\n down[i][j] = down[i + 1][j] + 1\n\n dp = [ [0] * n for i in range(m) ]\n for i in range(m - 1, -1, -1):\n if i == m - 1:\n if matrix[i][-1] == \"1\":\n dp[i][-1] = 1\n else:\n if matrix[i][-1] == \"1\":\n dp[i][-1] = 1 + dp[i + 1][-1]\n for j in range(n - 1, -1, -1):\n if j == n - 1:\n if matrix[-1][j] == \"1\":\n dp[-1][j] = 1\n else:\n if matrix[-1][j] == \"1\":\n dp[-1][j] = 1 + dp[-1][j + 1]\n\n for i in range(m - 2, -1, -1):\n for j in range(n - 2, -1, -1):\n if matrix[i][j] == \"1\":\n if matrix[i + 1][j + 1] == \"0\":\n if matrix[i + 1][j] == \"0\" and matrix[i][j + 1] == \"1\":\n dp[i][j] = 1 + right[i][j]\n elif matrix[i][j + 1] == \"0\" and matrix[i + 1][j] == \"1\":\n dp[i][j] = 1 + down[i][j]\n elif matrix[i][j + 1] == \"0\" and matrix[i + 1][j] == \"0\":\n dp[i][j] = 1\n else:\n if dp[i + 1][j] >= dp[i][j + 1]:\n dp[i][j] = 1 + dp[i + 1][j]\n else:\n dp[i][j] = 1 + dp[i][j + 1]\n else:\n if matrix[i + 1][j] == \"0\" and matrix[i][j + 1] == \"1\":\n dp[i][j] = 1 + right[i][j]\n elif matrix[i][j + 1] == \"0\" and matrix[i + 1][j] == \"1\":\n dp[i][j] = 1 + down[i][j]\n elif matrix[i][j + 1] == \"0\" and matrix[i + 1][j] == \"0\":\n dp[i][j] = 1\n else:\n horizontal = right[i][j] + 1\n vertical = down[i][j] + 1\n\n\n row_wise_area = 0\n curr_area = 0\n row_wise_area_rows = min(down[i][j] + 1, down[i + 1][j + 1] + 2)\n row_wise_area_cols = float('inf')\n for k in range(row_wise_area_rows):\n if i + k >= m: break\n cols = right[i + k][j] + 1\n row_wise_area_cols = min(cols, row_wise_area_cols)\n curr_area = (k + 1) * row_wise_area_cols\n row_wise_area = max(curr_area, row_wise_area)\n\n col_wise_area = 0\n curr_area = 0\n col_wise_area_cols = min(right[i][j] + 1, right[i + 1][j + 1] + 2)\n col_wise_area_rows = float('inf')\n for k in range(col_wise_area_cols):\n if j + k >= n : break\n rows = down[i][j + k] + 1\n col_wise_area_rows = min(rows, col_wise_area_rows)\n curr_area = (1 + k) * col_wise_area_rows\n col_wise_area_cols = max(curr_area, col_wise_area)\n \n dp[i][j] = max(horizontal, vertical, row_wise_area, col_wise_area)\n\n max_area = 0\n for row in dp:\n max_area = max(max_area, max(row))\n \n return max_area","runtime":"1926"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m = len(matrix)\n n = len(matrix[0])\n\n largest = 0\n # length/breadth\n dp = [[0]*n for __ in range(m)]\n\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == \"1\":\n width = dp[i][j] = dp[i][j-1] +1 if j-1 >= 0 else 1\n for k in range(i, -1, -1):\n width = min(width, dp[k][j])\n largest = max(largest, width * (i-k+1))\n return largest\n\n\"\"\"\n[\n [1,0,1,0,0]\n [2,0,2,2,3]\n [3,2,3,4,6]\n [4,0,0,3,0]\n]\n\n\"\"\"","runtime":"1952"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m = len(matrix)\n n = len(matrix[0])\n dp = [[0]*n for _ in range(m)]\n maxarea = 0\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == '0':\n continue\n\n # compute the maximum width and update dp with it\n width = dp[i][j] = dp[i][j - 1] + 1 if j else 1\n\n # compute the maximum area rectangle with a lower right corner at [i, j]\n for k in range(i, -1, -1):\n width = min(width, dp[k][j])\n maxarea = max(maxarea, width * (i - k + 1))\n \n return maxarea\n","runtime":"1977"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n # brute force: 4 loops; O(N^4), O(1)\n # better brute force: inner binary search: O(N^3*log(N)), O(1)\n # ? N^3 maybe dp, prefixsum\n # ? N^2\n ans = 0\n M, N = len(matrix), len(matrix[0])\n for row1 in range(M):\n for col1 in range(N):\n if matrix[row1][col1] == '0':\n continue\n \n hi = N\n for row2 in range(row1, M):\n if matrix[row2][col1] == '0':\n break\n if row1 == 1 and row2 == 1:\n print(hi)\n j = bisect.bisect_left(matrix[row2], 1, lo=col1 + 1, hi=hi, key=lambda k: 0 if k == '1' else 1)\n if not (col1 + 1 <= j <= N):\n raise RuntimeError(f\"{j}\")\n if (row2 - row1 + 1) * (hi - col1) == 10:\n print(row2, hi)\n ans = max(ans, (row2 - row1 + 1) * (hi - col1))\n\n return ans\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n maxarea = 0\n M, N = len(matrix), len(matrix[0])\n dp = [[0] * N for _ in range(M)]\n\n for i in range(M):\n for j in range(N):\n if matrix[i][j] == '0':\n continue\n \n width = dp[i][j] = dp[i][j - 1] + 1 if j else 1\n for k in range(i, -1, -1):\n width = min(width, dp[k][j])\n maxarea = max(maxarea, width * (i - k + 1))\n return maxarea\n\n","runtime":"2002"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n maxarea = 0\n n = len(matrix[0])\n m = len(matrix)\n\n dp = [[0] * n for _ in range(m)]\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == \"0\":\n continue\n\n width = dp[i][j] = dp[i][j - 1] + 1 if j else 1\n\n for k in range(i, -1, -1):\n width = min(width, dp[k][j])\n maxarea = max(maxarea, width * (i - k + 1))\n \n return maxarea","runtime":"2027"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n\n maxarea = 0 \n m,n = len(matrix), len(matrix[0])\n dp = [ [0] * n for _ in range(m)]\n\n\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == \"1\":\n dp[i][j] = dp[i][j-1] + 1 if j else 1\n width = dp[i][j]\n\n\n for k in range(i,-1,-1):\n width = min(width, dp[k][j])\n\n maxarea = max(maxarea, width * (i-k+1))\n\n return maxarea\n\n\n ","runtime":"2027"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n maxarea=0\n m,n=len(matrix),len(matrix[0])\n dp=[[0 for _ in range(n)] for _ in range(m)] \n for i in range(m):\n for j in range(n):\n if matrix[i][j]==\"0\":\n continue\n width=dp[i][j]=dp[i][j-1]+1 if j else 1\n for k in range(i,-1,-1):\n width=min(width,dp[k][j])\n maxarea=max(maxarea,width*(i-k+1))\n return maxarea ","runtime":"2053"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n maxarea = 0\n dp = [[0] * len(matrix[0]) for _ in range(len(matrix))]\n\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if matrix[i][j] == '0':\n continue\n \n width = dp[i][j] = dp[i][j-1] + 1 if j else 1\n\n for k in range(i, -1, -1):\n width = min(width, dp[k][j])\n maxarea = max(maxarea, width * (i-k+1))\n \n return maxarea","runtime":"2053"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m = len(matrix)\n n = len(matrix[0])\n maxarea = 0\n dp = [[0]*n for _ in range(m)] # record max width\n\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == '0':\n continue\n dp[i][j] = dp[i][j-1]+1 if j else 1\n width = dp[i][j]\n\n for k in range(i, -1, -1):\n width = min(width, dp[k][j])\n maxarea = max(maxarea, width*(i-k+1))\n return maxarea\n\n '''\n m = len(matrix)\n n = len(matrix[0])\n dp = [[(0, 0)]*n for _ in range(m)]\n area = -float('inf')\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == '0':\n dp[i][j] == (0, 0)\n else:\n if i == 0 and j == 0:\n dp[i][j] = (1, 1)\n elif i == 0 or matrix[i-1][j] == '0':\n if matrix[i][j-1] == '1':\n row, col = dp[i][j-1]\n dp[i][j] = (1, col+1)\n else:\n dp[i][j] = (1, 1)\n elif j == 0 or matrix[i][j-1] == '0':\n if matrix[i-1][j] == '1':\n row, col = dp[i-1][j]\n dp[i][j] = (row+1, 1)\n else:\n dp[i][j] = (1, 1)\n else:\n if matrix[i-1][j-1] == '0':\n uprow, upcol = dp[i-1][j]\n leftrow, leftcol = dp[i][j-1]\n if (uprow+1)*1 > 1*(leftcol+1):\n dp[i][j] = (uprow+1, 1)\n else:\n dp[i][j] = (1, leftcol+1)\n else:\n uprow, upcol = dp[i-1][j]\n leftrow, leftcol = dp[i][j-1]\n cornerrow, cornercol = dp[i-1][j-1]\n minrow = min(uprow, leftrow, cornerrow)\n mincol = min(upcol, leftcol, cornercol)\n uparea = (uprow+1)*1\n leftarea = 1*(leftcol+1)\n cornerarea = (minrow+1)*(mincol+1)\n maxarea = max(uparea, leftarea, cornerarea) \n if maxarea == uparea:\n dp[i][j] == (uprow+1, 1)\n elif maxarea == leftarea:\n dp[i][j] = (1, leftcol+1)\n else:\n dp[i][j] = (minrow+1, mincol+1)\n r, c = dp[i][j]\n area = max(area, r*c)\n print(dp)\n return area\n '''","runtime":"2078"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m = len(matrix)\n n = len(matrix[0])\n\n dp = [[0] * len(matrix[0]) for _ in range(len(matrix))]\n\n maxArea = 0\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == \"0\":\n continue\n \n width = dp[i][j] = dp[i][j-1] + 1 if j else 1\n\n for k in range(i, -1, -1):\n width = min(width, dp[k][j])\n maxArea = max(maxArea, width * (i - k + 1))\n\n print(dp)\n\n\n return maxArea","runtime":"2078"}],"string":"[\n {\n \"code\": \"def largestRectangleArea(heights: List[int]) -> int:\\n stack = []\\n max_area = 0\\n heights.append(0) \\n\\n for i in range(len(heights)):\\n while stack and heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i if not stack else i - stack[-1] - 1\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n \\n heights.pop() \\n return max_area\\n\\n\\nclass Solution:\\n def maximalRectangle(matrix: List[List[str]]) -> int:\\n if not matrix or not matrix[0]:\\n return 0\\n \\n n_cols = len(matrix[0])\\n heights = [0] * n_cols\\n max_area = 0\\n\\n for row in matrix:\\n for i in range(n_cols):\\n \\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n \\n max_area = max(max_area, largestRectangleArea(heights))\\n \\n return max_area\\n\\n with open('user.out','w') as f:\\n for i in map(loads, stdin):\\n print(maximalRectangle(i), file=f)\\n exit(0)\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"def largestRectangleArea(heights: List[int]) -> int:\\n print(f'heights: {heights}')\\n n = len(heights)\\n max_area = 0\\n stack = []\\n for j in range(n):\\n h = heights[j]\\n while stack and h < heights[stack[-1]]:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (j - left)\\n if area > max_area:\\n max_area = area\\n stack.append(j)\\n while stack:\\n i = stack.pop()\\n left = 0 if not stack else stack[-1] + 1\\n area = heights[i] * (n - left)\\n if area > max_area:\\n max_area = area\\n return max_area\\n\\n\\ndef maximalRectangle(matrix: List[List[str]]) -> int:\\n cols = len(matrix[0])\\n heights = [0]*cols\\n max_area = 0\\n for row in matrix:\\n for i, val in enumerate(row):\\n if val == '0':\\n heights[i] = 0\\n else:\\n heights[i] += 1\\n area = largestRectangleArea(heights)\\n if area > max_area:\\n max_area = area\\n return max_area\\n\\n\\nif __name__ == '__main__': \\n with open('user.out','w') as f:\\n for i in map(loads, stdin):\\n print(maximalRectangle(i), file=f)\\n exit(0)\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix or not matrix[0]:\\n return 0\\n \\n # Initialize the histogram heights\\n num_cols = len(matrix[0])\\n heights = [0] * num_cols\\n max_area = 0\\n\\n def largestRectangleArea(heights):\\n max_area = 0\\n stack = []\\n\\n for i, h in enumerate(heights):\\n s = i\\n while stack and stack[-1][1] > h:\\n index, height = stack.pop()\\n max_area = max(max_area, height * (i - index))\\n s = index\\n stack.append((s, h))\\n\\n for i, h in stack:\\n max_area = max(max_area, h * (len(heights) - i))\\n\\n return max_area\\n\\n \\n for row in matrix:\\n for i in range(num_cols):\\n if row[i] == '1':\\n heights[i] += 1\\n else:\\n heights[i] = 0\\n\\n max_area = max(max_area, largestRectangleArea(heights))\\n \\n return max_area\\n\\n\\n \",\n \"runtime\": \"107\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix:\\n return 0\\n \\n rows, cols = len(matrix), len(matrix[0])\\n heights = [0] * (cols + 1) # Include an extra element for easier calculation\\n max_area = 0\\n \\n for row in matrix:\\n for i in range(cols):\\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n # Calculate max area using histogram method\\n stack = []\\n for i in range(len(heights)):\\n while stack and heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i if not stack else i - stack[-1] - 1\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n \\n return max_area \",\n \"runtime\": \"133\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix:\\n return 0\\n \\n rows, cols = len(matrix), len(matrix[0])\\n heights = [0] * (cols + 1) # Include an extra element for easier calculation\\n max_area = 0\\n \\n for row in matrix:\\n for i in range(cols):\\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n # Calculate max area using histogram method\\n stack = []\\n for i in range(len(heights)):\\n while stack and heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i if not stack else i - stack[-1] - 1\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n \\n return max_area \",\n \"runtime\": \"158\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: list[list[str]], ans = 0) -> int:\\n\\n m, n = len(matrix), len(matrix[0])\\n dp = [0]*(n+1)\\n \\n for i in range(m):\\n stk = deque([-1])\\n\\n for j in range(n+1):\\n if j < n and matrix[i][j] == '1': dp[j]+= 1\\n else: dp[j] = 0\\n\\n while(dp[stk[0]] > dp[j]):\\n ans = max(ans,dp[stk.popleft()]*(j-stk[0]-1))\\n\\n stk.appendleft(j)\\n\\n return ans\",\n \"runtime\": \"183\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def largestRectangleArea(heights):\\n stack = []\\n max_area = 0\\n heights.append(0) # Add a sentinel value to make sure we process all elements in the stack\\n\\n for i in range(len(heights)):\\n while stack and heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i if not stack else i - stack[-1] - 1\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n \\n heights.pop() # Remove the sentinel value\\n return max_area\\n\\n if not matrix:\\n return 0\\n\\n max_area = 0\\n cols = len(matrix[0])\\n heights = [0] * cols\\n \\n for row in matrix:\\n for i in range(cols):\\n if row[i] == '1':\\n heights[i] += 1\\n else:\\n heights[i] = 0\\n\\n max_area = max(max_area, largestRectangleArea(heights))\\n\\n return max_area\\n\\n \",\n \"runtime\": \"208\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n grid = self.getHistGrid(matrix)\\n return self.getMaxRectangle(grid)\\n \\n def getHistGrid(self, grid):\\n m, n = len(grid), len(grid[0])\\n dp = [[0]*n for _ in range(m)]\\n for i in range(m):\\n for j in range(n):\\n if m == 0 and grid[i][j] == '1':\\n dp[i][j] == 1\\n elif grid[i][j] == '1':\\n dp[i][j] = 1+dp[i-1][j]\\n return dp\\n\\n def getMaxRectangle(self, grid):\\n m,n = len(grid), len(grid[0])\\n maxArea = 0\\n for i in range(m):\\n stack = [-1]\\n for j in range(n):\\n while stack[-1] != -1 and grid[i][stack[-1]] > grid[i][j]:\\n height = grid[i][stack.pop()]\\n width = j-stack[-1]-1\\n maxArea = max(maxArea, height*width)\\n stack.append(j)\\n while stack[-1] != -1:\\n height = grid[i][stack.pop()]\\n width = n-stack[-1]-1\\n maxArea = max(maxArea, height*width)\\n return maxArea\\n \",\n \"runtime\": \"208\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix:\\n return 0\\n\\n n = len(matrix[0])\\n heights = [0] * (n + 1)\\n max_area = 0\\n\\n for row in matrix:\\n \\n for i in range(n):\\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n \\n stack = [-1]\\n for i in range(n + 1):\\n while heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i - 1 - stack[-1]\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n\\n return max_area\",\n \"runtime\": \"234\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def rowMaxRectangle(heights: List[int]) -> int:\\n area = 0\\n stack = [-1]\\n for i in range(len(heights)):\\n while stack[-1] != -1 and heights[stack[-1]] >= heights[i]:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1\\n area = max(area, width * height)\\n stack.append(i)\\n while stack[-1] != -1:\\n height = heights[stack.pop()]\\n width = len(heights) - stack[-1] - 1\\n area = max(area, width * height)\\n return area\\n\\n max_area = 0\\n dp = [0] * len(matrix[0])\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n dp[j] = dp[j] + 1 if matrix[i][j] == \\\"1\\\" else 0\\n max_area = max(max_area, rowMaxRectangle(dp))\\n return max_area\",\n \"runtime\": \"234\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n def hist(arr):\\n l=[0]*len(arr)\\n r=[0]*len(arr)\\n rs=[]\\n for i in range(len(arr)):\\n while len(rs)>0 and arr[i]<rs[-1][0]:\\n top = rs.pop()\\n r[top[1]] = i-top[1]-1\\n rs.append((arr[i],i))\\n while len(rs)>0:\\n top = rs.pop()\\n r[top[1]] = len(arr)-top[1]-1\\n \\n ls=[]\\n for i in range(len(arr)-1,-1,-1):\\n while len(ls)>0 and arr[i]<ls[-1][0]:\\n top = ls.pop()\\n l[top[1]] = top[1]-i-1\\n ls.append((arr[i],i))\\n while len(ls)>0:\\n top = ls.pop()\\n l[top[1]] = top[1]\\n \\n ans=0\\n for i in range(len(arr)):\\n ans=max(ans,(l[i]+r[i]+1)*arr[i])\\n return ans\\n \\n count=[0]*len(matrix[0])\\n ans=0\\n for i in range(len(matrix)):\\n for j in range(len(matrix[i])):\\n if matrix[i][j]==\\\"0\\\":\\n count[j]=0\\n else:\\n count[j]+=1\\n # print(count)\\n ans = max(ans,hist(count))\\n return ans\\n \\n\\n\",\n \"runtime\": \"259\"\n },\n {\n \"code\": \"class Solution:\\n def getnearSmallerLeft(self, arr):\\n stack = []\\n ans = []\\n for i in range(len(arr)):\\n while stack and arr[i] <= arr[stack[-1]]:\\n stack.pop()\\n if stack:\\n ans.append(stack[-1])\\n else:\\n ans.append(-1)\\n stack.append(i)\\n return ans\\n\\n def getnearSmallerRight(self, arr):\\n stack = []\\n ans = [0] * len(arr)\\n for i in range(len(arr) - 1, -1, -1):\\n while stack and arr[i] <= arr[stack[-1]]:\\n stack.pop()\\n if stack:\\n ans[i] = stack[-1]\\n else:\\n ans[i] = len(arr)\\n stack.append(i)\\n return ans\\n\\n def largetst_rect(self, arr):\\n nseLeft = self.getnearSmallerLeft(arr)\\n nseRight = self.getnearSmallerRight(arr)\\n ans = 0\\n for i in range(len(arr)):\\n width = nseRight[i] - nseLeft[i] - 1\\n ans = max(ans, width * arr[i])\\n return ans\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix or not matrix[0]:\\n return 0\\n \\n n, m = len(matrix), len(matrix[0])\\n arr = [int(matrix[0][j]) for j in range(m)]\\n ans = self.largetst_rect(arr)\\n \\n for i in range(1, n):\\n arr = [arr[j] + int(matrix[i][j]) if matrix[i][j] == '1' else 0 for j in range(m)]\\n ans = max(ans, self.largetst_rect(arr))\\n\\n return ans\\n\",\n \"runtime\": \"259\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, arr: List[List[str]]) -> int:\\n def mah(arr):\\n st = []\\n left = [0] * len(arr)\\n right = [0] * len(arr)\\n i = 0\\n \\n while i < len(arr):\\n if len(st) == 0:\\n left[i] = -1\\n elif arr[i] > arr[st[-1]]:\\n left[i] = st[-1]\\n else:\\n while len(st) > 0 and arr[i] <= arr[st[-1]]:\\n st.pop()\\n if len(st) == 0:\\n left[i] = -1\\n else:\\n left[i] = st[-1]\\n st.append(i)\\n i += 1\\n \\n i = len(arr) - 1\\n st = []\\n \\n while i >= 0:\\n if len(st) == 0:\\n right[i] = len(arr)\\n elif arr[i] > arr[st[-1]]:\\n right[i] = st[-1]\\n else:\\n while len(st) > 0 and arr[i] <= arr[st[-1]]:\\n st.pop()\\n if len(st) == 0:\\n right[i] = len(arr)\\n else:\\n right[i] = st[-1]\\n st.append(i)\\n i -= 1\\n \\n width = [0] * len(arr)\\n for i in range(len(arr)):\\n width[i] = right[i] - left[i] - 1\\n \\n area = [0] * len(arr)\\n for i in range(len(arr)):\\n area[i] = width[i] * arr[i]\\n \\n return max(area)\\n m = len(arr[0])\\n n = len(arr)\\n for i in range(n):\\n for j in range(m):\\n arr[i][j] = int(arr[i][j])\\n l=[]\\n for j in range(m):\\n l.append(int(arr[0][j]))\\n mx=mah(l)\\n \\n if len(arr)<2:\\n return mx\\n for i in range(1,n):\\n for j in range(m):\\n if arr[i][j]==1:\\n l[j]=l[j]+arr[i][j]\\n\\n else:\\n l[j]=0\\n print(l)\\n mx=max(mx,mah(l))\\n return mx\\n \\n\\n \\n \",\n \"runtime\": \"284\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # tranverse matrix row by row, each row means based on this row what is the maximum rectangle\\n cur_height = [0 for _ in range(len(matrix[0]))]\\n res = float('-inf')\\n for row_index, cur_row in enumerate(matrix):\\n for cur_col, cur_item in enumerate(cur_row):\\n print(cur_col, cur_item)\\n if cur_item == '1':\\n cur_height[cur_col] = cur_height[cur_col] + 1 \\n else:\\n cur_height[cur_col] = 0\\n res = max(res, self.calculate_max_rectangle(cur_height))\\n return res\\n \\n def calculate_max_rectangle(self, heights):\\n stack = [] # (cur_index, cur_height)\\n ret = float('-inf')\\n for cur_index, cur_height in enumerate(heights):\\n while stack and cur_height <= stack[-1][1]:\\n last_index, last_height = stack.pop()\\n last_last_index = stack[-1][0] if stack else -1\\n ret = max(ret, (cur_index-last_last_index-1) * last_height)\\n stack.append((cur_index, cur_height))\\n while stack:\\n last_index, last_height = stack.pop()\\n last_last_index = stack[-1][0] if stack else -1\\n ret = max(ret, (len(heights)-last_last_index-1) * last_height)\\n return ret\",\n \"runtime\": \"284\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def mrec(matrix: List[List[str]], k, l, mms):\\n # print(k, l)\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n pj = m\\n i = k\\n while i < n:\\n if (n - k) * (pj - l) <= mms:\\n break\\n j = l\\n # print('i', i, j, pj)\\n while j < pj:\\n # print(k, l, i, j, pj)\\n if matrix[i][j] == '0':\\n break\\n j += 1\\n s = (i - k + 1) * (j - l)\\n # print('+', k, l, i, j, s)\\n if s > ms:\\n ms = s\\n pj = j\\n i += 1\\n return ms\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # print(len(matrix), print(len(matrix[0])))\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n for i in range(n):\\n for j in range(m):\\n pms = (n - i) * (m - j)\\n if pms < ms:\\n break\\n s = self.mrec(matrix, i, j, ms)\\n if s > ms:\\n ms = s\\n i += 1\\n return ms\\n\",\n \"runtime\": \"309\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def maxRectangle(arr):\\n leftMin = [-1 for x in arr]\\n rightMin = [len(arr) for x in arr]\\n stack = []\\n xarr=arr\\n i=0\\n for x in arr:\\n while len(stack) and x<stack[-1][0]:\\n top = stack.pop(-1)\\n rightMin[top[1]] = i\\n else:\\n stack.append((x,i))\\n i+=1\\n i=len(arr)-1\\n stack=[]\\n for x in arr[::-1]:\\n while len(stack) and x<stack[-1][0]:\\n top = stack.pop(-1)\\n print(top)\\n leftMin[top[1]] = i\\n else:\\n stack.append((x,i))\\n i-=1\\n \\n return [leftMin,rightMin]\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == '1':\\n matrix[i][j]=1\\n if matrix[i][j] == '0':\\n matrix[i][j]=0\\n if i != len(matrix)-1:\\n if matrix[i+1][j] == '1':\\n matrix[i+1][j] = 1+matrix[i][j]\\n maxx=0\\n for arr in matrix:\\n lm,rm=maxRectangle(arr)\\n # print(arr,lm,rm)\\n for i in range(len(lm)):\\n tmp=arr[i]*(abs(lm[i]-rm[i])-1)\\n if tmp>maxx:\\n maxx=tmp\\n return maxx\\n\\n \\n\",\n \"runtime\": \"309\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def mrec(matrix: List[List[str]], k, l, rx1, rx2, ry1, ry2, mms):\\n # print(k, l)\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n mi = -1\\n mj = -1\\n pj = m\\n i = k\\n while i < n:\\n if (n - k) * (pj - l) <= mms:\\n break\\n j = l\\n # print('i', i, j, pj)\\n if (i < ry1) or (i > ry2) or (pj <= rx1) or (l > rx2):\\n while j < pj:\\n # print(k, l, i, j, pj)\\n if matrix[i][j] == '0':\\n break\\n j += 1\\n s = (i - k + 1) * (j - l)\\n # print('+', k, l, i, j, s)\\n if s > ms:\\n ms = s\\n mi = i\\n mj = j - 1\\n else:\\n # in_x = (i >= ry1) and (i <= ry2)\\n while j < pj:\\n # print(k, l, i, j, pj)\\n if (j >= rx1) and (j <= rx2):\\n j = rx2 if j < pj else pj - 1\\n else:\\n if matrix[i][j] == '0':\\n break\\n j += 1\\n s = (i - k + 1) * (j - l)\\n # print('+', k, l, i, j, s)\\n if s > ms:\\n ms = s\\n mi = i\\n mj = j - 1\\n pj = j\\n i += 1\\n return ms, mi, mj\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # print(len(matrix), print(len(matrix[0])))\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n rs = 0\\n rx1 = -1\\n rx2 = -1\\n ry1 = -1\\n ry2 = -1\\n for i in range(n):\\n # pms = (n - i) * m\\n # if pms < ms:\\n # break\\n for j in range(m):\\n pms = (n - i) * (m - j)\\n if pms < ms:\\n break\\n s, ir, jr = self.mrec(matrix, i, j, rx1, rx2, ry1, ry2, ms)\\n if s > ms:\\n ms = s\\n if s > rs:\\n rx1 = j\\n rx2 = jr\\n ry1 = i\\n ry2 = ir\\n rs = s\\n i += 1\\n ry1 += 1\\n rs -= rx2 - rx1\\n return ms\\n\",\n \"runtime\": \"335\"\n },\n {\n \"code\": \"class Stack:\\n\\n def __init__(self):\\n self.arr = []\\n\\n def push(self, data):\\n self.arr.append(data)\\n\\n def pop(self):\\n if len(self.arr) == 0:\\n return -1\\n else:\\n y = self.arr.pop()\\n return y\\n\\n def len(self):\\n return len(self.arr)\\n\\n def top(self):\\n if len(self.arr) > 0:\\n return self.arr[-1]\\n else:\\n return -1e9 - 1\\n\\n def show(self):\\n return self.arr\\n\\n\\ndef pse(n, a):\\n # code here\\n\\n s = Stack()\\n b = n * [0]\\n\\n for i in range(n):\\n\\n while s.len() > 0 and a[s.top()] > a[i]:\\n s.pop()\\n if s.len() == 0:\\n b[i] = -1\\n s.push(i)\\n else:\\n b[i] = s.top()\\n s.push(i)\\n return b\\n\\n\\ndef nse(n, a):\\n # code here\\n\\n s = Stack()\\n b = n * [0]\\n\\n for i in range(n - 1, -1, -1):\\n while s.len() > 0 and a[s.top()] >= a[i]:\\n s.pop()\\n if s.len() == 0:\\n b[i] = n\\n s.push(i)\\n else:\\n b[i] = s.top()\\n s.push(i)\\n\\n return b\\ndef largestRectangleArea(heights) -> int:\\n\\n n = len(heights)\\n\\n left = pse(n,heights)\\n right = nse(n,heights)\\n #print(left,right)\\n ans = 0\\n for i in range(n):\\n if left[i] == -1:\\n if right[i] == n:\\n ans = max(ans,n*heights[i])\\n else:\\n ans = max(ans,(right[i]+1)*heights[right[i]],heights[i]*(right[i]))\\n else:\\n if right[i] == n:\\n ans = max(ans,(n-left[i])*(heights[left[i]]),(n-left[i]-1)*(heights[i]))\\n else:\\n ans = max(ans,(right[i]-left[i])*max(heights[left[i]],heights[right[i]]),(right[i]-left[i]-1)*heights[i])\\n return ans\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n \\n prefixmatrix =[[0 for i in range(len(matrix[0]))] for j in range(len(matrix))]\\n\\n for i in range(len(matrix[0])):\\n prefixmatrix[0][i] = int(matrix[0][i])\\n for j in range(1,len(matrix)):\\n if matrix[j][i] == \\\"0\\\":\\n prefixmatrix[j][i] = 0\\n else:\\n prefixmatrix[j][i] = prefixmatrix[j-1][i] + int(matrix[j][i])\\n ans = 0\\n print(prefixmatrix)\\n for i in prefixmatrix:\\n ans = max(ans,largestRectangleArea(i))\\n\\n return ans\\n\\n\\n\",\n \"runtime\": \"335\"\n },\n {\n \"code\": \"class Solution:\\n def find_max_vert_line(self, y, x):\\n if self.distances_matrix[y][x][0]:\\n return self.distances_matrix[y][x][0]\\n y_copy = y\\n val = 0\\n while y_copy<self.height and self.matrix[y_copy][x] == \\\"1\\\" :\\n val+=1\\n y_copy+=1\\n self.distances_matrix[y][x][0] = val\\n return self.distances_matrix[y][x][0]\\n\\n def find_max_horz_line(self, y, x):\\n if self.distances_matrix[y][x][1]:\\n return self.distances_matrix[y][x][1]\\n x_copy = x\\n val = 0\\n while x_copy<self.width and self.matrix[y][x_copy] == \\\"1\\\":\\n val+=1\\n x_copy+=1\\n self.distances_matrix[y][x][1] = val\\n return val\\n \\n def find_max_rect_in_local(self, y, x, current_max):\\n max_width = self.find_max_horz_line(y,x)\\n max_height = self.find_max_vert_line(y,x)\\n if max_height * max_width < current_max:\\n return current_max\\n for current_width in range(max_width, 0, -1):\\n if max_height * current_width < current_max:\\n return current_max\\n else:\\n row_counter = 1\\n for new_y in range(y+1, y+max_height):\\n if self.find_max_horz_line(new_y,x)>=current_width:\\n row_counter+=1\\n else:\\n break\\n new_max = row_counter*current_width\\n if new_max>current_max:\\n current_max=new_max\\n return current_max\\n \\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n self.matrix = matrix\\n current_max = 0\\n self.width=len(self.matrix[0])\\n self.height=len(self.matrix)\\n self.distances_matrix = [[[None,None] for _ in range(self.width)] for _ in range(self.height)]\\n # for y in range(0, len(self.matrix)):\\n # print(\\\"\\\".join(self.matrix[y]))\\n # print(self.find_max_rect_in_local(0,0))\\n for y in range(0, self.height):\\n for x in range(0, self.width):\\n if (self.width-x)*(self.height-y) < current_max:\\n break\\n # print(\\\"y:%s, x:%s, val:%s \\\"% (y, x, self.find_max_rect_in_local(y,x)))\\n current_max = self.find_max_rect_in_local(y,x, current_max)\\n return current_max\",\n \"runtime\": \"360\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m = len(matrix)\\n n = len(matrix[0])\\n def get_max_from_hist(heights):\\n n = len(heights)\\n left = [-1]*n\\n right = [-1] * n\\n \\n s = []\\n for i in range(n):\\n v = heights[i]\\n while s and heights[s[-1]]>v:\\n right[s[-1]] = i\\n s.pop()\\n s.append(i)\\n s = []\\n for i in range(n-1,-1,-1):\\n v = heights[i]\\n while s and heights[s[-1]]>v:\\n left[s[-1]] = i\\n s.pop()\\n s.append(i)\\n print(left)\\n print(right)\\n res = 0\\n for i in range(n):\\n l = left[i]\\n r = right[i]\\n if l==-1:\\n l = -1\\n if r==-1:\\n r = n\\n ans = (r-l-1)*heights[i]\\n if res<ans:\\n res = ans\\n print(l,r,i,heights[i],ans)\\n return res\\n # line\\n ans = 0\\n for k in range(m):\\n heights = [0]*n\\n for j in range(n):\\n h = 0\\n for i in range(k,m):\\n if matrix[i][j]=='1':\\n h+=1\\n else:\\n break\\n heights[j] = h\\n print(heights)\\n ans = max(ans,get_max_from_hist(heights))\\n return ans\\n\\n\\n\\n \",\n \"runtime\": \"360\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def mrec(matrix: List[List[str]], k, l, rx1, rx2, ry1, ry2, mms):\\n # print(k, l)\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n mi = -1\\n mj = -1\\n pj = m\\n i = k\\n while i < n:\\n if (n - k) * (pj - l) <= mms:\\n break\\n j = l\\n in_x = (i >= ry1) and (i <= ry2)\\n # print('i', i, j, pj)\\n if (pj <= rx1) or (l > rx2):\\n while j < pj:\\n # print(k, l, i, j, pj)\\n if matrix[i][j] == '0':\\n break\\n s = (i - k + 1) * (j - l + 1)\\n # print('+', k, l, i, j, s)\\n if s > ms:\\n ms = s\\n mi = i\\n mj = j\\n j += 1\\n else:\\n while j < pj:\\n # print(k, l, i, j, pj)\\n if in_x and (j >= rx1) and (j <= rx2):\\n j = rx2 if j < pj else pj - 1\\n s = (i - k + 1) * (j - l + 1)\\n else:\\n if matrix[i][j] == '0':\\n break\\n s = (i - k + 1) * (j - l + 1)\\n # print('+', k, l, i, j, s)\\n if s > ms:\\n ms = s\\n mi = i\\n mj = j\\n j += 1\\n pj = j\\n i += 1\\n return ms, mi, mj\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # print(len(matrix), print(len(matrix[0])))\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n rs = 0\\n rx1 = -1\\n rx2 = -1\\n ry1 = -1\\n ry2 = -1\\n for i in range(n):\\n # pms = (n - i) * m\\n # if pms < ms:\\n # break\\n for j in range(m):\\n pms = (n - i) * (m - j)\\n if pms < ms:\\n break\\n s, ir, jr = self.mrec(matrix, i, j, rx1, rx2, ry1, ry2, ms)\\n if s > ms:\\n ms = s\\n if s > rs:\\n rx1 = j\\n rx2 = jr\\n ry1 = i\\n ry2 = ir\\n rs = s\\n i += 1\\n ry1 += 1\\n rs -= rx2 - rx1\\n return ms\\n\",\n \"runtime\": \"385\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n def width(i):\\n arr = matrix[i]\\n count = 0\\n for k in range(len(arr)):\\n if arr[k] == \\\"1\\\":\\n count += 1\\n else:\\n count = 0 \\n arr[k] = count\\n \\n for i in range(len(matrix)):\\n width(i)\\n \\n matrix = np.array(matrix).T\\n \\n def leetcode88(i):\\n arr = matrix[i]\\n stack = []\\n\\n mx = 0 \\n \\n for k in range(len(arr)):\\n j = k\\n while stack and stack[-1][0] > arr[k]:\\n h, j = stack.pop()\\n mx = max(mx, h * (k - j))\\n stack.append([arr[k], j])\\n\\n k = len(arr)\\n while stack:\\n h, j = stack.pop()\\n mx = max(mx, h * (k - j))\\n return mx\\n \\n return max([leetcode88(i) for i in range(len(matrix))])\\n\\n\\n\",\n \"runtime\": \"385\"\n },\n {\n \"code\": \"import numpy as np\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix or not matrix[0]:\\n return 0\\n \\n # Convert matrix to numpy array for faster operations\\n matrix = np.array([[int(cell) for cell in row] for row in matrix], dtype=np.int32)\\n return self._maximal_rectangle_optimized(matrix)\\n \\n @staticmethod\\n def _maximal_rectangle_optimized(matrix):\\n rows, cols = matrix.shape\\n heights = np.zeros(cols, dtype=np.int32)\\n max_area = 0\\n \\n for row in range(rows):\\n # Update heights\\n heights = (heights + 1) * matrix[row]\\n \\n # Calculate max rectangle for current row\\n stack = [-1]\\n for i in range(cols + 1):\\n h = heights[i] if i < cols else 0\\n while stack[-1] != -1 and heights[stack[-1]] > h:\\n height = heights[stack.pop()]\\n width = i - stack[-1] - 1\\n max_area = max(max_area, height * width)\\n stack.append(i)\\n \\n return max_area\\n\",\n \"runtime\": \"411\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def mrec(matrix: List[List[str]], k, l, rx1, rx2, ry1, ry2, mms):\\n # print(k, l)\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n mi = -1\\n mj = -1\\n pj = m\\n i = k\\n while i < n:\\n if (n - k) * (pj - l) <= mms:\\n break\\n j = l\\n in_x = (i >= ry1) and (i <= ry2)\\n # print('i', i, j, pj)\\n while j < pj:\\n # print(k, l, i, j, pj)\\n if in_x and (j >= rx1) and (j <= rx2):\\n j = rx2\\n if j >= pj:\\n j = pj - 1\\n s = (i - k + 1) * (j - l + 1)\\n else:\\n if matrix[i][j] == '0':\\n break\\n s = (i - k + 1) * (j - l + 1)\\n # print('+', k, l, i, j, s)\\n if s > ms:\\n ms = s\\n mi = i\\n mj = j\\n j += 1\\n pj = j\\n i += 1\\n return ms, mi, mj\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # print(len(matrix), print(len(matrix[0])))\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n rs = 0\\n rx1 = -1\\n rx2 = -1\\n ry1 = -1\\n ry2 = -1\\n for i in range(n):\\n # pms = (n - i) * m\\n # if pms < ms:\\n # break\\n for j in range(m):\\n pms = (n - i) * (m - j)\\n if pms < ms:\\n break\\n s, ir, jr = self.mrec(matrix, i, j, rx1, rx2, ry1, ry2, ms)\\n if s > ms:\\n ms = s\\n if s > rs:\\n rx1 = j\\n rx2 = jr\\n ry1 = i\\n ry2 = ir\\n rs = s\\n i += 1\\n ry1 += 1\\n rs -= rx2 - rx1\\n return ms\\n\",\n \"runtime\": \"411\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_area = 0\\n matrix = [list(map(int, row)) for row in matrix]\\n R, C = len(matrix), len(matrix[0])\\n for r in range(len(matrix)):\\n heights = []\\n for c in range(C):\\n if matrix[r][c] == 0:\\n heights.append(0)\\n continue\\n r1 = r\\n while r1 + 1 < R and matrix[r1+1][c] == 1:\\n r1 += 1\\n heights.append(r1 - r + 1)\\n max_area = max(max_area, self.maxAreaInHistogram(heights))\\n \\n return max_area\\n\\n def maxAreaInHistogram(self, heights):\\n stack, max_area = [], 0\\n for height in heights + [-1]:\\n width = 0\\n while stack and stack[-1][0] >= height:\\n prev_height, prev_width = stack.pop()\\n width += prev_width\\n max_area = max(max_area, width * prev_height)\\n\\n stack.append((height, width + 1)) \\n \\n return max_area\\n\\n\\n'''\\nhistogram from every height\\ncalc prefix sums in n^2\\ngenerate histogram problem in n, n histogram problems\\n\\noverall n^2\\n'''\",\n \"runtime\": \"436\"\n },\n {\n \"code\": \"class Solution:\\n import sys\\n\\n def maxRectArea(self, ht):\\n n = len(ht)\\n\\n if n==1:\\n if ht[0] == 0:\\n return 0\\n elif ht[0] == 1:\\n return 1\\n\\n \\n ls = [-1]*n\\n rs = [n]*n\\n\\n maxArea = -1\\n\\n for i in range(0, n):\\n\\n for j in range(i-1, -1, -1):\\n if ht[j] < ht[i]:\\n ls[i] = j\\n break\\n\\n for k in range(i+1, n):\\n if ht[i] > ht[k]:\\n rs[i] = k\\n break\\n\\n area = (rs[i] - ls[i] - 1)*ht[i]\\n maxArea = max(maxArea, area)\\n\\n return maxArea\\n \\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n n = len(matrix)\\n m = len(matrix[0])\\n\\n if n==0:\\n return None\\n\\n ht = [0]*m\\n\\n maxArea = 0\\n\\n for i in range(0,n):\\n for j in range(0,m):\\n if matrix[i][j] == \\\"1\\\":\\n ht[j] += 1\\n\\n else: ht[j] = 0\\n\\n rowArea = self.maxRectArea(ht)\\n maxArea = max(maxArea, rowArea)\\n \\n return maxArea\",\n \"runtime\": \"436\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if matrix == []: return 0\\n else:\\n mat = [[0 for i in range(len(matrix[0]))] for j in range(len(matrix))]\\n for i in range(len(matrix)):\\n for j in range(len(matrix[i])):\\n if matrix[i][j] == \\\"1\\\":\\n hei = 0\\n idx = i\\n while idx < len(matrix):\\n if matrix[idx][j] == \\\"1\\\":\\n hei += 1\\n else: break\\n idx += 1\\n mat[i][j] = hei\\n result = 0\\n for i in range(len(mat)):\\n stack = [[0, mat[i][0]]]\\n for j in range(1, len(mat[i])):\\n idx = j\\n while stack != [] and stack[-1][1] > mat[i][j]:\\n val = stack[-1][1] * (j - stack[-1][0])\\n if result < val: result = val\\n idx = stack.pop()[0]\\n stack.append([idx, mat[i][j]])\\n while stack != []:\\n val = stack[-1][1] * (len(mat[i]) - stack[-1][0])\\n if result < val: result = val\\n stack.pop()\\n return result\\n \\n\",\n \"runtime\": \"461\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n rows = len(matrix)\\n cols = len(matrix[0])\\n \\n row_histogram = [0 for i in range(cols)]\\n\\n def get_max_rect_area(hist):\\n l = len(hist)\\n #prev less array\\n prev_less = [-1 for i in range(l)]\\n \\n for i in range(1,l):\\n for j in range(i-1,-1,-1):\\n if hist[i]>hist[j]:\\n prev_less[i]=j\\n break\\n #next less array\\n next_less = [-1 for i in range(l)]\\n \\n for i in range(l-1,-1,-1):\\n for j in range(i+1,l):\\n if hist[i]>hist[j]:\\n next_less[i]=j\\n break\\n \\n\\n\\n '''\\n counter = 0\\n prev_less = [-1 for i in range(l)]\\n while counter+1<l and hist[counter]>=hist[counter+1]:\\n counter+=1\\n\\n if counter<l-1:\\n min_ = hist[counter]\\n min_index=counter\\n for i in range(counter+1,l):\\n if min_ >= hist[i]:\\n prev_less[i] = -1\\n min_ = hist[i]\\n min_index = i\\n else:\\n prev_less[i] = min_index\\n '''\\n # next less array\\n '''\\n counter = l-1\\n next_less = [-1 for i in range(l)]\\n while counter-1>=0 and hist[counter-1]<=hist[counter]:\\n counter-=1\\n\\n if counter>0:\\n min_ = hist[counter]\\n min_index=counter\\n for i in range(counter-1,-1,-1):\\n if min_ >= hist[i]:\\n next_less[i] = -1\\n min_ = hist[i]\\n min_index = i\\n else:\\n next_less[i] = min_index\\n '''\\n \\n area = -1\\n for i in range(l):\\n width_left = i-prev_less[i]-1\\n ''' #above condition equivalent to below if else code\\n if prev_less[i]==-1:\\n width_left = i\\n else:\\n width_left = i-prev_less[i]-1\\n '''\\n width_right = 0\\n if next_less[i]==-1:\\n width_right = l-1-i\\n else:\\n width_right = next_less[i] - i -1\\n area = max(area, (width_left+width_right+1)*hist[i])\\n \\n if False:\\n print(\\\"\\\\n--------------------------------------\\\\nhistogram: \\\", end='')\\n for i in hist:\\n print(i, end= ' ')\\n print(\\\"\\\\nprev less: \\\",end='')\\n for i in prev_less:\\n print(i, end= ' ')\\n print(\\\"\\\\nnext less: \\\",end='')\\n for i in next_less:\\n print(i, end= ' ')\\n return area\\n\\n area = -1\\n\\n for i in range(rows):\\n for j in range(cols):\\n if matrix[i][j]=='1':\\n row_histogram[j]+=1\\n else:\\n row_histogram[j]=0\\n \\n area = max(area, get_max_rect_area(row_histogram))\\n \\n \\n return area\",\n \"runtime\": \"461\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n mat_1 = []\\n for y in range(len(matrix)):\\n temp = [0]*len(matrix[0])\\n mat_1.append(temp)\\n\\n cur_big = 0\\n for y in range(len(matrix)-1,-1,-1):\\n\\n\\n for x in range(len(matrix[0])-1,-1,-1):\\n\\n\\n if matrix[y][x] == \\\"1\\\":\\n if cur_big < 1: cur_big = 1\\n mat_1[y][x] += 1\\n if (x+1) < len(matrix[0]):\\n mat_1[y][x] += mat_1[y][x+1]\\n if cur_big < mat_1[y][x]: cur_big = mat_1[y][x]\\n \\n \\n #for x in mat_1:print(x)\\n\\n #for i in range(1,len(mat_1)):\\n temp = [0]*(len(mat_1[0])+5)\\n for x in range(len(mat_1[0])):\\n for i in range(len(temp)):temp[i]=0\\n for y in range(len(mat_1)):\\n len_x = mat_1[y][x]\\n for i in range(1,mat_1[y][x]+1):\\n temp[i] += 1\\n if temp[i]*i > cur_big: cur_big = temp[i]*i\\n \\n if (y+1) < len(mat_1) and mat_1[y+1][x] < len_x:\\n for i in range(mat_1[y+1][x]+1,len_x+1):\\n temp[i] = 0\\n\\n return cur_big\",\n \"runtime\": \"486\"\n },\n {\n \"code\": \"class Solution:\\n def f(self,array):\\n n=len(array)\\n result=[-1]*n\\n stack=[]\\n for i in range(n):\\n next_element=array[i]\\n while stack and array[stack[-1]]>next_element:\\n index=stack.pop()\\n result[index]=i\\n stack.append(i)\\n return result\\n def g(self,array):\\n n=len(array)\\n result=[-1]*n\\n stack=[]\\n for i in range(n-1,-1,-1):\\n next_element=array[i]\\n while stack and array[stack[-1]]>next_element:\\n index=stack.pop()\\n result[index]=i\\n stack.append(i)\\n return result\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n n=len(heights)\\n x=self.f(heights)\\n y=self.g(heights)\\n d=[0]*n\\n for i in range(n):\\n if x[i]==-1 and y[i]==-1:\\n d[i]=heights[i]*n\\n elif x[i]==-1 and y[i]!=-1:\\n d[i]=heights[i]*(n-y[i]-1)\\n elif y[i]==-1 and x[i]!=-1:\\n d[i]=heights[i]*(x[i])\\n else: \\n d[i]=heights[i]*(x[i]-y[i]-1) \\n return max(d)\\n \\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n \\n m=len(matrix)\\n n=len(matrix[0])\\n s=0\\n for i in range(m):\\n heights=[0]*n\\n for j in range(n):\\n k=0\\n while (k+i)<=m-1 and matrix[k+i][j]==\\\"1\\\":\\n k+=1\\n heights[j]=k\\n s=max(s,self.largestRectangleArea(heights))\\n return s\\n \\n\\n\",\n \"runtime\": \"486\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def largestRectangleArea(heights):\\n if not heights:\\n return 0\\n stack = [heights[0]]\\n maxi = 0\\n for item in heights[1:]:\\n if item >= stack[-1]:\\n stack.append(item)\\n else:\\n for i in range(len(stack)-1, -1, -1):\\n if stack[i] < item:\\n break\\n if i == 0:\\n i = -1\\n for j in range(i+1, len(stack)):\\n cur = stack[j]*(len(stack)-j)\\n if cur > maxi:\\n maxi = cur\\n for j in range(i+1, len(stack)):\\n stack[j] = item\\n stack.append(item)\\n for i in range(0, len(stack)):\\n cur = stack[i]*(len(stack)-i)\\n if cur > maxi:\\n maxi = cur\\n return maxi\\n \\n if not matrix:\\n return 0\\n maxi_matrix = 0\\n for i in range(0, len(matrix)):\\n heights = [0 for _ in range(0, len(matrix[0]))]\\n for j in range(0, len(matrix[0])):\\n for k in range(i, -1, -1):\\n if matrix[k][j] == '1':\\n heights[j] += 1\\n else:\\n break\\n maxi_line = largestRectangleArea(heights)\\n if maxi_line > maxi_matrix:\\n maxi_matrix = maxi_line\\n return maxi_matrix\",\n \"runtime\": \"537\"\n },\n {\n \"code\": \"import numpy as np \\nclass Solution:\\n \\n def find_largest_rectangle(self, heights): \\n\\n n = len(heights)\\n s = []\\n l = [-1] * n \\n r = [n] * n \\n for i in range(n): \\n while s and heights[s[-1]] >= heights[i]: \\n r[s[-1]] = i \\n s.pop()\\n \\n if s: \\n l[i] = s[-1]\\n s.append(i)\\n\\n return max([heights[i] * (r[i] - l[i]-1) for i in range(n)])\\n\\n def compute_heights(self, matrix, start_index=0):\\n # hard problem \\n m, n = len(matrix), len(matrix[0])\\n\\n heights = [0] * m\\n for i in range(m): \\n if matrix[i][start_index] == '0': \\n continue\\n for j in range(start_index, n): \\n if matrix[i][j] == '1': \\n heights[i] += 1\\n else:\\n break \\n return heights\\n\\n \\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n m, n = len(matrix), len(matrix[0]) \\n max_area = float('-inf')\\n for start_index in range(n):\\n heights = self.compute_heights(matrix, start_index)\\n area = self.find_largest_rectangle(heights)\\n max_area = max(max_area, area)\\n \\n return max_area\\n\\n \",\n \"runtime\": \"537\"\n },\n {\n \"code\": \"import numpy as np \\nclass Solution:\\n \\n def find_largest_rectangle(self, heights): \\n\\n n = len(heights)\\n s = []\\n l = [-1] * n \\n r = [n] * n \\n for i in range(n): \\n while s and heights[s[-1]] >= heights[i]: \\n r[s[-1]] = i \\n s.pop()\\n \\n if s: \\n l[i] = s[-1]\\n s.append(i)\\n\\n return max([heights[i] * (r[i] - l[i]-1) for i in range(n)])\\n\\n def compute_heights(self, matrix, start_index=0):\\n # hard problem \\n m, n = len(matrix), len(matrix[0])\\n\\n heights = [0] * m\\n for i in range(m): \\n if matrix[i][start_index] == '0': \\n continue\\n for j in range(start_index, n): \\n if matrix[i][j] == '1': \\n heights[i] += 1\\n else:\\n break \\n return heights\\n\\n \\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n m, n = len(matrix), len(matrix[0]) \\n max_area = float('-inf')\\n for start_index in range(n):\\n heights = self.compute_heights(matrix, start_index)\\n area = self.find_largest_rectangle(heights)\\n max_area = max(max_area, area)\\n \\n return max_area\\n\\n \",\n \"runtime\": \"562\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix:\\n return 0\\n\\n m, n = len(matrix), len(matrix[0])\\n ans = 0\\n for i in range(m):\\n # monotonic stk for each \\\"histogram\\\" max area\\n stk = []\\n h = [0]*n\\n for j in range(n):\\n # get height for (i, j)\\n j_h = 0\\n while i-j_h >= 0 and matrix[i-j_h][j] == '1':\\n j_h += 1\\n h[j] = j_h\\n\\n # check max area in stk\\n for idx, h in enumerate([0]+h+[0]):\\n print(stk)\\n while stk and stk[-1][1] >= h:\\n idx1, h1 = stk.pop()\\n if stk:\\n idx2, _ = stk[-1]\\n ans = max(ans, (idx-idx2-1)*h1)\\n stk.append((idx, h))\\n\\n return ans\",\n \"runtime\": \"562\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n # worst O(n**3)\\n \\n length = len(matrix[0])\\n width = len(matrix)\\n\\n for i in range(width):\\n for j in range(length):\\n matrix[i][j] = int(matrix[i][j])\\n\\n for row in range(width):\\n for col in range(length):\\n cur_cell = matrix[row][col]\\n directions = [(-1,0), (-1,-1), (0,-1)]\\n temp = []\\n\\n if cur_cell == 1:\\n for dr, dc in directions:\\n next_r = row + dr\\n next_c = col + dc\\n\\n if next_r in range(width) and next_c in range(length):\\n next_cell = matrix[next_r][next_c]\\n temp.append(next_cell)\\n else: temp.append(0)\\n matrix[row][col] = matrix[row][col] + min(temp)\\n \\n max_ans = 0\\n \\n # expansion\\n for i in range(width):\\n for j in range(length):\\n\\n current = matrix[i][j]\\n current_area_v = current * current\\n current_area_h = current * current\\n\\n if current >= 1:\\n # downward\\n for down in range(i+1, width):\\n if matrix[down][j] >= current:\\n current_area_v += current\\n else: break\\n\\n for right in range(j+1, length):\\n if matrix[i][right] >= current:\\n current_area_h += current\\n else: break\\n \\n max_ans = max(max_ans, current_area_v, current_area_h)\\n \\n return max_ans\",\n \"runtime\": \"587\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n # worst O(n**3)\\n \\n length = len(matrix[0])\\n width = len(matrix)\\n\\n # 每个正方形的点向下或者向右扩张\\n\\n for i in range(width):\\n for j in range(length):\\n matrix[i][j] = int(matrix[i][j])\\n\\n for row in range(width):\\n for col in range(length):\\n cur_cell = matrix[row][col]\\n directions = [(-1,0), (-1,-1), (0,-1)]\\n temp = []\\n\\n if cur_cell == 1:\\n for dr, dc in directions:\\n next_r = row + dr\\n next_c = col + dc\\n\\n if next_r in range(width) and next_c in range(length):\\n next_cell = matrix[next_r][next_c]\\n temp.append(next_cell)\\n else: temp.append(0)\\n matrix[row][col] = matrix[row][col] + min(temp)\\n \\n max_ans = 0\\n \\n # expansion\\n for i in range(width):\\n for j in range(length):\\n\\n current = matrix[i][j]\\n current_area_v = current * current\\n current_area_h = current * current\\n\\n if current >= 1:\\n # downward\\n for down in range(i+1, width):\\n if matrix[down][j] >= current:\\n current_area_v += current\\n else: break\\n\\n for right in range(j+1, length):\\n if matrix[i][right] >= current:\\n current_area_h += current\\n else: break\\n \\n max_ans = max(max_ans, current_area_v, current_area_h)\\n \\n return max_ans\",\n \"runtime\": \"587\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n N, M = len(matrix), len(matrix[0])\\n self.ans = 0\\n\\n def maxTriangleContaining(r, c):\\n row = r\\n min_width = float('inf')\\n area = 0\\n\\n while row < N and matrix[row][c] == '1':\\n width = 1\\n\\n for nc in range(c + 1, M):\\n if matrix[row][nc] != '1':\\n break\\n \\n width += 1\\n \\n min_width = min(min_width, width)\\n row += 1\\n\\n if min_width * (N - r) < self.ans:\\n break\\n \\n area = max(area, min_width * (row - r))\\n\\n return area\\n \\n for r in range(N):\\n for c in range(M):\\n if matrix[r][c] == '1':\\n self.ans = max(self.ans, maxTriangleContaining(r, c))\\n\\n return self.ans\",\n \"runtime\": \"613\"\n },\n {\n \"code\": \"class Solution:\\n def maxHist(self, ls, n):\\n ans = 0\\n for p, val in enumerate(ls):\\n w = 1\\n temp = p-1\\n while p != 0 and temp >= 0 and ls[temp] >= val:\\n w += 1\\n temp -= 1\\n temp = p+1\\n while temp < n and ls[temp] >= val:\\n w += 1\\n temp += 1\\n ans = max(ans, val*w)\\n return ans\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n matrix[0] = [int(i) for i in matrix[0]]\\n ans = max(0, self.maxHist(matrix[0], n))\\n for i in range(1, m):\\n for j in range(n):\\n matrix[i][j] = int(matrix[i][j])\\n if matrix[i][j] > 0:\\n matrix[i][j] += matrix[i-1][j]\\n ans = max(ans, self.maxHist(matrix[i], n))\\n # print(matrix)\\n return ans\",\n \"runtime\": \"613\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, arr: List[List[str]]) -> int:\\n m=len(arr)\\n n=len(arr[0])\\n for j in range(n):\\n arr[0][j]=eval(arr[0][j])\\n for i in range(1,m):\\n for j in range(n):\\n arr[i][j]=eval(arr[i][j])\\n if arr[i][j]==1:\\n arr[i][j]+=arr[i-1][j]\\n def largestRectangleArea(heights):\\n n_s=[-1]*len(heights)\\n p_s=[-1]*len(heights)\\n def next_smaller(arr):\\n s=[]\\n top=-1\\n for i in range(len(arr)):\\n while top>-1:\\n if arr[s[top]]>arr[i]:\\n n_s[s.pop(top)]=i\\n top-=1\\n else:\\n break\\n if top!=-1:\\n p_s[i]=s[top] \\n s.append(i)\\n top+=1\\n \\n m=0\\n l=0\\n r=0\\n next_smaller(heights)\\n for i in range(len(heights)):\\n l=p_s[i]\\n r=n_s[i]\\n if r==-1:\\n r=len(heights)\\n if m < heights[i]*(r-(l+1)):\\n m=heights[i]*(r-(l+1))\\n return m\\n mq=-1\\n for x in arr:\\n mq=max(mq,largestRectangleArea(x))\\n return mq\\n\\n \",\n \"runtime\": \"638\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n # worst O(n**3)\\n \\n length = len(matrix[0])\\n width = len(matrix)\\n\\n \\n # find maximal square\\n for i in range(width):\\n for j in range(length):\\n matrix[i][j] = int(matrix[i][j])\\n\\n for row in range(width):\\n for col in range(length):\\n cur_cell = matrix[row][col]\\n directions = [(-1,0), (-1,-1), (0,-1)]\\n temp = []\\n\\n if cur_cell == 1:\\n for dr, dc in directions:\\n next_r = row + dr\\n next_c = col + dc\\n\\n if next_r in range(width) and next_c in range(length):\\n next_cell = matrix[next_r][next_c]\\n temp.append(next_cell)\\n else: temp.append(0)\\n matrix[row][col] = matrix[row][col] + min(temp)\\n \\n max_ans = 0\\n \\n # expansion\\n # 每个正方形的点向下或者向右扩张\\n for i in range(width):\\n for j in range(length):\\n\\n current = matrix[i][j]\\n current_area_v = current * current\\n current_area_h = current * current\\n\\n if current >= 1:\\n # downward\\n for down in range(i+1, width):\\n if matrix[down][j] >= current:\\n current_area_v += current\\n else: break\\n\\n for right in range(j+1, length):\\n if matrix[i][right] >= current:\\n current_area_h += current\\n else: break\\n \\n max_ans = max(max_ans, current_area_v, current_area_h)\\n \\n return max_ans\",\n \"runtime\": \"638\"\n },\n {\n \"code\": \"from typing import List\\r\\nimport time\\r\\nclass Solution:\\r\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\r\\n def find_continuous(row: List[int]) -> List[tuple]:\\r\\n res = []\\r\\n last = 0\\r\\n start = -1\\r\\n end = -1\\r\\n for idx, item in enumerate(row):\\r\\n item = int(item)\\r\\n if item == 1 and last == 0:\\r\\n start = idx\\r\\n end = idx\\r\\n elif item == 0 and last == 1:\\r\\n res.append((start, end))\\r\\n start = -1\\r\\n end = -1\\r\\n elif item == 1:\\r\\n end = idx\\r\\n last = item\\r\\n if end != -1:\\r\\n res.append((start, end))\\r\\n return res\\r\\n def get_hists(matrix, row_index, start, end) -> tuple[List[int], int]:\\r\\n res = []\\r\\n max_height = 0\\r\\n for i in range(start, end+1):\\r\\n height = 0\\r\\n for j in range(row_index, -1, -1):\\r\\n if int(matrix[j][i]) == 1:\\r\\n height += 1\\r\\n else:\\r\\n break\\r\\n if height > max_height:\\r\\n max_height = height\\r\\n res.append(height)\\r\\n return res, max_height\\r\\n def calc_largest(heights: List[int]) -> int:\\r\\n stack = [] # Stack to store indices\\r\\n max_area = 0 # Initialize max area\\r\\n index = 0 # Current index\\r\\n\\r\\n while index < len(heights):\\r\\n # If this bar is higher than the bar on top stack, push it to stack\\r\\n if not stack or heights[index] >= heights[stack[-1]]:\\r\\n stack.append(index)\\r\\n index += 1\\r\\n else:\\r\\n # Pop the top\\r\\n top_of_stack = stack.pop()\\r\\n # Calculate the area with heights[top_of_stack]\\r\\n # as the smallest bar\\r\\n width = index if not stack else index - stack[-1] - 1\\r\\n area = heights[top_of_stack] * width\\r\\n # Update max area, if needed\\r\\n max_area = max(max_area, area)\\r\\n\\r\\n # Now pop the remaining bars from stack and calculate area\\r\\n while stack:\\r\\n top_of_stack = stack.pop()\\r\\n width = index if not stack else index - stack[-1] - 1\\r\\n area = heights[top_of_stack] * width\\r\\n max_area = max(max_area, area)\\r\\n return max_area\\r\\n\\r\\n rows = len(matrix)\\r\\n cols = len(matrix[0])\\r\\n max_area = 0\\r\\n for i in range(rows):\\r\\n continuous_range = find_continuous(matrix[i])\\r\\n for item in continuous_range:\\r\\n start = item[0]\\r\\n end = item[1]\\r\\n hists, maxh = get_hists(matrix, i, start, end)\\r\\n width = end - start + 1\\r\\n if maxh * width <= max_area:\\r\\n continue\\r\\n area = calc_largest(hists)\\r\\n if area > max_area:\\r\\n max_area = area\\r\\n return max_area\\r\\n \",\n \"runtime\": \"663\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # Brute force.\\n n_rows = len(matrix)\\n n_cols = len(matrix[0])\\n\\n def maxAreaIJ(i, j):\\n max_area = 0\\n max_j = n_cols - 1\\n for ii in range(i, n_rows):\\n if matrix[ii][j] != \\\"1\\\": break\\n for jj in range(j, n_cols+1):\\n if jj == n_cols or matrix[ii][jj] == \\\"0\\\":\\n max_j= min(jj-1, max_j)\\n area = (max_j - j + 1) * (ii - i + 1)\\n max_area = max(max_area, area)\\n break\\n \\n return max_area\\n \\n res = 0\\n for i in range(n_rows):\\n for j in range(n_cols):\\n # Stop early if res is already bigger than max possible.\\n if res > (n_cols - j) * (n_rows - i):\\n continue\\n res = max(res, maxAreaIJ(i,j))\\n \\n return res\\n \\n\\n\\n\\n \",\n \"runtime\": \"663\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n x=len(matrix[0]) # obtain dimensions of the matrix\\n y=len(matrix)\\n dict_x={} # dict for horizontal contiguous sequences a tile is in; key is xy coordinate of tile\\n visited=[0 for i in range(x*y)] # dict of visited positions\\n all_1=1\\n\\n \\n\\n for i in range(y): # traverse each row find all contiguous sequences of 1's\\n start=0\\n temp=[]\\n for j in range(x):\\n \\n if matrix[i][j]==\\\"1\\\":\\n temp.append(i*x + j)\\n\\n if j==x-1:\\n for elem in temp:\\n dict_x[elem]=[start,j]\\n\\n if matrix[i][j]=='0':\\n for elem in temp:\\n dict_x[elem]=[start,j-1]\\n temp=[]\\n start=j+1\\n all_1=0\\n if(all_1):\\n return x*y\\n \\n\\n\\n \\n \\n current=0 # current position \\n curr_size=0\\n greatest=0\\n\\n \\n \\n while(current < x*y): \\n curr_y=current//x # current x-coordinate\\n curr_x=current - curr_y*x # current y-coordinate\\n \\n position=curr_x + x*curr_y # position of tile as integer\\n \\n if(matrix[curr_y][curr_x]!=\\\"1\\\"):\\n current+=1\\n continue\\n \\n endpoint1=dict_x[position][0] # endpoints for the horizontal band of 1's\\n endpoint2=x\\n\\n for i in range(curr_y,y):\\n\\n position=i*x + curr_x\\n \\n if(position in dict_x.keys()):\\n endpoint1=max(endpoint1,dict_x[position][0])\\n endpoint2=min(endpoint2,dict_x[position][1])\\n length=1+i-curr_y\\n height=1 + endpoint2-endpoint1\\n curr_size = length*height\\n\\n\\n if curr_size>greatest:\\n greatest=curr_size\\n\\n for z in range(endpoint1,endpoint2+1):\\n visited[i*x + z]=1 # visited\\n \\n else:\\n visited[i*x + curr_x]=1 \\n break\\n \\n\\n current+=1\\n\\n \\n return greatest\",\n \"runtime\": \"688\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n for i in range(len(matrix)):\\n for j in range(len(matrix[i])):\\n matrix[i][j] = int(matrix[i][j])\\n # if matrix[i][j] == 1 and j-1 >= 0:\\n # matrix[i][j] = matrix[i][j] + matrix[i][j-1]\\n # print(matrix[i])\\n # print(\\\"__________________\\\")\\n\\n max_rect = 0\\n # print(matrix[0])\\n for i in range(len(matrix)):\\n base = 0\\n heigth = []\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == 1:\\n if i-1 >= 0:\\n matrix[i][j] += matrix[i-1][j]\\n count = 0\\n while heigth and heigth[-1] > matrix[i][j]:\\n count += 1\\n heigth.pop()\\n while count > 0:\\n heigth.append(matrix[i][j])\\n count -= 1\\n heigth.append(matrix[i][j])\\n base += 1\\n else:\\n heigth = []\\n base = 0\\n for k in range(len(heigth)):\\n # print(i, j, max_rect)\\n max_rect = max(max_rect, heigth[k] * (len(heigth) - k) )\\n # print(matrix[i])\\n return max_rect\",\n \"runtime\": \"688\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n rows = len(matrix)\\n cols = len(matrix[0])\\n dp = matrix.copy()\\n\\n dp[0] = list(map(int, dp[0]))\\n for r in range(1, rows):\\n for c in range(cols):\\n if int(dp[r][c]) > 0:\\n dp[r][c] = 1 + int(dp[r-1][c])\\n for row in dp:\\n print(row)\\n best_rec = 0\\n for r in range(rows):\\n for c in range(cols):\\n if int(dp[r][c]) == 0:\\n continue\\n current_val = int(dp[r][c])\\n\\n i,j = c, c \\n while i >= 0 and int(dp[r][i]) >= current_val:\\n i -= 1\\n while j < cols and int(dp[r][j]) >= current_val:\\n j += 1\\n i += 1\\n j -= 1\\n best_rec = max( (j - i + 1) * current_val , best_rec)\\n\\n return best_rec\\n \\n\\n\",\n \"runtime\": \"714\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n rows = len(matrix)\\n cols = len(matrix[0])\\n dp = matrix.copy()\\n\\n dp[0] = list(map(int, dp[0]))\\n for r in range(1, rows):\\n for c in range(cols):\\n if int(dp[r][c]) > 0:\\n dp[r][c] = 1 + int(dp[r-1][c])\\n for row in dp:\\n print(row)\\n best_rec = 0\\n for r in range(rows):\\n for c in range(cols):\\n if int(dp[r][c]) == 0:\\n continue\\n current_val = int(dp[r][c])\\n\\n i,j = c, c \\n while i >= 0 and int(dp[r][i]) >= current_val:\\n i -= 1\\n while j < cols and int(dp[r][j]) >= current_val:\\n j += 1\\n i += 1\\n j -= 1\\n best_rec = max( (j - i + 1) * current_val , best_rec)\\n\\n return best_rec\\n \\n\\n\",\n \"runtime\": \"714\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n ## Set intersection and memoization (first solution)\\n ## 23 LOC in 1:23:40 at 3:42 pm\\n ## 397 ms 17.23%, 21.58 MB 5.01%\\n ans, m, n = 0, len(matrix), len(matrix[0])\\n matrix = [[int(v) for v in row] for row in matrix]\\n mat = [set(j for j,v in enumerate(row) if v) for row in matrix]\\n # @cache\\n def widest(s):\\n ans, wid, prev = 0, 1, -5\\n for i in s:\\n if i == prev+1:\\n wid += 1\\n else:\\n wid = 1\\n ans = max(ans, wid)\\n prev = i\\n return ans\\n for i in range(m):\\n setter = mat[i]\\n w = widest(tuple(setter))\\n ans = max(ans, w)\\n for u in range(i+1, m):\\n setter &= mat[u]\\n w = widest(tuple(setter))\\n ans = max(ans, (u-i+1)*w)\\n return ans\\n\\n\\n\\n # ## WIP DP\\n # @cache\\n # def contig(i,j):\\n # if i==0 and j==0:\\n # return matrix[i][j]\\n \\n # if not i or not contig(i-1,j):\\n # return \\n\\n\\n\\n\\n # ## WIP - TLE 72/74 cases passed\\n # ## 14 LOC in 56:00\\n # ans, m, n = 0, len(matrix), len(matrix[0])\\n # matrix = [[int(v) for v in row] for row in matrix]\\n # for i,j in product(range(m), range(n)):\\n # if matrix[i][j]:\\n # maxv = n\\n # for u in range(i, m):\\n # for v in range(j, maxv):\\n # # area = (u-i+1)*(v-j+1)\\n # # print('i,j,u,v,a = ', i, j, u, v, area)\\n # if not matrix[u][v]:\\n # maxv = v\\n # break\\n # # elif area > ans:\\n # elif (area := (u-i+1)*(v-j+1)) > ans:\\n # ans = area\\n # return ans\\n\\n\\n\\n\\n # ## Still TLE\\n # ans, m, n = 0, len(matrix), len(matrix[0])\\n # matrix = [[int(v) for v in row] for row in matrix]\\n # # acc = [list(accumulate([0] + row)) for row in matrix]\\n # acc = [[0]*(n+1) for _ in range(m+1)]\\n # for i in range(m):\\n # for j in range(n):\\n # acc[i+1][j+1] = matrix[i][j] + acc[i+1][j]\\n # for j in range(n):\\n # for i in range(m):\\n # acc[i+1][j+1] += acc[i][j+1]\\n # # print('acc = ', acc)\\n # # print('len(acc) = ', len(acc))\\n # # print('len(acc[0]) = ', len(acc[0]))\\n # def area(i,j,u,v):\\n # # print(' area(', i, j, u, v, ') = ')\\n # return acc[u+1][v+1] + acc[i][j] - acc[i][v+1] - acc[u+1][j]\\n # # print('area = ', area(0, 0, 0, 0))\\n # # if m > 3 and n > 4:\\n # # print('area = ', area(1, 2, 3, 4))\\n # # for i,j in product(range(m), range(n)):\\n # # if matrix[i][j]:\\n # # for w,h in\\n # # if w*h >= ans and \\n # ans, m, n = 0, len(matrix), len(matrix[0])\\n # for i,j in product(range(m), range(n)):\\n # if matrix[i][j]:\\n # for h,w in product(range(1, m-i+1), range(1,n-j+1)):\\n # # print('testing i,j,h,w = ', i, j, h, w)\\n # if w*h >= ans and area(i,j,i+h-1,j+w-1) == h*w:\\n # ans = h*w\\n # return ans\\n\\n\\n # ## WIP BF - TLE 68/74 cases passed\\n # ## 13 LOC in 41:00 at 2:58 pm\\n # matrix = [[int(v) for v in row] for row in matrix]\\n # ans, m, n = 0, len(matrix), len(matrix[0])\\n # for i,j in product(range(m), range(n)):\\n # if matrix[i][j]:\\n # for h,w in product(range(1, m-i+1), range(1,n-j+1)):\\n # # print('testing i,j,h,w = ', i, j, h, w)\\n # if w*h >= ans:\\n # # Whole with early break\\n # whole = True\\n # for u,v in product(range(i,i+h), range(j,j+w)):\\n # # print(' u,v,m = ', u,v,matrix[u][v])\\n # # if matrix[u][v] == '0':\\n # if not matrix[u][v]:\\n # whole = False\\n # break\\n # if whole:\\n # # print(' WINNER i,j,h,w = ', i, j, h, w)\\n # ans = w*h\\n # # sumo = 0\\n # # for u,v in product(range(i,i+h), range(j,j+w)):\\n # # sumo += int(matrix[u][v])\\n # # if sumo == w*h:\\n # # ans = sumo\\n # # assert(area(i,j,u,v) == sumo)\\n # return ans\\n\\n\\n ## start 2024.07.30 Tue 1:58 pm\",\n \"runtime\": \"739\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # dp[i][j] 表示在第i行，以j-th 结尾的最长1子串的长度\\n # max(min(dp[k: l + 1][j]) * (l - k + 1))\\n # T: O(n * m^2)\\n # S: O(m*n)\\n if len(matrix) == 0 or len(matrix[0]) == 0:\\n return 0\\n \\n m = len(matrix)\\n n = len(matrix[0])\\n dp = [[0 for _ in range(n)] for _ in range(m)]\\n for i in range(m):\\n for j in range(n):\\n if i == 0 and j == 0:\\n dp[i][j] = int(matrix[i][j])\\n else:\\n if matrix[i][j] == \\\"0\\\":\\n dp[i][j] = 0\\n else:\\n dp[i][j] = dp[i][j - 1] + 1\\n \\n # print(dp)\\n max_area = 0\\n for j in range(n):\\n for k in range(m):\\n min_len = dp[k][j]\\n if min_len == 0:\\n continue\\n if max_area < min_len:\\n max_area = min_len\\n\\n for l in range(k + 1, m):\\n if dp[l][j] < min_len:\\n min_len = dp[l][j]\\n if min_len == 0:\\n break\\n\\n max_area = max(max_area, min_len * (l - k + 1))\\n \\n return max_area\\n\\n \",\n \"runtime\": \"739\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def mrec(matrix: List[List[str]], k, l, mms):\\n # print(k, l)\\n n = len(matrix)\\n m = len(matrix[0])\\n ms = 0\\n pj = m\\n i = k\\n while i < n:\\n # if (n - k) * (pj - l) <= mms:\\n # break\\n j = l\\n # print('i', i, j, pj)\\n while j < pj:\\n # print(k, l, i, j, pj)\\n if matrix[i][j] == '0':\\n break\\n j += 1\\n s = (i - k + 1) * (j - l)\\n # print('+', k, l, i, j, s)\\n if s > ms:\\n ms = s\\n pj = j\\n i += 1\\n return ms\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # print(len(matrix), print(len(matrix[0])))\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n for i in range(n):\\n for j in range(m):\\n pms = (n - i) * (m - j)\\n if pms < ms:\\n break\\n s = self.mrec(matrix, i, j, ms)\\n if s > ms:\\n ms = s\\n i += 1\\n return ms\\n\",\n \"runtime\": \"764\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, mat: List[List[str]]) -> int:\\n n = len(mat)\\n m = len(mat[0])\\n prevR = [int(i) for i in mat[0]]\\n maxAns = 0\\n mat[0] = prevR.copy()\\n for i in range(1,n):\\n for j in range(m):\\n mat[i][j] = int(mat[i][j])\\n if mat[i][j] == 1:\\n mat[i][j] = mat[i][j] + prevR[j]\\n prevR[j] = mat[i][j]\\n for i in range(n):\\n for j in range(m):\\n if mat[i][j] == 0:\\n continue\\n maxAns = max(maxAns , mat[i][j])\\n mini = mat[i][j]\\n for k in range(j+1,m):\\n if mat[i][k] == 0:\\n break\\n else:\\n if mat[i][k] < mini:\\n mini = mat[i][k]\\n maxAns = max(maxAns , (k-j+1)*mini)\\n return maxAns\\n \",\n \"runtime\": \"789\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def mrec(matrix: List[List[str]], k, l, mms):\\n # print(k, l)\\n n = len(matrix)\\n m = len(matrix[0])\\n ms = 0\\n pj = m\\n i = k\\n while i < n:\\n # if (n - k) * (pj - l) <= mms:\\n # break\\n j = l\\n # print('i', i, j, pj)\\n while j < pj:\\n # print(k, l, i, j, pj)\\n if matrix[i][j] == '0':\\n break\\n j += 1\\n s = (i - k + 1) * (j - l)\\n # print('+', k, l, i, j, s)\\n if s > ms:\\n ms = s\\n pj = j\\n i += 1\\n return ms\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # print(len(matrix), print(len(matrix[0])))\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n for i in range(n):\\n for j in range(m):\\n pms = (n - i) * (m - j)\\n if pms < ms:\\n break\\n s = self.mrec(matrix, i, j, ms)\\n if s > ms:\\n ms = s\\n i += 1\\n return ms\\n\",\n \"runtime\": \"789\"\n },\n {\n \"code\": \"class Solution:\\n def mrec(self, matrix: List[List[str]], k, l, rx1, rx2, ry1, ry2):\\n # print(k, l)\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n mi = -1\\n mj = -1\\n pj = m\\n i = k\\n while i < n:\\n j = l\\n in_x = (i >= ry1) and (i <= ry2)\\n # print('i', i, j, pj)\\n while j < pj:\\n # print(k, l, i, j, pj)\\n if in_x and (j >= rx1) and (j <= rx2):\\n j = rx2\\n if j >= pj:\\n j = pj - 1\\n s = (i - k + 1) * (j - l + 1)\\n else:\\n if matrix[i][j] == '0':\\n break\\n s = (i - k + 1) * (j - l + 1)\\n # print('+', k, l, i, j, s)\\n if s > ms:\\n ms = s\\n mi = i\\n mj = j\\n j += 1\\n pj = j\\n i += 1\\n return ms, mi, mj\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n print(len(matrix), print(len(matrix[0])))\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n rs = 0\\n rx1 = -1\\n rx2 = -1\\n ry1 = -1\\n ry2 = -1\\n for i in range(n):\\n pms = (n - i) * m\\n if pms < ms:\\n break\\n for j in range(m):\\n pms = (n - i) * (m - j)\\n if pms < ms:\\n break\\n s, ir, jr = self.mrec(matrix, i, j, rx1, rx2, ry1, ry2)\\n if s > ms:\\n ms = s\\n if s > rs:\\n rx1 = j\\n rx2 = jr\\n ry1 = i\\n ry2 = ir\\n rs = s\\n i += 1\\n ry1 += 1\\n rs -= rx2 - rx1\\n return ms\\n\",\n \"runtime\": \"815\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def helper(self, i, j, visited, matrix):\\n m, n = len(matrix), len(matrix[0])\\n if (i, j) in visited or i >= m or j >= n or matrix[i][j] == '0':\\n return\\n \\n self.helper(i + 1, j + 1, visited, matrix)\\n\\n i_max = i + 1\\n while True:\\n if i_max >= m or matrix[i_max][j] == '0':\\n break\\n i_max += 1\\n i_max -= 1\\n\\n if j == n - 1:\\n visited[(i, j)].add((i_max, j))\\n return\\n\\n j_max = j + 1\\n while True:\\n if j_max >= n or matrix[i][j_max] == '0':\\n break\\n j_max += 1\\n j_max -= 1\\n\\n if i == m - 1:\\n visited[(i, j)].add((i, j_max))\\n return\\n\\n if i == i_max and j == j_max:\\n visited[(i, j)].add((i, j))\\n return \\n \\n i_sub_max = i\\n j_sub_max = j\\n for i_sub, j_sub in visited[(i+1, j+1)]:\\n i_new = min(i_max, i_sub)\\n j_new = min(j_max, j_sub)\\n visited[(i, j)].add((i_new, j_new))\\n i_sub_max = max(i_sub_max, i_new)\\n j_sub_max = max(j_sub_max, j_new)\\n\\n if i_max > i_sub_max:\\n visited[(i, j)].add((i_max, j))\\n \\n if j_max > j_sub_max:\\n visited[(i, j)].add((i, j_max))\\n \\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n visited = defaultdict(set)\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n self.helper(i, j, visited, matrix)\\n\\n area = 0\\n for i, j in visited:\\n for k, l in visited[(i, j)]:\\n area = max(area, (k - i + 1) * (l - j + 1))\\n return area\\n\\n\\n \",\n \"runtime\": \"815\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_rect = 0\\n cumulative_row = [0] * len(matrix[0])\\n\\n for row in range(len(matrix)):\\n for column in range(len(matrix[0])):\\n if matrix[row][column] == '1':\\n cumulative_row[column] += 1\\n else:\\n cumulative_row[column] = 0\\n\\n # print(cumulative_row, self.get_max(cumulative_row))\\n max_rect = max(max_rect, self.get_max(cumulative_row))\\n \\n return max_rect\\n\\n def get_max(self, row: list[int]) -> int:\\n result = 0\\n\\n for limit in range(max(row) + 1):\\n local = 0\\n\\n for a in row:\\n local = (local + limit) if limit <= a else 0\\n result = max(result, local)\\n \\n return result\\n\",\n \"runtime\": \"840\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def helper(self, i, j, visited, matrix):\\n m, n = len(matrix), len(matrix[0])\\n if (i, j) in visited or i >= m or j >= n or matrix[i][j] == '0':\\n return\\n \\n self.helper(i + 1, j + 1, visited, matrix)\\n\\n i_max = i + 1\\n while True:\\n if i_max >= m or matrix[i_max][j] == '0':\\n break\\n i_max += 1\\n i_max -= 1\\n\\n if j == n - 1:\\n visited[(i, j)].add((i_max, j))\\n return\\n\\n j_max = j + 1\\n while True:\\n if j_max >= n or matrix[i][j_max] == '0':\\n break\\n j_max += 1\\n j_max -= 1\\n\\n if i == m - 1:\\n visited[(i, j)].add((i, j_max))\\n return\\n\\n if i == i_max and j == j_max:\\n visited[(i, j)].add((i, j))\\n return \\n \\n i_sub_max = i\\n j_sub_max = j\\n for i_sub, j_sub in visited[(i+1, j+1)]:\\n i_new = min(i_max, i_sub)\\n j_new = min(j_max, j_sub)\\n visited[(i, j)].add((i_new, j_new))\\n i_sub_max = max(i_sub_max, i_new)\\n j_sub_max = max(j_sub_max, j_new)\\n\\n if i_max > i_sub_max:\\n visited[(i, j)].add((i_max, j))\\n \\n if j_max > j_sub_max:\\n visited[(i, j)].add((i, j_max))\\n \\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n visited = defaultdict(set)\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n self.helper(i, j, visited, matrix)\\n\\n area = 0\\n for i, j in visited:\\n for k, l in visited[(i, j)]:\\n area = max(area, (k - i + 1) * (l - j + 1))\\n return area\\n\\n\\n \",\n \"runtime\": \"840\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_rect = 0\\n cumulative_row = [0] * len(matrix[0])\\n\\n for row in matrix:\\n cumulative_row = [\\n (cumulative_row[column] + 1) * (row[column] == '1')\\n for column in range(len(row))\\n ]\\n max_rect = max(max_rect, self.get_max(cumulative_row))\\n \\n return max_rect\\n\\n def get_max(self, row: list[int]) -> int:\\n result = 0\\n\\n for limit in row:\\n local = 0\\n\\n for a in row:\\n local = (local + limit) if limit <= a else 0\\n if result < local: result = local\\n \\n return result\\n\",\n \"runtime\": \"865\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # height->length so far\\n maxArea = 0\\n dp = [[None for i in range(len(matrix[0]))] for j in range(len(matrix))]\\n for row in range(len(matrix)):\\n record = dict()\\n for cal in range(len(matrix[0])):\\n if matrix[row][cal] == \\\"0\\\":\\n record = dict()\\n dp[row][cal] = 0\\n continue\\n if row == 0:\\n dp[row][cal] = 1\\n else:\\n dp[row][cal] = dp[row-1][cal] + 1 \\n height = dp[row][cal]\\n newRecord = dict()\\n for i in range(1,height+1):\\n if i not in record:\\n newRecord[i] = 1\\n maxArea = max(maxArea, i)\\n else:\\n \\n newRecord[i] = record[i] + 1\\n maxArea = max(maxArea, i * newRecord[i])\\n record = newRecord\\n return maxArea\\n \\n\\n \",\n \"runtime\": \"891\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n best = 0\\n largestRect = [[(0, 0)] for _ in range(len(matrix[0]) + 1)]\\n for row in matrix:\\n for j, entry in enumerate(row):\\n if entry == '0':\\n largestRect[j + 1] = [(0, 0)]\\n continue\\n maxWidth = largestRect[j][0][0] + 1\\n a = largestRect[j + 1]\\n res = [(maxWidth, 1)]\\n best = max(maxWidth, best)\\n for w, h in a:\\n if w > maxWidth:\\n res[0] = (maxWidth, h + 1)\\n best = max(maxWidth * (h + 1), best)\\n elif h + 1 > res[-1][1]:\\n res.append((w, h + 1))\\n best = max(w * (h + 1), best)\\n largestRect[j + 1] = res\\n \\n return best\",\n \"runtime\": \"891\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n dp = [[int(i) for i in row] for row in matrix]\\n for j in range(len(matrix[0])):\\n for i in range(len(matrix)-2,-1,-1):\\n if(dp[i][j] != 0):\\n dp[i][j] += dp[i+1][j]\\n print(dp)\\n best = 0\\n for i in range(len(matrix)):\\n for test_num in range(1, 201):\\n curr_best = 0\\n for j in range(len(matrix[0])):\\n if(dp[i][j]>=test_num):\\n curr_best += test_num\\n if(curr_best>best):\\n best= curr_best\\n else:\\n curr_best = 0\\n return best\\n \\n \\n \\n \\n \\n\\n \",\n \"runtime\": \"916\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_rect = 0\\n cumulative_row = [0] * len(matrix[0])\\n\\n for row in range(len(matrix)):\\n for column in range(len(matrix[0])):\\n if matrix[row][column] == '1':\\n cumulative_row[column] += 1\\n else:\\n cumulative_row[column] = 0\\n\\n # print(cumulative_row, self.get_max(cumulative_row))\\n max_rect = max(max_rect, self.get_max(cumulative_row))\\n \\n return max_rect\\n\\n def get_max(self, row: list[int]) -> int:\\n result = 0\\n\\n for limit in range(max(row) + 1):\\n local = 0\\n\\n for a in row:\\n local = (local + limit) * (limit <= a)\\n result = max(result, local)\\n \\n return result\\n\",\n \"runtime\": \"916\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n row = len(matrix)\\n col = len(matrix[0])\\n x=[0]*col\\n ans=0\\n for i in range(row):\\n y=[0]*(row+1)\\n for j in range(col):\\n if matrix[i][j]=='1':\\n x[j]+=1\\n for k in range(1,x[j]+1):\\n y[k]+=1\\n ans=max(ans,y[k]*k)\\n for k in range(x[j]+1,row+1):\\n y[k]=0\\n else:\\n x[j]=0\\n y=[0]*(row+1)\\n return ans\",\n \"runtime\": \"941\"\n },\n {\n \"code\": \"class Solution:\\r\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\r\\n li = len(matrix)\\r\\n lj = len(matrix[0])\\r\\n dp = [0] * lj\\r\\n res = 0\\r\\n for i in range(li):\\r\\n kj = -1\\r\\n for j in range(lj):\\r\\n if matrix[i][j] == \\\"1\\\":\\r\\n dp[j] += 1\\r\\n # ans = 0\\r\\n ymin = float(\\\"inf\\\")\\r\\n for k in range(j, kj, -1):\\r\\n ymin = min(ymin, dp[k])\\r\\n res = max(res, ymin * (j - k + 1))\\r\\n # res = max(res, ans)\\r\\n\\r\\n else:\\r\\n dp[j] = 0\\r\\n kj = j\\r\\n\\r\\n return res\\r\\n\\r\\n\",\n \"runtime\": \"941\"\n },\n {\n \"code\": \"class Solution:\\r\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\r\\n li = len(matrix)\\r\\n lj = len(matrix[0])\\r\\n dp = [0] * lj\\r\\n res = 0\\r\\n for i in range(li):\\r\\n kj = -1\\r\\n for j in range(lj):\\r\\n if matrix[i][j] == \\\"1\\\":\\r\\n dp[j] += 1\\r\\n ans = 0\\r\\n ymin = float(\\\"inf\\\")\\r\\n for k in range(j, kj, -1):\\r\\n ymin = min(ymin, dp[k])\\r\\n ans = max(ans, ymin * (j - k + 1))\\r\\n res = max(res, ans)\\r\\n\\r\\n else:\\r\\n dp[j] = 0\\r\\n kj = j\\r\\n\\r\\n return res\\r\\n\\r\\n\",\n \"runtime\": \"966\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m = len(matrix)\\n n = len(matrix[0])\\n\\n dp_right = [[0] * n for _ in range(m)]\\n dp_below = [[0] * n for _ in range(m)]\\n\\n for i in range(m):\\n if matrix[i][n-1] == \\\"1\\\":\\n dp_right[i][n-1] = 1\\n for i in range(m):\\n for j in range(n-2, -1, -1):\\n if matrix[i][j] == \\\"1\\\":\\n dp_right[i][j] = 1 + dp_right[i][j+1]\\n\\n for j in range(n):\\n if matrix[m-1][j] == \\\"1\\\":\\n dp_below[m-1][j] = 1\\n for j in range(n):\\n for i in range(m-2, -1, -1):\\n if matrix[i][j] == \\\"1\\\":\\n dp_below[i][j] = 1 + dp_below[i+1][j]\\n\\n res = 0\\n # Calculate maximal rectangle area\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == \\\"1\\\":\\n width = dp_right[i][j]\\n for k in range(dp_below[i][j]):\\n width = min(width, dp_right[i+k][j])\\n res = max(res, (k + 1) * width)\\n return res\\n\\n \",\n \"runtime\": \"992\"\n },\n {\n \"code\": \"def helper(i, j, d, r):\\n z = d[i][j]\\n if z==0: return 0\\n mn = 200\\n res = c = 0\\n for x in range(i, i+z):\\n c += 1\\n mn = min(mn, r[x][j])\\n res = max(res, c*mn)\\n return res\\nclass Solution:\\n def maximalRectangle(self, mat: List[List[str]]) -> int:\\n n = len(mat)\\n m = len(mat[0])\\n down = [[0]*m for i in range(n)]\\n right = [[0]*m for i in range(n)]\\n for i in range(n):\\n c = 0\\n for j in range(m-1, -1, -1):\\n if mat[i][j]==\\\"1\\\":\\n c += 1\\n else:\\n c = 0\\n right[i][j] = c\\n for j in range(m):\\n c = 0\\n for i in range(n-1, -1, -1):\\n if mat[i][j]==\\\"1\\\":\\n c += 1\\n else:\\n c = 0\\n down[i][j] = c\\n ans = 0\\n for i in range(n):\\n for j in range(m):\\n ans = max(ans, helper(i, j, down, right))\\n #print(i, j, ans)\\n return ans\",\n \"runtime\": \"992\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n mat_1 = []\\n for y in range(len(matrix)):\\n temp = []\\n for x in range(len(matrix[0])):\\n temp.append([0]*len(matrix))\\n mat_1.append(temp)\\n\\n print(len(matrix[0]),len(matrix))\\n cur_big = 0\\n for y in range(len(matrix)-1,-1,-1):\\n for x in range(len(matrix[0])-1,-1,-1):\\n if matrix[y][x] == \\\"1\\\":\\n if cur_big < 1: cur_big = 1\\n \\n mat_1[y][x][0] += 1\\n if (x+1) < len(matrix[0]):\\n mat_1[y][x][0] += mat_1[y][x+1][0]\\n if cur_big < mat_1[y][x][0]: cur_big = mat_1[y][x][0]\\n\\n if (y+1) < len(matrix):\\n min_1 = mat_1[y][x][0]\\n for i in range(1,len(matrix)):\\n if mat_1[y+1][x][i-1] == 0: break\\n mat_1[y][x][i] = mat_1[y+1][x][i-1]\\n if min_1 > mat_1[y][x][i]: min_1 = mat_1[y][x][i]\\n if cur_big < (i+1)*min_1: cur_big = (i+1)*min_1\\n\\n \\n\\n\\n #[1,1,5,1][0,0,0,0][1,3,3,0][0,0,0,0][0,0,0,0]\\n #[1,5,1] [0,0,0] [3,3,0] [2,2,1] [1,1,0]\\n #[5,1] [4,0] [3,0] [2,1] [1,0]\\n #[1] [0] [0] [1] [0]\\n \\n\\n return cur_big\",\n \"runtime\": \"1017\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_rect = 0\\n cumulative_row = [0] * len(matrix[0])\\n\\n for row in range(len(matrix)):\\n for column in range(len(matrix[0])):\\n if matrix[row][column] == '1':\\n cumulative_row[column] += 1\\n else:\\n cumulative_row[column] = 0\\n\\n # print(cumulative_row, self.get_max(cumulative_row))\\n max_rect = max(max_rect, self.get_max(cumulative_row))\\n \\n return max_rect\\n\\n def get_max(self, row: list[int]) -> int:\\n result = 0\\n\\n for limit in range(max(row) + 1):\\n local = 0\\n\\n for a in row:\\n local = (local + limit) * bool(limit <= a)\\n result = max(result, local)\\n \\n return result\\n\",\n \"runtime\": \"1017\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n n = len(matrix)\\n m = len(matrix[0])\\n\\n for j in range (m):\\n for i in range (n):\\n if i==0:\\n matrix[i][j] = 1 if matrix[i][j]=='1' else 0\\n elif matrix[i][j] == '1':\\n matrix[i][j] = 1+matrix[i-1][j]\\n else:\\n matrix[i][j] = 0\\n \\n ans = 0\\n for i in range (n):\\n for j in range (m):\\n if matrix[i][j]>0:\\n k = j-1\\n width = 1\\n height = matrix[i][j]\\n ans = max(ans, width*height)\\n while k>=0 and matrix[i][k]>0:\\n width+=1\\n height = min(height, matrix[i][k])\\n k-=1\\n ans = max(ans, width*height)\\n return ans\",\n \"runtime\": \"1042\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n max_area = 0\\n dp = [[0 for _ in range(len(matrix[0]))] for _ in range(len(matrix))]\\n\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n if j == 0:\\n dp[i][j] = 1 if matrix[i][j] == \\\"1\\\" else 0\\n continue\\n dp[i][j] = 1 + dp[i][j-1] if matrix[i][j] == \\\"1\\\" else 0\\n \\n\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n\\n min_width = dp[i][j]\\n\\n for h in range(i, -1, -1):\\n min_width = min(min_width, dp[h][j])\\n\\n if min_width == 0:\\n break\\n \\n max_area = max(max_area, min_width * (i - h + 1))\\n\\n return max_area\\n \",\n \"runtime\": \"1042\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n n_r, n_c = len(matrix), len(matrix[0])\\n\\n dp = [[0 for x in range(n_c)] for _ in range(n_r)]\\n\\n result = 0\\n \\n for r in range(n_r):\\n for c in range(n_c):\\n if matrix[r][c] == \\\"1\\\":\\n if c == 0:\\n dp[r][c] = 1\\n else:\\n dp[r][c] = 1 + dp[r][c-1]\\n\\n minWidth = dp[r][c]\\n for k in range (r, -1, -1):\\n if dp[k][c] == 0:\\n break\\n minWidth = min(minWidth, dp[k][c])\\n # print(f\\\"r, c, k: {r, c, k}\\\")\\n # print(f\\\"minWidth: {minWidth}, len:{r-k+1}\\\")\\n result = max(result, minWidth * (r-k+1))\\n # print(f\\\"dp[r]: {r, dp[r]}, result: {result}\\\")\\n\\n print(f\\\"dp: {dp}\\\")\\n return result\",\n \"runtime\": \"1067\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m,n = len(matrix),len(matrix[0])\\n ans = 0\\n dp = [[(0,0) for i in range(n)] for j in range(m)]\\n\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j]=='1':\\n x = dp[i][j-1][0]+1 if j>0 else 1\\n y = dp[i-1][j][1]+1 if i>0 else 1\\n dp[i][j] = [x,y]\\n ans = max(x,y,ans)\\n minWidth = x\\n\\n for r in range(i-1,i-y,-1):\\n minWidth = min(minWidth,dp[r][j][0])\\n ans = max(ans,minWidth*(i-r+1))\\n\\n return ans\",\n \"runtime\": \"1067\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n n = len(matrix)\\n m = len(matrix[0])\\n\\n for j in range (m):\\n for i in range (n):\\n if i==0:\\n matrix[i][j] = 1 if matrix[i][j]=='1' else 0\\n elif matrix[i][j] == '1':\\n matrix[i][j] = 1+matrix[i-1][j]\\n else:\\n matrix[i][j] = 0\\n \\n ans = 0\\n for i in range (n):\\n for j in range (m):\\n if matrix[i][j]>0:\\n k = j-1\\n width = 1\\n height = matrix[i][j]\\n ans = max(ans, width*height)\\n while k>=0 and matrix[i][k]>0:\\n width+=1\\n height = min(height, matrix[i][k])\\n k-=1\\n ans = max(ans, width*height)\\n return ans\",\n \"runtime\": \"1093\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m,n = len(matrix),len(matrix[0])\\n ans = 0\\n dp = [[(0,0) for i in range(n)] for j in range(m)]\\n\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j]=='1':\\n x = dp[i][j-1][0]+1 if j>0 else 1\\n y = dp[i-1][j][1]+1 if i>0 else 1\\n dp[i][j] = [x,y]\\n ans = max(ans,x,y)\\n minWidth = x\\n\\n for r in range(i-1,i-y,-1):\\n minWidth = min(minWidth,dp[r][j][0])\\n ans = max(ans,minWidth*(i-r+1))\\n\\n return ans\",\n \"runtime\": \"1093\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n answer = 0\\n\\n m = len(matrix)\\n n = len(matrix[0])\\n\\n successive_r = [[0] * n for _ in range(m)]\\n successive_c = [[0] * n for _ in range(m)]\\n\\n for r in range(m):\\n c = 0\\n while c < n:\\n if matrix[r][c] == \\\"1\\\":\\n c_start, c_end = c, c\\n while c_end < n and matrix[r][c_end] == \\\"1\\\":\\n c_end += 1\\n \\n for c_temp in range(c_start, c_end):\\n successive_c[r][c_temp] = c_end - c_temp\\n \\n c = c_end\\n else:\\n c += 1\\n\\n for c in range(n):\\n r = 0\\n while r < m:\\n if matrix[r][c] == \\\"1\\\":\\n r_start, r_end = r, r\\n while r_end < m and matrix[r_end][c] == \\\"1\\\":\\n r_end += 1\\n \\n for r_temp in range(r_start, r_end):\\n successive_r[r_temp][c] = r_end - r_temp\\n \\n r = r_end\\n else:\\n r += 1\\n\\n for r in range(m):\\n for c in range(n):\\n r_len, c_len = inf, inf\\n \\n r_count = successive_r[r][c]\\n for i in range(r_count):\\n r_temp = r + i\\n c_count = successive_c[r_temp][c]\\n\\n r_len = i + 1\\n c_len = min(c_len, c_count)\\n\\n answer = max(answer, r_len * c_len)\\n\\n return answer\\n\\n\\n \\n \\n\\n\\n \",\n \"runtime\": \"1118\"\n },\n {\n \"code\": \"class Solution:\\n def mrec(self, matrix: List[List[str]], k, l, rx1, rx2, ry1, ry2):\\n # print(k, l)\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n mi = -1\\n mj = -1\\n pj = m\\n i = k\\n while i < n:\\n j = l\\n # print('i', i, j, pj)\\n while j < pj:\\n # print(k, l, i, j, pj)\\n if (i >= ry1) and (i <= ry2) and (j >= rx1) and (j <= rx2):\\n j = rx2\\n if j >= pj:\\n j = pj - 1\\n s = (i - k + 1) * (j - l + 1)\\n else:\\n if matrix[i][j] == '0':\\n break\\n s = (i - k + 1) * (j - l + 1)\\n # print('+', k, l, i, j, s)\\n if s > ms:\\n ms = s\\n mi = i\\n mj = j\\n j += 1\\n pj = j\\n i += 1\\n return ms, mi, mj\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n rs = 0\\n rx1 = -1\\n rx2 = -1\\n ry1 = -1\\n ry2 = -1\\n for i in range(n):\\n for j in range(m):\\n s, ir, jr = self.mrec(matrix, i, j, rx1, rx2, ry1, ry2)\\n if s > ms:\\n ms = s\\n if s > rs:\\n rx1 = j\\n rx2 = jr\\n ry1 = i\\n ry2 = ir\\n rs = s\\n i += 1\\n ry1 += 1\\n rs -= rx2 - rx1\\n return ms\\n\",\n \"runtime\": \"1118\"\n },\n {\n \"code\": \"from typing import List,Optional\\nfrom collections import deque\\nimport sys\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]):\\n m,n = len(matrix),len(matrix[0])\\n \\n nseRow = [[0]*n for _ in range(m)]\\n for i in range(m):\\n stack = []\\n for j in range(n-1,-1,-1):\\n while(stack and int(matrix[i][stack[-1]])>=int(matrix[i][j])):stack.pop()\\n if(stack==[]):nseRow[i][j] = n\\n else:nseRow[i][j] = stack[-1]\\n stack.append(j)\\n \\n nseCol = [[0]*n for _ in range(m)]\\n for j in range(n):\\n stack = []\\n for i in range(m-1,-1,-1):\\n while(stack and int(matrix[stack[-1]][j])>=int(matrix[i][j])):stack.pop()\\n if(stack==[]):nseCol[i][j] = m\\n else:nseCol[i][j] = stack[-1]\\n stack.append(i)\\n \\n # print(nseRow)\\n # print(nseCol)\\n\\n area = 0\\n for i in range(m):\\n for j in range(n):\\n if(matrix[i][j]=='1'):\\n index = nseRow[i][j]\\n ans = m\\n for k in range(j,index):\\n ans = min(nseCol[i][k]-i,ans)\\n area = max(area,ans*(k-j+1))\\n return area\\n \\n# time complexity: O(m*n*m)\\n# space complexity: O(m*n)\",\n \"runtime\": \"1143\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n res, m, n = 0, len(matrix), len(matrix[0])\\n dp = [[0 for _ in range(n)] for _ in range(m)]\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == '1':\\n x = dp[i][j] = (dp[i][j - 1] if j > 0 else 0) + 1\\n for y in range(i + 1):\\n if dp[i - y][j] == 0:\\n break\\n x = min(x, dp[i - y][j])\\n res = max(res, x * (y + 1))\\n return res\",\n \"runtime\": \"1143\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n #dp[i][j] = maximal rectangle that can be built from row i, column j (including the (i,j) element)\\n ROWS, COLS = len(matrix), len(matrix[0])\\n dp = [[0 for _ in range(COLS)] for _ in range(ROWS)]\\n dp[0] = [1 if matrix[0][i] == \\\"1\\\" else 0 for i in range(COLS)]\\n\\n cnt = 0\\n largest_area = 0\\n for i in range(COLS):\\n if matrix[0][i] == \\\"1\\\":\\n cnt += 1\\n largest_area = max(largest_area, cnt)\\n else:\\n cnt = 0\\n\\n for r in range(1, ROWS):\\n if matrix[r][0] == \\\"1\\\":\\n dp[r][0] = 1 + dp[r-1][0]\\n largest_area = max(largest_area, dp[r][0])\\n\\n for c in range(1, COLS):\\n curr_height = ROWS\\n if matrix[r][c] == \\\"1\\\":\\n dp[r][c] = 1 + dp[r-1][c]\\n for cpt in range(c, -1, -1):\\n if matrix[r][cpt] == \\\"0\\\":\\n break\\n curr_height = min(curr_height, dp[r][cpt])\\n largest_area = max(largest_area, (c-cpt+1) * curr_height)\\n if r == ROWS-1:\\n print(cpt, curr_height)\\n return largest_area\\n \\n \",\n \"runtime\": \"1168\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, mat: List[List[str]]) -> int:\\n \\n n=len(mat)\\n m=len(mat[0])\\n\\n dp=[[0 for i in range(m)] for j in range(n)]\\n ans=[[0 for i in range(m)] for j in range(n)]\\n\\n for j in range(m):\\n dp[0][j]=int(mat[0][j])\\n \\n for i in range(1,n):\\n for j in range(m):\\n if mat[i][j]!='0':\\n #print(dp[i-1][j])\\n dp[i][j]=1+dp[i-1][j]\\n \\n for i in range(n):\\n for j in range(m):\\n mini=dp[i][j]\\n cnt=1\\n for k in range(j,-1,-1):\\n mini=min(mini,dp[i][k])\\n if mini==0:\\n break\\n ans[i][j]=max(ans[i][j],cnt*mini)\\n cnt+=1\\n\\n # for i in dp:\\n # print(i)\\n # for i in ans:\\n # print(i)\\n return max([max(i) for i in ans])\\n\\n\",\n \"runtime\": \"1168\"\n },\n {\n \"code\": \"import numpy as np\\n\\ndef largestRectangleArea(heights):\\n if max(heights) == 0: return 0\\n heights_unique = np.unique(heights).astype(int)\\n height_to_unique_heights_idcs = np.zeros(np.max(heights)+1,dtype=int)\\n for x in range(max(heights)+1):\\n if x in heights_unique:\\n height_to_unique_heights_idcs[x] = np.where(x==heights_unique)[0][0]\\n buffer_height_unique_rolling_length = np.zeros(shape=len(heights_unique)).astype(int)\\n largest_s = 0\\n #heights_unique_idx_prev_best\\n for idx, height in enumerate(heights):\\n heights_unique_idx = height_to_unique_heights_idcs[height]\\n buffer_height_unique_rolling_length[:heights_unique_idx+1] += 1 #heights_unique[:heights_unique_idx]\\n buffer_height_unique_rolling_length[heights_unique_idx+1:] = 0\\n \\n curr_largest_s = np.max(buffer_height_unique_rolling_length[:heights_unique_idx+1] * \\n heights_unique[:heights_unique_idx+1])\\n \\n \\n largest_s = max(largest_s, curr_largest_s)\\n \\n\\n return largest_s\\n\\n \\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]], verbose=False) -> int:\\n matrix_rolling_sum_vertical = [[int(x) for x in matrix[0]]]\\n for row in matrix[1:]:\\n matrix_rolling_sum_vertical.append([(x+1) * int(v) for x, v in zip(matrix_rolling_sum_vertical[-1], row)])\\n if verbose:\\n print(\\\"matrix_rolling_sum_vertical:\\\\n\\\", np.array(matrix_rolling_sum_vertical))\\n\\n max_size = 0\\n for row in matrix_rolling_sum_vertical:\\n new_largest_rectangle = largestRectangleArea(row)\\n if verbose: print(new_largest_rectangle)\\n max_size = max(max_size, new_largest_rectangle)\\n return max_size\\n \",\n \"runtime\": \"1194\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n self.max = 0 \\n self.row, self.col = len(matrix), len(matrix[0])\\n self.compute(matrix)\\n \\n return(self.max)\\n\\n def compute(self, matrix):\\n\\n stack_ = []\\n\\n for i in range(self.row):\\n row_query = matrix[i]\\n for j in range(i):\\n combined, area = self.compute_area(row_query, stack_[j],i ,j)\\n stack_[j] = combined.copy()\\n \\n \\n area_row = self.check(row_query)\\n if area_row>self.max:\\n self.max = area_row\\n stack_ += [row_query]\\n\\n def check(self, row):\\n\\n temp = []\\n area = 0 \\n for i in range(self.col):\\n\\n if row[i]==\\\"1\\\" :\\n area+=1 \\n else:\\n if area>0:\\n if area>self.max:\\n self.max = area\\n area = 0 \\n\\n if area>0:\\n if area>self.max:\\n self.max = area \\n return area\\n\\n def compute_area(self, query, base, index, indexs):\\n\\n temp = []\\n area = 0 \\n for i in range(self.col):\\n\\n if query[i]==\\\"1\\\" and base[i]==\\\"1\\\":\\n temp+=[\\\"1\\\"]\\n area+=index-indexs+1 \\n else:\\n if area>0:\\n if area>self.max:\\n self.max = area\\n area = 0 \\n temp+=[\\\"0\\\"]\\n\\n if area>0:\\n if area>self.max:\\n self.max = area \\n return temp, area\",\n \"runtime\": \"1194\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n left_store = [[1] * len(matrix[0]) for _ in range(len(matrix))]\\n for i in range(len(matrix)):\\n j = len(matrix[0])-1\\n cnt = 0\\n while j >=0:\\n if matrix[i][j]==\\\"1\\\":\\n cnt+=1\\n else:\\n cnt= 0\\n left_store[i][j] = cnt\\n j-=1\\n print(left_store)\\n res = 0\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n maxLen = left_store[i][j]\\n maxArea = maxLen\\n c = i\\n while c+1 < len(matrix) and matrix[c+1][j] == \\\"1\\\":\\n c += 1\\n maxLen = min(maxLen, left_store[c][j])\\n maxArea = max(maxArea, (c - i + 1)*maxLen)\\n res = max(maxArea, res)\\n return res\\n\\n\",\n \"runtime\": \"1219\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def check_col(r,c):\\n if r==len(matrix) or matrix[r][c]=='0':\\n return 0\\n matrix[r][c] = check_col(r+1,c) + 1\\n return matrix[r][c]\\n\\n def check_row(r,c):\\n global max_rec\\n min_col = 1e9\\n count = 0\\n while not(c+count==len(matrix[0]) or matrix[r][c+count]=='0'):\\n count+=1\\n min_col = min(min_col, check_col(r,c+count-1))\\n max_rec = max(max_rec, count*min_col)\\n if (len(matrix[0])-c)*min_col<max_rec:\\n return\\n \\n global max_rec\\n max_rec = 0\\n for c in range(len(matrix[0])):\\n for r in range(len(matrix)):\\n check_row(r,c)\\n return max_rec\",\n \"runtime\": \"1219\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_rect = 0\\n cumulative_row = [0] * len(matrix[0])\\n\\n for row in range(len(matrix)):\\n for column in range(len(matrix[0])):\\n if matrix[row][column] == '1':\\n cumulative_row[column] += 1\\n else:\\n cumulative_row[column] = 0\\n\\n # print(cumulative_row, self.get_max(cumulative_row))\\n max_rect = max(max_rect, self.get_max(cumulative_row))\\n \\n return max_rect\\n\\n def get_max(self, row: list[int]) -> int:\\n rows: list[list[int]] = []\\n\\n for number in range(max(row) + 1):\\n rows.append([\\n number if number <= a else 0\\n for a in row\\n ])\\n\\n return max(\\n max(a) * self.get_max_same_nums(a)\\n for a in rows\\n )\\n\\n def get_max_same_nums(self, nums: list[int]) -> int:\\n result = 1\\n local = 1\\n\\n for index in range(1, len(nums)):\\n local = local + 1 if nums[index] and nums[index] == nums[index - 1] else 1\\n result = max(result, local)\\n\\n return result\",\n \"runtime\": \"1244\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # 200*200*200*200\\n self.precompute(matrix)\\n print(self.down_matrix)\\n largest = 0\\n for i, row in enumerate(matrix):\\n for j, num in enumerate(row):\\n if matrix[i][j] == \\\"1\\\":\\n count = self.find_rect(matrix, i, j)\\n largest = max(largest, count)\\n return largest\\n\\n def precompute(self, matrix):\\n self.down_matrix = [[0 for j in range(len(matrix[0]))] for i in range(len(matrix))]\\n for i in range(len(matrix)-1, -1, -1):\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == \\\"1\\\":\\n prev = 0\\n if i+1 < len(matrix):\\n prev = self.down_matrix[i+1][j]\\n self.down_matrix[i][j] = prev + 1\\n \\n def find_rect(self, matrix, i, j):\\n # O(200)\\n depths = []\\n for c in range(j, len(matrix[0])):\\n if matrix[i][c] == \\\"0\\\":\\n break\\n depths.append(self.down_matrix[i][c])\\n \\n largest = 1\\n smallest = depths[0]\\n for count, depth in enumerate(depths):\\n smallest = min(smallest, depth)\\n area = (count+1) * smallest\\n largest = max(largest, area)\\n return largest\\n\\n # def go_down(self, matrix, row, columns):\\n # count = 1\\n # row += 1\\n # break_flag = False\\n # while row < len(matrix) and not break_flag:\\n # for column in columns:\\n # if matrix[row][column] == \\\"0\\\":\\n # break_flag = True\\n # break\\n # row += 1\\n # if not break_flag:\\n # count += 1\\n # return count\",\n \"runtime\": \"1244\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def check_col(r,c):\\n if r==len(matrix) or matrix[r][c]=='0':\\n return 0\\n matrix[r][c] = check_col(r+1,c) + 1\\n return matrix[r][c]\\n\\n def check_row(r,c):\\n global max_rec\\n min_col = 1e9\\n count = 0\\n while not(c+count==len(matrix[0]) or matrix[r][c+count]=='0'):\\n count+=1\\n min_col = min(min_col, check_col(r,c+count-1))\\n max_rec = max(max_rec, count*min_col)\\n if (len(matrix[0])-c)*min_col<max_rec:\\n return\\n \\n global max_rec\\n max_rec = 0\\n for c in range(len(matrix[0])):\\n for r in range(len(matrix)):\\n check_row(r,c)\\n return max_rec\",\n \"runtime\": \"1269\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n '''\\n Review\\n Given\\n -matrix of 0s and 1s where there's at least 1 row and 1 col\\n Want\\n -Find the largest rectangle containing only 1s and return its area (or 0 if no such value exists)\\n \\n Analysis\\n -What is a rectangle?\\n -Starting from the top left 1, go straight down until end of matrix or 0, that is the first rectangle it's in\\n -From there, move to the right and do the same, respecting the shortest height between each column of 1s\\n -Repeat until you get to the right end of the matrix or get to 0\\n -Repeat all that for every 1 in the matrix => O(nm*nm) in the worst case\\n \\n -Optimization: using next smaller than elements to avoid re-processing the size of the columns of 1s and just pick the smallest\\n -Starting from the top left 1, find the location of its vertical next smaller, that height is the size of the first rectangle\\n -Move to the right for as many 1s as there are to the right of the top left 1, determine the location of vertical next smaller\\n -pick the shortest height and respect that in determining the size of the rectangle and save the shortest height and largest rectangle O(nm * m) in worst case \\n \\n Overall Optimized Flow\\n Identify each vertical next smaller for all 1s\\n For each 1, perform max rectangle calculation if it's top left in rectangle and save if the largest overall\\n Return the largest rectangle\\n '''\\n verticalNextSmallers = self.getVerticalNextSmallers(matrix)\\n maxRectangle = 0\\n \\n for r in range(len(matrix)):\\n for c in range(len(matrix[0])):\\n if matrix[r][c] == '1':\\n curMaxRect = self.findMaxRectangleForElement(matrix, r, c, verticalNextSmallers)\\n maxRectangle = max(maxRectangle, curMaxRect)\\n \\n return maxRectangle\\n \\n def getVerticalNextSmallers(self, matrix):\\n # default value: row = beyond the last element of the matrix; col = current element index in row\\n # set the row beyond the matrix so it can be used to define the vertical length correctly when there is no next smaller\\n nextSmallerMatrix = [[(len(matrix), i) for i in range(len(row))] for row in matrix]\\n \\n stack = deque()\\n \\n for c in range(len(matrix[0])):\\n for r in range(len(matrix)):\\n while stack and matrix[r][c] == '0':\\n elementWithNextSmaller = stack.pop()\\n nextSmallerMatrix[elementWithNextSmaller[0]][elementWithNextSmaller[1]] = (r, c)\\n \\n # only care to process the 1s\\n if matrix[r][c] == '1':\\n stack.append((r, c))\\n \\n # looking into new column\\n stack.clear()\\n \\n \\n return nextSmallerMatrix\\n \\n def findMaxRectangleForElement(self, matrix, r, c, nextSmallers):\\n curCol = c\\n largestRectangle = 0\\n shortestHeight = len(matrix)\\n \\n while curCol < len(matrix[0]) and matrix[r][curCol] == '1':\\n nextSmallerLocation = nextSmallers[r][curCol]\\n \\n # vertical length is the distance between the index of the next smaller (or the length\\n # of the matrix itself) and the current row\\n verticalLength = nextSmallerLocation[0] - r\\n \\n # use the shortest height to determine the rectangle area\\n shortestHeight = min(shortestHeight, verticalLength)\\n \\n # area is the shortest height * width of rectangle\\n curRectangleArea = shortestHeight * (curCol - c + 1)\\n \\n # update the var for the loop\\n curCol += 1\\n \\n # save the largest rectangle for the given (r, c) element\\n largestRectangle = max(largestRectangle, curRectangleArea)\\n \\n return largestRectangle\",\n \"runtime\": \"1269\"\n },\n {\n \"code\": \"from functools import cache\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n @cache\\n def dp(i, j):\\n # return largest square, largest rectangle\\n # largest square, longest row, longest column, largest rect area\\n if i == m or j == n or matrix[i][j] == \\\"0\\\":\\n return 0, 0, 0, 0\\n\\n # largest square\\n len_square = 1 + min(dp(i, j + 1)[0], dp(i + 1, j)[0], dp(i + 1, j + 1)[0])\\n\\n # longest row\\n len_row = 1 + dp(i, j + 1)[1]\\n\\n # longest column\\n len_col = 1 + dp(i + 1, j)[2]\\n\\n # find the area of the maximum rectangle\\n bottom_len = len_square\\n max_area = len_square ** 2\\n k1 = i\\n k2 = j + len_square\\n val = dp(k1, k2)\\n while k2 <= n and val[0]:\\n bottom_len = min(bottom_len, val[2])\\n max_area = max(max_area, bottom_len * (k2 - j + 1))\\n k2 += 1\\n val = dp(k1, k2)\\n \\n right_len = len_square\\n k1 = i + len_square\\n k2 = j\\n val = dp(k1, k2)\\n while k1 <=m and val[0]:\\n right_len = min(right_len, val[1])\\n max_area = max(max_area, right_len * (k1 - i + 1))\\n k1 += 1\\n val = dp(k1, k2)\\n\\n return len_square, len_row, len_col, max_area\\n\\n ans = 0\\n m = len(matrix)\\n n = len(matrix[0])\\n for i in range(m):\\n for j in range(n):\\n ans = max(ans, dp(i, j)[3])\\n \\n return ans\",\n \"runtime\": \"1295\"\n },\n {\n \"code\": \"from functools import cache\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n @cache\\n def dp(i, j):\\n # return largest square, largest rectangle\\n # largest square, longest row, longest column, largest rect area\\n if i == m or j == n or matrix[i][j] == \\\"0\\\":\\n return 0, 0, 0, 0\\n\\n # largest square\\n len_square = 1 + min(dp(i, j + 1)[0], dp(i + 1, j)[0], dp(i + 1, j + 1)[0])\\n\\n # longest row\\n len_row = 1 + dp(i, j + 1)[1]\\n\\n # longest column\\n len_col = 1 + dp(i + 1, j)[2]\\n\\n # find the area of the maximum rectangle\\n bottom_len = len_square\\n max_area = len_square ** 2\\n k1 = i\\n k2 = j + len_square\\n val = dp(k1, k2)\\n while k2 <= n and val[0]:\\n bottom_len = min(bottom_len, val[2])\\n max_area = max(max_area, bottom_len * (k2 - j + 1))\\n k2 += 1\\n val = dp(k1, k2)\\n \\n right_len = len_square\\n k1 = i + len_square\\n k2 = j\\n val = dp(k1, k2)\\n while k1 <=m and val[0]:\\n right_len = min(right_len, val[1])\\n max_area = max(max_area, right_len * (k1 - i + 1))\\n k1 += 1\\n val = dp(k1, k2)\\n\\n return len_square, len_row, len_col, max_area\\n\\n ans = 0\\n m = len(matrix)\\n n = len(matrix[0])\\n for i in range(m):\\n for j in range(n):\\n ans = max(ans, dp(i, j)[3])\\n \\n return ans\",\n \"runtime\": \"1295\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n n = len(matrix)\\n m = len(matrix[0])\\n ans = 0\\n\\n next_max_seen = {}\\n max_seen = {}\\n for i in range(n):\\n if \\\"1\\\" not in matrix[i]:\\n max_seen = {}\\n continue\\n last_one = -1\\n for j in range(m):\\n if matrix[i][j] == \\\"1\\\":\\n for start_j in range(last_one, j):\\n rect_area = j-start_j\\n cand = (j,start_j)\\n if cand in max_seen:\\n rect_area += max_seen[cand]\\n next_max_seen[cand] = rect_area\\n ans = max(ans, rect_area)\\n else:\\n last_one = j\\n \\n max_seen = next_max_seen\\n next_max_seen = {}\\n \\n return ans\\n \",\n \"runtime\": \"1320\"\n },\n {\n \"code\": \"class Solution:\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n dp = [[[0] for cell in row] for row in matrix]\\n max_area = 0\\n\\n for i, row in enumerate(matrix):\\n for j, cell in enumerate(row):\\n\\n if cell == '0':\\n continue\\n\\n h = 1 if i == 0 else 1 + dp[i - 1][j][0]\\n dp[i][j][0] = h\\n\\n max_area = max(max_area, h)\\n\\n for k in range(1, j + 1):\\n # print(i, j, k, i, j - k, k - 1)\\n a = dp[i][j - 1][k - 1] if len(dp[i][j - 1]) >= k else 0\\n\\n if a == 0:\\n break\\n\\n h = min(h, a)\\n dp[i][j].append(h)\\n\\n max_area = max(max_area, h * (k + 1))\\n\\n # print(i, dp[i])\\n # print('----')\\n\\n return max_area\\n\\n\\n # def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n # dp = [[[set()] for cell in row] for row in matrix]\\n # max_area = 0\\n\\n # for i, row in enumerate(matrix):\\n # for j, cell in enumerate(row):\\n\\n # if cell == '0':\\n # continue\\n \\n # left_rects = set() if i == 0 else dp[i - 1][j][0]\\n # up_rects = set() if j == 0 else dp[i][j - 1][0]\\n\\n # if len(left_rects) == 0 and len(up_rects) == 0:\\n # dp[i][j].add((1, 1))\\n # continue\\n\\n # for l in left_rects:\\n # for u in up_rects:\\n # x = min(1 + l[0], u[0])\\n # y = min(l[1], 1 + u[1])\\n\\n # max_area = max(max_area, x * y)\\n \\n # return max_area\\n\\n\\n # def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n # dp = [[[(0, 0)] for cell in row] for row in matrix]\\n\\n # for i, row in enumerate(matrix):\\n # for j, cell in enumerate(row):\\n\\n # if cell == '0':\\n # dp[i][j] = (0, 0)\\n # continue\\n\\n # dist_left = 1 if i == 0 else 1 + dp[i - 1][j][0]\\n # dist_up = 1 if j == 0 else 1 + dp[i][j - 1][1]\\n # dp[i][j] = (dist_left, dist_up)\\n\\n # max_area = 0\\n\\n # for i, row in enumerate(matrix):\\n\\n # rect1, rect2 = (0, 0), (0, 0)\\n\\n # for j, cell in enumerate(row):\\n\\n # if cell == '0':\\n # rect1, rect2 = (0, 0), (0, 0)\\n # continue\\n \\n # return max_area\\n\\n# 3 x 1\\n# 2 x 1\\n# 2 x 2\\n \",\n \"runtime\": \"1371\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m,n = len(matrix),len(matrix[0])\\n ans = 0\\n dp = {}\\n\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j]=='0':\\n dp[(i,j)]=(0,0)\\n else:\\n x = dp[(i,j-1)][0]+1 if j>0 else 1\\n y = dp[(i-1,j)][1]+1 if i>0 else 1\\n dp[(i,j)] = (x,y)\\n ans = max(x,y,ans)\\n minWidth = x\\n # verical max possible\\n for r in range(i-1,i-y,-1):\\n minWidth = min(minWidth,dp[(r,j)][0])\\n ans = max(ans,minWidth*(i-r+1))\\n \\n \\n return ans\",\n \"runtime\": \"1371\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m,n = len(matrix),len(matrix[0])\\n ans = 0\\n dp = {}\\n\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j]=='0':\\n dp[(i,j)]=(0,0)\\n else:\\n x = dp[(i,j-1)][0]+1 if j>0 else 1\\n y = dp[(i-1,j)][1]+1 if i>0 else 1\\n dp[(i,j)] = (x,y)\\n ans = max(x,y,ans)\\n minWidth = x\\n # verical max possible\\n for r in range(i-1,i-y,-1):\\n minWidth = min(minWidth,dp[(r,j)][0])\\n ans = max(ans,minWidth*(i-r+1))\\n \\n \\n return ans\",\n \"runtime\": \"1396\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # Step 1: Define the problem in terms of DP\\n # m: number of rows, n: number of columns in the matrix\\n m, n = len(matrix), len(matrix[0])\\n \\n # Step 2: Initialize DP table\\n # dp will store for each cell (i, j) a tuple (x, y)\\n # where x is the width of the consecutive '1's in the current row\\n # and y is the height of the consecutive '1's in the current column\\n dp = {}\\n\\n # Variable to store the maximum area found so far\\n ans = 0\\n \\n # Step 3: Iterate through each cell in the matrix (bottom-up approach)\\n for i in range(m):\\n for j in range(n):\\n \\n # Step 4: Base case - If the current cell is '0', it contributes no area\\n if matrix[i][j] == '0':\\n dp[(i, j)] = (0, 0) # No width, no height for this cell\\n else:\\n # If current cell is '1', calculate width and height\\n # x = width of consecutive '1's in the current row ending at (i, j)\\n # If we're at the first column, width is 1, otherwise extend from left\\n x = dp[(i, j-1)][0] + 1 if j > 0 else 1\\n \\n # y = height of consecutive '1's in the current column ending at (i, j)\\n # If we're at the first row, height is 1, otherwise extend from top\\n y = dp[(i-1, j)][1] + 1 if i > 0 else 1\\n \\n # Store the width and height in dp for current cell (i, j)\\n dp[(i, j)] = (x, y)\\n\\n # Update the maximum rectangle size that can be formed\\n # Consider horizontal line from (i, j) and update answer with max(x, y)\\n ans = max(x * 1, y * 1, ans)\\n\\n # Step 5: Check for possible rectangles with height > 1\\n # Start at the current row (i), and go up row by row to check vertical rectangles\\n minWidth = x # Set the current width as the minimum width\\n for r in range(i-1, i-y, -1):\\n # For every row above the current one, find the minimum width possible\\n minWidth = min(minWidth, dp[(r, j)][0]) # Ensure rectangle width fits\\n \\n # Calculate area = minWidth * height (i - r + 1), update maximum\\n ans = max(ans, minWidth * (i - r + 1))\\n \\n # Step 6: Return the final result, which is the maximum area found\\n return ans\",\n \"runtime\": \"1396\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n rows, cols = len(matrix), len(matrix[0])\\n length = [[0]*cols for _ in range(rows)]\\n for col in range(cols):\\n for row in range(rows-1, -1, -1):\\n if matrix[row][col] == \\\"1\\\":\\n length[row][col] = 1 if row == rows-1 else 1+length[row+1][col]\\n\\n # print(length)\\n res = 0\\n for height in range(rows,0,-1):\\n for i in range(rows-height+1):\\n curr_wid = 0\\n for j in range(cols):\\n if length[i][j] >= height:\\n curr_wid += 1\\n else:\\n curr_wid = 0\\n res = max(res, height*curr_wid)\\n return res\\n\\n\\n \",\n \"runtime\": \"1421\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m,n = len(matrix), len(matrix[0])\\n ans = 0\\n dp = {}\\n\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == '0':\\n dp[(i,j)] = (0,0)\\n else:\\n x = dp[(i,j-1)][0]+1 if j>0 else 1\\n y = dp[(i-1,j)][1]+1 if i>0 else 1\\n dp[(i,j)] = (x,y)\\n ans = max(x,y,ans)\\n minWidth = x\\n #vertical max possible\\n for r in range(i-1,i-y,-1):\\n minWidth = min(minWidth,dp[(r,j)][0])\\n ans = max(ans,minWidth*(i-r+1))\\n return ans\",\n \"runtime\": \"1421\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m,n = len(matrix),len(matrix[0])\\n ans = 0\\n dp = {}\\n\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j]=='0':\\n dp[(i,j)]=(0,0)\\n else:\\n x = dp[(i,j-1)][0]+1 if j>0 else 1\\n y = dp[(i-1,j)][1]+1 if i>0 else 1\\n dp[(i,j)] = (x,y)\\n ans = max(x, y, ans)\\n minWidth = x\\n # verical max possible\\n for r in range(i-1,i-y,-1):\\n minWidth = min(minWidth,dp[(r,j)][0])\\n ans = max(ans,minWidth*(i-r+1))\\n \\n \\n return ans\",\n \"runtime\": \"1446\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n rows, cols = len(matrix), len(matrix[0])\\n rightBound = [[0 for _ in range(cols)] for _ in range(rows)]\\n for r in range(rows):\\n prevZero = -1\\n for c in range(cols):\\n if int(matrix[r][c]) == 0:\\n for k in range(prevZero + 1, c):\\n rightBound[r][k] = c - 1\\n prevZero = c\\n for k in range(prevZero + 1, cols):\\n rightBound[r][k] = cols - 1\\n ans = 0\\n for r1 in range(rows):\\n for c1 in range(cols):\\n if int(matrix[r1][c1]) == 0:\\n continue\\n curMax = rightBound[r1][c1] - c1 + 1\\n colWidth = rightBound[r1][c1] - c1 + 1\\n for r2 in range(r1 + 1, rows):\\n if int(matrix[r2][c1]) == 0:\\n break\\n colWidth = min(colWidth, rightBound[r2][c1] - c1 + 1)\\n curMax = max(curMax, colWidth * (r2 - r1 + 1))\\n ans = max(curMax, ans)\\n return ans\\n\",\n \"runtime\": \"1446\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m,n = len(matrix),len(matrix[0])\\n ans = 0\\n dp = {}\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j]=='0':\\n dp[(i,j)]=(0,0)\\n else:\\n x = dp[(i,j-1)][0]+1 if j>0 else 1\\n y = dp[(i-1,j)][1]+1 if i>0 else 1\\n dp[(i,j)] = (x,y)\\n ans = max(x,y,ans)\\n minWidth = x\\n for r in range(i-1,i-y,-1):\\n minWidth = min(minWidth,dp[(r,j)][0])\\n ans = max(ans,minWidth*(i-r+1))\\n return ans\",\n \"runtime\": \"1472\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m = len(matrix)\\n n = len(matrix[0])\\n maxarea = 0\\n for a in range(m):\\n ands = [1]*n\\n maxstretch = 0\\n for b in range(a,m):\\n stretch = 0\\n for col in range(n):\\n ands[col] = ands[col] & (ord(matrix[b][col])-48)\\n if ands[col] == 1:\\n stretch += 1\\n maxarea = max(maxarea,stretch*(b+1-a))\\n else:\\n stretch = 0\\n# print(a,b,ands)\\n return maxarea\\n\",\n \"runtime\": \"1472\"\n },\n {\n \"code\": \"class Solution:\\n def compute_heights(self, matrix):\\n heights = [len(matrix)]*len(matrix[0])\\n for level in range(len(matrix)):\\n for idx in range(len(matrix[0])):\\n if matrix[level][idx] == 0:\\n heights[idx] = min(heights[idx], level)\\n return heights\\n\\n def get_largest_rect_from_heights(self, heights):\\n largest_rect = 0\\n for idx, val in enumerate(heights):\\n if val == 0: continue\\n i = idx\\n height = 200\\n while i >= 0:\\n if heights[i] == 0:\\n break\\n width = idx-i + 1\\n height = min(heights[i], height, val)\\n area = width*height\\n largest_rect = max(largest_rect, area)\\n i -= 1\\n return largest_rect\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n sub_matrices = [[int(y) for y in x] for x in matrix]\\n sub_matrices = [sub_matrices[:i+1][::-1] for i in range(len(sub_matrices))]\\n\\n max_area = 0\\n for matrix in sub_matrices:\\n heights = self.compute_heights(matrix)\\n largest_rect = self.get_largest_rect_from_heights(heights)\\n if largest_rect > max_area:\\n max_area = largest_rect\\n return max_area\",\n \"runtime\": \"1497\"\n },\n {\n \"code\": \"class Solution:\\n def compute_heights(self, matrix):\\n heights = [len(matrix)]*len(matrix[0])\\n for level in range(len(matrix)):\\n for idx in range(len(matrix[0])):\\n if matrix[level][idx] == 0:\\n heights[idx] = min(heights[idx], level)\\n return heights\\n\\n def get_largest_rect_from_heights(self, heights):\\n largest_rect = 0\\n for idx, val in enumerate(heights):\\n if val == 0: continue\\n # print('f', idx, val)\\n # largest_rect = max(largest_rect, val)\\n i = idx\\n height = 200\\n while i >= 0:\\n if heights[i] == 0:\\n break\\n width = idx-i + 1\\n height = min(heights[i], height, val)\\n area = width*height\\n largest_rect = max(largest_rect, area)\\n # print(f'i: {i}, idx: {idx}, ht: {height}, wd: {width}, ar: {area}, rect: {largest_rect}')\\n i -= 1\\n return largest_rect\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n sub_matrices = [[int(y) for y in x] for x in matrix]\\n sub_matrices = [sub_matrices[:i+1][::-1] for i in range(len(sub_matrices))]\\n\\n max_area = 0\\n for matrix in sub_matrices:\\n heights = self.compute_heights(matrix)\\n # print(heights)\\n largest_rect = self.get_largest_rect_from_heights(heights)\\n if largest_rect > max_area:\\n max_area = largest_rect\\n return max_area\",\n \"runtime\": \"1497\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n res=0\\n m,n=len(matrix),len(matrix[0])\\n bruh=defaultdict(int)\\n for c in range(n):\\n for r in range(m):\\n k=0\\n while r+k < m and matrix[r+k][c]==\\\"1\\\": k+=1\\n bruh[(r,c)]=k\\n for r in range(m):\\n for c in range(n):\\n k=0\\n cur=bruh[(r,c)]\\n while cur and c+k<n:\\n cur=min(cur,bruh[(r,c+k)])\\n res=max(res,(k+1)*cur)\\n k+=1\\n return res\\n\\n\",\n \"runtime\": \"1522\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n res = 0\\n rows = len(matrix)\\n cols = len(matrix[0])\\n for r in range(rows):\\n for c in range(cols):\\n if matrix[r][c] == '0':\\n continue\\n if res >= (rows - r) * (cols - c):\\n continue\\n for w in range(cols - c):\\n if matrix[r][c + w] == '0':\\n break\\n h = 0\\n while h + r < rows:\\n valid = True\\n for k in range(w + 1):\\n if matrix[r + h][c + k] == '0':\\n valid = False\\n if valid:\\n res = max(res, (h + 1) * (w + 1))\\n # print(\\\"res=\\\",res, \\\"=\\\", h + 1, \\\" x \\\", w + 1, \\\"from (\\\", r, \\\",\\\", c)\\n h += 1\\n else:\\n break\\n return res\\n\\n \",\n \"runtime\": \"1547\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n ans = 0\\n m = len(matrix)\\n n = len(matrix[0])\\n long_m = [[0 for j in range(n)] for i in range(m)]\\n long_n = [[0 for j in range(n)] for i in range(m)]\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == '1':\\n if i == 0:\\n long_m[i][j] = 1\\n else:\\n long_m[i][j] = long_m[i - 1][j] + 1\\n if j == 0:\\n long_n[i][j] = 1\\n else:\\n long_n[i][j] = long_n[i][j - 1] + 1\\n rect = [[[0 for k in range(m + 1)] for j in range(n)] for i in range(m)]\\n for k in range(1, m + 1):\\n for i in range(k - 1, m):\\n if long_m[i][0] >= k:\\n rect[i][0][k] = 1\\n ans = max(ans, k)\\n for j in range(1, n):\\n if long_m[i][j] >= k:\\n rect[i][j][k] = rect[i][j - 1][k] + 1\\n ans = max(ans, k * rect[i][j][k])\\n return ans\",\n \"runtime\": \"1573\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # dp[i][j] 表示在第i行，以j-th 结尾的最长1子串的长度\\n # max(min(dp[k: l + 1][j]) * (l - k + 1))\\n if len(matrix) == 0 or len(matrix[0]) == 0:\\n return 0\\n \\n m = len(matrix)\\n n = len(matrix[0])\\n dp = [[0 for _ in range(n)] for _ in range(m)]\\n for i in range(m):\\n for j in range(n):\\n if i == 0 and j == 0:\\n dp[i][j] = int(matrix[i][j])\\n else:\\n if matrix[i][j] == \\\"0\\\":\\n dp[i][j] = 0\\n else:\\n dp[i][j] = dp[i][j - 1] + 1\\n \\n # print(dp)\\n max_area = 0\\n for j in range(n):\\n for k in range(m):\\n min_len = dp[k][j]\\n if max_area < min_len:\\n max_area = min_len\\n for l in range(k + 1, m):\\n if dp[l][j] < min_len:\\n min_len = dp[l][j]\\n max_area = max(max_area, min_len * (l - k + 1))\\n \\n return max_area\\n\\n \",\n \"runtime\": \"1598\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n dp = [[[] for _ in range(n+1)] for _ in range(m+1)]\\n MAX = 0\\n for i in range(1, m+1):\\n for j in range(1, n+1):\\n if matrix[i-1][j-1] == '1':\\n left, top = dp[i][j-1], dp[i-1][j]\\n\\n dp[i][j].append(left[0] + 1 if len(left) > 0 else 1)\\n MAX = max(MAX, dp[i][j][0])\\n k = 0\\n while k < len(top):\\n if k < len(left) - 1:\\n temp = min(max(left[k+1] + 1, top[k]), dp[i][j][-1])\\n else:\\n temp = min(top[k], dp[i][j][-1])\\n dp[i][j].append(temp)\\n MAX = max(MAX, temp * (k+2)) ###\\n k += 1\\n return MAX\",\n \"runtime\": \"1623\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n maxRec = 0\\n r = 0\\n while len(matrix) != 0:\\n for c in range(len(matrix[r])):\\n maxRec = self.search(maxRec, matrix, r, c)\\n if maxRec == len(matrix)*len(matrix[0]): return maxRec\\n matrix.pop(0)\\n return maxRec\\n def search(self, maxRec, matrix, r, c):\\n startingCol = c\\n while r < len(matrix) and matrix[r][c] == \\\"1\\\":\\n r += 1\\n if r == 0: return maxRec\\n # print(\\\"row:\\\", r)\\n selectedCol = list(range(r))\\n while len(selectedCol) != 0 and c < len(matrix[0]):\\n # print(\\\"col:\\\", c)\\n # print(\\\"len:\\\", len(selectedCol))\\n i = 0\\n while i < len(selectedCol):\\n selectedRow = selectedCol[i]\\n if matrix[selectedRow][c] == \\\"0\\\":\\n selectedCol.pop(i)\\n continue\\n i += 1\\n carryRow, carry = -1, 0\\n for selectedRow in selectedCol:\\n # print(\\\"selectedRow:\\\", selectedRow)\\n rec = c-startingCol + 1\\n if selectedRow == carryRow:\\n rec += carry\\n carryRow, carry = selectedRow + 1, rec\\n # print(\\\"rec:\\\",rec)\\n maxRec = max(maxRec, rec)\\n c += 1\\n\\n return maxRec\",\n \"runtime\": \"1648\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n maxRec = 0\\n r = 0\\n while len(matrix) != 0:\\n for c in range(len(matrix[r])):\\n maxRec = self.search(maxRec, matrix, r, c)\\n if maxRec == len(matrix)*len(matrix[0]): return maxRec\\n matrix.pop(0)\\n return maxRec\\n def search(self, maxRec, matrix, r, c):\\n startingCol = c\\n while r < len(matrix) and matrix[r][c] == \\\"1\\\":\\n r += 1\\n if r == 0: return maxRec\\n # print(\\\"row:\\\", r)\\n selectedCol = list(range(r))\\n while len(selectedCol) != 0 and c < len(matrix[0]):\\n # print(\\\"col:\\\", c)\\n # print(\\\"len:\\\", len(selectedCol))\\n i = 0\\n while i < len(selectedCol):\\n selectedRow = selectedCol[i]\\n if matrix[selectedRow][c] == \\\"0\\\":\\n selectedCol.pop(i)\\n continue\\n i += 1\\n carryRow, carry = -1, 0\\n for selectedRow in selectedCol:\\n # print(\\\"selectedRow:\\\", selectedRow)\\n rec = c-startingCol + 1\\n if selectedRow == carryRow:\\n rec += carry\\n carryRow, carry = selectedRow + 1, rec\\n # print(\\\"rec:\\\",rec)\\n maxRec = max(maxRec, rec)\\n c += 1\\n\\n return maxRec\",\n \"runtime\": \"1648\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n dp = [[[] for _ in range(n+1)] for _ in range(m+1)]\\n MAX = 0\\n for i in range(1, m+1):\\n for j in range(1, n+1):\\n if matrix[i-1][j-1] == '1':\\n left, top = dp[i][j-1], dp[i-1][j]\\n\\n dp[i][j].append(left[0] + 1 if len(left) > 0 else 1)\\n MAX = max(MAX, dp[i][j][0])\\n k = 0\\n while k < len(top):\\n if k < len(left) - 1:\\n temp = min(max(left[k+1] + 1, top[k]), dp[i][j][-1])\\n else:\\n temp = min(top[k], dp[i][j][-1])\\n dp[i][j].append(temp)\\n MAX = max(MAX, temp * (k+2)) ###\\n k += 1\\n return MAX\",\n \"runtime\": \"1674\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n n_rows, n_cols = len(matrix), len(matrix[0])\\n dp = [[0 for _ in range(n_cols)] for _ in range(n_rows)]\\n dp[0][0] = 1 if matrix[0][0] == '1' else 0\\n \\n count = dp[0][0]\\n for i in range(1, n_rows):\\n count = count + 1 if matrix[i][0] == \\\"1\\\" else 0\\n dp[i][0] = max(count, dp[i-1][0])\\n \\n count = dp[0][0]\\n for i in range(1, n_cols):\\n count = count + 1 if matrix[0][i] == \\\"1\\\" else 0\\n dp[0][i] = max(count, dp[0][i-1])\\n\\n dp_cols = [[0 for _ in range(n_cols)] for _ in range(n_rows)]\\n for i in range(0, n_rows):\\n dp_cols[i][0] = int(matrix[i][0])\\n for j in range(1, n_cols):\\n dp_cols[i][j] = dp_cols[i][j-1] + 1 if int(matrix[i][j]) else 0\\n \\n\\n \\n for i in range(1, n_rows):\\n for j in range(1, n_cols):\\n dp[i][j] = max(dp[i-1][j], dp[i][j-1])\\n if int(matrix[i][j]):\\n rects = []\\n for k in range(i, -1, -1):\\n if int(matrix[k][j]) == 0:\\n break\\n rects.append(dp_cols[k][j])\\n min_value = 1e8\\n for k in range(len(rects)):\\n min_value = min(min_value, rects[k])\\n dp[i][j] = max(dp[i][j], (k+1)*min_value)\\n # print(dp)\\n # print(dp_cols)\\n return dp[-1][-1] \",\n \"runtime\": \"1699\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def getWidth(str):\\n subStr = str.split(\\\"0\\\")\\n return len(max(subStr, key=lambda x: len(x)))\\n\\n def getStrAnd(str1, str2):\\n newStr = \\\"\\\"\\n for i in range(len(str1)):\\n if str1[i] == str2[i] == \\\"1\\\": newStr = newStr+\\\"1\\\"\\n else: newStr = newStr+\\\"0\\\"\\n return newStr\\n \\n def convertToStr(row):\\n st = \\\"\\\"\\n for el in row: st = st + el\\n return st\\n\\n longest = 0\\n for rowStart in range(0, len(matrix)):\\n resStr = convertToStr(matrix[rowStart])\\n longest = max(longest, getWidth(resStr))\\n for i in range(rowStart+1, len(matrix)):\\n addStr = convertToStr(matrix[i])\\n resStr = getStrAnd(resStr, addStr)\\n longest = max(longest, getWidth(resStr)*(i-rowStart+1))\\n\\n return longest\",\n \"runtime\": \"1699\"\n },\n {\n \"code\": \"def collectZeroRows(matrix):\\n zeroRows = []\\n for i in range(0, len(matrix)):\\n zeros = []\\n for j in range(0, len(matrix[i])):\\n if matrix[i][j] == '0':\\n zeros.append(j)\\n zeroRows.append(zeros)\\n return zeroRows\\n\\n# at matrix[i][j] == 1; find max k > j s.t. matrix[i][k] == '0'\\ndef getLongHRun(matrix, zeroRows, i, j):\\n idx = bisect.bisect_left( zeroRows[i], j )\\n if idx == len(zeroRows[i]):\\n return len(matrix[i]) - j\\n if idx == 0 and zeroRows[i][idx] < j:\\n return 1\\n return zeroRows[i][idx] - j\\n\\ndef maxRect(matrix, i, j, zeroRows):\\n result = 1\\n v_len = 1\\n h_len = getLongHRun(matrix, zeroRows, i + v_len - 1, j)\\n while i + v_len - 1 < len(matrix) and matrix[i + v_len - 1][j] == '1':\\n h_run = getLongHRun(matrix, zeroRows, i + v_len - 1, j)\\n h_len = min(h_len, h_run )\\n result = max(result, h_len * v_len)\\n # print(i, j, h_run, zeroRows[i + v_len - 1], h_len, v_len, result)\\n v_len += 1\\n return result\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n zeroRows = collectZeroRows(matrix)\\n result = 0\\n for i in range(0, len(matrix)):\\n for j in range(0, len(matrix[i])):\\n if matrix[i][j] == '0':\\n continue\\n # matrix[i][j] == '1'\\n temp_res = maxRect(matrix, i, j, zeroRows)\\n result = max(result, temp_res)\\n # print(i, j, temp_res)\\n return result\\n\",\n \"runtime\": \"1724\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int: \\n m = len(matrix)\\n n = len(matrix[0])\\n\\n for j in range(n-1, -1, -1):\\n for i in range(m-1, -1, -1):\\n if matrix[i][j] == \\\"0\\\":\\n matrix[i][j] = 0\\n else:\\n down = matrix[i+1][j] if i+1 != m else 0\\n right = matrix[i][j+1] if j+1 != n else 0\\n\\n x = set()\\n if down and right:\\n x_down = {(a+1, b) for a, b in down}\\n x_right = {(a, b+1) for a, b in right}\\n for d in x_down:\\n for r in x_right:\\n x.add((min(d[0], r[0]), min(d[1], r[1])))\\n x |= {(a, b) for a, b in (x_down | x_right) if a == 1 or b == 1}\\n if (1, 1) in x:\\n x.remove((1, 1))\\n elif down:\\n a = max(a for a, _ in down)\\n x.add((a + 1, 1))\\n elif right:\\n b = max(b for _, b in right)\\n x.add((1, b + 1))\\n else:\\n x.add((1, 1))\\n matrix[i][j] = x\\n\\n for j in range(n-1, -1, -1):\\n for i in range(m-1, -1, -1):\\n if matrix[i][j]:\\n matrix[i][j] = max(a*b for a, b in matrix[i][j])\\n\\n return max(max(row) for row in matrix)\",\n \"runtime\": \"1749\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n ret = 0\\n H = len(matrix)\\n Y_arr = [[] for i in range(H)]\\n for i in range(H):\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == '0': Y_arr[i].append(j)\\n Y_arr[i].append(len(matrix[0]))\\n # print(Y_arr)\\n\\n can_t = []\\n for i in range(H):\\n can_t.clear()\\n for j in range(len(Y_arr[i])):\\n can_t.append(Y_arr[i][j])\\n\\n ret_t = 0\\n count_t = 0\\n for k in range(i, H):\\n count_t += 1\\n if k != i:\\n for u in range(len(Y_arr[k])):\\n if Y_arr[k][u] >= can_t[len(can_t) - 1]: break\\n elif Y_arr[k][u] not in can_t:\\n can_t.append(Y_arr[k][u])\\n can_t.sort()\\n # print(can_t)\\n for u in range(len(can_t)):\\n if u == 0: ret_t = max(ret_t, count_t * can_t[u])\\n else: ret_t = max(ret_t, count_t * (can_t[u] - can_t[u - 1] - 1))\\n ret = max(ret, ret_t)\\n # print(ret)\\n\\n return ret\\n\",\n \"runtime\": \"1775\"\n },\n {\n \"code\": \"def get_max_right(i,j, matrix, memory):\\n if (i,j) in memory:\\n return memory[(i,j)]\\n if j!=0 and (i,j-1) in memory and memory[(i,j-1)] != 0:\\n memory[(i,j)] = memory[(i,j-1)]-1\\n return memory[(i,j)]\\n \\n n = len(matrix[0])\\n counter = 0\\n p = j\\n while p < n and matrix[i][p] == \\\"1\\\":\\n counter += 1\\n p+=1\\n memory[(i,j)] = counter\\n return memory[(i,j)]\\n \\n\\n\\ndef get_max_at_pos(i,j,matrix, memory):\\n if matrix[i][j] == \\\"0\\\":\\n memory[(i,j)] = 0\\n return memory[(i,j)]\\n flag = True\\n p = i\\n rec_max = 0\\n right_max = float(\\\"Inf\\\")\\n n = len(matrix)\\n while flag:\\n if p < n and matrix[p][j] == \\\"1\\\":\\n t_right = get_max_right(p,j,matrix,memory)\\n right_max = min(right_max, t_right)\\n square_size = (p-i+1)*right_max\\n rec_max = max(square_size, rec_max)\\n p+=1\\n else:\\n flag = False\\n return rec_max\\n\\n \\n \\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n n = len(matrix)\\n m = len(matrix[0])\\n memory = {}\\n rec_max = 0\\n for i in range(n):\\n for j in range(m):\\n ij_max = get_max_at_pos(i,j,matrix,memory)\\n rec_max = max(ij_max, rec_max)\\n return rec_max\\n\\n \",\n \"runtime\": \"1800\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int: \\n m = len(matrix)\\n n = len(matrix[0])\\n\\n for j in range(n-1, -1, -1):\\n for i in range(m-1, -1, -1):\\n if matrix[i][j] == \\\"0\\\":\\n matrix[i][j] = 0\\n else:\\n down = matrix[i+1][j] if i+1 != m else 0\\n right = matrix[i][j+1] if j+1 != n else 0\\n\\n x = set()\\n if down and right:\\n x_down = {(a+1, b) for a, b in down}\\n x_right = {(a, b+1) for a, b in right}\\n for d in x_down:\\n for r in x_right:\\n x.add((min(d[0], r[0]), min(d[1], r[1])))\\n x |= {(a, b) for a, b in (x_down | x_right) if a == 1 or b == 1}\\n elif down:\\n a = max(a for a, _ in down)\\n x.add((a + 1, 1))\\n elif right:\\n b = max(b for _, b in right)\\n x.add((1, b + 1))\\n else:\\n x.add((1, 1))\\n matrix[i][j] = x\\n\\n for j in range(n-1, -1, -1):\\n for i in range(m-1, -1, -1):\\n if matrix[i][j]:\\n matrix[i][j] = max(a*b for a, b in matrix[i][j])\\n\\n return max(max(row) for row in matrix)\",\n \"runtime\": \"1825\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n d ={}\\n d1 = {}\\n m = 0\\n for i in range(len(matrix)-1, -1, -1):\\n for j in range(len(matrix[0])-1, -1, -1):\\n if matrix[i][j] == \\\"0\\\":\\n d[f\\\"{i},{j}\\\"] = 0\\n else:\\n if f\\\"{i},{j+1}\\\" not in d:\\n d[f\\\"{i},{j}\\\"] = 1\\n else:\\n d[f\\\"{i},{j}\\\"] = 1 + d[f\\\"{i},{j+1}\\\"]\\n \\n \\n for j in range(len(matrix[0])-1, -1, -1):\\n for i in range(len(matrix)-1, -1, -1): \\n if matrix[i][j] == \\\"0\\\":\\n d1[f\\\"{i},{j}\\\"] = 0\\n else:\\n if f\\\"{i + 1},{j}\\\" not in d1:\\n d1[f\\\"{i},{j}\\\"] = 1\\n else:\\n d1[f\\\"{i},{j}\\\"] = 1 + d1[f\\\"{i + 1},{j}\\\"]\\n\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n if d[f\\\"{i},{j}\\\"] == 0:\\n continue\\n v = d[f\\\"{i},{j}\\\"]\\n while v > 0:\\n temp = v\\n c = i + 1\\n while f\\\"{c},{j}\\\" in d and d[f\\\"{c},{j}\\\"] >= v:\\n temp += v\\n c += 1\\n if temp > m:\\n m = temp\\n v -= 1\\n if v*d1[f\\\"{i},{j}\\\"] < m:\\n break\\n \\n \\n return m\\n\\n\",\n \"runtime\": \"1851\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # dp with histograms\\n # dp[i][j] stores the max width for rectangel end with cell [i][j]\\n m, n = len(matrix), len(matrix[0])\\n dp = [[0 for i in range(n)] for j in range(m)]\\n res = 0\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == \\\"0\\\": continue\\n dp[i][j] = 1 if j == 0 else dp[i][j-1] + 1\\n\\n curr_width, height = dp[i][j], 0\\n for k in range(i, -1, -1):\\n curr_width = min(curr_width, dp[k][j])\\n height += 1\\n res = max(res, curr_width * height)\\n\\n return res\\n \",\n \"runtime\": \"1876\"\n },\n {\n \"code\": \"def get_max_right(i,j, matrix, memory):\\n if (i,j) in memory:\\n return memory[(i,j)]\\n n = len(matrix[0])\\n counter = 0\\n p = j\\n while p < n and matrix[i][p] == \\\"1\\\":\\n counter += 1\\n p+=1\\n memory[(i,j)] = counter\\n return memory[(i,j)]\\n \\n\\n\\ndef get_max_at_pos(i,j,matrix, memory):\\n if matrix[i][j] == \\\"0\\\":\\n memory[(i,j)] = 0\\n return memory[(i,j)]\\n flag = True\\n p = i\\n rec_max = 0\\n right_max = float(\\\"Inf\\\")\\n n = len(matrix)\\n while flag:\\n if p < n and matrix[p][j] == \\\"1\\\":\\n t_right = get_max_right(p,j,matrix,memory)\\n right_max = min(right_max, t_right)\\n square_size = (p-i+1)*right_max\\n rec_max = max(square_size, rec_max)\\n p+=1\\n else:\\n flag = False\\n return rec_max\\n\\n \\n \\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n n = len(matrix)\\n m = len(matrix[0])\\n memory = {}\\n rec_max = 0\\n for i in range(n):\\n for j in range(m):\\n ij_max = get_max_at_pos(i,j,matrix,memory)\\n rec_max = max(ij_max, rec_max)\\n return rec_max\\n\\n \",\n \"runtime\": \"1901\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n \\n down = [ [ 0 ] * n for i in range(m) ]\\n right = [ [0] * n for i in range(m) ]\\n for i in range(m - 1, -1, -1):\\n for j in range(n - 1, -1, -1):\\n if j < n - 1:\\n if matrix[i][j + 1] == \\\"1\\\":\\n right[i][j] = right[i][j + 1] + 1\\n if i < m - 1:\\n if matrix[i + 1][j] == \\\"1\\\":\\n down[i][j] = down[i + 1][j] + 1\\n\\n dp = [ [0] * n for i in range(m) ]\\n for i in range(m - 1, -1, -1):\\n if i == m - 1:\\n if matrix[i][-1] == \\\"1\\\":\\n dp[i][-1] = 1\\n else:\\n if matrix[i][-1] == \\\"1\\\":\\n dp[i][-1] = 1 + dp[i + 1][-1]\\n for j in range(n - 1, -1, -1):\\n if j == n - 1:\\n if matrix[-1][j] == \\\"1\\\":\\n dp[-1][j] = 1\\n else:\\n if matrix[-1][j] == \\\"1\\\":\\n dp[-1][j] = 1 + dp[-1][j + 1]\\n\\n for i in range(m - 2, -1, -1):\\n for j in range(n - 2, -1, -1):\\n if matrix[i][j] == \\\"1\\\":\\n if matrix[i + 1][j + 1] == \\\"0\\\":\\n if matrix[i + 1][j] == \\\"0\\\" and matrix[i][j + 1] == \\\"1\\\":\\n dp[i][j] = 1 + right[i][j]\\n elif matrix[i][j + 1] == \\\"0\\\" and matrix[i + 1][j] == \\\"1\\\":\\n dp[i][j] = 1 + down[i][j]\\n elif matrix[i][j + 1] == \\\"0\\\" and matrix[i + 1][j] == \\\"0\\\":\\n dp[i][j] = 1\\n else:\\n if dp[i + 1][j] >= dp[i][j + 1]:\\n dp[i][j] = 1 + dp[i + 1][j]\\n else:\\n dp[i][j] = 1 + dp[i][j + 1]\\n else:\\n if matrix[i + 1][j] == \\\"0\\\" and matrix[i][j + 1] == \\\"1\\\":\\n dp[i][j] = 1 + right[i][j]\\n elif matrix[i][j + 1] == \\\"0\\\" and matrix[i + 1][j] == \\\"1\\\":\\n dp[i][j] = 1 + down[i][j]\\n elif matrix[i][j + 1] == \\\"0\\\" and matrix[i + 1][j] == \\\"0\\\":\\n dp[i][j] = 1\\n else:\\n horizontal = right[i][j] + 1\\n vertical = down[i][j] + 1\\n\\n\\n row_wise_area = 0\\n curr_area = 0\\n row_wise_area_rows = min(down[i][j] + 1, down[i + 1][j + 1] + 2)\\n row_wise_area_cols = float('inf')\\n for k in range(row_wise_area_rows):\\n if i + k >= m: break\\n cols = right[i + k][j] + 1\\n row_wise_area_cols = min(cols, row_wise_area_cols)\\n curr_area = (k + 1) * row_wise_area_cols\\n row_wise_area = max(curr_area, row_wise_area)\\n\\n col_wise_area = 0\\n curr_area = 0\\n col_wise_area_cols = min(right[i][j] + 1, right[i + 1][j + 1] + 2)\\n col_wise_area_rows = float('inf')\\n for k in range(col_wise_area_cols):\\n if j + k >= n : break\\n rows = down[i][j + k] + 1\\n col_wise_area_rows = min(rows, col_wise_area_rows)\\n curr_area = (1 + k) * col_wise_area_rows\\n col_wise_area_cols = max(curr_area, col_wise_area)\\n \\n dp[i][j] = max(horizontal, vertical, row_wise_area, col_wise_area)\\n\\n max_area = 0\\n for row in dp:\\n max_area = max(max_area, max(row))\\n \\n return max_area\",\n \"runtime\": \"1926\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m = len(matrix)\\n n = len(matrix[0])\\n\\n largest = 0\\n # length/breadth\\n dp = [[0]*n for __ in range(m)]\\n\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == \\\"1\\\":\\n width = dp[i][j] = dp[i][j-1] +1 if j-1 >= 0 else 1\\n for k in range(i, -1, -1):\\n width = min(width, dp[k][j])\\n largest = max(largest, width * (i-k+1))\\n return largest\\n\\n\\\"\\\"\\\"\\n[\\n [1,0,1,0,0]\\n [2,0,2,2,3]\\n [3,2,3,4,6]\\n [4,0,0,3,0]\\n]\\n\\n\\\"\\\"\\\"\",\n \"runtime\": \"1952\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m = len(matrix)\\n n = len(matrix[0])\\n dp = [[0]*n for _ in range(m)]\\n maxarea = 0\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == '0':\\n continue\\n\\n # compute the maximum width and update dp with it\\n width = dp[i][j] = dp[i][j - 1] + 1 if j else 1\\n\\n # compute the maximum area rectangle with a lower right corner at [i, j]\\n for k in range(i, -1, -1):\\n width = min(width, dp[k][j])\\n maxarea = max(maxarea, width * (i - k + 1))\\n \\n return maxarea\\n\",\n \"runtime\": \"1977\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n # brute force: 4 loops; O(N^4), O(1)\\n # better brute force: inner binary search: O(N^3*log(N)), O(1)\\n # ? N^3 maybe dp, prefixsum\\n # ? N^2\\n ans = 0\\n M, N = len(matrix), len(matrix[0])\\n for row1 in range(M):\\n for col1 in range(N):\\n if matrix[row1][col1] == '0':\\n continue\\n \\n hi = N\\n for row2 in range(row1, M):\\n if matrix[row2][col1] == '0':\\n break\\n if row1 == 1 and row2 == 1:\\n print(hi)\\n j = bisect.bisect_left(matrix[row2], 1, lo=col1 + 1, hi=hi, key=lambda k: 0 if k == '1' else 1)\\n if not (col1 + 1 <= j <= N):\\n raise RuntimeError(f\\\"{j}\\\")\\n if (row2 - row1 + 1) * (hi - col1) == 10:\\n print(row2, hi)\\n ans = max(ans, (row2 - row1 + 1) * (hi - col1))\\n\\n return ans\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n maxarea = 0\\n M, N = len(matrix), len(matrix[0])\\n dp = [[0] * N for _ in range(M)]\\n\\n for i in range(M):\\n for j in range(N):\\n if matrix[i][j] == '0':\\n continue\\n \\n width = dp[i][j] = dp[i][j - 1] + 1 if j else 1\\n for k in range(i, -1, -1):\\n width = min(width, dp[k][j])\\n maxarea = max(maxarea, width * (i - k + 1))\\n return maxarea\\n\\n\",\n \"runtime\": \"2002\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n maxarea = 0\\n n = len(matrix[0])\\n m = len(matrix)\\n\\n dp = [[0] * n for _ in range(m)]\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == \\\"0\\\":\\n continue\\n\\n width = dp[i][j] = dp[i][j - 1] + 1 if j else 1\\n\\n for k in range(i, -1, -1):\\n width = min(width, dp[k][j])\\n maxarea = max(maxarea, width * (i - k + 1))\\n \\n return maxarea\",\n \"runtime\": \"2027\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n\\n maxarea = 0 \\n m,n = len(matrix), len(matrix[0])\\n dp = [ [0] * n for _ in range(m)]\\n\\n\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == \\\"1\\\":\\n dp[i][j] = dp[i][j-1] + 1 if j else 1\\n width = dp[i][j]\\n\\n\\n for k in range(i,-1,-1):\\n width = min(width, dp[k][j])\\n\\n maxarea = max(maxarea, width * (i-k+1))\\n\\n return maxarea\\n\\n\\n \",\n \"runtime\": \"2027\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n maxarea=0\\n m,n=len(matrix),len(matrix[0])\\n dp=[[0 for _ in range(n)] for _ in range(m)] \\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j]==\\\"0\\\":\\n continue\\n width=dp[i][j]=dp[i][j-1]+1 if j else 1\\n for k in range(i,-1,-1):\\n width=min(width,dp[k][j])\\n maxarea=max(maxarea,width*(i-k+1))\\n return maxarea \",\n \"runtime\": \"2053\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n maxarea = 0\\n dp = [[0] * len(matrix[0]) for _ in range(len(matrix))]\\n\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == '0':\\n continue\\n \\n width = dp[i][j] = dp[i][j-1] + 1 if j else 1\\n\\n for k in range(i, -1, -1):\\n width = min(width, dp[k][j])\\n maxarea = max(maxarea, width * (i-k+1))\\n \\n return maxarea\",\n \"runtime\": \"2053\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m = len(matrix)\\n n = len(matrix[0])\\n maxarea = 0\\n dp = [[0]*n for _ in range(m)] # record max width\\n\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == '0':\\n continue\\n dp[i][j] = dp[i][j-1]+1 if j else 1\\n width = dp[i][j]\\n\\n for k in range(i, -1, -1):\\n width = min(width, dp[k][j])\\n maxarea = max(maxarea, width*(i-k+1))\\n return maxarea\\n\\n '''\\n m = len(matrix)\\n n = len(matrix[0])\\n dp = [[(0, 0)]*n for _ in range(m)]\\n area = -float('inf')\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == '0':\\n dp[i][j] == (0, 0)\\n else:\\n if i == 0 and j == 0:\\n dp[i][j] = (1, 1)\\n elif i == 0 or matrix[i-1][j] == '0':\\n if matrix[i][j-1] == '1':\\n row, col = dp[i][j-1]\\n dp[i][j] = (1, col+1)\\n else:\\n dp[i][j] = (1, 1)\\n elif j == 0 or matrix[i][j-1] == '0':\\n if matrix[i-1][j] == '1':\\n row, col = dp[i-1][j]\\n dp[i][j] = (row+1, 1)\\n else:\\n dp[i][j] = (1, 1)\\n else:\\n if matrix[i-1][j-1] == '0':\\n uprow, upcol = dp[i-1][j]\\n leftrow, leftcol = dp[i][j-1]\\n if (uprow+1)*1 > 1*(leftcol+1):\\n dp[i][j] = (uprow+1, 1)\\n else:\\n dp[i][j] = (1, leftcol+1)\\n else:\\n uprow, upcol = dp[i-1][j]\\n leftrow, leftcol = dp[i][j-1]\\n cornerrow, cornercol = dp[i-1][j-1]\\n minrow = min(uprow, leftrow, cornerrow)\\n mincol = min(upcol, leftcol, cornercol)\\n uparea = (uprow+1)*1\\n leftarea = 1*(leftcol+1)\\n cornerarea = (minrow+1)*(mincol+1)\\n maxarea = max(uparea, leftarea, cornerarea) \\n if maxarea == uparea:\\n dp[i][j] == (uprow+1, 1)\\n elif maxarea == leftarea:\\n dp[i][j] = (1, leftcol+1)\\n else:\\n dp[i][j] = (minrow+1, mincol+1)\\n r, c = dp[i][j]\\n area = max(area, r*c)\\n print(dp)\\n return area\\n '''\",\n \"runtime\": \"2078\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m = len(matrix)\\n n = len(matrix[0])\\n\\n dp = [[0] * len(matrix[0]) for _ in range(len(matrix))]\\n\\n maxArea = 0\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == \\\"0\\\":\\n continue\\n \\n width = dp[i][j] = dp[i][j-1] + 1 if j else 1\\n\\n for k in range(i, -1, -1):\\n width = min(width, dp[k][j])\\n maxArea = max(maxArea, width * (i - k + 1))\\n\\n print(dp)\\n\\n\\n return maxArea\",\n \"runtime\": \"2078\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":130,"string":"130"},"mm_list":{"kind":"list like","value":[{"code":"def largestRectangleArea(heights: List[int]) -> int:\n stack = []\n max_area = 0\n heights.append(0) \n\n for i in range(len(heights)):\n while stack and heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i if not stack else i - stack[-1] - 1\n max_area = max(max_area, h * w)\n stack.append(i)\n \n heights.pop() \n return max_area\n\n\nclass Solution:\n def maximalRectangle(matrix: List[List[str]]) -> int:\n if not matrix or not matrix[0]:\n return 0\n \n n_cols = len(matrix[0])\n heights = [0] * n_cols\n max_area = 0\n\n for row in matrix:\n for i in range(n_cols):\n \n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n \n max_area = max(max_area, largestRectangleArea(heights))\n \n return max_area\n\n with open('user.out','w') as f:\n for i in map(loads, stdin):\n print(maximalRectangle(i), file=f)\n exit(0)","memory":"17200"},{"code":"class Solution:\n @staticmethod\n def mrec(matrix: List[List[str]], k, l, mms):\n n = len(matrix)\n m = len(matrix[0])\n ms = mms\n pj = m\n i = k\n if (n - k) * (pj - l) <= ms:\n return ms\n while i < n:\n if (n - k) * (pj - l) <= ms:\n break\n j = l\n while j < pj:\n if matrix[i][j] == '0':\n break\n j += 1\n s = (i - k + 1) * (j - l)\n if s > ms:\n ms = s\n pj = j\n i += 1\n return ms\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n n = len(matrix)\n m = 0 if n == 0 else len(matrix[0])\n ms = 0\n for i in range(n):\n for j in range(m):\n # if ((n - i) * (m - j)) < ms:\n # break\n s = self.mrec(matrix, i, j, ms)\n if s > ms:\n ms = s\n return ms\n","memory":"17300"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def check_col(r,c):\n if r==len(matrix) or matrix[r][c]=='0':\n return 0\n matrix[r][c] = check_col(r+1,c) + 1\n return matrix[r][c]\n\n def check_row(r,c):\n global max_rec\n min_col = 1e9\n count = 0\n while not(c+count==len(matrix[0]) or matrix[r][c+count]=='0'):\n count+=1\n min_col = min(min_col, check_col(r,c+count-1))\n max_rec = max(max_rec, count*min_col)\n if (len(matrix[0])-c)*min_col<max_rec:\n return\n \n global max_rec\n max_rec = 0\n for c in range(len(matrix[0])):\n for r in range(len(matrix)):\n check_row(r,c)\n return max_rec","memory":"17400"},{"code":"class Solution:\n\n def maximalRectangle(self, matrix):\n if not matrix:\n return 0\n \n rows, cols = len(matrix), len(matrix[0])\n heights = [0] * cols\n max_area = 0\n \n for row in matrix:\n for i in range(cols):\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n max_area = max(max_area, self.maxHistogramArea(heights))\n \n return max_area\n \n def maxHistogramArea(self, heights):\n stack = []\n max_area = 0\n heights.append(0) # Sentinel value to ensure stack is emptied at the end\n \n for i in range(len(heights)):\n while stack and heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i if not stack else i - stack[-1] - 1\n max_area = max(max_area, h * w)\n stack.append(i)\n \n heights.pop() # Remove sentinel value\n return max_area\n","memory":"17500"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n r, c=len(matrix), len(matrix[0])\n if r==1 and c==1:\n if matrix[0][0]=='1': return 1\n else: return 0\n h=[0]*(c+1)\n maxArea=0\n\n for i, row in enumerate(matrix):\n st=[-1] \n row.append('0')\n for j, x in enumerate(row):\n # build h\n if x=='1': h[j]+=1\n else: h[j]=0\n # mononotonic stack has at leat element -1\n while len(st)>1 and (j==c or h[j]<h[st[-1]]):\n m=st[-1]\n st.pop()\n w=j-st[-1]-1\n area=h[m]*w\n maxArea=max(maxArea, area)\n st.append(j)\n return maxArea\n\n ","memory":"17600"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix:\n return 0\n\n n = len(matrix[0])\n heights = [0] * (n + 1)\n max_area = 0\n\n for row in matrix:\n \n for i in range(n):\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n \n stack = [-1]\n for i in range(n + 1):\n while heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i - 1 - stack[-1]\n max_area = max(max_area, h * w)\n stack.append(i)\n\n return max_area","memory":"17700"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def calc(heights):\n res = 0\n heights.append(-1)\n stack = [-1]\n for i in range(len(heights)):\n while stack and heights[stack[-1]] > heights[i]:\n h = heights[stack.pop()]\n w = i - stack[-1] - 1\n res = max(res, h * w)\n stack.append(i)\n return res\n\n m, n = len(matrix), len(matrix[0])\n result = 0\n heights = [0] * n\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == '1':\n heights[j] += int(matrix[i][j])\n else:\n heights[j] = 0\n result = max(result, calc(heights))\n return result\n\n ","memory":"17700"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix:\n return 0\n\n n = len(matrix[0])\n heights = [0] * (n + 1)\n max_area = 0\n\n for row in matrix:\n \n for i in range(n):\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n \n stack = [-1]\n for i in range(n + 1):\n while heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i - 1 - stack[-1]\n max_area = max(max_area, h * w)\n stack.append(i)\n\n return max_area","memory":"17800"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix:\n return 0\n\n n = len(matrix[0])\n heights = [0] * (n + 1)\n max_area = 0\n\n for row in matrix:\n \n for i in range(n):\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n \n stack = [-1]\n for i in range(n + 1):\n while heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i - 1 - stack[-1]\n max_area = max(max_area, h * w)\n stack.append(i)\n\n return max_area","memory":"17800"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix:\n return 0\n\n n = len(matrix[0])\n heights = [0] * (n + 1)\n max_area = 0\n\n for row in matrix:\n \n for i in range(n):\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n \n stack = [-1]\n for i in range(n + 1):\n while heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i - 1 - stack[-1]\n max_area = max(max_area, h * w)\n stack.append(i)\n\n return max_area","memory":"17900"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def calc(heights):\n res = 0\n heights.append(-1)\n stack = [-1]\n for i in range(len(heights)):\n while stack and heights[stack[-1]] > heights[i]:\n h = heights[stack.pop()]\n w = i - stack[-1] - 1\n res = max(res, h * w)\n stack.append(i)\n return res\n\n m, n = len(matrix), len(matrix[0])\n result = 0\n heights = [0] * n\n for i in range(m):\n for j in range(n):\n if int(matrix[i][j]) == 1:\n heights[j] += int(matrix[i][j])\n else:\n heights[j] = 0\n result = max(result, calc(heights))\n return result\n\n ","memory":"17900"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix:\n return 0\n\n n = len(matrix[0])\n heights = [0] * (n + 1)\n max_area = 0\n\n for row in matrix:\n \n for i in range(n):\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\n \n \n stack = [-1]\n for i in range(n + 1):\n while heights[i] < heights[stack[-1]]:\n h = heights[stack.pop()]\n w = i - 1 - stack[-1]\n max_area = max(max_area, h * w)\n stack.append(i)\n\n return max_area","memory":"18000"},{"code":"class Solution:\n def maximalRectangle(self, matrix: list[list[str]]) -> int:\n if not matrix:\n return 0\n\n ans = 0\n hist = [0] * len(matrix[0])\n\n def largestRectangleArea(heights: list[int]) -> int:\n ans = 0\n stack = []\n\n for i in range(len(heights) + 1):\n while stack and (i == len(heights) or heights[stack[-1]] > heights[i]):\n h = heights[stack.pop()]\n w = i - stack[-1] - 1 if stack else i\n ans = max(ans, h * w)\n stack.append(i)\n\n return ans\n\n for row in matrix:\n for i, num in enumerate(row):\n hist[i] = 0 if num == '0' else hist[i] + 1\n ans = max(ans, largestRectangleArea(hist))\n\n return ans","memory":"18000"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n row = len(matrix)\n col = len(matrix[0])\n tab = [ [0 for _ in range(col)] for _ in range(row)]\n\n def largestRectangleArea(heights: List[int]) -> int:\n n = len(heights)\n stk = [] \n maxx = 0\n\n for i in range(n):\n start = i\n while stk and heights[i]<stk[-1][1]:\n maxx = max(maxx, stk[-1][1]*( i - stk[-1][0]) ) \n start=stk.pop()[0]\n stk.append([start, heights[i]])\n \n while stk:\n maxx= max(maxx, stk[-1][1]*( n - stk[-1][0]))\n stk.pop()\n return maxx\n\n for i in range(col):\n if matrix[0][i]=='0':\n tab[0][i]=0\n else:\n tab[0][i]=1\n \n maxx2 = largestRectangleArea(tab[0])\n \n for i in range(1,row):\n for j in range(col):\n if matrix[i][j]=='0':\n tab[i][j] = 0\n else:\n tab[i][j] = 1 + tab[i-1][j]\n maxx2 = max(maxx2, largestRectangleArea(tab[i]))\n return maxx2\n \n ","memory":"18100"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n def maxArea(heights):\n n = len(heights)\n left = list(range(n))\n right = list(range(n))\n\n # to right\n stack = []\n for i in range(n):\n cur = heights[i]\n if len(stack) == 0 or cur >= stack[-1][1]:\n stack.append((i, cur))\n else:\n while stack and cur < stack[-1][1]:\n top = stack.pop()\n right[top[0]] = i\n stack.append((i, cur))\n while stack:\n top = stack.pop()\n right[top[0]] = n\n # to left\n for i in range(n-1, -1, -1):\n cur = heights[i]\n if len(stack) == 0 or cur >= stack[-1][1]:\n stack.append((i, cur))\n else:\n while stack and cur < stack[-1][1]:\n top = stack.pop()\n left[top[0]] = i\n stack.append((i, cur))\n while stack:\n top = stack.pop()\n left[top[0]] = -1\n \n max_val = -1\n for i in range(n):\n s = left[i]\n e = right[i]\n h = heights[i]\n v = (e - s - 1) * h\n if max_val < v:\n max_val = v\n \n return max_val\n\n n = len(matrix)\n m = len(matrix[0])\n heights = [0] * m\n max_val = 0\n for i in range(n):\n for j in range(m):\n if matrix[i][j] == \"0\":\n heights[j] = 0\n else:\n heights[j] += int(matrix[i][j])\n val = maxArea(heights)\n if val > max_val:\n max_val = val\n \n return max_val\n","memory":"18100"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n rows = len(matrix)\n columns = len(matrix[0])\n maxArea = 0\n\n for i in range(rows) :\n for j in range(columns) :\n matrix[i][j] = ord(matrix[i][j]) - ord('0')\n\n for i in range(rows) :\n for j in range(columns-2, -1, -1) :\n if matrix[i][j] == 1 :\n matrix[i][j] += matrix[i][j+1]\n \n print(matrix)\n curMax = []\n for j in range(columns) :\n for i in range(rows) :\n print(i,j, maxArea, curMax)\n if(matrix[i][j] != 0) :\n lowest = i\n while(len(curMax) != 0) :\n if(curMax[0][0] < -matrix[i][j]) :\n val = heappop(curMax)\n maxArea = max(maxArea, -val[0]*(i - val[1]))\n lowest = val[1]\n else :\n break\n if(not (len(curMax) !=0 and curMax[0][0] == -matrix[i][j])) :\n heappush(curMax, (-matrix[i][j], lowest))\n else :\n while(len(curMax) !=0) :\n val = heappop(curMax)\n maxArea = max(maxArea, -val[0]*(i - val[1]))\n print(curMax)\n while(len(curMax) !=0) :\n val = heappop(curMax)\n maxArea = max(maxArea, -val[0]*(i - val[1] + 1))\n while(len(curMax) !=0) :\n val = heappop(curMax)\n maxArea = max(maxArea, -val[0]*(i - val[1] + 1))\n \n return maxArea","memory":"18200"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n #start end act1 act2\n #0 0 commit drop\n #0 2 cut_commit_keep add_rmndr\n #0 \n #\n #\n\n #rect : [ s,e,cnt, [c1,c2...] ] #childs are disjoint!; anyway optimal rectangles are ither non adjecent \n #one one includes other\n\n\n\n def get_spans(row):\n res=[]\n start=None\n for i,v in enumerate(row):\n if start is None:\n if v=='1':\n start=i\n else:\n if v=='0':\n res.append( [start,i,1,[]] ) \n start=None \n\n if start is not None:\n res.append( [start,i+1,1,[]] ) \n return res \n\n def area(rect,add):\n return (rect[1]-rect[0])*(rect[2]+add)\n\n def commit(rect,best,add=0):\n return max( best, area(rect,add), *( commit(rect_cld,0,add+rect[2]) for rect_cld in rect[3] ) )\n\n def cut_commit_keep(rect,best,loc,add=0):\n new_rect=[ loc,rect[1], rect[2], [] ]\n\n best=max(best, area(rect,add) )\n for cld in rect[3]:\n if cld[1]<=loc:\n best=max(best,commit(cld,0,rect[2]+add))\n elif cld[0]<loc:\n best_cld,cut_cld = cut_commit_keep( cld, 0, loc,rect[2]+add )\n best=max(best, best_cld)\n new_rect[3].append(cut_cld)\n else:\n new_rect[3].append( cld )\n\n return best, new_rect \n\n def cut_keep_keep(rect,best,loc,add=0):\n l_rect=[ rect[0], loc, rect[2], [] ]\n r_rect=[ loc,rect[1], rect[2],[] ]\n best=max(best,area(rect,add))\n for cld in rect[3]:\n if cld[1]<=loc:\n l_rect[3].append(cld)\n elif cld[0]>=loc:\n r_rect[3].append(cld)\n else:\n best, l_cld, r_cld = cut_keep_keep( cld, best,loc, rect[2]+add ) \n l_rect[3].append(l_cld)\n r_rect[3].append(r_cld)\n\n return best, l_rect, r_rect \n\n\n def get_next(i,lst):\n if len(lst)>i:\n return i+1, lst[i]\n else:\n return i, None \n\n\n best=0\n struct=[]\n for row in matrix:\n struct_new=[]\n\n j,prev=get_next(0,struct)\n spans=get_spans(row)\n k,span=get_next(0,spans)\n\n #print(prev,span)\n while prev is not None or span is not None:\n if prev is None:\n struct_new.append(span)\n k,span=get_next(k,spans)\n\n elif span is None: \n best=commit( prev, best )\n j,prev=get_next(j,struct)\n\n else: \n e1=prev[1]\n e2=span[1]\n #decide on left part\n if prev[1]<=span[0]:\n best=commit(prev,best)\n prev=None\n elif prev[0]<span[0]:\n best,prev=cut_commit_keep( prev, best, span[0] ) \n else:\n pass\n\n #decide on combination\n prev_next=None\n if prev is not None:\n if prev[0]>=span[1]:\n prev_next=prev #no combination\n prev=None\n elif prev[1]>span[1]: #slicing\n best,prev,prev_next=cut_keep_keep( prev,best, span[1] )\n else:\n pass\n\n if prev is not None:\n if prev[0]==span[0] and prev[1]==span[1]:\n span=prev\n span[2]+=1\n else:\n span[3].append(prev) \n\n #decide on next prev\n if prev_next is not None:\n prev=prev_next\n else:\n j,prev=get_next(j,struct) \n\n #on next span\n if e1>=e2:\n struct_new.append(span)\n k,span=get_next(k,spans) \n struct=struct_new\n #print(struct,best)\n for prev in struct:\n best=commit(prev,best)\n \n return best\n ","memory":"18300"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n #start end act1 act2\n #0 0 commit drop\n #0 2 cut_commit_keep add_rmndr\n #0 \n #\n #\n\n #rect : [ s,e,cnt, [c1,c2...] ] #childs are disjoint!; anyway optimal rectangles are ither non adjecent \n #one one includes other\n\n\n\n def get_spans(row):\n res=[]\n start=None\n for i,v in enumerate(row):\n if start is None:\n if v=='1':\n start=i\n else:\n if v=='0':\n res.append( [start,i,1,[]] ) \n start=None \n\n if start is not None:\n res.append( [start,i+1,1,[]] ) \n return res \n\n def area(rect,add):\n return (rect[1]-rect[0])*(rect[2]+add)\n\n def commit(rect,best,add=0):\n return max( best, area(rect,add), *( commit(rect_cld,0,add+rect[2]) for rect_cld in rect[3] ) )\n\n def cut_commit_keep(rect,best,loc,add=0):\n new_rect=[ loc,rect[1], rect[2], [] ]\n\n best=max(best, area(rect,add) )\n for cld in rect[3]:\n if cld[1]<=loc:\n best=max(best,commit(cld,0,rect[2]+add))\n elif cld[0]<loc:\n best_cld,cut_cld = cut_commit_keep( cld, 0, loc,rect[2]+add )\n best=max(best, best_cld)\n new_rect[3].append(cut_cld)\n else:\n new_rect[3].append( cld )\n\n return best, new_rect \n\n def cut_keep_keep(rect,best,loc,add=0):\n l_rect=[ rect[0], loc, rect[2], [] ]\n r_rect=[ loc,rect[1], rect[2],[] ]\n best=max(best,area(rect,add))\n for cld in rect[3]:\n if cld[1]<=loc:\n l_rect[3].append(cld)\n elif cld[0]>=loc:\n r_rect[3].append(cld)\n else:\n best, l_cld, r_cld = cut_keep_keep( cld, best,loc, rect[2]+add ) \n l_rect[3].append(l_cld)\n r_rect[3].append(r_cld)\n\n return best, l_rect, r_rect \n\n\n def get_next(i,lst):\n if len(lst)>i:\n return i+1, lst[i]\n else:\n return i, None \n\n\n best=0\n struct=[]\n for row in matrix:\n struct_new=[]\n\n j,prev=get_next(0,struct)\n spans=get_spans(row)\n k,span=get_next(0,spans)\n\n #print(prev,span)\n while prev is not None or span is not None:\n if prev is None:\n struct_new.append(span)\n k,span=get_next(k,spans)\n\n elif span is None: \n best=commit( prev, best )\n j,prev=get_next(j,struct)\n\n else: \n e1=prev[1]\n e2=span[1]\n #decide on left part\n if prev[1]<=span[0]:\n best=commit(prev,best)\n prev=None\n elif prev[0]<span[0]:\n best,prev=cut_commit_keep( prev, best, span[0] ) \n else:\n pass\n\n #decide on combination\n prev_next=None\n if prev is not None:\n if prev[0]>=span[1]:\n prev_next=prev #no combination\n prev=None\n elif prev[1]>span[1]: #slicing\n best,prev,prev_next=cut_keep_keep( prev,best, span[1] )\n else:\n pass\n\n if prev is not None:\n if prev[0]==span[0] and prev[1]==span[1]:\n span=prev\n span[2]+=1\n else:\n span[3].append(prev) \n\n #decide on next prev\n if prev_next is not None:\n prev=prev_next\n else:\n j,prev=get_next(j,struct) \n\n #on next span\n if e1>=e2:\n struct_new.append(span)\n k,span=get_next(k,spans) \n struct=struct_new\n #print(struct,best)\n for prev in struct:\n best=commit(prev,best)\n \n return best\n ","memory":"18300"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n #start end act1 act2\n #0 0 commit drop\n #0 2 cut_commit_keep add_rmndr\n #0 \n #\n #\n\n #rect : [ s,e,cnt, [c1,c2...] ] #childs are disjoint!; anyway optimal rectangles are ither non adjecent \n #one one includes other\n\n\n\n def get_spans(row):\n res=[]\n start=None\n for i,v in enumerate(row):\n if start is None:\n if v=='1':\n start=i\n else:\n if v=='0':\n res.append( [start,i,1,[]] ) \n start=None \n\n if start is not None:\n res.append( [start,i+1,1,[]] ) \n return res \n\n def area(rect,add):\n return (rect[1]-rect[0])*(rect[2]+add)\n\n def commit(rect,best,add=0):\n return max( best, area(rect,add), *( commit(rect_cld,0,add+rect[2]) for rect_cld in rect[3] ) )\n\n def cut_commit_keep(rect,best,loc,add=0):\n new_rect=[ loc,rect[1], rect[2], [] ]\n\n best=max(best, area(rect,add) )\n for cld in rect[3]:\n if cld[1]<=loc:\n best=commit(cld,best,rect[2]+add)\n elif cld[0]<loc:\n best,cut_cld = cut_commit_keep( cld, best, loc,rect[2]+add )\n new_rect[3].append(cut_cld)\n else:\n new_rect[3].append( cld )\n\n return best, new_rect \n\n def cut_keep_commit(rect,best,loc,add=0):\n new_rect=[rect[0],loc, rect[2], []] \n best=max(best, area(rect,add) ) \n for cld in rect[3]:\n if cld[0]>=loc:\n best=commit(cld,best,rect[2]+add)\n elif cld[1]>loc:\n best,cut_cld = cut_keep_commit(cld,best,loc,rect[2]+add) \n new_rect[3].append(cut_cld)\n else:\n new_rect[3].append(cld)\n return best,new_rect \n\n def cut_keep_keep(rect,best,loc,add=0):\n l_rect=[ rect[0], loc, rect[2], [] ]\n r_rect=[ loc,rect[1], rect[2],[] ]\n best=max(best,area(rect,add))\n for cld in rect[3]:\n if cld[1]<=loc:\n l_rect[3].append(cld)\n elif cld[0]>=loc:\n r_rect[3].append(cld)\n else:\n best, l_cld, r_cld = cut_keep_keep( cld, best,loc, rect[2]+add ) \n l_rect[3].append(l_cld)\n r_rect[3].append(r_cld)\n\n return best, l_rect, r_rect \n\n\n def get_next(i,lst):\n if len(lst)>i:\n return i+1, lst[i]\n else:\n return i, None \n\n L=len(matrix)\n best=0\n struct=[]\n for row in matrix:\n struct_new=[]\n\n j,prev=get_next(0,struct)\n spans=get_spans(row)\n k,span=get_next(0,spans)\n\n #print(prev,span)\n while prev is not None or span is not None:\n if prev is None:\n struct_new.append(span)\n k,span=get_next(k,spans)\n\n elif span is None: \n best=commit( prev, best )\n j,prev=get_next(j,struct)\n\n else: \n e1=prev[1]\n e2=span[1]\n #decide on left part\n if prev[1]<=span[0]:\n best=commit(prev,best)\n prev=None\n elif prev[0]<span[0]:\n best,prev=cut_commit_keep( prev, best, span[0] ) \n else:\n pass\n\n #decide on combination\n prev_next=None\n if prev is not None:\n if prev[0]>=span[1]:\n prev_next=prev #no combination\n prev=None\n elif prev[1]>span[1]: #slicing\n if len(spans)>k and prev[1]>spans[k][0]:\n best,prev,prev_next=cut_keep_keep( prev,best, span[1] )\n else:\n best,prev=cut_keep_commit(prev,best,span[1]) \n else:\n pass\n\n if prev is not None:\n if prev[0]==span[0] and prev[1]==span[1]:\n span=prev\n span[2]+=1\n else:\n span[3].append(prev) \n\n #decide on next prev\n if prev_next is not None:\n prev=prev_next\n else:\n j,prev=get_next(j,struct) \n\n #on next span\n if e1>=e2:\n if not span[3] and ( span[2]+L-k )*(span[1]-span[0] ) <=best:\n pass\n else: \n struct_new.append(span)\n k,span=get_next(k,spans) \n struct=struct_new\n #print(struct,best)\n for prev in struct:\n best=commit(prev,best)\n \n return best\n ","memory":"18400"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n #start end act1 act2\n #0 0 commit drop\n #0 2 cut_commit_keep add_rmndr\n #0 \n #\n #\n\n #rect : [ s,e,cnt, [c1,c2...] ] #childs are disjoint!; anyway optimal rectangles are ither non adjecent \n #one one includes other\n\n\n\n def get_spans(row):\n res=[]\n start=None\n for i,v in enumerate(row):\n if start is None:\n if v=='1':\n start=i\n else:\n if v=='0':\n res.append( [start,i,1,[]] ) \n start=None \n\n if start is not None:\n res.append( [start,i+1,1,[]] ) \n return res \n\n def area(rect,add):\n return (rect[1]-rect[0])*(rect[2]+add)\n\n def commit(rect,best,add=0):\n return max( best, area(rect,add), *( commit(rect_cld,0,add+rect[2]) for rect_cld in rect[3] ) )\n\n def cut_commit_keep(rect,best,loc,add=0):\n new_rect=[ loc,rect[1], rect[2], [] ]\n\n best=max(best, area(rect,add) )\n for cld in rect[3]:\n if cld[1]<=loc:\n best=commit(cld,best,rect[2]+add)\n elif cld[0]<loc:\n best,cut_cld = cut_commit_keep( cld, best, loc,rect[2]+add )\n new_rect[3].append(cut_cld)\n else:\n new_rect[3].append( cld )\n\n return best, new_rect \n\n def cut_keep_commit(rect,best,loc,add=0):\n new_rect=[rect[0],loc, rect[2], []] \n best=max(best, area(rect,add) ) \n for cld in rect[3]:\n if cld[0]>=loc:\n best=commit(cld,best,rect[2]+add)\n elif cld[1]>loc:\n best,cut_cld = cut_keep_commit(cld,best,loc,rect[2]+add) \n new_rect[3].append(cut_cld)\n else:\n new_rect[3].append(cld)\n return best,new_rect \n\n def cut_keep_keep(rect,best,loc,add=0):\n l_rect=[ rect[0], loc, rect[2], [] ]\n r_rect=[ loc,rect[1], rect[2],[] ]\n best=max(best,area(rect,add))\n for cld in rect[3]:\n if cld[1]<=loc:\n l_rect[3].append(cld)\n elif cld[0]>=loc:\n r_rect[3].append(cld)\n else:\n best, l_cld, r_cld = cut_keep_keep( cld, best,loc, rect[2]+add ) \n l_rect[3].append(l_cld)\n r_rect[3].append(r_cld)\n\n return best, l_rect, r_rect \n\n\n def get_next(i,lst):\n if len(lst)>i:\n return i+1, lst[i]\n else:\n return i, None \n\n L=len(matrix)\n best=0\n struct=[]\n for row in matrix:\n struct_new=[]\n\n j,prev=get_next(0,struct)\n spans=get_spans(row)\n k,span=get_next(0,spans)\n\n #print(prev,span)\n while prev is not None or span is not None:\n if prev is None:\n struct_new.append(span)\n k,span=get_next(k,spans)\n\n elif span is None: \n best=commit( prev, best )\n j,prev=get_next(j,struct)\n\n else: \n e1=prev[1]\n e2=span[1]\n #decide on left part\n if prev[1]<=span[0]:\n best=commit(prev,best)\n prev=None\n elif prev[0]<span[0]:\n best,prev=cut_commit_keep( prev, best, span[0] ) \n else:\n pass\n\n #decide on combination\n prev_next=None\n if prev is not None:\n if prev[0]>=span[1]:\n prev_next=prev #no combination\n prev=None\n elif prev[1]>span[1]: #slicing\n if len(spans)>k and prev[1]>spans[k][0]:\n best,prev,prev_next=cut_keep_keep( prev,best, span[1] )\n else:\n best,prev=cut_keep_commit(prev,best,span[1]) \n else:\n pass\n\n if prev is not None:\n if prev[0]==span[0] and prev[1]==span[1]:\n span=prev\n span[2]+=1\n else:\n span[3].append(prev) \n\n #decide on next prev\n if prev_next is not None:\n prev=prev_next\n else:\n j,prev=get_next(j,struct) \n\n #on next span\n if e1>=e2:\n if not span[3] and ( span[2]+L-k )*(span[1]-span[0] ) <=best:\n pass\n else: \n struct_new.append(span)\n k,span=get_next(k,spans) \n struct=struct_new\n #print(struct,best)\n for prev in struct:\n best=commit(prev,best)\n \n return best\n ","memory":"18400"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n ROWS = len(matrix)\n COLS = len(matrix[0])\n for r in range(ROWS):\n for c in range(COLS):\n matrix[r][c] = int(matrix[r][c])\n prefix = [[0] * (COLS + 1) for _ in range(ROWS + 1)]\n for r in range(1, ROWS+1):\n for c in range(1, COLS+1):\n prefix[r][c] = matrix[r-1][c-1] + prefix[r-1][c] + prefix[r][c-1] - prefix[r-1][c-1]\n \n def is_rectange(start, end):\n r_start, c_start = start\n r_end, c_end = end\n area = prefix[r_end+1][c_end+1] + prefix[r_start][c_start] - prefix[r_start][c_end+1] - prefix[r_end+1][c_start]\n is_rectangle = area == (r_end - r_start + 1) * (c_end - c_start + 1)\n return is_rectangle\n \n def get_area(start, end):\n r_start, c_start = start\n r_end, c_end = end\n return (r_end - r_start + 1) * (c_end - c_start + 1)\n\n max_area = 0\n for start_row in range(ROWS):\n for end_row in range(start_row, ROWS):\n cur = 0\n for i in range(COLS):\n if is_rectange((start_row, i), (end_row, i)):\n cur += get_area((start_row, i), (end_row, i))\n max_area = max(max_area, cur)\n else:\n cur = 0\n return max_area","memory":"18600"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n ROWS = len(matrix)\n COLS = len(matrix[0])\n for r in range(ROWS):\n for c in range(COLS):\n matrix[r][c] = int(matrix[r][c])\n prefix = [[0] * (COLS + 1) for _ in range(ROWS + 1)]\n for r in range(1, ROWS+1):\n for c in range(1, COLS+1):\n prefix[r][c] = matrix[r-1][c-1] + prefix[r-1][c] + prefix[r][c-1] - prefix[r-1][c-1]\n \n def is_rectange(start, end):\n # print(start, end)\n r_start, c_start = start\n r_end, c_end = end\n area = prefix[r_end+1][c_end+1] + prefix[r_start][c_start] - prefix[r_start][c_end+1] - prefix[r_end+1][c_start]\n is_rectangle = area == (r_end - r_start + 1) * (c_end - c_start + 1)\n return is_rectangle\n \n def get_area(start, end):\n r_start, c_start = start\n r_end, c_end = end\n return (r_end - r_start + 1) * (c_end - c_start + 1)\n\n max_area = 0\n for start_row in range(ROWS):\n for end_row in range(start_row, ROWS):\n # find the max rectangle:\n # local_max = 0\n cur = 0\n for i in range(COLS):\n if is_rectange((start_row, i), (end_row, i)):\n # print(\"hello\")\n cur += get_area((start_row, i), (end_row, i))\n max_area = max(max_area, cur)\n else:\n cur = 0\n return max_area\n","memory":"18700"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n pass\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_y, max_x = 1, 1\n\n @lru_cache(None)\n def recursion(y, x):\n nonlocal max_y, max_x\n if y < 0 or x < 0:\n return 0, 0\n\n min_y1, min_x1 = recursion(y-1, x)\n min_y2, min_x2 = recursion(y-1, x-1)\n min_y3, min_x3 = recursion(y, x-1)\n min_x = min(min_x1, min_x2, min_x3)\n min_y = min(min_y1, min_y2, min_y3)\n\n if matrix[y][x] == '1':\n min_x += 1\n min_y += 1\n max_y = max(max_y, min_y)\n max_x = max(max_x, min_x)\n else:\n min_x = 0\n min_y = 0\n return min_y, min_x\n \n recursion(len(matrix)-1, len(matrix[0])-1)\n return max_y * max_x\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_area = 0\n dp = [[0] * len(matrix[0]) for _ in range(len(matrix))]\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if matrix[i][j] == '0':\n continue\n \n if j >= 1:\n width = dp[i][j] = dp[i][j-1] + 1\n else:\n width = dp[i][j] = 1\n\n for k in range(i, -1, -1):\n width = min(width, dp[k][j])\n max_area = max(max_area, width * (i-k+1))\n return max_area\n\n\nclass Solution:\n def largestRectangleArea(self, heights: List[int]) -> int:\n if not heights:\n return 0 \n\n heights = heights + [0]\n stack = [-1]\n max_vol = heights[0]\n for i, h in enumerate(heights):\n while stack and stack[-1] != -1 and heights[stack[-1]] >= h:\n idx_popped = stack.pop()\n \n vol = (i - stack[-1] - 1) * heights[idx_popped]\n max_vol = max(max_vol, vol)\n stack.append(i)\n return max_vol\n\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n if not matrix:\n return 0\n\n max_area = 0\n dp = [0] * len(matrix[0])\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if matrix[i][j] == '1':\n dp[j] = dp[j] + 1\n else:\n dp[j] = 0\n max_area = max(max_area, self.largestRectangleArea(dp))\n return max_area\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n dp = [[0] * n for _ in range(m)]\n max_area = 0\n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '0':\n continue\n \n dp[y][x] = dp[y][x-1] + 1 if x > 0 else 1\n \n min_w = dp[y][x]\n for yy in range(y, -1, -1):\n min_w = min(min_w, dp[yy][x])\n area = (y - yy + 1) * min_w\n max_area = max(max_area, area)\n return max_area\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n dp = [0] * n\n max_area = 0\n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '1':\n dp[x] = dp[x] + 1\n else:\n dp[x] = 0\n \n area = self.hist(dp)\n max_area = max(max_area, area)\n return max_area\n \n def hist(self, dp):\n dp.append(0)\n max_area = 0\n stack = [-1]\n for i, h in enumerate(dp):\n while stack[-1] != -1 and dp[stack[-1]] >= h:\n idx_popped = stack.pop()\n area = (i - stack[-1] - 1) * dp[idx_popped]\n max_area = max(max_area, area)\n stack.append(i)\n return max_area\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_area = 0\n m, n = len(matrix), len(matrix[0])\n\n '''\n dp[y][x] stores length of continuous 1s in yth row, ending at xth col. \n Continuous 1s is counted only at yth row, from left to right, ending at xth col. \n See the figure in editorial. \n '''\n dp = [[0] * n for _ in range(m)]\n \n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '0':\n continue\n \n if x == 0:\n dp[y][x] = 1\n else:\n dp[y][x] = dp[y][x-1] + 1\n \n width = dp[y][x]\n for k in range(y, -1, -1):\n width = min(width, dp[k][x])\n max_area = max(max_area, width * (y - k + 1))\n return max_area\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_area = 0\n m, n = len(matrix), len(matrix[0])\n \n '''\n dp[x] counts the number of continuous 1s from to to the current row. \n If you think it as an histogram, it is a rotated version of the historgram from editorial approach 2. \n '''\n dp = [0] * n\n\n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '1':\n dp[x] = dp[x] + 1\n else:\n dp[x] = 0\n \n max_area = max(max_area, self.hist(dp))\n return max_area\n \n def hist(self, dp):\n dp += [0]\n stack = [-1]\n max_area = 0\n for i, h in enumerate(dp):\n while stack[-1] != -1 and dp[stack[-1]] >= h:\n popped_idx = stack.pop()\n height = dp[popped_idx]\n if not stack:\n break\n area = height * (i - stack[-1] - 1)\n max_area = max(area, max_area)\n stack.append(i)\n return max_area\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n dp = [0] * n\n max_area = 0\n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '1':\n dp[x] = dp[x] + 1\n else:\n dp[x] = 0\n area = self.hist(dp)\n max_area = max(max_area, area)\n return max_area\n \n def hist(self, arr):\n arr += [0]\n stack = [-1]\n max_area = 0\n for i in range(len(arr)):\n while stack[-1] != -1 and arr[stack[-1]] >= arr[i]:\n idx_popped = stack.pop()\n area = arr[idx_popped] * (i - stack[-1] - 1)\n max_area = max(max_area, area)\n stack.append(i)\n return max_area\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n dp = [0] * n\n max_area = 0\n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '1':\n dp[x] += 1\n else:\n dp[x] = 0\n area = self.hist(dp)\n max_area = max(max_area, area)\n return max_area\n \n def hist(self, arr):\n arr += [0]\n stack = [-1]\n max_area = 0\n for i in range(len(arr)):\n while stack[-1] != -1 and arr[stack[-1]] >= arr[i]:\n idx_popped = stack.pop()\n height = arr[idx_popped]\n area = height * (i - stack[-1] - 1)\n max_area = max(max_area, area)\n stack.append(i)\n return max_area\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n dp = [0] * n\n max_area = 0\n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '1':\n dp[x] += 1\n else:\n dp[x] = 0\n area = self.hist(dp)\n max_area = max(max_area, area)\n return max_area\n\n def hist(self, arr):\n arr += [0]\n stack = [-1]\n max_area = 0\n for i, num in enumerate(arr):\n while stack[-1] != -1 and arr[stack[-1]] >= num:\n idx_popped = stack.pop()\n height = arr[idx_popped]\n area = height * (i - stack[-1] -1)\n max_area = max(max_area, area)\n stack.append(i)\n return max_area\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n max_area = 0\n m, n = len(matrix), len(matrix[0])\n dp = [0] * n\n\n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '1':\n dp[x] += 1\n else:\n dp[x] = 0\n area = self.hist(dp)\n max_area = max(max_area, area)\n return max_area\n \n def hist(self, arr):\n if not arr:\n return 0\n arr += [0]\n stack = [-1]\n max_area = 0\n for i in range(len(arr)):\n while stack[-1] != -1 and arr[stack[-1]] >= arr[i]:\n idx_popped = stack.pop()\n height = arr[idx_popped]\n area = height * (i - stack[-1] - 1)\n max_area = max(max_area, area)\n stack.append(i)\n return max_area\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n dp = [0] * n\n max_area = 0\n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '1':\n dp[x] += 1\n else:\n dp[x] = 0\n area = self.hist(dp)\n max_area = max(max_area, area)\n return max_area\n\n def hist(self, arr):\n arr += [0]\n stack = [-1]\n max_area = 0\n for i in range(len(arr)):\n while stack[-1] != -1 and arr[stack[-1]] >= arr[i]:\n idx_popped = stack.pop()\n height = arr[idx_popped]\n area = height * (i - stack[-1] - 1)\n max_area = max(max_area, area)\n stack.append(i)\n return max_area\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n dp = [0] * n\n max_area = 0\n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '1':\n dp[x] += 1\n else:\n dp[x] = 0\n max_area = max(max_area, self.hist(dp))\n return max_area\n \n def hist(self, arr):\n arr += [0]\n stack = [-1]\n max_area = 0\n for i, h in enumerate(arr):\n while stack[-1] != -1 and arr[stack[-1]] >= h:\n idx_popped = stack.pop()\n height = arr[idx_popped]\n area = height * (i - stack[-1] - 1)\n max_area = max(max_area, area)\n stack.append(i)\n return max_area\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n m, n = len(matrix), len(matrix[0])\n dp = [0] * n\n max_area = 0\n for y in range(m):\n for x in range(n):\n if matrix[y][x] == '1':\n dp[x] += 1\n else:\n dp[x] = 0\n max_area = max(max_area, self.hist(dp))\n return max_area\n\n def hist(self, arr):\n arr += [0]\n stack = [-1]\n max_area = 0\n for i, h in enumerate(arr):\n while stack[-1] != -1 and arr[stack[-1]] >= h:\n idx_popped = stack.pop()\n height = arr[idx_popped]\n area = height * (i - stack[-1] -1)\n max_area = max(max_area, area)\n stack.append(i)\n return max_area\n ","memory":"18800"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n counts = [[0 for i in range(len(matrix[0])+1)] for j in range(len(matrix)+1)]\n out = 0\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n counts[i+1][j+1] += counts[i][j+1]\n counts[i+1][j+1] += counts[i+1][j]\n counts[i+1][j+1] -= counts[i][j]\n if matrix[i][j] == '1':\n counts[i+1][j+1] += 1\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if matrix[i][j] == '1':\n for x in range(i, len(matrix)):\n if matrix[x][j] == '1':\n l, r = j, len(matrix[0])-1\n while l<=r:\n y = (l+r)//2\n if matrix[x][y] == '1':\n temp = counts[x+1][y+1] - counts[i][y+1] - counts[x+1][j] + counts[i][j]\n if temp == (x-i+1)*(y-j+1):\n out = max(out, temp)\n l = y+1\n else:\n r = y-1\n else:\n r = y-1\n else:\n break\n\n return out\n\n\n\n","memory":"18900"},{"code":"class Solution:\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\n ROWS = len(matrix)\n COLS = len(matrix[0])\n for r in range(ROWS):\n for c in range(COLS):\n matrix[r][c] = int(matrix[r][c])\n prefix = [[0] * (COLS + 1) for _ in range(ROWS + 1)]\n for r in range(1, ROWS+1):\n for c in range(1, COLS+1):\n prefix[r][c] = matrix[r-1][c-1] + prefix[r-1][c] + prefix[r][c-1] - prefix[r-1][c-1]\n \n def is_rectange(start, end):\n r_start, c_start = start\n r_end, c_end = end\n area = prefix[r_end+1][c_end+1] + prefix[r_start][c_start] - prefix[r_start][c_end+1] - prefix[r_end+1][c_start]\n is_rectangle = area == (r_end - r_start + 1) * (c_end - c_start + 1)\n return is_rectangle\n \n def get_area(start, end):\n r_start, c_start = start\n r_end, c_end = end\n return (r_end - r_start + 1) * (c_end - c_start + 1)\n\n max_area = 0\n for start_row in range(ROWS):\n for end_row in range(start_row, ROWS):\n cur = 0\n for i in range(COLS):\n if is_rectange((start_row, i), (end_row, i)):\n cur += get_area((start_row, i), (end_row, i))\n max_area = max(max_area, cur)\n else:\n cur = 0\n return max_area","memory":"19000"}],"string":"[\n {\n \"code\": \"def largestRectangleArea(heights: List[int]) -> int:\\n stack = []\\n max_area = 0\\n heights.append(0) \\n\\n for i in range(len(heights)):\\n while stack and heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i if not stack else i - stack[-1] - 1\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n \\n heights.pop() \\n return max_area\\n\\n\\nclass Solution:\\n def maximalRectangle(matrix: List[List[str]]) -> int:\\n if not matrix or not matrix[0]:\\n return 0\\n \\n n_cols = len(matrix[0])\\n heights = [0] * n_cols\\n max_area = 0\\n\\n for row in matrix:\\n for i in range(n_cols):\\n \\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n \\n max_area = max(max_area, largestRectangleArea(heights))\\n \\n return max_area\\n\\n with open('user.out','w') as f:\\n for i in map(loads, stdin):\\n print(maximalRectangle(i), file=f)\\n exit(0)\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def mrec(matrix: List[List[str]], k, l, mms):\\n n = len(matrix)\\n m = len(matrix[0])\\n ms = mms\\n pj = m\\n i = k\\n if (n - k) * (pj - l) <= ms:\\n return ms\\n while i < n:\\n if (n - k) * (pj - l) <= ms:\\n break\\n j = l\\n while j < pj:\\n if matrix[i][j] == '0':\\n break\\n j += 1\\n s = (i - k + 1) * (j - l)\\n if s > ms:\\n ms = s\\n pj = j\\n i += 1\\n return ms\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n n = len(matrix)\\n m = 0 if n == 0 else len(matrix[0])\\n ms = 0\\n for i in range(n):\\n for j in range(m):\\n # if ((n - i) * (m - j)) < ms:\\n # break\\n s = self.mrec(matrix, i, j, ms)\\n if s > ms:\\n ms = s\\n return ms\\n\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def check_col(r,c):\\n if r==len(matrix) or matrix[r][c]=='0':\\n return 0\\n matrix[r][c] = check_col(r+1,c) + 1\\n return matrix[r][c]\\n\\n def check_row(r,c):\\n global max_rec\\n min_col = 1e9\\n count = 0\\n while not(c+count==len(matrix[0]) or matrix[r][c+count]=='0'):\\n count+=1\\n min_col = min(min_col, check_col(r,c+count-1))\\n max_rec = max(max_rec, count*min_col)\\n if (len(matrix[0])-c)*min_col<max_rec:\\n return\\n \\n global max_rec\\n max_rec = 0\\n for c in range(len(matrix[0])):\\n for r in range(len(matrix)):\\n check_row(r,c)\\n return max_rec\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n\\n def maximalRectangle(self, matrix):\\n if not matrix:\\n return 0\\n \\n rows, cols = len(matrix), len(matrix[0])\\n heights = [0] * cols\\n max_area = 0\\n \\n for row in matrix:\\n for i in range(cols):\\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n max_area = max(max_area, self.maxHistogramArea(heights))\\n \\n return max_area\\n \\n def maxHistogramArea(self, heights):\\n stack = []\\n max_area = 0\\n heights.append(0) # Sentinel value to ensure stack is emptied at the end\\n \\n for i in range(len(heights)):\\n while stack and heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i if not stack else i - stack[-1] - 1\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n \\n heights.pop() # Remove sentinel value\\n return max_area\\n\",\n \"memory\": \"17500\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n r, c=len(matrix), len(matrix[0])\\n if r==1 and c==1:\\n if matrix[0][0]=='1': return 1\\n else: return 0\\n h=[0]*(c+1)\\n maxArea=0\\n\\n for i, row in enumerate(matrix):\\n st=[-1] \\n row.append('0')\\n for j, x in enumerate(row):\\n # build h\\n if x=='1': h[j]+=1\\n else: h[j]=0\\n # mononotonic stack has at leat element -1\\n while len(st)>1 and (j==c or h[j]<h[st[-1]]):\\n m=st[-1]\\n st.pop()\\n w=j-st[-1]-1\\n area=h[m]*w\\n maxArea=max(maxArea, area)\\n st.append(j)\\n return maxArea\\n\\n \",\n \"memory\": \"17600\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix:\\n return 0\\n\\n n = len(matrix[0])\\n heights = [0] * (n + 1)\\n max_area = 0\\n\\n for row in matrix:\\n \\n for i in range(n):\\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n \\n stack = [-1]\\n for i in range(n + 1):\\n while heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i - 1 - stack[-1]\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n\\n return max_area\",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def calc(heights):\\n res = 0\\n heights.append(-1)\\n stack = [-1]\\n for i in range(len(heights)):\\n while stack and heights[stack[-1]] > heights[i]:\\n h = heights[stack.pop()]\\n w = i - stack[-1] - 1\\n res = max(res, h * w)\\n stack.append(i)\\n return res\\n\\n m, n = len(matrix), len(matrix[0])\\n result = 0\\n heights = [0] * n\\n for i in range(m):\\n for j in range(n):\\n if matrix[i][j] == '1':\\n heights[j] += int(matrix[i][j])\\n else:\\n heights[j] = 0\\n result = max(result, calc(heights))\\n return result\\n\\n \",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix:\\n return 0\\n\\n n = len(matrix[0])\\n heights = [0] * (n + 1)\\n max_area = 0\\n\\n for row in matrix:\\n \\n for i in range(n):\\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n \\n stack = [-1]\\n for i in range(n + 1):\\n while heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i - 1 - stack[-1]\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n\\n return max_area\",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix:\\n return 0\\n\\n n = len(matrix[0])\\n heights = [0] * (n + 1)\\n max_area = 0\\n\\n for row in matrix:\\n \\n for i in range(n):\\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n \\n stack = [-1]\\n for i in range(n + 1):\\n while heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i - 1 - stack[-1]\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n\\n return max_area\",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix:\\n return 0\\n\\n n = len(matrix[0])\\n heights = [0] * (n + 1)\\n max_area = 0\\n\\n for row in matrix:\\n \\n for i in range(n):\\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n \\n stack = [-1]\\n for i in range(n + 1):\\n while heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i - 1 - stack[-1]\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n\\n return max_area\",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def calc(heights):\\n res = 0\\n heights.append(-1)\\n stack = [-1]\\n for i in range(len(heights)):\\n while stack and heights[stack[-1]] > heights[i]:\\n h = heights[stack.pop()]\\n w = i - stack[-1] - 1\\n res = max(res, h * w)\\n stack.append(i)\\n return res\\n\\n m, n = len(matrix), len(matrix[0])\\n result = 0\\n heights = [0] * n\\n for i in range(m):\\n for j in range(n):\\n if int(matrix[i][j]) == 1:\\n heights[j] += int(matrix[i][j])\\n else:\\n heights[j] = 0\\n result = max(result, calc(heights))\\n return result\\n\\n \",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix:\\n return 0\\n\\n n = len(matrix[0])\\n heights = [0] * (n + 1)\\n max_area = 0\\n\\n for row in matrix:\\n \\n for i in range(n):\\n heights[i] = heights[i] + 1 if row[i] == '1' else 0\\n \\n \\n stack = [-1]\\n for i in range(n + 1):\\n while heights[i] < heights[stack[-1]]:\\n h = heights[stack.pop()]\\n w = i - 1 - stack[-1]\\n max_area = max(max_area, h * w)\\n stack.append(i)\\n\\n return max_area\",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: list[list[str]]) -> int:\\n if not matrix:\\n return 0\\n\\n ans = 0\\n hist = [0] * len(matrix[0])\\n\\n def largestRectangleArea(heights: list[int]) -> int:\\n ans = 0\\n stack = []\\n\\n for i in range(len(heights) + 1):\\n while stack and (i == len(heights) or heights[stack[-1]] > heights[i]):\\n h = heights[stack.pop()]\\n w = i - stack[-1] - 1 if stack else i\\n ans = max(ans, h * w)\\n stack.append(i)\\n\\n return ans\\n\\n for row in matrix:\\n for i, num in enumerate(row):\\n hist[i] = 0 if num == '0' else hist[i] + 1\\n ans = max(ans, largestRectangleArea(hist))\\n\\n return ans\",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n row = len(matrix)\\n col = len(matrix[0])\\n tab = [ [0 for _ in range(col)] for _ in range(row)]\\n\\n def largestRectangleArea(heights: List[int]) -> int:\\n n = len(heights)\\n stk = [] \\n maxx = 0\\n\\n for i in range(n):\\n start = i\\n while stk and heights[i]<stk[-1][1]:\\n maxx = max(maxx, stk[-1][1]*( i - stk[-1][0]) ) \\n start=stk.pop()[0]\\n stk.append([start, heights[i]])\\n \\n while stk:\\n maxx= max(maxx, stk[-1][1]*( n - stk[-1][0]))\\n stk.pop()\\n return maxx\\n\\n for i in range(col):\\n if matrix[0][i]=='0':\\n tab[0][i]=0\\n else:\\n tab[0][i]=1\\n \\n maxx2 = largestRectangleArea(tab[0])\\n \\n for i in range(1,row):\\n for j in range(col):\\n if matrix[i][j]=='0':\\n tab[i][j] = 0\\n else:\\n tab[i][j] = 1 + tab[i-1][j]\\n maxx2 = max(maxx2, largestRectangleArea(tab[i]))\\n return maxx2\\n \\n \",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n def maxArea(heights):\\n n = len(heights)\\n left = list(range(n))\\n right = list(range(n))\\n\\n # to right\\n stack = []\\n for i in range(n):\\n cur = heights[i]\\n if len(stack) == 0 or cur >= stack[-1][1]:\\n stack.append((i, cur))\\n else:\\n while stack and cur < stack[-1][1]:\\n top = stack.pop()\\n right[top[0]] = i\\n stack.append((i, cur))\\n while stack:\\n top = stack.pop()\\n right[top[0]] = n\\n # to left\\n for i in range(n-1, -1, -1):\\n cur = heights[i]\\n if len(stack) == 0 or cur >= stack[-1][1]:\\n stack.append((i, cur))\\n else:\\n while stack and cur < stack[-1][1]:\\n top = stack.pop()\\n left[top[0]] = i\\n stack.append((i, cur))\\n while stack:\\n top = stack.pop()\\n left[top[0]] = -1\\n \\n max_val = -1\\n for i in range(n):\\n s = left[i]\\n e = right[i]\\n h = heights[i]\\n v = (e - s - 1) * h\\n if max_val < v:\\n max_val = v\\n \\n return max_val\\n\\n n = len(matrix)\\n m = len(matrix[0])\\n heights = [0] * m\\n max_val = 0\\n for i in range(n):\\n for j in range(m):\\n if matrix[i][j] == \\\"0\\\":\\n heights[j] = 0\\n else:\\n heights[j] += int(matrix[i][j])\\n val = maxArea(heights)\\n if val > max_val:\\n max_val = val\\n \\n return max_val\\n\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n rows = len(matrix)\\n columns = len(matrix[0])\\n maxArea = 0\\n\\n for i in range(rows) :\\n for j in range(columns) :\\n matrix[i][j] = ord(matrix[i][j]) - ord('0')\\n\\n for i in range(rows) :\\n for j in range(columns-2, -1, -1) :\\n if matrix[i][j] == 1 :\\n matrix[i][j] += matrix[i][j+1]\\n \\n print(matrix)\\n curMax = []\\n for j in range(columns) :\\n for i in range(rows) :\\n print(i,j, maxArea, curMax)\\n if(matrix[i][j] != 0) :\\n lowest = i\\n while(len(curMax) != 0) :\\n if(curMax[0][0] < -matrix[i][j]) :\\n val = heappop(curMax)\\n maxArea = max(maxArea, -val[0]*(i - val[1]))\\n lowest = val[1]\\n else :\\n break\\n if(not (len(curMax) !=0 and curMax[0][0] == -matrix[i][j])) :\\n heappush(curMax, (-matrix[i][j], lowest))\\n else :\\n while(len(curMax) !=0) :\\n val = heappop(curMax)\\n maxArea = max(maxArea, -val[0]*(i - val[1]))\\n print(curMax)\\n while(len(curMax) !=0) :\\n val = heappop(curMax)\\n maxArea = max(maxArea, -val[0]*(i - val[1] + 1))\\n while(len(curMax) !=0) :\\n val = heappop(curMax)\\n maxArea = max(maxArea, -val[0]*(i - val[1] + 1))\\n \\n return maxArea\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n #start end act1 act2\\n #0 0 commit drop\\n #0 2 cut_commit_keep add_rmndr\\n #0 \\n #\\n #\\n\\n #rect : [ s,e,cnt, [c1,c2...] ] #childs are disjoint!; anyway optimal rectangles are ither non adjecent \\n #one one includes other\\n\\n\\n\\n def get_spans(row):\\n res=[]\\n start=None\\n for i,v in enumerate(row):\\n if start is None:\\n if v=='1':\\n start=i\\n else:\\n if v=='0':\\n res.append( [start,i,1,[]] ) \\n start=None \\n\\n if start is not None:\\n res.append( [start,i+1,1,[]] ) \\n return res \\n\\n def area(rect,add):\\n return (rect[1]-rect[0])*(rect[2]+add)\\n\\n def commit(rect,best,add=0):\\n return max( best, area(rect,add), *( commit(rect_cld,0,add+rect[2]) for rect_cld in rect[3] ) )\\n\\n def cut_commit_keep(rect,best,loc,add=0):\\n new_rect=[ loc,rect[1], rect[2], [] ]\\n\\n best=max(best, area(rect,add) )\\n for cld in rect[3]:\\n if cld[1]<=loc:\\n best=max(best,commit(cld,0,rect[2]+add))\\n elif cld[0]<loc:\\n best_cld,cut_cld = cut_commit_keep( cld, 0, loc,rect[2]+add )\\n best=max(best, best_cld)\\n new_rect[3].append(cut_cld)\\n else:\\n new_rect[3].append( cld )\\n\\n return best, new_rect \\n\\n def cut_keep_keep(rect,best,loc,add=0):\\n l_rect=[ rect[0], loc, rect[2], [] ]\\n r_rect=[ loc,rect[1], rect[2],[] ]\\n best=max(best,area(rect,add))\\n for cld in rect[3]:\\n if cld[1]<=loc:\\n l_rect[3].append(cld)\\n elif cld[0]>=loc:\\n r_rect[3].append(cld)\\n else:\\n best, l_cld, r_cld = cut_keep_keep( cld, best,loc, rect[2]+add ) \\n l_rect[3].append(l_cld)\\n r_rect[3].append(r_cld)\\n\\n return best, l_rect, r_rect \\n\\n\\n def get_next(i,lst):\\n if len(lst)>i:\\n return i+1, lst[i]\\n else:\\n return i, None \\n\\n\\n best=0\\n struct=[]\\n for row in matrix:\\n struct_new=[]\\n\\n j,prev=get_next(0,struct)\\n spans=get_spans(row)\\n k,span=get_next(0,spans)\\n\\n #print(prev,span)\\n while prev is not None or span is not None:\\n if prev is None:\\n struct_new.append(span)\\n k,span=get_next(k,spans)\\n\\n elif span is None: \\n best=commit( prev, best )\\n j,prev=get_next(j,struct)\\n\\n else: \\n e1=prev[1]\\n e2=span[1]\\n #decide on left part\\n if prev[1]<=span[0]:\\n best=commit(prev,best)\\n prev=None\\n elif prev[0]<span[0]:\\n best,prev=cut_commit_keep( prev, best, span[0] ) \\n else:\\n pass\\n\\n #decide on combination\\n prev_next=None\\n if prev is not None:\\n if prev[0]>=span[1]:\\n prev_next=prev #no combination\\n prev=None\\n elif prev[1]>span[1]: #slicing\\n best,prev,prev_next=cut_keep_keep( prev,best, span[1] )\\n else:\\n pass\\n\\n if prev is not None:\\n if prev[0]==span[0] and prev[1]==span[1]:\\n span=prev\\n span[2]+=1\\n else:\\n span[3].append(prev) \\n\\n #decide on next prev\\n if prev_next is not None:\\n prev=prev_next\\n else:\\n j,prev=get_next(j,struct) \\n\\n #on next span\\n if e1>=e2:\\n struct_new.append(span)\\n k,span=get_next(k,spans) \\n struct=struct_new\\n #print(struct,best)\\n for prev in struct:\\n best=commit(prev,best)\\n \\n return best\\n \",\n \"memory\": \"18300\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n #start end act1 act2\\n #0 0 commit drop\\n #0 2 cut_commit_keep add_rmndr\\n #0 \\n #\\n #\\n\\n #rect : [ s,e,cnt, [c1,c2...] ] #childs are disjoint!; anyway optimal rectangles are ither non adjecent \\n #one one includes other\\n\\n\\n\\n def get_spans(row):\\n res=[]\\n start=None\\n for i,v in enumerate(row):\\n if start is None:\\n if v=='1':\\n start=i\\n else:\\n if v=='0':\\n res.append( [start,i,1,[]] ) \\n start=None \\n\\n if start is not None:\\n res.append( [start,i+1,1,[]] ) \\n return res \\n\\n def area(rect,add):\\n return (rect[1]-rect[0])*(rect[2]+add)\\n\\n def commit(rect,best,add=0):\\n return max( best, area(rect,add), *( commit(rect_cld,0,add+rect[2]) for rect_cld in rect[3] ) )\\n\\n def cut_commit_keep(rect,best,loc,add=0):\\n new_rect=[ loc,rect[1], rect[2], [] ]\\n\\n best=max(best, area(rect,add) )\\n for cld in rect[3]:\\n if cld[1]<=loc:\\n best=max(best,commit(cld,0,rect[2]+add))\\n elif cld[0]<loc:\\n best_cld,cut_cld = cut_commit_keep( cld, 0, loc,rect[2]+add )\\n best=max(best, best_cld)\\n new_rect[3].append(cut_cld)\\n else:\\n new_rect[3].append( cld )\\n\\n return best, new_rect \\n\\n def cut_keep_keep(rect,best,loc,add=0):\\n l_rect=[ rect[0], loc, rect[2], [] ]\\n r_rect=[ loc,rect[1], rect[2],[] ]\\n best=max(best,area(rect,add))\\n for cld in rect[3]:\\n if cld[1]<=loc:\\n l_rect[3].append(cld)\\n elif cld[0]>=loc:\\n r_rect[3].append(cld)\\n else:\\n best, l_cld, r_cld = cut_keep_keep( cld, best,loc, rect[2]+add ) \\n l_rect[3].append(l_cld)\\n r_rect[3].append(r_cld)\\n\\n return best, l_rect, r_rect \\n\\n\\n def get_next(i,lst):\\n if len(lst)>i:\\n return i+1, lst[i]\\n else:\\n return i, None \\n\\n\\n best=0\\n struct=[]\\n for row in matrix:\\n struct_new=[]\\n\\n j,prev=get_next(0,struct)\\n spans=get_spans(row)\\n k,span=get_next(0,spans)\\n\\n #print(prev,span)\\n while prev is not None or span is not None:\\n if prev is None:\\n struct_new.append(span)\\n k,span=get_next(k,spans)\\n\\n elif span is None: \\n best=commit( prev, best )\\n j,prev=get_next(j,struct)\\n\\n else: \\n e1=prev[1]\\n e2=span[1]\\n #decide on left part\\n if prev[1]<=span[0]:\\n best=commit(prev,best)\\n prev=None\\n elif prev[0]<span[0]:\\n best,prev=cut_commit_keep( prev, best, span[0] ) \\n else:\\n pass\\n\\n #decide on combination\\n prev_next=None\\n if prev is not None:\\n if prev[0]>=span[1]:\\n prev_next=prev #no combination\\n prev=None\\n elif prev[1]>span[1]: #slicing\\n best,prev,prev_next=cut_keep_keep( prev,best, span[1] )\\n else:\\n pass\\n\\n if prev is not None:\\n if prev[0]==span[0] and prev[1]==span[1]:\\n span=prev\\n span[2]+=1\\n else:\\n span[3].append(prev) \\n\\n #decide on next prev\\n if prev_next is not None:\\n prev=prev_next\\n else:\\n j,prev=get_next(j,struct) \\n\\n #on next span\\n if e1>=e2:\\n struct_new.append(span)\\n k,span=get_next(k,spans) \\n struct=struct_new\\n #print(struct,best)\\n for prev in struct:\\n best=commit(prev,best)\\n \\n return best\\n \",\n \"memory\": \"18300\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n #start end act1 act2\\n #0 0 commit drop\\n #0 2 cut_commit_keep add_rmndr\\n #0 \\n #\\n #\\n\\n #rect : [ s,e,cnt, [c1,c2...] ] #childs are disjoint!; anyway optimal rectangles are ither non adjecent \\n #one one includes other\\n\\n\\n\\n def get_spans(row):\\n res=[]\\n start=None\\n for i,v in enumerate(row):\\n if start is None:\\n if v=='1':\\n start=i\\n else:\\n if v=='0':\\n res.append( [start,i,1,[]] ) \\n start=None \\n\\n if start is not None:\\n res.append( [start,i+1,1,[]] ) \\n return res \\n\\n def area(rect,add):\\n return (rect[1]-rect[0])*(rect[2]+add)\\n\\n def commit(rect,best,add=0):\\n return max( best, area(rect,add), *( commit(rect_cld,0,add+rect[2]) for rect_cld in rect[3] ) )\\n\\n def cut_commit_keep(rect,best,loc,add=0):\\n new_rect=[ loc,rect[1], rect[2], [] ]\\n\\n best=max(best, area(rect,add) )\\n for cld in rect[3]:\\n if cld[1]<=loc:\\n best=commit(cld,best,rect[2]+add)\\n elif cld[0]<loc:\\n best,cut_cld = cut_commit_keep( cld, best, loc,rect[2]+add )\\n new_rect[3].append(cut_cld)\\n else:\\n new_rect[3].append( cld )\\n\\n return best, new_rect \\n\\n def cut_keep_commit(rect,best,loc,add=0):\\n new_rect=[rect[0],loc, rect[2], []] \\n best=max(best, area(rect,add) ) \\n for cld in rect[3]:\\n if cld[0]>=loc:\\n best=commit(cld,best,rect[2]+add)\\n elif cld[1]>loc:\\n best,cut_cld = cut_keep_commit(cld,best,loc,rect[2]+add) \\n new_rect[3].append(cut_cld)\\n else:\\n new_rect[3].append(cld)\\n return best,new_rect \\n\\n def cut_keep_keep(rect,best,loc,add=0):\\n l_rect=[ rect[0], loc, rect[2], [] ]\\n r_rect=[ loc,rect[1], rect[2],[] ]\\n best=max(best,area(rect,add))\\n for cld in rect[3]:\\n if cld[1]<=loc:\\n l_rect[3].append(cld)\\n elif cld[0]>=loc:\\n r_rect[3].append(cld)\\n else:\\n best, l_cld, r_cld = cut_keep_keep( cld, best,loc, rect[2]+add ) \\n l_rect[3].append(l_cld)\\n r_rect[3].append(r_cld)\\n\\n return best, l_rect, r_rect \\n\\n\\n def get_next(i,lst):\\n if len(lst)>i:\\n return i+1, lst[i]\\n else:\\n return i, None \\n\\n L=len(matrix)\\n best=0\\n struct=[]\\n for row in matrix:\\n struct_new=[]\\n\\n j,prev=get_next(0,struct)\\n spans=get_spans(row)\\n k,span=get_next(0,spans)\\n\\n #print(prev,span)\\n while prev is not None or span is not None:\\n if prev is None:\\n struct_new.append(span)\\n k,span=get_next(k,spans)\\n\\n elif span is None: \\n best=commit( prev, best )\\n j,prev=get_next(j,struct)\\n\\n else: \\n e1=prev[1]\\n e2=span[1]\\n #decide on left part\\n if prev[1]<=span[0]:\\n best=commit(prev,best)\\n prev=None\\n elif prev[0]<span[0]:\\n best,prev=cut_commit_keep( prev, best, span[0] ) \\n else:\\n pass\\n\\n #decide on combination\\n prev_next=None\\n if prev is not None:\\n if prev[0]>=span[1]:\\n prev_next=prev #no combination\\n prev=None\\n elif prev[1]>span[1]: #slicing\\n if len(spans)>k and prev[1]>spans[k][0]:\\n best,prev,prev_next=cut_keep_keep( prev,best, span[1] )\\n else:\\n best,prev=cut_keep_commit(prev,best,span[1]) \\n else:\\n pass\\n\\n if prev is not None:\\n if prev[0]==span[0] and prev[1]==span[1]:\\n span=prev\\n span[2]+=1\\n else:\\n span[3].append(prev) \\n\\n #decide on next prev\\n if prev_next is not None:\\n prev=prev_next\\n else:\\n j,prev=get_next(j,struct) \\n\\n #on next span\\n if e1>=e2:\\n if not span[3] and ( span[2]+L-k )*(span[1]-span[0] ) <=best:\\n pass\\n else: \\n struct_new.append(span)\\n k,span=get_next(k,spans) \\n struct=struct_new\\n #print(struct,best)\\n for prev in struct:\\n best=commit(prev,best)\\n \\n return best\\n \",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n #start end act1 act2\\n #0 0 commit drop\\n #0 2 cut_commit_keep add_rmndr\\n #0 \\n #\\n #\\n\\n #rect : [ s,e,cnt, [c1,c2...] ] #childs are disjoint!; anyway optimal rectangles are ither non adjecent \\n #one one includes other\\n\\n\\n\\n def get_spans(row):\\n res=[]\\n start=None\\n for i,v in enumerate(row):\\n if start is None:\\n if v=='1':\\n start=i\\n else:\\n if v=='0':\\n res.append( [start,i,1,[]] ) \\n start=None \\n\\n if start is not None:\\n res.append( [start,i+1,1,[]] ) \\n return res \\n\\n def area(rect,add):\\n return (rect[1]-rect[0])*(rect[2]+add)\\n\\n def commit(rect,best,add=0):\\n return max( best, area(rect,add), *( commit(rect_cld,0,add+rect[2]) for rect_cld in rect[3] ) )\\n\\n def cut_commit_keep(rect,best,loc,add=0):\\n new_rect=[ loc,rect[1], rect[2], [] ]\\n\\n best=max(best, area(rect,add) )\\n for cld in rect[3]:\\n if cld[1]<=loc:\\n best=commit(cld,best,rect[2]+add)\\n elif cld[0]<loc:\\n best,cut_cld = cut_commit_keep( cld, best, loc,rect[2]+add )\\n new_rect[3].append(cut_cld)\\n else:\\n new_rect[3].append( cld )\\n\\n return best, new_rect \\n\\n def cut_keep_commit(rect,best,loc,add=0):\\n new_rect=[rect[0],loc, rect[2], []] \\n best=max(best, area(rect,add) ) \\n for cld in rect[3]:\\n if cld[0]>=loc:\\n best=commit(cld,best,rect[2]+add)\\n elif cld[1]>loc:\\n best,cut_cld = cut_keep_commit(cld,best,loc,rect[2]+add) \\n new_rect[3].append(cut_cld)\\n else:\\n new_rect[3].append(cld)\\n return best,new_rect \\n\\n def cut_keep_keep(rect,best,loc,add=0):\\n l_rect=[ rect[0], loc, rect[2], [] ]\\n r_rect=[ loc,rect[1], rect[2],[] ]\\n best=max(best,area(rect,add))\\n for cld in rect[3]:\\n if cld[1]<=loc:\\n l_rect[3].append(cld)\\n elif cld[0]>=loc:\\n r_rect[3].append(cld)\\n else:\\n best, l_cld, r_cld = cut_keep_keep( cld, best,loc, rect[2]+add ) \\n l_rect[3].append(l_cld)\\n r_rect[3].append(r_cld)\\n\\n return best, l_rect, r_rect \\n\\n\\n def get_next(i,lst):\\n if len(lst)>i:\\n return i+1, lst[i]\\n else:\\n return i, None \\n\\n L=len(matrix)\\n best=0\\n struct=[]\\n for row in matrix:\\n struct_new=[]\\n\\n j,prev=get_next(0,struct)\\n spans=get_spans(row)\\n k,span=get_next(0,spans)\\n\\n #print(prev,span)\\n while prev is not None or span is not None:\\n if prev is None:\\n struct_new.append(span)\\n k,span=get_next(k,spans)\\n\\n elif span is None: \\n best=commit( prev, best )\\n j,prev=get_next(j,struct)\\n\\n else: \\n e1=prev[1]\\n e2=span[1]\\n #decide on left part\\n if prev[1]<=span[0]:\\n best=commit(prev,best)\\n prev=None\\n elif prev[0]<span[0]:\\n best,prev=cut_commit_keep( prev, best, span[0] ) \\n else:\\n pass\\n\\n #decide on combination\\n prev_next=None\\n if prev is not None:\\n if prev[0]>=span[1]:\\n prev_next=prev #no combination\\n prev=None\\n elif prev[1]>span[1]: #slicing\\n if len(spans)>k and prev[1]>spans[k][0]:\\n best,prev,prev_next=cut_keep_keep( prev,best, span[1] )\\n else:\\n best,prev=cut_keep_commit(prev,best,span[1]) \\n else:\\n pass\\n\\n if prev is not None:\\n if prev[0]==span[0] and prev[1]==span[1]:\\n span=prev\\n span[2]+=1\\n else:\\n span[3].append(prev) \\n\\n #decide on next prev\\n if prev_next is not None:\\n prev=prev_next\\n else:\\n j,prev=get_next(j,struct) \\n\\n #on next span\\n if e1>=e2:\\n if not span[3] and ( span[2]+L-k )*(span[1]-span[0] ) <=best:\\n pass\\n else: \\n struct_new.append(span)\\n k,span=get_next(k,spans) \\n struct=struct_new\\n #print(struct,best)\\n for prev in struct:\\n best=commit(prev,best)\\n \\n return best\\n \",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n ROWS = len(matrix)\\n COLS = len(matrix[0])\\n for r in range(ROWS):\\n for c in range(COLS):\\n matrix[r][c] = int(matrix[r][c])\\n prefix = [[0] * (COLS + 1) for _ in range(ROWS + 1)]\\n for r in range(1, ROWS+1):\\n for c in range(1, COLS+1):\\n prefix[r][c] = matrix[r-1][c-1] + prefix[r-1][c] + prefix[r][c-1] - prefix[r-1][c-1]\\n \\n def is_rectange(start, end):\\n r_start, c_start = start\\n r_end, c_end = end\\n area = prefix[r_end+1][c_end+1] + prefix[r_start][c_start] - prefix[r_start][c_end+1] - prefix[r_end+1][c_start]\\n is_rectangle = area == (r_end - r_start + 1) * (c_end - c_start + 1)\\n return is_rectangle\\n \\n def get_area(start, end):\\n r_start, c_start = start\\n r_end, c_end = end\\n return (r_end - r_start + 1) * (c_end - c_start + 1)\\n\\n max_area = 0\\n for start_row in range(ROWS):\\n for end_row in range(start_row, ROWS):\\n cur = 0\\n for i in range(COLS):\\n if is_rectange((start_row, i), (end_row, i)):\\n cur += get_area((start_row, i), (end_row, i))\\n max_area = max(max_area, cur)\\n else:\\n cur = 0\\n return max_area\",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n ROWS = len(matrix)\\n COLS = len(matrix[0])\\n for r in range(ROWS):\\n for c in range(COLS):\\n matrix[r][c] = int(matrix[r][c])\\n prefix = [[0] * (COLS + 1) for _ in range(ROWS + 1)]\\n for r in range(1, ROWS+1):\\n for c in range(1, COLS+1):\\n prefix[r][c] = matrix[r-1][c-1] + prefix[r-1][c] + prefix[r][c-1] - prefix[r-1][c-1]\\n \\n def is_rectange(start, end):\\n # print(start, end)\\n r_start, c_start = start\\n r_end, c_end = end\\n area = prefix[r_end+1][c_end+1] + prefix[r_start][c_start] - prefix[r_start][c_end+1] - prefix[r_end+1][c_start]\\n is_rectangle = area == (r_end - r_start + 1) * (c_end - c_start + 1)\\n return is_rectangle\\n \\n def get_area(start, end):\\n r_start, c_start = start\\n r_end, c_end = end\\n return (r_end - r_start + 1) * (c_end - c_start + 1)\\n\\n max_area = 0\\n for start_row in range(ROWS):\\n for end_row in range(start_row, ROWS):\\n # find the max rectangle:\\n # local_max = 0\\n cur = 0\\n for i in range(COLS):\\n if is_rectange((start_row, i), (end_row, i)):\\n # print(\\\"hello\\\")\\n cur += get_area((start_row, i), (end_row, i))\\n max_area = max(max_area, cur)\\n else:\\n cur = 0\\n return max_area\\n\",\n \"memory\": \"18700\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n pass\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_y, max_x = 1, 1\\n\\n @lru_cache(None)\\n def recursion(y, x):\\n nonlocal max_y, max_x\\n if y < 0 or x < 0:\\n return 0, 0\\n\\n min_y1, min_x1 = recursion(y-1, x)\\n min_y2, min_x2 = recursion(y-1, x-1)\\n min_y3, min_x3 = recursion(y, x-1)\\n min_x = min(min_x1, min_x2, min_x3)\\n min_y = min(min_y1, min_y2, min_y3)\\n\\n if matrix[y][x] == '1':\\n min_x += 1\\n min_y += 1\\n max_y = max(max_y, min_y)\\n max_x = max(max_x, min_x)\\n else:\\n min_x = 0\\n min_y = 0\\n return min_y, min_x\\n \\n recursion(len(matrix)-1, len(matrix[0])-1)\\n return max_y * max_x\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_area = 0\\n dp = [[0] * len(matrix[0]) for _ in range(len(matrix))]\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == '0':\\n continue\\n \\n if j >= 1:\\n width = dp[i][j] = dp[i][j-1] + 1\\n else:\\n width = dp[i][j] = 1\\n\\n for k in range(i, -1, -1):\\n width = min(width, dp[k][j])\\n max_area = max(max_area, width * (i-k+1))\\n return max_area\\n\\n\\nclass Solution:\\n def largestRectangleArea(self, heights: List[int]) -> int:\\n if not heights:\\n return 0 \\n\\n heights = heights + [0]\\n stack = [-1]\\n max_vol = heights[0]\\n for i, h in enumerate(heights):\\n while stack and stack[-1] != -1 and heights[stack[-1]] >= h:\\n idx_popped = stack.pop()\\n \\n vol = (i - stack[-1] - 1) * heights[idx_popped]\\n max_vol = max(max_vol, vol)\\n stack.append(i)\\n return max_vol\\n\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n if not matrix:\\n return 0\\n\\n max_area = 0\\n dp = [0] * len(matrix[0])\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == '1':\\n dp[j] = dp[j] + 1\\n else:\\n dp[j] = 0\\n max_area = max(max_area, self.largestRectangleArea(dp))\\n return max_area\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n dp = [[0] * n for _ in range(m)]\\n max_area = 0\\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '0':\\n continue\\n \\n dp[y][x] = dp[y][x-1] + 1 if x > 0 else 1\\n \\n min_w = dp[y][x]\\n for yy in range(y, -1, -1):\\n min_w = min(min_w, dp[yy][x])\\n area = (y - yy + 1) * min_w\\n max_area = max(max_area, area)\\n return max_area\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n dp = [0] * n\\n max_area = 0\\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '1':\\n dp[x] = dp[x] + 1\\n else:\\n dp[x] = 0\\n \\n area = self.hist(dp)\\n max_area = max(max_area, area)\\n return max_area\\n \\n def hist(self, dp):\\n dp.append(0)\\n max_area = 0\\n stack = [-1]\\n for i, h in enumerate(dp):\\n while stack[-1] != -1 and dp[stack[-1]] >= h:\\n idx_popped = stack.pop()\\n area = (i - stack[-1] - 1) * dp[idx_popped]\\n max_area = max(max_area, area)\\n stack.append(i)\\n return max_area\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_area = 0\\n m, n = len(matrix), len(matrix[0])\\n\\n '''\\n dp[y][x] stores length of continuous 1s in yth row, ending at xth col. \\n Continuous 1s is counted only at yth row, from left to right, ending at xth col. \\n See the figure in editorial. \\n '''\\n dp = [[0] * n for _ in range(m)]\\n \\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '0':\\n continue\\n \\n if x == 0:\\n dp[y][x] = 1\\n else:\\n dp[y][x] = dp[y][x-1] + 1\\n \\n width = dp[y][x]\\n for k in range(y, -1, -1):\\n width = min(width, dp[k][x])\\n max_area = max(max_area, width * (y - k + 1))\\n return max_area\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_area = 0\\n m, n = len(matrix), len(matrix[0])\\n \\n '''\\n dp[x] counts the number of continuous 1s from to to the current row. \\n If you think it as an histogram, it is a rotated version of the historgram from editorial approach 2. \\n '''\\n dp = [0] * n\\n\\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '1':\\n dp[x] = dp[x] + 1\\n else:\\n dp[x] = 0\\n \\n max_area = max(max_area, self.hist(dp))\\n return max_area\\n \\n def hist(self, dp):\\n dp += [0]\\n stack = [-1]\\n max_area = 0\\n for i, h in enumerate(dp):\\n while stack[-1] != -1 and dp[stack[-1]] >= h:\\n popped_idx = stack.pop()\\n height = dp[popped_idx]\\n if not stack:\\n break\\n area = height * (i - stack[-1] - 1)\\n max_area = max(area, max_area)\\n stack.append(i)\\n return max_area\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n dp = [0] * n\\n max_area = 0\\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '1':\\n dp[x] = dp[x] + 1\\n else:\\n dp[x] = 0\\n area = self.hist(dp)\\n max_area = max(max_area, area)\\n return max_area\\n \\n def hist(self, arr):\\n arr += [0]\\n stack = [-1]\\n max_area = 0\\n for i in range(len(arr)):\\n while stack[-1] != -1 and arr[stack[-1]] >= arr[i]:\\n idx_popped = stack.pop()\\n area = arr[idx_popped] * (i - stack[-1] - 1)\\n max_area = max(max_area, area)\\n stack.append(i)\\n return max_area\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n dp = [0] * n\\n max_area = 0\\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '1':\\n dp[x] += 1\\n else:\\n dp[x] = 0\\n area = self.hist(dp)\\n max_area = max(max_area, area)\\n return max_area\\n \\n def hist(self, arr):\\n arr += [0]\\n stack = [-1]\\n max_area = 0\\n for i in range(len(arr)):\\n while stack[-1] != -1 and arr[stack[-1]] >= arr[i]:\\n idx_popped = stack.pop()\\n height = arr[idx_popped]\\n area = height * (i - stack[-1] - 1)\\n max_area = max(max_area, area)\\n stack.append(i)\\n return max_area\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n dp = [0] * n\\n max_area = 0\\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '1':\\n dp[x] += 1\\n else:\\n dp[x] = 0\\n area = self.hist(dp)\\n max_area = max(max_area, area)\\n return max_area\\n\\n def hist(self, arr):\\n arr += [0]\\n stack = [-1]\\n max_area = 0\\n for i, num in enumerate(arr):\\n while stack[-1] != -1 and arr[stack[-1]] >= num:\\n idx_popped = stack.pop()\\n height = arr[idx_popped]\\n area = height * (i - stack[-1] -1)\\n max_area = max(max_area, area)\\n stack.append(i)\\n return max_area\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n max_area = 0\\n m, n = len(matrix), len(matrix[0])\\n dp = [0] * n\\n\\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '1':\\n dp[x] += 1\\n else:\\n dp[x] = 0\\n area = self.hist(dp)\\n max_area = max(max_area, area)\\n return max_area\\n \\n def hist(self, arr):\\n if not arr:\\n return 0\\n arr += [0]\\n stack = [-1]\\n max_area = 0\\n for i in range(len(arr)):\\n while stack[-1] != -1 and arr[stack[-1]] >= arr[i]:\\n idx_popped = stack.pop()\\n height = arr[idx_popped]\\n area = height * (i - stack[-1] - 1)\\n max_area = max(max_area, area)\\n stack.append(i)\\n return max_area\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n dp = [0] * n\\n max_area = 0\\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '1':\\n dp[x] += 1\\n else:\\n dp[x] = 0\\n area = self.hist(dp)\\n max_area = max(max_area, area)\\n return max_area\\n\\n def hist(self, arr):\\n arr += [0]\\n stack = [-1]\\n max_area = 0\\n for i in range(len(arr)):\\n while stack[-1] != -1 and arr[stack[-1]] >= arr[i]:\\n idx_popped = stack.pop()\\n height = arr[idx_popped]\\n area = height * (i - stack[-1] - 1)\\n max_area = max(max_area, area)\\n stack.append(i)\\n return max_area\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n dp = [0] * n\\n max_area = 0\\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '1':\\n dp[x] += 1\\n else:\\n dp[x] = 0\\n max_area = max(max_area, self.hist(dp))\\n return max_area\\n \\n def hist(self, arr):\\n arr += [0]\\n stack = [-1]\\n max_area = 0\\n for i, h in enumerate(arr):\\n while stack[-1] != -1 and arr[stack[-1]] >= h:\\n idx_popped = stack.pop()\\n height = arr[idx_popped]\\n area = height * (i - stack[-1] - 1)\\n max_area = max(max_area, area)\\n stack.append(i)\\n return max_area\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n m, n = len(matrix), len(matrix[0])\\n dp = [0] * n\\n max_area = 0\\n for y in range(m):\\n for x in range(n):\\n if matrix[y][x] == '1':\\n dp[x] += 1\\n else:\\n dp[x] = 0\\n max_area = max(max_area, self.hist(dp))\\n return max_area\\n\\n def hist(self, arr):\\n arr += [0]\\n stack = [-1]\\n max_area = 0\\n for i, h in enumerate(arr):\\n while stack[-1] != -1 and arr[stack[-1]] >= h:\\n idx_popped = stack.pop()\\n height = arr[idx_popped]\\n area = height * (i - stack[-1] -1)\\n max_area = max(max_area, area)\\n stack.append(i)\\n return max_area\\n \",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n counts = [[0 for i in range(len(matrix[0])+1)] for j in range(len(matrix)+1)]\\n out = 0\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n counts[i+1][j+1] += counts[i][j+1]\\n counts[i+1][j+1] += counts[i+1][j]\\n counts[i+1][j+1] -= counts[i][j]\\n if matrix[i][j] == '1':\\n counts[i+1][j+1] += 1\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == '1':\\n for x in range(i, len(matrix)):\\n if matrix[x][j] == '1':\\n l, r = j, len(matrix[0])-1\\n while l<=r:\\n y = (l+r)//2\\n if matrix[x][y] == '1':\\n temp = counts[x+1][y+1] - counts[i][y+1] - counts[x+1][j] + counts[i][j]\\n if temp == (x-i+1)*(y-j+1):\\n out = max(out, temp)\\n l = y+1\\n else:\\n r = y-1\\n else:\\n r = y-1\\n else:\\n break\\n\\n return out\\n\\n\\n\\n\",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"class Solution:\\n def maximalRectangle(self, matrix: List[List[str]]) -> int:\\n ROWS = len(matrix)\\n COLS = len(matrix[0])\\n for r in range(ROWS):\\n for c in range(COLS):\\n matrix[r][c] = int(matrix[r][c])\\n prefix = [[0] * (COLS + 1) for _ in range(ROWS + 1)]\\n for r in range(1, ROWS+1):\\n for c in range(1, COLS+1):\\n prefix[r][c] = matrix[r-1][c-1] + prefix[r-1][c] + prefix[r][c-1] - prefix[r-1][c-1]\\n \\n def is_rectange(start, end):\\n r_start, c_start = start\\n r_end, c_end = end\\n area = prefix[r_end+1][c_end+1] + prefix[r_start][c_start] - prefix[r_start][c_end+1] - prefix[r_end+1][c_start]\\n is_rectangle = area == (r_end - r_start + 1) * (c_end - c_start + 1)\\n return is_rectangle\\n \\n def get_area(start, end):\\n r_start, c_start = start\\n r_end, c_end = end\\n return (r_end - r_start + 1) * (c_end - c_start + 1)\\n\\n max_area = 0\\n for start_row in range(ROWS):\\n for end_row in range(start_row, ROWS):\\n cur = 0\\n for i in range(COLS):\\n if is_rectange((start_row, i), (end_row, i)):\\n cur += get_area((start_row, i), (end_row, i))\\n max_area = max(max_area, cur)\\n else:\\n cur = 0\\n return max_area\",\n \"memory\": \"19000\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":25,"string":"25"}}},{"rowIdx":40,"cells":{"question_id":{"kind":"number","value":86,"string":"86"},"name":{"kind":"string","value":"partition-list"},"content":{"kind":"string","value":"<p>Given the <code>head</code> of a linked list and a value <code>x</code>, partition it such that all nodes <strong>less than</strong> <code>x</code> come before nodes <strong>greater than or equal</strong> to <code>x</code>.</p>\n\n<p>You should <strong>preserve</strong> the original relative order of the nodes in each of the two partitions.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/01/04/partition.jpg\" style=\"width: 662px; height: 222px;\" />\n<pre>\n<strong>Input:</strong> head = [1,4,3,2,5,2], x = 3\n<strong>Output:</strong> [1,2,2,4,3,5]\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> head = [2,1], x = 2\n<strong>Output:</strong> [1,2]\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of nodes in the list is in the range <code>[0, 200]</code>.</li>\n\t<li><code>-100 <= Node.val <= 100</code></li>\n\t<li><code>-200 <= x <= 200</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":57.21093676017803,"string":"57.210937"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["linked-list","two-pointers"],"string":"[\n \"linked-list\",\n \"two-pointers\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16\", 0.0488], [\"17\", 0.0163], [\"18\", 0.0163], [\"19\", 0.0814], [\"20\", 0.0488], [\"21\", 0.0326], [\"22\", 0.2117], [\"23\", 0.4884], [\"24\", 0.4396], [\"25\", 0.4559], [\"26\", 0.7489], [\"27\", 1.9212], [\"28\", 1.6119], [\"29\", 1.7584], [\"30\", 2.1654], [\"31\", 4.9007], [\"32\", 4.7216], [\"33\", 4.4122], [\"34\", 4.4448], [\"35\", 8.4012], [\"36\", 7.7011], [\"37\", 6.1218], [\"38\", 5.6333], [\"39\", 8.9059], [\"40\", 7.7336], [\"41\", 5.7962], [\"42\", 4.7216], [\"43\", 4.4448], [\"44\", 3.7447], [\"45\", 2.491]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16200\", 0.0814], [\"16300\", 2.0352], [\"16400\", 18.3654], [\"16500\", 43.5689]]}"},"rt_list":{"kind":"list like","value":[{"code":"\"\"\"\nWhat if we use a queue to store all nodes in order that are greater than x\nAll smaller nodes than x will be appended in list and move ahead in list to find more nodes.\n\nPut the partition node in the queue as well\n\"\"\"\n\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n if head is None or head.next is None:\n return head\n\n greater_node_queue = []\n smaller_node_queue = []\n\n curr_ptr = head\n while curr_ptr:\n if curr_ptr.val < x:\n smaller_node_queue.append(curr_ptr)\n else:\n greater_node_queue.append(curr_ptr)\n \n curr_ptr = curr_ptr.next\n \n new_head = None\n prev_node = None\n for index in range(len(smaller_node_queue)):\n node = smaller_node_queue[index]\n if new_head is None:\n new_head = node\n prev_node = node\n node.next = None\n continue\n \n prev_node.next = node\n node.next = None\n prev_node = node\n\n for index in range(len(greater_node_queue)):\n node = greater_node_queue[index]\n if new_head is None:\n new_head = node\n prev_node = node\n node.next = None\n continue\n \n prev_node.next = node\n node.next = None\n prev_node = node\n \n return new_head\n","runtime":"16"},{"code":"class Solution:\n def partition(self, head: ListNode, x: int) -> ListNode:\n beforeHead = ListNode(0)\n afterHead = ListNode(0)\n before = beforeHead\n after = afterHead\n\n while head:\n if head.val < x:\n before.next = head\n before = head\n else:\n after.next = head\n after = head\n head = head.next\n\n after.next = None\n before.next = afterHead.next\n\n return beforeHead.next","runtime":"17"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n current_node = head\n ans_node = None\n ans_node_head = None\n queue = []\n\n if head is None:\n return None\n\n while current_node:\n if not current_node.val < x:\n queue.append(current_node)\n else:\n break\n current_node = current_node.next\n \n if current_node is not None:\n \n ans_node = current_node\n ans_node_head = ans_node\n current_node = current_node.next\n\n # print('here', current_node, ans_node_head)\n \n while current_node:\n # print('here2',current_node.val, ans_node_head)\n if current_node.val < x:\n ans_node.next = current_node\n ans_node = ans_node.next\n else:\n queue.append(current_node)\n current_node = current_node.next\n\n if ans_node:\n ans_node.next = None\n \n if queue:\n # x=[]\n # for i in queue:\n # x.append(i.val)\n # print(x, ans_node_head)\n start = queue[0]\n while True:\n elem = queue.pop(0)\n if len(queue) == 0:\n elem.next = None\n break\n elem.next = queue[0]\n # print(start)\n\n if ans_node:\n ans_node.next = start\n else:\n ans_node_head = start\n \n return ans_node_head\n\n \n \n\n\n\n ","runtime":"18"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n \n if not head or not head.next:\n return head\n \n taill = None\n headl = None\n tailh = None\n headh = None\n currnode = head\n\n while currnode:\n if currnode.val < x:\n if not headl:\n headl = currnode\n taill = currnode\n else:\n taill.next = currnode\n taill = taill.next\n\n elif not headh:\n headh = currnode\n tailh = currnode\n \n else:\n tailh.next = currnode\n tailh = tailh.next\n \n currnode = currnode.next\n \n if tailh:\n tailh.next = None\n \n if taill:\n taill.next = headh\n return headl if headl else headh\n","runtime":"19"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n init_small_head = ListNode()\n init_large_head = ListNode()\n\n small_tail = init_small_head\n large_tail = init_large_head\n\n while head:\n if head.val < x:\n small_tail.next = head\n small_tail = small_tail.next\n else:\n large_tail.next = head\n large_tail = large_tail.next\n head = head.next\n\n small_tail.next = init_large_head.next\n large_tail.next = None\n return init_small_head.next\n","runtime":"20"},{"code":"# ##################################\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n dummy = ListNode(next=head)\n cur, prev = dummy, dummy\n while cur.next is not None:\n if cur.next.val >= x:\n cur, cur.next = cur.next, cur.next.next\n else:\n if cur.next != prev.next:\n prev.next, cur.next.next, cur.next = cur.next, prev.next, cur.next.next\n cur.next, prev = cur.next, prev.next\n else:\n prev, cur, cur.next = prev.next, cur.next, cur.next.next\n return dummy.next\n","runtime":"21"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n \n lessThanX = None\n GreaterThanX = None\n startOfGreaterThanX = None\n startOflessThanX = None\n while head is not None:\n if head.val < x:\n if lessThanX is None:\n lessThanX = ListNode(head.val)\n startOflessThanX = lessThanX\n else:\n lessThanX.next = ListNode(head.val)\n lessThanX = lessThanX.next\n else:\n if GreaterThanX is None:\n GreaterThanX = ListNode(head.val)\n startOfGreaterThanX = GreaterThanX\n else:\n GreaterThanX.next = ListNode(head.val)\n GreaterThanX = GreaterThanX.next\n \n head = head.next\n if lessThanX is not None:\n lessThanX.next = startOfGreaterThanX\n return startOflessThanX\n elif GreaterThanX is not None:\n return startOfGreaterThanX\n else:\n return None\n\n ","runtime":"22"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n dummy1, dummy2 = ListNode(), ListNode()\n dummy1.next = head\n\n tail1, tail2 = dummy1, dummy2\n while tail1.next:\n node = tail1.next\n if node.val < x:\n tail1.next = node.next\n node.next = None\n tail2.next = node\n tail2 = node\n else:\n tail1 = node\n \n tail2.next = dummy1.next\n return dummy2.next","runtime":"23"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n small_dummy = ListNode(0)\n small = small_dummy\n big_dummy = ListNode(0)\n big = big_dummy\n\n while head:\n temp = ListNode(head.val)\n if temp.val < x:\n small.next = temp\n small = small.next\n else:\n big.next = temp\n big = big.next\n head = head.next\n \n small.next = big_dummy.next\n return small_dummy.next","runtime":"24"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n if not head:\n return head\n dummy1 = ListNode(0)\n dummy2 = ListNode(0)\n pointer1, pointer2 = dummy1, dummy2\n current = head\n while current:\n if current.val < x:\n pointer1.next = current\n pointer1 = pointer1.next\n else:\n pointer2.next = current\n pointer2 = pointer2.next\n current = current.next\n pointer1.next, pointer2.next = None, None\n pointer1.next = dummy2.next\n \n return dummy1.next\n\n","runtime":"25"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n less, greater = ListNode(0), ListNode(0)\n lessHead, greaterHead = less, greater\n curr = head\n\n while curr is not None:\n if curr.val < x:\n ## Attach to less \n less.next = curr\n curr = curr.next\n less = less.next\n less.next = None\n else:\n greater.next = curr\n curr = curr.next\n greater = greater.next\n greater.next = None\n \n less.next = greaterHead.next\n\n return lessHead.next","runtime":"25"},{"code":"# 思路：将链表拆成两个链表，一个储存小于该链表的元素，一个储存大于等于该链表的元素。然后将二者拼起来即可\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n cur = head\n p1, p2 = ListNode(-1), ListNode(-1) # 两个虚拟头节点\n p1_head, p2_head = p1, p2 # 两个新链表的头\n while cur:\n if cur.val < x:\n p1.next = cur\n p1 = p1.next\n else:\n p2.next = cur\n p2 = p2.next\n\n # # 下面三行尤为重要！如果直接cur = cur.next的话，链表中会出现环\n # # 因为如果不断开cur.next，则整个拼完的链表\n # temp = cur.next\n # cur.next = None\n # cur = temp\n cur = cur.next\n \n p2.next = None\n p1.next = p2_head.next\n return p1_head.next","runtime":"26"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lesser = ListNode()\n lesser.next = head\n greater = ListNode()\n greater.next = head\n current = head\n first_greater = None\n\n while current:\n if current.val < x:\n if head.val >= x:\n head = current\n lesser.next = current\n lesser = current\n \n else:\n if first_greater is None:\n first_greater = current\n greater.next = current\n greater = current\n\n current = current.next\n\n lesser.next = first_greater\n greater.next = None\n\n return head","runtime":"27"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n sentinel_left = ListNode(0)\n sentinel_right = ListNode(0)\n left, right = sentinel_left, sentinel_right\n while head:\n if head.val < x:\n left.next = head\n left = left.next\n else:\n right.next = head\n right = right.next\n head = head.next\n\n left.next = sentinel_right.next\n right.next = None\n # sentinel_right.next = None\n return sentinel_left.next","runtime":"28"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n left, right = ListNode(0), ListNode(0)\n leftTail, rightTail = left, right \n\n while head:\n if head.val < x:\n leftTail.next = head\n leftTail = leftTail.next\n else:\n rightTail.next = head\n rightTail = rightTail.next\n\n head = head.next\n\n leftTail.next = right.next\n rightTail.next = None\n return left.next","runtime":"29"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lst1 = []\n lst2 = []\n curr = head\n while curr:\n if curr.val < x:\n lst1.append(curr.val)\n else:\n lst2.append(curr.val)\n curr = curr.next\n\n ln = ListNode(0)\n curr = ln\n for i in lst1 + lst2:\n curr.next = ListNode(i)\n curr = curr.next\n return ln.next","runtime":"29"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lHead = ListNode(0)\n gHead = ListNode(0)\n\n lessP = lHead\n greaterP = gHead\n\n current = head\n\n while (current):\n if current.val < x:\n lessP.next = current\n lessP = lessP.next\n else:\n greaterP.next = current\n greaterP = greaterP.next\n current = current.next\n\n lessP.next = gHead.next\n greaterP.next = None\n\n lHead = lHead.next\n\n return lHead\n\n\n ","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n fake = ListNode(-101)\n fake.next = head\n prev = fake\n curr = head\n sortList = []\n temp_head = head\n larger_list = ListNode(0)\n track_large = larger_list\n while curr:\n if curr.val < x:\n sortList.append(curr.val)\n else:\n larger_list.next = ListNode(curr.val)\n larger_list = larger_list.next\n #prev.next = curr.next\n #curr = prev.next\n curr = curr.next\n #print(sortList)\n #sorted = sortList.sort()\n #print(sorted)\n temp_list = ListNode(-101)\n res = temp_list\n for val in sortList:\n temp_list.next = ListNode(val)\n temp_list = temp_list.next\n temp_list.next = track_large.next\n return res.next\n","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n sentinel_left = ListNode(0)\n sentinel_right = ListNode(0)\n left, right = sentinel_left, sentinel_right\n while head:\n if head.val < x:\n left.next = head\n left = left.next\n else:\n right.next = head\n right = right.next\n head = head.next\n\n left.next = sentinel_right.next\n right.next = None\n # sentinel_right.next = None\n return sentinel_left.next","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lh = ListNode(0)\n gh = ListNode(0)\n\n l = lh\n g = gh \n\n while(head):\n if(head.val<x):\n l.next = head \n l = l.next \n else:\n g.next = head \n g = g.next \n head = head.next \n \n l.next = gh.next \n g.next = None\n\n return lh.next\n\n\n\n\n\n\n\n\n # p = head \n # l = []\n # while(p):\n # l.append(p.val)\n # p = p.next \n\n # ls = []\n\n # for i in l:\n # if(i<x):\n # l.remove(i)\n # ls.append(i)\n\n # print(ls,l)\n\n # nh = ListNode(0)\n # p = nh \n\n # for i in ls:\n # p.next=ListNode(i)\n # p = p.next\n\n # for j in l:\n # p.next=ListNode(j)\n # p = p.next\n \n # return nh.next","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n dummy = head\n\n dummy_l1 = l1 = ListNode() # nodes < X\n dummy_l2 = l2 = ListNode() # nodes >= X\n\n while head:\n if head.val < x:\n l1.next = ListNode(head.val)\n l1 = l1.next\n else:\n l2.next = ListNode(head.val)\n l2 = l2.next\n head = head.next\n \n l1.next = dummy_l2.next\n return dummy_l1.next","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n\n less_than = copy_less_than = ListNode()\n greater_than = copy_greater_than = ListNode()\n\n while head != None:\n if head.val < x:\n less_than.next = ListNode(head.val)\n less_than = less_than.next\n \n else:\n greater_than.next = ListNode(head.val)\n greater_than = greater_than.next\n \n head = head.next\n \n less_than.next = copy_greater_than.next\n return copy_less_than.next","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n dummy = ListNode()\n new_head = dummy\n p1, p2 = head, head\n while p1:\n if p1.val < x:\n new_head.next = ListNode(p1.val)\n new_head = new_head.next\n p1 = p1.next \n \n while p2:\n if p2.val >= x:\n new_head.next = ListNode(p2.val)\n new_head = new_head.next\n p2 = p2.next\n\n return dummy.next","runtime":"33"},{"code":"class Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n dummy_small, dummy_big = ListNode(), ListNode()\n small, big = dummy_small, dummy_big\n while head:\n if head.val < x:\n small.next = head\n small = small.next\n else:\n big.next = head\n big = big.next\n head = head.next\n small.next = dummy_big.next\n big.next = None\n return dummy_small.next","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n prev = None\n curr = head\n\n bip = None\n aip = None\n\n new_head = head\n\n # find first node in second partition\n while curr is not None:\n if curr.val < x:\n prev = curr\n curr = curr.next\n else:\n bip = prev\n aip = curr\n break\n\n while curr is not None:\n if curr.val >= x:\n prev = curr\n curr = curr.next\n else:\n if prev is not None:\n prev.next = curr.next\n \n if bip is not None:\n bip.next = curr\n else:\n new_head = curr\n \n curr.next = aip\n bip = curr\n curr = prev.next\n\n return new_head\n\n ","runtime":"34"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n dummy_smaller = ListNode(0)\n curr_smaller = dummy_smaller\n dummy_bigger = ListNode(0)\n curr_bigger = dummy_bigger\n curr = head\n while curr:\n if(curr.val < x):\n curr_smaller.next = curr\n curr_smaller = curr_smaller.next\n else:\n curr_bigger.next = curr\n curr_bigger = curr_bigger.next\n curr = curr.next\n curr_smaller.next = dummy_bigger.next\n curr_bigger.next = None\n return dummy_smaller.next","runtime":"34"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n\n left,right = ListNode(),ListNode()\n start = right\n start_left = left\n\n node = head\n while node is not None:\n if node.val < x:\n left.next = node\n left = left.next\n else:\n right.next = node\n right = right.next\n\n node = node.next\n\n left.next = start.next\n right.next = None\n\n return start_left.next\n\n \n\n \n\n ","runtime":"35"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lesser = ListNode()\n greater = ListNode()\n current = head\n first_greater = None\n\n while current:\n if current.val < x:\n if head.val >= x:\n head = current\n lesser.next = current\n lesser = current\n \n else:\n if first_greater is None:\n first_greater = current\n greater.next = current\n greater = current\n\n current = current.next\n\n lesser.next = first_greater\n greater.next = None\n\n return head","runtime":"35"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n left = ListNode(0,None)\n l = left\n right = ListNode(0,None)\n r = right\n cur = head\n while cur:\n if cur.val < x:\n l.next = cur\n l = l.next\n else:\n r.next = cur\n r = r.next \n cur = cur.next\n \n l.next = right.next\n r.next = None\n return left.next\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # left , right = ListNode(),ListNode()\n # l = left\n # r = right\n # while head:\n # if head.val >= x:\n # r.next = head\n # r = r.next\n # else:\n # l.next = head\n # l = l.next\n # head = head.next\n # l.next = right.next\n # r.next = None\n # return left.next","runtime":"36"},{"code":"class Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n before, after = ListNode(0), ListNode(0)\n before_curr, after_curr = before, after\n \n while head:\n if head.val < x:\n before_curr.next, before_curr = head, head\n else:\n after_curr.next, after_curr = head, head\n head = head.next\n \n after_curr.next = None\n before_curr.next = after.next\n \n return before.next","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lesser = ListNode()\n lesser.next = head\n greater = ListNode()\n greater.next = head\n current = head\n first_greater = None\n\n while current:\n if current.val < x:\n if head.val >= x:\n head = current\n lesser.next = current\n lesser = current\n \n else:\n if first_greater is None:\n first_greater = current\n greater.next = current\n greater = current\n\n current = current.next\n\n lesser.next = first_greater\n greater.next = None\n\n return head","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n left=ListNode()\n right=ListNode()\n i=left\n j=right\n while head:\n if head.val <x:\n i.next=head\n i=i.next\n else:\n j.next=head\n j=j.next\n head=head.next\n j.next=None\n i.next=right.next\n return left.next\n\n ","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lesser = ListNode()\n lesser.next = head\n greater = ListNode()\n greater.next = head\n current = head\n first_greater = None\n\n while current:\n if current.val < x:\n if head.val >= x:\n head = current\n lesser.next = current\n lesser = current\n \n else:\n if first_greater is None:\n first_greater = current\n greater.next = current\n greater = current\n\n current = current.next\n\n lesser.next = first_greater\n greater.next = None\n\n return head","runtime":"38"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n res = less = ListNode()\n start = more = ListNode()\n\n while head:\n if head.val < x:\n less.next = head\n less = less.next\n else: # head.val >= x\n more.next = head\n more = more.next\n head = head.next\n\n more.next = None\n less.next = start.next\n\n return res.next","runtime":"38"},{"code":"class Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n before, after = ListNode(0), ListNode(0)\n before_curr, after_curr = before, after\n \n while head:\n if head.val < x:\n before_curr.next, before_curr = head, head\n else:\n after_curr.next, after_curr = head, head\n head = head.next\n \n after_curr.next = None\n before_curr.next = after.next\n \n return before.next","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\n# [2,2,1], 2 -> [1,2,2]\n\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n \n if not head:\n return head\n\n less_dummy, greater_dummy = ListNode(), ListNode()\n less, greater = less_dummy, greater_dummy\n\n lookup = head\n while lookup:\n if lookup.val < x:\n less.next = lookup\n less = less.next\n else:\n greater.next = lookup\n greater = greater.next\n\n lookup = lookup.next\n \n greater.next = None\n less.next = greater_dummy.next\n\n return less_dummy.next","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lesser = ListNode()\n lesser.next = head\n greater = ListNode()\n greater.next = head\n current = head\n first_greater = None\n\n while current:\n if current.val < x:\n if head.val >= x:\n head = current\n lesser.next = current\n lesser = current\n \n else:\n if first_greater is None:\n first_greater = current\n greater.next = current\n greater = current\n\n current = current.next\n\n lesser.next = first_greater\n greater.next = None\n\n return head","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n sentinel_left = ListNode(0)\n sentinel_right = ListNode(0)\n left, right = sentinel_left, sentinel_right\n while head:\n if head.val < x:\n left.next = head\n left = left.next\n else:\n right.next = head\n right = right.next\n head = head.next\n\n left.next = sentinel_right.next\n right.next = None\n # sentinel_right.next = None\n return sentinel_left.next","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n pre, post = ListNode(), ListNode()\n curr, curr_pre, curr_post = head, pre, post\n while curr:\n if curr.val < x:\n curr_pre.next = curr\n curr_pre = curr_pre.next\n else:\n curr_post.next = curr\n curr_post = curr_post.next\n curr = curr.next\n curr_pre.next = post.next\n curr_post.next = None\n return pre.next","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n before = before_head = ListNode(next=head)\n after = after_head = ListNode(next=head)\n\n while head:\n if head.val < x:\n before.next = head\n before = before.next\n else:\n after.next = head\n after = after.next\n head = head.next\n \n after.next = None\n before.next = after_head.next\n return before_head.next\n","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lesser = ListNode()\n lesser.next = head\n greater = ListNode()\n greater.next = head\n current = head\n first_greater = None\n\n while current:\n if current.val < x:\n if head.val >= x:\n head = current\n lesser.next = current\n lesser = current\n \n else:\n if first_greater is None:\n first_greater = current\n greater.next = current\n greater = current\n\n current = current.next\n\n lesser.next = first_greater\n greater.next = None\n\n return head","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n dummy = ListNode()\n dummy.next = head\n p = head\n while p.next:\n p = p.next\n \n tail = p\n head = dummy\n while head.next != tail:\n print(tail.val, head.val)\n if head.next.val < x:\n head = head.next\n else:\n tmpNode = head.next\n head.next = head.next.next\n tmpNode.next = None\n p.next = tmpNode\n p = p.next\n\n if tail.val >= x and tail.next:\n head.next = tail.next\n tail.next = None\n p.next = tail\n\n return dummy.next\n","runtime":"42"},{"code":"# 思路：将链表拆成两个链表，一个储存小于该链表的元素，一个储存大于等于该链表的元素。然后将二者拼起来即可\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n cur = head\n p1, p2 = ListNode(-1), ListNode(-1) # 两个虚拟头节点\n p1_head, p2_head = p1, p2 # 两个新链表的头\n while cur:\n if cur.val < x:\n p1.next = cur\n p1 = p1.next\n else:\n p2.next = cur\n p2 = p2.next\n cur = cur.next\n \n p2.next = None # 如果不加这行，新的整体链表的尾巴仍然连到了链表中间的某处，会出现环；因此要手动置None\n p1.next = p2_head.next\n return p1_head.next","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n sml, lrg = ListNode(), ListNode(0, head)\n\n slow = sml\n fast = lrg\n \n while fast and fast.next:\n if fast.next.val < x:\n val = fast.next.val\n slow.next = ListNode(val)\n slow = slow.next\n fast.next = fast.next.next\n else:\n fast = fast.next\n \n slow.next = lrg.next\n return sml.next\n\n \n ","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n one = ListNode()\n two = ListNode()\n o = one\n t = two\n while head:\n if head.val < x:\n o.next = head\n o = o.next\n else:\n t.next = head\n t = t.next\n head = head.next\n o.next = None\n t.next = None\n o.next = two.next\n return one.next\n ","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n p=head\n l=[]\n g=[]\n while p:\n if p.val>=x:\n g.append(p.val)\n if p.val<x:\n l.append(p.val)\n p=p.next\n r=l+g\n rh=ListNode(0)\n c=rh\n for i in r:\n c.next=ListNode(i)\n c=c.next\n return rh.next","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n sentinel_left = ListNode(0)\n sentinel_right = ListNode(0)\n left, right = sentinel_left, sentinel_right\n while head:\n if head.val < x:\n left.next = head\n left = left.next\n else:\n right.next = head\n right = right.next\n head = head.next\n\n left.next = sentinel_right.next\n right.next = None\n # sentinel_right.next = None\n return sentinel_left.next","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n dummy1 = ListNode(-1)\n dummy2 = ListNode(-2)\n\n p1 = dummy1\n p2 = dummy2\n\n while head:\n if head.val < x:\n p1.next = head\n p1 = p1.next\n else:\n p2.next = head\n p2 = p2.next\n head = head.next\n \n p2.next = None\n p1.next = dummy2.next\n return dummy1.next","runtime":"45"}],"string":"[\n {\n \"code\": \"\\\"\\\"\\\"\\nWhat if we use a queue to store all nodes in order that are greater than x\\nAll smaller nodes than x will be appended in list and move ahead in list to find more nodes.\\n\\nPut the partition node in the queue as well\\n\\\"\\\"\\\"\\n\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return head\\n\\n greater_node_queue = []\\n smaller_node_queue = []\\n\\n curr_ptr = head\\n while curr_ptr:\\n if curr_ptr.val < x:\\n smaller_node_queue.append(curr_ptr)\\n else:\\n greater_node_queue.append(curr_ptr)\\n \\n curr_ptr = curr_ptr.next\\n \\n new_head = None\\n prev_node = None\\n for index in range(len(smaller_node_queue)):\\n node = smaller_node_queue[index]\\n if new_head is None:\\n new_head = node\\n prev_node = node\\n node.next = None\\n continue\\n \\n prev_node.next = node\\n node.next = None\\n prev_node = node\\n\\n for index in range(len(greater_node_queue)):\\n node = greater_node_queue[index]\\n if new_head is None:\\n new_head = node\\n prev_node = node\\n node.next = None\\n continue\\n \\n prev_node.next = node\\n node.next = None\\n prev_node = node\\n \\n return new_head\\n\",\n \"runtime\": \"16\"\n },\n {\n \"code\": \"class Solution:\\n def partition(self, head: ListNode, x: int) -> ListNode:\\n beforeHead = ListNode(0)\\n afterHead = ListNode(0)\\n before = beforeHead\\n after = afterHead\\n\\n while head:\\n if head.val < x:\\n before.next = head\\n before = head\\n else:\\n after.next = head\\n after = head\\n head = head.next\\n\\n after.next = None\\n before.next = afterHead.next\\n\\n return beforeHead.next\",\n \"runtime\": \"17\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n current_node = head\\n ans_node = None\\n ans_node_head = None\\n queue = []\\n\\n if head is None:\\n return None\\n\\n while current_node:\\n if not current_node.val < x:\\n queue.append(current_node)\\n else:\\n break\\n current_node = current_node.next\\n \\n if current_node is not None:\\n \\n ans_node = current_node\\n ans_node_head = ans_node\\n current_node = current_node.next\\n\\n # print('here', current_node, ans_node_head)\\n \\n while current_node:\\n # print('here2',current_node.val, ans_node_head)\\n if current_node.val < x:\\n ans_node.next = current_node\\n ans_node = ans_node.next\\n else:\\n queue.append(current_node)\\n current_node = current_node.next\\n\\n if ans_node:\\n ans_node.next = None\\n \\n if queue:\\n # x=[]\\n # for i in queue:\\n # x.append(i.val)\\n # print(x, ans_node_head)\\n start = queue[0]\\n while True:\\n elem = queue.pop(0)\\n if len(queue) == 0:\\n elem.next = None\\n break\\n elem.next = queue[0]\\n # print(start)\\n\\n if ans_node:\\n ans_node.next = start\\n else:\\n ans_node_head = start\\n \\n return ans_node_head\\n\\n \\n \\n\\n\\n\\n \",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n \\n if not head or not head.next:\\n return head\\n \\n taill = None\\n headl = None\\n tailh = None\\n headh = None\\n currnode = head\\n\\n while currnode:\\n if currnode.val < x:\\n if not headl:\\n headl = currnode\\n taill = currnode\\n else:\\n taill.next = currnode\\n taill = taill.next\\n\\n elif not headh:\\n headh = currnode\\n tailh = currnode\\n \\n else:\\n tailh.next = currnode\\n tailh = tailh.next\\n \\n currnode = currnode.next\\n \\n if tailh:\\n tailh.next = None\\n \\n if taill:\\n taill.next = headh\\n return headl if headl else headh\\n\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n init_small_head = ListNode()\\n init_large_head = ListNode()\\n\\n small_tail = init_small_head\\n large_tail = init_large_head\\n\\n while head:\\n if head.val < x:\\n small_tail.next = head\\n small_tail = small_tail.next\\n else:\\n large_tail.next = head\\n large_tail = large_tail.next\\n head = head.next\\n\\n small_tail.next = init_large_head.next\\n large_tail.next = None\\n return init_small_head.next\\n\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"# ##################################\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n dummy = ListNode(next=head)\\n cur, prev = dummy, dummy\\n while cur.next is not None:\\n if cur.next.val >= x:\\n cur, cur.next = cur.next, cur.next.next\\n else:\\n if cur.next != prev.next:\\n prev.next, cur.next.next, cur.next = cur.next, prev.next, cur.next.next\\n cur.next, prev = cur.next, prev.next\\n else:\\n prev, cur, cur.next = prev.next, cur.next, cur.next.next\\n return dummy.next\\n\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n \\n lessThanX = None\\n GreaterThanX = None\\n startOfGreaterThanX = None\\n startOflessThanX = None\\n while head is not None:\\n if head.val < x:\\n if lessThanX is None:\\n lessThanX = ListNode(head.val)\\n startOflessThanX = lessThanX\\n else:\\n lessThanX.next = ListNode(head.val)\\n lessThanX = lessThanX.next\\n else:\\n if GreaterThanX is None:\\n GreaterThanX = ListNode(head.val)\\n startOfGreaterThanX = GreaterThanX\\n else:\\n GreaterThanX.next = ListNode(head.val)\\n GreaterThanX = GreaterThanX.next\\n \\n head = head.next\\n if lessThanX is not None:\\n lessThanX.next = startOfGreaterThanX\\n return startOflessThanX\\n elif GreaterThanX is not None:\\n return startOfGreaterThanX\\n else:\\n return None\\n\\n \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n dummy1, dummy2 = ListNode(), ListNode()\\n dummy1.next = head\\n\\n tail1, tail2 = dummy1, dummy2\\n while tail1.next:\\n node = tail1.next\\n if node.val < x:\\n tail1.next = node.next\\n node.next = None\\n tail2.next = node\\n tail2 = node\\n else:\\n tail1 = node\\n \\n tail2.next = dummy1.next\\n return dummy2.next\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n small_dummy = ListNode(0)\\n small = small_dummy\\n big_dummy = ListNode(0)\\n big = big_dummy\\n\\n while head:\\n temp = ListNode(head.val)\\n if temp.val < x:\\n small.next = temp\\n small = small.next\\n else:\\n big.next = temp\\n big = big.next\\n head = head.next\\n \\n small.next = big_dummy.next\\n return small_dummy.next\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n if not head:\\n return head\\n dummy1 = ListNode(0)\\n dummy2 = ListNode(0)\\n pointer1, pointer2 = dummy1, dummy2\\n current = head\\n while current:\\n if current.val < x:\\n pointer1.next = current\\n pointer1 = pointer1.next\\n else:\\n pointer2.next = current\\n pointer2 = pointer2.next\\n current = current.next\\n pointer1.next, pointer2.next = None, None\\n pointer1.next = dummy2.next\\n \\n return dummy1.next\\n\\n\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n less, greater = ListNode(0), ListNode(0)\\n lessHead, greaterHead = less, greater\\n curr = head\\n\\n while curr is not None:\\n if curr.val < x:\\n ## Attach to less \\n less.next = curr\\n curr = curr.next\\n less = less.next\\n less.next = None\\n else:\\n greater.next = curr\\n curr = curr.next\\n greater = greater.next\\n greater.next = None\\n \\n less.next = greaterHead.next\\n\\n return lessHead.next\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"# 思路：将链表拆成两个链表，一个储存小于该链表的元素，一个储存大于等于该链表的元素。然后将二者拼起来即可\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n cur = head\\n p1, p2 = ListNode(-1), ListNode(-1) # 两个虚拟头节点\\n p1_head, p2_head = p1, p2 # 两个新链表的头\\n while cur:\\n if cur.val < x:\\n p1.next = cur\\n p1 = p1.next\\n else:\\n p2.next = cur\\n p2 = p2.next\\n\\n # # 下面三行尤为重要！如果直接cur = cur.next的话，链表中会出现环\\n # # 因为如果不断开cur.next，则整个拼完的链表\\n # temp = cur.next\\n # cur.next = None\\n # cur = temp\\n cur = cur.next\\n \\n p2.next = None\\n p1.next = p2_head.next\\n return p1_head.next\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lesser = ListNode()\\n lesser.next = head\\n greater = ListNode()\\n greater.next = head\\n current = head\\n first_greater = None\\n\\n while current:\\n if current.val < x:\\n if head.val >= x:\\n head = current\\n lesser.next = current\\n lesser = current\\n \\n else:\\n if first_greater is None:\\n first_greater = current\\n greater.next = current\\n greater = current\\n\\n current = current.next\\n\\n lesser.next = first_greater\\n greater.next = None\\n\\n return head\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n sentinel_left = ListNode(0)\\n sentinel_right = ListNode(0)\\n left, right = sentinel_left, sentinel_right\\n while head:\\n if head.val < x:\\n left.next = head\\n left = left.next\\n else:\\n right.next = head\\n right = right.next\\n head = head.next\\n\\n left.next = sentinel_right.next\\n right.next = None\\n # sentinel_right.next = None\\n return sentinel_left.next\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n left, right = ListNode(0), ListNode(0)\\n leftTail, rightTail = left, right \\n\\n while head:\\n if head.val < x:\\n leftTail.next = head\\n leftTail = leftTail.next\\n else:\\n rightTail.next = head\\n rightTail = rightTail.next\\n\\n head = head.next\\n\\n leftTail.next = right.next\\n rightTail.next = None\\n return left.next\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lst1 = []\\n lst2 = []\\n curr = head\\n while curr:\\n if curr.val < x:\\n lst1.append(curr.val)\\n else:\\n lst2.append(curr.val)\\n curr = curr.next\\n\\n ln = ListNode(0)\\n curr = ln\\n for i in lst1 + lst2:\\n curr.next = ListNode(i)\\n curr = curr.next\\n return ln.next\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lHead = ListNode(0)\\n gHead = ListNode(0)\\n\\n lessP = lHead\\n greaterP = gHead\\n\\n current = head\\n\\n while (current):\\n if current.val < x:\\n lessP.next = current\\n lessP = lessP.next\\n else:\\n greaterP.next = current\\n greaterP = greaterP.next\\n current = current.next\\n\\n lessP.next = gHead.next\\n greaterP.next = None\\n\\n lHead = lHead.next\\n\\n return lHead\\n\\n\\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n fake = ListNode(-101)\\n fake.next = head\\n prev = fake\\n curr = head\\n sortList = []\\n temp_head = head\\n larger_list = ListNode(0)\\n track_large = larger_list\\n while curr:\\n if curr.val < x:\\n sortList.append(curr.val)\\n else:\\n larger_list.next = ListNode(curr.val)\\n larger_list = larger_list.next\\n #prev.next = curr.next\\n #curr = prev.next\\n curr = curr.next\\n #print(sortList)\\n #sorted = sortList.sort()\\n #print(sorted)\\n temp_list = ListNode(-101)\\n res = temp_list\\n for val in sortList:\\n temp_list.next = ListNode(val)\\n temp_list = temp_list.next\\n temp_list.next = track_large.next\\n return res.next\\n\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n sentinel_left = ListNode(0)\\n sentinel_right = ListNode(0)\\n left, right = sentinel_left, sentinel_right\\n while head:\\n if head.val < x:\\n left.next = head\\n left = left.next\\n else:\\n right.next = head\\n right = right.next\\n head = head.next\\n\\n left.next = sentinel_right.next\\n right.next = None\\n # sentinel_right.next = None\\n return sentinel_left.next\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lh = ListNode(0)\\n gh = ListNode(0)\\n\\n l = lh\\n g = gh \\n\\n while(head):\\n if(head.val<x):\\n l.next = head \\n l = l.next \\n else:\\n g.next = head \\n g = g.next \\n head = head.next \\n \\n l.next = gh.next \\n g.next = None\\n\\n return lh.next\\n\\n\\n\\n\\n\\n\\n\\n\\n # p = head \\n # l = []\\n # while(p):\\n # l.append(p.val)\\n # p = p.next \\n\\n # ls = []\\n\\n # for i in l:\\n # if(i<x):\\n # l.remove(i)\\n # ls.append(i)\\n\\n # print(ls,l)\\n\\n # nh = ListNode(0)\\n # p = nh \\n\\n # for i in ls:\\n # p.next=ListNode(i)\\n # p = p.next\\n\\n # for j in l:\\n # p.next=ListNode(j)\\n # p = p.next\\n \\n # return nh.next\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n dummy = head\\n\\n dummy_l1 = l1 = ListNode() # nodes < X\\n dummy_l2 = l2 = ListNode() # nodes >= X\\n\\n while head:\\n if head.val < x:\\n l1.next = ListNode(head.val)\\n l1 = l1.next\\n else:\\n l2.next = ListNode(head.val)\\n l2 = l2.next\\n head = head.next\\n \\n l1.next = dummy_l2.next\\n return dummy_l1.next\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n\\n less_than = copy_less_than = ListNode()\\n greater_than = copy_greater_than = ListNode()\\n\\n while head != None:\\n if head.val < x:\\n less_than.next = ListNode(head.val)\\n less_than = less_than.next\\n \\n else:\\n greater_than.next = ListNode(head.val)\\n greater_than = greater_than.next\\n \\n head = head.next\\n \\n less_than.next = copy_greater_than.next\\n return copy_less_than.next\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n dummy = ListNode()\\n new_head = dummy\\n p1, p2 = head, head\\n while p1:\\n if p1.val < x:\\n new_head.next = ListNode(p1.val)\\n new_head = new_head.next\\n p1 = p1.next \\n \\n while p2:\\n if p2.val >= x:\\n new_head.next = ListNode(p2.val)\\n new_head = new_head.next\\n p2 = p2.next\\n\\n return dummy.next\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n dummy_small, dummy_big = ListNode(), ListNode()\\n small, big = dummy_small, dummy_big\\n while head:\\n if head.val < x:\\n small.next = head\\n small = small.next\\n else:\\n big.next = head\\n big = big.next\\n head = head.next\\n small.next = dummy_big.next\\n big.next = None\\n return dummy_small.next\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n prev = None\\n curr = head\\n\\n bip = None\\n aip = None\\n\\n new_head = head\\n\\n # find first node in second partition\\n while curr is not None:\\n if curr.val < x:\\n prev = curr\\n curr = curr.next\\n else:\\n bip = prev\\n aip = curr\\n break\\n\\n while curr is not None:\\n if curr.val >= x:\\n prev = curr\\n curr = curr.next\\n else:\\n if prev is not None:\\n prev.next = curr.next\\n \\n if bip is not None:\\n bip.next = curr\\n else:\\n new_head = curr\\n \\n curr.next = aip\\n bip = curr\\n curr = prev.next\\n\\n return new_head\\n\\n \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n dummy_smaller = ListNode(0)\\n curr_smaller = dummy_smaller\\n dummy_bigger = ListNode(0)\\n curr_bigger = dummy_bigger\\n curr = head\\n while curr:\\n if(curr.val < x):\\n curr_smaller.next = curr\\n curr_smaller = curr_smaller.next\\n else:\\n curr_bigger.next = curr\\n curr_bigger = curr_bigger.next\\n curr = curr.next\\n curr_smaller.next = dummy_bigger.next\\n curr_bigger.next = None\\n return dummy_smaller.next\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n\\n left,right = ListNode(),ListNode()\\n start = right\\n start_left = left\\n\\n node = head\\n while node is not None:\\n if node.val < x:\\n left.next = node\\n left = left.next\\n else:\\n right.next = node\\n right = right.next\\n\\n node = node.next\\n\\n left.next = start.next\\n right.next = None\\n\\n return start_left.next\\n\\n \\n\\n \\n\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lesser = ListNode()\\n greater = ListNode()\\n current = head\\n first_greater = None\\n\\n while current:\\n if current.val < x:\\n if head.val >= x:\\n head = current\\n lesser.next = current\\n lesser = current\\n \\n else:\\n if first_greater is None:\\n first_greater = current\\n greater.next = current\\n greater = current\\n\\n current = current.next\\n\\n lesser.next = first_greater\\n greater.next = None\\n\\n return head\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n left = ListNode(0,None)\\n l = left\\n right = ListNode(0,None)\\n r = right\\n cur = head\\n while cur:\\n if cur.val < x:\\n l.next = cur\\n l = l.next\\n else:\\n r.next = cur\\n r = r.next \\n cur = cur.next\\n \\n l.next = right.next\\n r.next = None\\n return left.next\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # left , right = ListNode(),ListNode()\\n # l = left\\n # r = right\\n # while head:\\n # if head.val >= x:\\n # r.next = head\\n # r = r.next\\n # else:\\n # l.next = head\\n # l = l.next\\n # head = head.next\\n # l.next = right.next\\n # r.next = None\\n # return left.next\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n before, after = ListNode(0), ListNode(0)\\n before_curr, after_curr = before, after\\n \\n while head:\\n if head.val < x:\\n before_curr.next, before_curr = head, head\\n else:\\n after_curr.next, after_curr = head, head\\n head = head.next\\n \\n after_curr.next = None\\n before_curr.next = after.next\\n \\n return before.next\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lesser = ListNode()\\n lesser.next = head\\n greater = ListNode()\\n greater.next = head\\n current = head\\n first_greater = None\\n\\n while current:\\n if current.val < x:\\n if head.val >= x:\\n head = current\\n lesser.next = current\\n lesser = current\\n \\n else:\\n if first_greater is None:\\n first_greater = current\\n greater.next = current\\n greater = current\\n\\n current = current.next\\n\\n lesser.next = first_greater\\n greater.next = None\\n\\n return head\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n left=ListNode()\\n right=ListNode()\\n i=left\\n j=right\\n while head:\\n if head.val <x:\\n i.next=head\\n i=i.next\\n else:\\n j.next=head\\n j=j.next\\n head=head.next\\n j.next=None\\n i.next=right.next\\n return left.next\\n\\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lesser = ListNode()\\n lesser.next = head\\n greater = ListNode()\\n greater.next = head\\n current = head\\n first_greater = None\\n\\n while current:\\n if current.val < x:\\n if head.val >= x:\\n head = current\\n lesser.next = current\\n lesser = current\\n \\n else:\\n if first_greater is None:\\n first_greater = current\\n greater.next = current\\n greater = current\\n\\n current = current.next\\n\\n lesser.next = first_greater\\n greater.next = None\\n\\n return head\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n res = less = ListNode()\\n start = more = ListNode()\\n\\n while head:\\n if head.val < x:\\n less.next = head\\n less = less.next\\n else: # head.val >= x\\n more.next = head\\n more = more.next\\n head = head.next\\n\\n more.next = None\\n less.next = start.next\\n\\n return res.next\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n before, after = ListNode(0), ListNode(0)\\n before_curr, after_curr = before, after\\n \\n while head:\\n if head.val < x:\\n before_curr.next, before_curr = head, head\\n else:\\n after_curr.next, after_curr = head, head\\n head = head.next\\n \\n after_curr.next = None\\n before_curr.next = after.next\\n \\n return before.next\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\n# [2,2,1], 2 -> [1,2,2]\\n\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n \\n if not head:\\n return head\\n\\n less_dummy, greater_dummy = ListNode(), ListNode()\\n less, greater = less_dummy, greater_dummy\\n\\n lookup = head\\n while lookup:\\n if lookup.val < x:\\n less.next = lookup\\n less = less.next\\n else:\\n greater.next = lookup\\n greater = greater.next\\n\\n lookup = lookup.next\\n \\n greater.next = None\\n less.next = greater_dummy.next\\n\\n return less_dummy.next\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lesser = ListNode()\\n lesser.next = head\\n greater = ListNode()\\n greater.next = head\\n current = head\\n first_greater = None\\n\\n while current:\\n if current.val < x:\\n if head.val >= x:\\n head = current\\n lesser.next = current\\n lesser = current\\n \\n else:\\n if first_greater is None:\\n first_greater = current\\n greater.next = current\\n greater = current\\n\\n current = current.next\\n\\n lesser.next = first_greater\\n greater.next = None\\n\\n return head\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n sentinel_left = ListNode(0)\\n sentinel_right = ListNode(0)\\n left, right = sentinel_left, sentinel_right\\n while head:\\n if head.val < x:\\n left.next = head\\n left = left.next\\n else:\\n right.next = head\\n right = right.next\\n head = head.next\\n\\n left.next = sentinel_right.next\\n right.next = None\\n # sentinel_right.next = None\\n return sentinel_left.next\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n pre, post = ListNode(), ListNode()\\n curr, curr_pre, curr_post = head, pre, post\\n while curr:\\n if curr.val < x:\\n curr_pre.next = curr\\n curr_pre = curr_pre.next\\n else:\\n curr_post.next = curr\\n curr_post = curr_post.next\\n curr = curr.next\\n curr_pre.next = post.next\\n curr_post.next = None\\n return pre.next\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n before = before_head = ListNode(next=head)\\n after = after_head = ListNode(next=head)\\n\\n while head:\\n if head.val < x:\\n before.next = head\\n before = before.next\\n else:\\n after.next = head\\n after = after.next\\n head = head.next\\n \\n after.next = None\\n before.next = after_head.next\\n return before_head.next\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lesser = ListNode()\\n lesser.next = head\\n greater = ListNode()\\n greater.next = head\\n current = head\\n first_greater = None\\n\\n while current:\\n if current.val < x:\\n if head.val >= x:\\n head = current\\n lesser.next = current\\n lesser = current\\n \\n else:\\n if first_greater is None:\\n first_greater = current\\n greater.next = current\\n greater = current\\n\\n current = current.next\\n\\n lesser.next = first_greater\\n greater.next = None\\n\\n return head\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n dummy = ListNode()\\n dummy.next = head\\n p = head\\n while p.next:\\n p = p.next\\n \\n tail = p\\n head = dummy\\n while head.next != tail:\\n print(tail.val, head.val)\\n if head.next.val < x:\\n head = head.next\\n else:\\n tmpNode = head.next\\n head.next = head.next.next\\n tmpNode.next = None\\n p.next = tmpNode\\n p = p.next\\n\\n if tail.val >= x and tail.next:\\n head.next = tail.next\\n tail.next = None\\n p.next = tail\\n\\n return dummy.next\\n\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# 思路：将链表拆成两个链表，一个储存小于该链表的元素，一个储存大于等于该链表的元素。然后将二者拼起来即可\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n cur = head\\n p1, p2 = ListNode(-1), ListNode(-1) # 两个虚拟头节点\\n p1_head, p2_head = p1, p2 # 两个新链表的头\\n while cur:\\n if cur.val < x:\\n p1.next = cur\\n p1 = p1.next\\n else:\\n p2.next = cur\\n p2 = p2.next\\n cur = cur.next\\n \\n p2.next = None # 如果不加这行，新的整体链表的尾巴仍然连到了链表中间的某处，会出现环；因此要手动置None\\n p1.next = p2_head.next\\n return p1_head.next\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n sml, lrg = ListNode(), ListNode(0, head)\\n\\n slow = sml\\n fast = lrg\\n \\n while fast and fast.next:\\n if fast.next.val < x:\\n val = fast.next.val\\n slow.next = ListNode(val)\\n slow = slow.next\\n fast.next = fast.next.next\\n else:\\n fast = fast.next\\n \\n slow.next = lrg.next\\n return sml.next\\n\\n \\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n one = ListNode()\\n two = ListNode()\\n o = one\\n t = two\\n while head:\\n if head.val < x:\\n o.next = head\\n o = o.next\\n else:\\n t.next = head\\n t = t.next\\n head = head.next\\n o.next = None\\n t.next = None\\n o.next = two.next\\n return one.next\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n p=head\\n l=[]\\n g=[]\\n while p:\\n if p.val>=x:\\n g.append(p.val)\\n if p.val<x:\\n l.append(p.val)\\n p=p.next\\n r=l+g\\n rh=ListNode(0)\\n c=rh\\n for i in r:\\n c.next=ListNode(i)\\n c=c.next\\n return rh.next\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n sentinel_left = ListNode(0)\\n sentinel_right = ListNode(0)\\n left, right = sentinel_left, sentinel_right\\n while head:\\n if head.val < x:\\n left.next = head\\n left = left.next\\n else:\\n right.next = head\\n right = right.next\\n head = head.next\\n\\n left.next = sentinel_right.next\\n right.next = None\\n # sentinel_right.next = None\\n return sentinel_left.next\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n dummy1 = ListNode(-1)\\n dummy2 = ListNode(-2)\\n\\n p1 = dummy1\\n p2 = dummy2\\n\\n while head:\\n if head.val < x:\\n p1.next = head\\n p1 = p1.next\\n else:\\n p2.next = head\\n p2 = p2.next\\n head = head.next\\n \\n p2.next = None\\n p1.next = dummy2.next\\n return dummy1.next\",\n \"runtime\": \"45\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":48,"string":"48"},"mm_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n less = ListNode(0)\n bigger = ListNode(0)\n middle = bigger\n dummy = head\n newhead = less\n while dummy:\n if dummy.val >= x:\n bigger.next = ListNode(dummy.val)\n bigger = bigger.next\n else:\n less.next = ListNode(dummy.val)\n less = less.next\n dummy = dummy.next\n\n less.next = middle.next\n\n return newhead.next","memory":"16200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n dummy = ListNode()\n new_head = dummy\n p1, p2 = head, head\n while p1:\n if p1.val < x:\n new_head.next = ListNode(p1.val)\n new_head = new_head.next\n p1 = p1.next \n \n while p2:\n if p2.val >= x:\n new_head.next = ListNode(p2.val)\n new_head = new_head.next\n p2 = p2.next\n\n return dummy.next","memory":"16300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n left = ListNode(0,None)\n l = left\n right = ListNode(0,None)\n r = right\n cur = head\n while cur:\n if cur.val < x:\n l.next = cur\n l = l.next\n else:\n r.next = cur\n r = r.next \n cur = cur.next\n \n l.next = right.next\n r.next = None\n return left.next\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # left , right = ListNode(),ListNode()\n # l = left\n # r = right\n # while head:\n # if head.val >= x:\n # r.next = head\n # r = r.next\n # else:\n # l.next = head\n # l = l.next\n # head = head.next\n # l.next = right.next\n # r.next = None\n # return left.next","memory":"16400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lesser = ListNode()\n lesser.next = head\n greater = ListNode()\n greater.next = head\n current = head\n first_greater = None\n\n while current:\n if current.val < x:\n if head.val >= x:\n head = current\n lesser.next = current\n lesser = current\n \n else:\n if first_greater is None:\n first_greater = current\n greater.next = current\n greater = current\n\n current = current.next\n\n lesser.next = first_greater\n greater.next = None\n\n return head","memory":"16400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n lower_x = ListNode(0, None)\n higher_x = ListNode(0, None)\n\n curr_low = lower_x\n curr_high = higher_x\n\n curr = head \n while curr:\n if curr.val < x:\n curr_low.next = curr\n curr_low = curr\n else:\n curr_high.next = curr\n curr_high = curr\n curr = curr.next\n \n curr_low.next = higher_x.next\n curr_high.next = None\n\n return lower_x.next\n \n\n","memory":"16500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n sentinel_left = ListNode(0)\n sentinel_right = ListNode(0)\n left, right = sentinel_left, sentinel_right\n while head:\n if head.val < x:\n left.next = head\n left = left.next\n else:\n right.next = head\n right = right.next\n head = head.next\n\n left.next = sentinel_right.next\n right.next = None\n # sentinel_right.next = None\n return sentinel_left.next","memory":"16500"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n less = ListNode(0)\\n bigger = ListNode(0)\\n middle = bigger\\n dummy = head\\n newhead = less\\n while dummy:\\n if dummy.val >= x:\\n bigger.next = ListNode(dummy.val)\\n bigger = bigger.next\\n else:\\n less.next = ListNode(dummy.val)\\n less = less.next\\n dummy = dummy.next\\n\\n less.next = middle.next\\n\\n return newhead.next\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n dummy = ListNode()\\n new_head = dummy\\n p1, p2 = head, head\\n while p1:\\n if p1.val < x:\\n new_head.next = ListNode(p1.val)\\n new_head = new_head.next\\n p1 = p1.next \\n \\n while p2:\\n if p2.val >= x:\\n new_head.next = ListNode(p2.val)\\n new_head = new_head.next\\n p2 = p2.next\\n\\n return dummy.next\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n left = ListNode(0,None)\\n l = left\\n right = ListNode(0,None)\\n r = right\\n cur = head\\n while cur:\\n if cur.val < x:\\n l.next = cur\\n l = l.next\\n else:\\n r.next = cur\\n r = r.next \\n cur = cur.next\\n \\n l.next = right.next\\n r.next = None\\n return left.next\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # left , right = ListNode(),ListNode()\\n # l = left\\n # r = right\\n # while head:\\n # if head.val >= x:\\n # r.next = head\\n # r = r.next\\n # else:\\n # l.next = head\\n # l = l.next\\n # head = head.next\\n # l.next = right.next\\n # r.next = None\\n # return left.next\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lesser = ListNode()\\n lesser.next = head\\n greater = ListNode()\\n greater.next = head\\n current = head\\n first_greater = None\\n\\n while current:\\n if current.val < x:\\n if head.val >= x:\\n head = current\\n lesser.next = current\\n lesser = current\\n \\n else:\\n if first_greater is None:\\n first_greater = current\\n greater.next = current\\n greater = current\\n\\n current = current.next\\n\\n lesser.next = first_greater\\n greater.next = None\\n\\n return head\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n lower_x = ListNode(0, None)\\n higher_x = ListNode(0, None)\\n\\n curr_low = lower_x\\n curr_high = higher_x\\n\\n curr = head \\n while curr:\\n if curr.val < x:\\n curr_low.next = curr\\n curr_low = curr\\n else:\\n curr_high.next = curr\\n curr_high = curr\\n curr = curr.next\\n \\n curr_low.next = higher_x.next\\n curr_high.next = None\\n\\n return lower_x.next\\n \\n\\n\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\\n sentinel_left = ListNode(0)\\n sentinel_right = ListNode(0)\\n left, right = sentinel_left, sentinel_right\\n while head:\\n if head.val < x:\\n left.next = head\\n left = left.next\\n else:\\n right.next = head\\n right = right.next\\n head = head.next\\n\\n left.next = sentinel_right.next\\n right.next = None\\n # sentinel_right.next = None\\n return sentinel_left.next\",\n \"memory\": \"16500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":6,"string":"6"}}},{"rowIdx":41,"cells":{"question_id":{"kind":"number","value":87,"string":"87"},"name":{"kind":"string","value":"scramble-string"},"content":{"kind":"string","value":"<p>We can scramble a string s to get a string t using the following algorithm:</p>\n\n<ol>\n\t<li>If the length of the string is 1, stop.</li>\n\t<li>If the length of the string is > 1, do the following:\n\t<ul>\n\t\t<li>Split the string into two non-empty substrings at a random index, i.e., if the string is <code>s</code>, divide it to <code>x</code> and <code>y</code> where <code>s = x + y</code>.</li>\n\t\t<li><strong>Randomly</strong> decide to swap the two substrings or to keep them in the same order. i.e., after this step, <code>s</code> may become <code>s = x + y</code> or <code>s = y + x</code>.</li>\n\t\t<li>Apply step 1 recursively on each of the two substrings <code>x</code> and <code>y</code>.</li>\n\t</ul>\n\t</li>\n</ol>\n\n<p>Given two strings <code>s1</code> and <code>s2</code> of <strong>the same length</strong>, return <code>true</code> if <code>s2</code> is a scrambled string of <code>s1</code>, otherwise, return <code>false</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> s1 = "great", s2 = "rgeat"\n<strong>Output:</strong> true\n<strong>Explanation:</strong> One possible scenario applied on s1 is:\n"great" --> "gr/eat" // divide at random index.\n"gr/eat" --> "gr/eat" // random decision is not to swap the two substrings and keep them in order.\n"gr/eat" --> "g/r / e/at" // apply the same algorithm recursively on both substrings. divide at random index each of them.\n"g/r / e/at" --> "r/g / e/at" // random decision was to swap the first substring and to keep the second substring in the same order.\n"r/g / e/at" --> "r/g / e/ a/t" // again apply the algorithm recursively, divide "at" to "a/t".\n"r/g / e/ a/t" --> "r/g / e/ a/t" // random decision is to keep both substrings in the same order.\nThe algorithm stops now, and the result string is "rgeat" which is s2.\nAs one possible scenario led s1 to be scrambled to s2, we return true.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> s1 = "abcde", s2 = "caebd"\n<strong>Output:</strong> false\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> s1 = "a", s2 = "a"\n<strong>Output:</strong> true\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>s1.length == s2.length</code></li>\n\t<li><code>1 <= s1.length <= 30</code></li>\n\t<li><code>s1</code> and <code>s2</code> consist of lowercase English letters.</li>\n</ul>\n"},"acRate":{"kind":"number","value":40.73730110444336,"string":"40.737301"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["string","dynamic-programming"],"string":"[\n \"string\",\n \"dynamic-programming\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"28\", 0.5468], [\"32\", 1.3281], [\"36\", 2.8125], [\"40\", 6.4844], [\"44\", 9.609300000000001], [\"48\", 9.2969], [\"52\", 6.6406], [\"56\", 3.75], [\"60\", 3.2812], [\"64\", 2.7343], [\"68\", 2.6562], [\"72\", 1.7188], [\"76\", 1.3281], [\"80\", 0.8593000000000001], [\"84\", 1.5625], [\"88\", 1.3281], [\"92\", 1.25], [\"96\", 1.3281], [\"100\", 1.0156], [\"104\", 0.6249], [\"108\", 0.3906], [\"112\", 0.6249], [\"116\", 0.1562], [\"120\", 0.3905], [\"124\", 0.9375], [\"128\", 0.7811999999999999], [\"132\", 0.4687], [\"136\", 0.5468], [\"140\", 0.5468], [\"144\", 1.0156], [\"148\", 0.8593999999999999], [\"152\", 2.4999000000000002], [\"156\", 2.5781], [\"160\", 2.3439], [\"164\", 1.5626], [\"168\", 2.1875], [\"172\", 2.3437], [\"176\", 2.5782], [\"180\", 2.0314], [\"184\", 0.9375], [\"188\", 0.6249], [\"192\", 0.0781], [\"196\", 0.0781], [\"200\", 0.1562], [\"204\", 0.1562], [\"208\", 0.0781], [\"212\", 0.0781], [\"216\", 0.2344], [\"220\", 0.1562], [\"224\", 0.2343], [\"228\", 0.0781], [\"232\", 0.2343], [\"236\", 0.2343], [\"240\", 0.3906], [\"244\", 0.2343], [\"248\", 0.3124], [\"252\", 0.0781], [\"256\", 0.1562], [\"260\", 0.0781], [\"264\", 0.0781], [\"268\", 0.0781], [\"272\", 0.0781], [\"276\", 0.0781], [\"280\", 0.0781], [\"284\", 0.8593000000000001], [\"288\", 0.0781], [\"292\", 0.4687], [\"296\", 0.4687], [\"300\", 0.3906], [\"304\", 0.4687], [\"308\", 0.5468], [\"312\", 0.2343], [\"316\", 0.2343], [\"320\", 0.2343], [\"324\", 0.4686], [\"328\", 0.0781], [\"332\", 0.1562], [\"336\", 0.3125]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16400\", 0.2344], [\"16500\", 1.7188], [\"16600\", 7.4219], [\"16700\", 11.3281], [\"16800\", 14.0625], [\"16900\", 9.1406], [\"17000\", 3.6719], [\"17100\", 3.0469], [\"17200\", 3.0469], [\"17300\", 5.0781], [\"17400\", 4.4531], [\"17500\", 3.4375], [\"17600\", 3.6719], [\"17700\", 0.7031], [\"17800\", 1.4062], [\"17900\", 0.7812], [\"18000\", 1.0938], [\"18100\", 0.8594], [\"18200\", 0.9375], [\"18300\", 4.375], [\"18400\", 1.3281], [\"18500\", 0.625], [\"18600\", 0.4688], [\"18700\", 0.5469], [\"18800\", 0.4688], [\"18900\", 0.9375], [\"19000\", 0.4688], [\"19100\", 1.0156], [\"19200\", 0.9375], [\"19300\", 1.6406], [\"19400\", 1.7188], [\"19500\", 0.4688], [\"19600\", 0.1562], [\"19700\", 0.7031], [\"19800\", 0.0781], [\"19900\", 0.3125], [\"20000\", 0.3125], [\"20100\", 0.2344], [\"20500\", 0.1562], [\"20600\", 0.0781], [\"20800\", 0.3125], [\"20900\", 0.7812], [\"21000\", 0.0781], [\"22600\", 0.0781], [\"23000\", 0.0781], [\"23100\", 0.0781], [\"23200\", 0.1562], [\"23600\", 0.3125]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n # dictionary to store previously computed substrings\n map = {}\n\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n # check if the two strings are equal\n if s1 == s2:\n return True\n # initialize frequency lists for s1, s2, and current substring\n a, b, c = [0] * 26, [0] * 26, [0] * 26\n # check if the current substring has already been computed\n if (s1 + s2) in self.map:\n return self.map[s1 + s2]\n # check all possible splits of the two strings\n for i in range(1, n):\n j = n - i\n # update frequency lists for s1, s2, and current substring\n a[ord(s1[i - 1]) - ord('a')] += 1\n b[ord(s2[i - 1]) - ord('a')] += 1\n c[ord(s2[j]) - ord('a')] += 1\n # check if the current substring has the same characters\n if a == b and self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n # if the substrings are scrambled versions of each other, return True\n self.map[s1 + s2] = True\n return True\n # check if the current substring and its complement have the same characters\n if a == c and self.isScramble(s1[:i], s2[j:]) and self.isScramble(s1[i:], s2[:j]):\n # if the substrings are scrambled versions of each other, return True\n self.map[s1 + s2] = True\n return True\n # if none of the splits result in scrambled versions, return False\n self.map[s1 + s2] = False\n return False","runtime":"28"},{"code":"class Solution:\n map = {}\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n # check if the two strings are equal\n if s1 == s2:\n return True\n # initialize frequency lists for s1, s2, and current substring\n a, b, c = [0] * 26, [0] * 26, [0] * 26\n # check if the current substring has already been computed\n if (s1 + s2) in self.map:\n return self.map[s1 + s2]\n # check all possible splits of the two strings\n for i in range(1, n):\n j = n - i\n # update frequency lists for s1, s2, and current substring\n a[ord(s1[i - 1]) - ord('a')] += 1\n b[ord(s2[i - 1]) - ord('a')] += 1\n c[ord(s2[j]) - ord('a')] += 1\n # check if the current substring has the same characters\n if a == b and self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n # if the substrings are scrambled versions of each other, return True\n self.map[s1 + s2] = True\n return True\n # check if the current substring and its complement have the same characters\n if a == c and self.isScramble(s1[:i], s2[j:]) and self.isScramble(s1[i:], s2[:j]):\n # if the substrings are scrambled versions of each other, return True\n self.map[s1 + s2] = True\n return True\n # if none of the splits result in scrambled versions, return False\n self.map[s1 + s2] = False\n return False","runtime":"28"},{"code":"class Solution:\n map = {}\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n # check if the two strings are equal\n if s1 == s2:\n return True\n # initialize frequency lists for s1, s2, and current substring\n a, b, c = [0] * 26, [0] * 26, [0] * 26\n # check if the current substring has already been computed\n if (s1 + s2) in self.map:\n return self.map[s1 + s2]\n # check all possible splits of the two strings\n for i in range(1, n):\n j = n - i\n # update frequency lists for s1, s2, and current substring\n a[ord(s1[i - 1]) - ord('a')] += 1\n b[ord(s2[i - 1]) - ord('a')] += 1\n c[ord(s2[j]) - ord('a')] += 1\n # check if the current substring has the same characters\n if a == b and self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n # if the substrings are scrambled versions of each other, return True\n self.map[s1 + s2] = True\n return True\n # check if the current substring and its complement have the same characters\n if a == c and self.isScramble(s1[:i], s2[j:]) and self.isScramble(s1[i:], s2[:j]):\n # if the substrings are scrambled versions of each other, return True\n self.map[s1 + s2] = True\n return True\n # if none of the splits result in scrambled versions, return False\n self.map[s1 + s2] = False\n return False","runtime":"32"},{"code":"class Solution:\n # dictionary to store previously computed substrings\n map = {}\n\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n # check if the two strings are equal\n if s1 == s2:\n return True\n # initialize frequency lists for s1, s2, and current substring\n a, b, c = [0] * 26, [0] * 26, [0] * 26\n # check if the current substring has already been computed\n if (s1 + s2) in self.map:\n return self.map[s1 + s2]\n # check all possible splits of the two strings\n for i in range(1, n):\n j = n - i\n # update frequency lists for s1, s2, and current substring\n a[ord(s1[i - 1]) - ord('a')] += 1\n b[ord(s2[i - 1]) - ord('a')] += 1\n c[ord(s2[j]) - ord('a')] += 1\n # check if the current substring has the same characters\n if a == b and self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n # if the substrings are scrambled versions of each other, return True\n self.map[s1 + s2] = True\n return True\n # check if the current substring and its complement have the same characters\n if a == c and self.isScramble(s1[:i], s2[j:]) and self.isScramble(s1[i:], s2[:j]):\n # if the substrings are scrambled versions of each other, return True\n self.map[s1 + s2] = True\n return True\n # if none of the splits result in scrambled versions, return False\n self.map[s1 + s2] = False\n return False","runtime":"32"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n '''\nThe solution uses recursion with memoization to check all possible partitions of the two strings and determine if they are scrambled versions of each other. The memoization is achieved using a dictionary m that stores the result of previous computations for the same inputs.\n\nThe func function takes in two strings s1 and s2, and returns a boolean value indicating whether they are scrambled versions of each other. The function first checks the length of the strings - if they are both of length 1, it simply compares the characters. If the sorted characters in the two strings are not equal, it returns False.\n\nOtherwise, the function loops through all possible partitions of s1 and checks if they are valid scrambles of corresponding partitions in s2. The partitions are formed by looping through the length of s1 from index 1 to the end. If a valid partition is found, the function recursively checks the remaining partitions to see if they are also valid scrambles.\n\nIf at least one valid partition is found, the function returns True and stores the result in the m dictionary. If no valid partitions are found, the function returns False and stores the result in the m dictionary.\n\nFinally, the isScramble function calls the func function with the two input strings and returns the resulting boolean value.\n\n '''\n m ={}\n def func(s1, s2):\n if (s1, s2) in m:\n return m[(s1, s2)]\n if not sorted(s1) == sorted(s2):\n return False\n if len(s1) == 1:\n return True\n \n\n for i in range(1, len(s1)):\n if func(s1[:i], s2[-i:]) and func(s1[i:], s2[:-i]) or func(s1[:i], s2[:i]) and func(s1[i:], s2[i:]):\n m[(s1, s2)] = True\n return True\n m[(s1, s2)] = False\n return False\n return func(s1, s2)","runtime":"36"},{"code":"class Solution:\n def isScramble(self,s1, s2):\n from functools import lru_cache\n\n n = len(s1)\n if n != len(s2):\n return False\n\n @lru_cache(None)\n def isScrambleRec(s1, s2):\n # Base cases\n if s1 == s2:\n return True\n if sorted(s1) != sorted(s2):\n return False\n\n n = len(s1)\n for i in range(1, n):\n # Without Swap\n if (isScrambleRec(s1[:i], s2[:i]) and isScrambleRec(s1[i:], s2[i:])):\n return True\n # With Swap\n if (isScrambleRec(s1[:i], s2[-i:]) and isScrambleRec(s1[i:], s2[:-i])):\n return True\n return False\n\n return isScrambleRec(s1, s2)\n","runtime":"36"},{"code":"class Solution:\n\n def __init__(self):\n self.scramble_dict = dict()\n\n def isScramble(self, s1: str, s2: str) -> bool:\n if not self.is_permutation(s1, s2):\n return False\n return self.is_scramble_rec(s1, s2)\n\n def is_permutation(self, s1, s2) -> bool:\n return sorted(s1) == sorted(s2)\n\n def is_scramble_rec(self, s1, s2) -> bool:\n if len(s1) <= 3 or s1 == s2:\n return True\n if (s1, s2) in self.scramble_dict:\n return self.scramble_dict[(s1, s2)]\n N = len(s1)\n for pos in range(1, N):\n x1 = s1[:pos]\n x2 = s2[:pos]\n if self.is_permutation(x1, x2):\n x1_rest = s1[pos:]\n x2_rest = s2[pos:]\n if self.is_scramble_rec(x1, x2) and self.is_scramble_rec(x1_rest, x2_rest):\n self.scramble_dict[(s1, s2)] = True\n return True\n x2_back = s2[N - pos:]\n if self.is_permutation(x1, x2_back):\n x1_rest = s1[pos:]\n x2_back_rest = s2[: N - pos]\n if self.is_scramble_rec(x1, x2_back) and self.is_scramble_rec(x1_rest, x2_back_rest):\n self.scramble_dict[(s1, s2)] = True\n return True\n\n self.scramble_dict[(s1, s2)] = False\n return False","runtime":"40"},{"code":"class Solution:\n MAP = {}\n def isScramble(self, s1: str, s2: str) -> bool:\n if (s1, s2) in self.MAP:\n return self.MAP[(s1, s2)]\n if len(s1) != len(s2) or sorted(s1) != sorted(s2):\n self.MAP[(s1, s2)] = False\n return self.MAP[(s1, s2)]\n if s1 == s2:\n self.MAP[(s1, s2)] = True\n return self.MAP[(s1, s2)]\n for i in range(1, len(s1)):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n return True\n swap_i = len(s2) - i\n if self.isScramble(s1[:i], s2[swap_i:]) and self.isScramble(s1[i:], s2[:swap_i]):\n return True\n self.MAP[(s1, s2)] = False\n return self.MAP[(s1, s2)]\n","runtime":"40"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # Dictionary to store results for memoization\n memo = {}\n \n # Helper function to recursively check for scrambled strings\n def solve(s1, s2):\n if s1 == s2:\n return True\n if len(s1) != len(s2):\n return False\n \n # Check memo table for already computed results\n if (s1, s2) in memo:\n return memo[(s1, s2)]\n \n # If sorted characters of both strings don't match, no scramble is possible\n if sorted(s1) != sorted(s2):\n memo[(s1, s2)] = False\n return False\n \n n = len(s1)\n for k in range(1, n):\n # Case 1: s1[0:k] matches s2[0:k] and s1[k:n] matches s2[k:n]\n if solve(s1[:k], s2[:k]) and solve(s1[k:], s2[k:]):\n memo[(s1, s2)] = True\n return True\n \n # Case 2: s1[0:k] matches s2[n-k:n] and s1[k:n] matches s2[0:n-k]\n if solve(s1[:k], s2[n-k:]) and solve(s1[k:], s2[:n-k]):\n memo[(s1, s2)] = True\n return True\n \n memo[(s1, s2)] = False\n return False\n \n return solve(s1, s2)\n","runtime":"44"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n def mm(dct1,dct2):\n mmCnt=0\n for l,cnt in dct1.items():\n try:\n cnt2=dct2[l]\n except KeyError:\n cnt2=0\n if cnt>cnt2: \n mmCnt+=cnt-cnt2\n return mmCnt \n\n def count(s):\n dct={}\n for l in s:\n try:\n dct[l]+=1\n except KeyError:\n dct[l]=1\n return dct \n\n def upd(s,i,dcts):\n l=s[i]\n cnt=dcts[1].pop(l)\n if cnt >1:\n dcts[1][l]=cnt-1\n try:\n dcts[0][l]+=1\n except KeyError:\n dcts[0][l]=1\n def upd2(s,i,dcts):\n #print(dcts)\n l=s[-1-i]\n cnt=dcts[0].pop(l)\n if cnt >1:\n dcts[0][l]=cnt-1\n try:\n dcts[1][l]+=1\n except KeyError:\n dcts[1][l]=1 \n\n cache={}\n def check(s1,s2,dct1=None,dct2=None,n=0):\n try:\n r= cache[(s1,s2)]\n #print(' '*n,s1,s2, 'HIT!')\n return r\n except KeyError:\n pass \n \n\n #print(' '*n,s1,s2)\n if s1==s2:\n return True\n if dct1 is None:\n dcts1={},count(s1)\n dcts2={},count(s2)\n dcts2x=dcts2[1].copy(),{}\n\n if dcts1[1]!=dcts2[1]:\n return False\n else:\n if len(s1)<=3:\n return True\n dcts1={},dct1.copy()\n dcts2={},dct2.copy()\n dcts2x=dct2.copy(),{} \n\n for i in range(0,len(s1)-1):\n upd(s1,i,dcts1)\n upd(s2,i,dcts2)\n upd2(s2,i,dcts2x)\n if dcts1==dcts2:\n if check(s1[:i+1],s2[:i+1],dcts1[0],dcts2[0] , n+1 ) and check(s1[i+1:],s2[i+1:],dcts1[1],dcts2[1],n+1):\n cache[s1,s2]=True\n return True \n if dcts1==dcts2x[::-1]:\n if check( s1[:i+1],s2[-1-i:], dcts1[0],dcts2x[1] , n+1) and check(s1[i+1:],s2[:-1-i],dcts1[1],dcts2x[0],n+1):\n cache[s1,s2]=True\n return True\n cache[s1,s2]=False \n return False \n\n\n return check(s1,s2)\n\n","runtime":"44"},{"code":"# intuition is that s2 can be scrabled by s1 as long as they have the same letters.\n\n# for example \n\n# 12345 -> 54321\n# 12 / 345\n# 12 -> 2 / 1\n# 345 -> 5 / 34\n# 34 -> 4/3\n\n# oh here is a counter example \n\n# abcde -> caebd\n\n# abcde -> bcde / a to move c before a\n\n# but now we have no way to move b/d/e after a \n\n# every scrable moves a substring s1 permanently after s2\n\n# cadbe won't work either, because when you move c before a, you must be moving de before a and no way back\n\n# so the first split must happen between the first letters of s1 and s2, the scramble is promising only when \n# all letter after s2's first letter is always in front of s1's letter\n\n# brute force is to enumerate all scrambled s2, for a string of length n, each split is O(n), and there are n-1 positions to split\n\n# so O(n) = n(n-1)*T(n-1) = O(n^2n)\n# theta(n) = n(n-1)*T(n/2) = O(n^(2*log_2^n))\n\n\n# so basically we can divide and conqure the problem: \n\n# for s1 = abcde and s2 = cdeba, we have 4 split\n\n# a/bcde, ab/cde, abc/de, abcd/e\n\n# now for s2 to be a scramble string, it must be any of the following split match the those for s1's split\n\n# c/deba, cd/eba, cde/ba, cdeb/a\n\n# by match we means the two part of at least one s2 spllits can be scramble, individualy by the two part of at least one s1 splits\n# we know that when letters doesn't match, or length doesn't match, it won't be scramble. This help eliminate many cases. \n\n# Effectively, we only need to check: \n# a/bcde v.s. c/deba and cdeb/a => i=1, s1[:1] v.s. s2[:i] && s1[1:5] v.s. s2[1:5] | s1[:1] v.s. s2[5-1:5] && s1[1:5] v.s. s2[:5-1]\n# ab/cde v.s. cd/eba and cde/ba\n# abc/de v.s. cd/eba and cde/ba\n# abcd/e v.s. c/deba and cdeb/a\n\n# and we can also expect many substrings comparison will be repeated and we can memorize for quicker solution.\n\nclass Solution:\n @functools.lru_cache(maxsize=1024*1024, typed=False)\n def isScramble(self, s1: str, s2: str) -> bool:\n # print(s1, s2)\n if s1 == s2:\n return True\n if sorted(s1) != sorted(s2):\n return False;\n n = len(s1)\n for i in range(1,n):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:n], s2[i:n]):\n return True\n if self.isScramble(s1[:i], s2[n-i:n]) and self.isScramble(s1[i:n], s2[:n-i]):\n return True\n return False\n","runtime":"48"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \n memo = {}\n \n def dfs(s1, s2):\n \n if s1 == s2:\n return True\n \n if sorted(s1) != sorted(s2):\n return False\n \n if (s1, s2) in memo:\n return memo[(s1, s2)]\n \n n = len(s1)\n for i in range(1, n):\n \n if (dfs(s1[:i], s2[:i]) and dfs(s1[i:], s2[i:])) or \\\n (dfs(s1[:i], s2[-i:]) and dfs(s1[i:], s2[:-i])):\n memo[(s1, s2)] = True\n return True\n \n memo[(s1, s2)] = False\n return False\n \n return dfs(s1, s2)\n\n\nsol = Solution()\nprint(sol.isScramble(\"great\", \"rgeat\")) \nprint(sol.isScramble(\"abcde\", \"caebd\")) \nprint(sol.isScramble(\"a\", \"a\")) \n","runtime":"48"},{"code":"import time\r\nclass Solution:\r\n cache = {}\r\n cach2 = {}\r\n def isScramble(self, s1: str, s2: str) -> bool: \r\n def hashmatch(s1, s2):\r\n key = f'{s1}0{s2}'\r\n if key in self.cach2:\r\n return self.cach2[key]\r\n s1map = {}\r\n s2map = {}\r\n for s in s1:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n for s in s2:\r\n if s not in s2map:\r\n s2map[s] = 1\r\n else:\r\n s2map[s] += 1\r\n for key in s1map.keys():\r\n if key not in s2map or s2map[key] != s1map[key]:\r\n self.cach2[key] = False\r\n return False\r\n self.cach2[key] = True\r\n return True \r\n if len(s1) == 1:\r\n return s1 == s2\r\n key = f'{s1}-{s2}'\r\n if key in self.cache:\r\n return self.cache[key]\r\n n = len(s1)\r\n for i in range(n):\r\n if i+1<n-i-1:\r\n s1_l = s1[:i+1]\r\n s2_l = s2[:i+1]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[i+1:]\r\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n s1_l = s1[:i+1]\r\n s2_l = s2[-i-1:]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[:-i-1]\r\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n else:\r\n s1_l = s1[i+1:]\r\n s2_l = s2[i+1:]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[:i+1]\r\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n s1_l = s1[i+1:]\r\n s2_l = s2[:-i-1]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[-i-1:]\r\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n self.cache[key] = False\r\n return False","runtime":"52"},{"code":"import time\r\nclass Solution:\r\n cache = {}\r\n def isScramble(self, s1: str, s2: str) -> bool: \r\n def hashmatch(s1map, s2):\r\n s2map = {}\r\n for s in s2:\r\n if s not in s2map:\r\n s2map[s] = 1\r\n else:\r\n s2map[s] += 1\r\n for key in s1map.keys():\r\n if key not in s2map or s2map[key] != s1map[key]:\r\n return False\r\n return True \r\n if len(s1) == 1:\r\n return s1 == s2\r\n key = f'{s1}-{s2}'\r\n if key in self.cache:\r\n return self.cache[key]\r\n n = len(s1)\r\n for i in range(n):\r\n if i+1<n-i-1:\r\n s1_l = s1[:i+1]\r\n s2_l = s2[:i+1]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[i+1:]\r\n s1map = {}\r\n for s in s1_l:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n s1rmap = {}\r\n for s in s1_r:\r\n if s not in s1rmap:\r\n s1rmap[s] = 1\r\n else:\r\n s1rmap[s] += 1\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n s1_l = s1[:i+1]\r\n s2_l = s2[-i-1:]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[:-i-1]\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n else:\r\n s1_l = s1[i+1:]\r\n s2_l = s2[i+1:]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[:i+1]\r\n s1map = {}\r\n for s in s1_l:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n s1rmap = {}\r\n for s in s1_r:\r\n if s not in s1rmap:\r\n s1rmap[s] = 1\r\n else:\r\n s1rmap[s] += 1 \r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n s1_l = s1[i+1:]\r\n s2_l = s2[:-i-1]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[-i-1:]\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n self.cache[key] = False\r\n return False","runtime":"52"},{"code":"import time\r\nclass Solution:\r\n cache = {}\r\n def isScramble(self, s1: str, s2: str) -> bool: \r\n def hashmatch(s1map, s2):\r\n s2map = {}\r\n for s in s2:\r\n if s not in s2map:\r\n s2map[s] = 1\r\n else:\r\n s2map[s] += 1\r\n for key in s1map.keys():\r\n if key not in s2map or s2map[key] != s1map[key]:\r\n return False\r\n return True \r\n if len(s1) == 1:\r\n return s1 == s2\r\n key = f'{s1}-{s2}'\r\n if key in self.cache:\r\n return self.cache[key]\r\n n = len(s1)\r\n for i in range(n):\r\n if i+1<n-i-1:\r\n s1_l = s1[:i+1]\r\n s2_l = s2[:i+1]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[i+1:]\r\n s1map = {}\r\n for s in s1_l:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n s1rmap = {}\r\n for s in s1_r:\r\n if s not in s1rmap:\r\n s1rmap[s] = 1\r\n else:\r\n s1rmap[s] += 1\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n s1_l = s1[:i+1]\r\n s2_l = s2[-i-1:]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[:-i-1]\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n else:\r\n s1_l = s1[i+1:]\r\n s2_l = s2[i+1:]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[:i+1]\r\n s1map = {}\r\n for s in s1_l:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n s1rmap = {}\r\n for s in s1_r:\r\n if s not in s1rmap:\r\n s1rmap[s] = 1\r\n else:\r\n s1rmap[s] += 1 \r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n s1_l = s1[i+1:]\r\n s2_l = s2[:-i-1]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[-i-1:]\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n self.cache[key] = False\r\n return False","runtime":"56"},{"code":"import time\r\nclass Solution:\r\n cache = {}\r\n def isScramble(self, s1: str, s2: str) -> bool: \r\n def hashmatch(s1map, s2):\r\n s2map = {}\r\n for s in s2:\r\n if s not in s2map:\r\n s2map[s] = 1\r\n else:\r\n s2map[s] += 1\r\n for key in s1map.keys():\r\n if key not in s2map or s2map[key] != s1map[key]:\r\n return False\r\n return True \r\n if len(s1) == 1:\r\n return s1 == s2\r\n key = f'{s1}-{s2}'\r\n if key in self.cache:\r\n return self.cache[key]\r\n n = len(s1)\r\n for i in range(n):\r\n if i+1<n-i-1:\r\n s1_l = s1[:i+1]\r\n s2_l = s2[:i+1]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[i+1:]\r\n s1map = {}\r\n for s in s1_l:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n s1rmap = {}\r\n for s in s1_r:\r\n if s not in s1rmap:\r\n s1rmap[s] = 1\r\n else:\r\n s1rmap[s] += 1\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n s1_l = s1[:i+1]\r\n s2_l = s2[-i-1:]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[:-i-1]\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n else:\r\n s1_l = s1[i+1:]\r\n s2_l = s2[i+1:]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[:i+1]\r\n s1map = {}\r\n for s in s1_l:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n s1rmap = {}\r\n for s in s1_r:\r\n if s not in s1rmap:\r\n s1rmap[s] = 1\r\n else:\r\n s1rmap[s] += 1 \r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n s1_l = s1[i+1:]\r\n s2_l = s2[:-i-1]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[-i-1:]\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n self.cache[key] = False\r\n return False\r\n\r\n def isScramble2(self, s1: str, s2: str) -> bool:\r\n from functools import lru_cache\r\n\r\n @lru_cache(None)\r\n def dfs(s1, s2):\r\n if s1 == s2:\r\n return True\r\n if sorted(s1) != sorted(s2):\r\n return False\r\n n = len(s1)\r\n for i in range(1, n):\r\n # Check without swap\r\n if dfs(s1[:i], s2[:i]) and dfs(s1[i:], s2[i:]):\r\n return True\r\n # Check with swap\r\n if dfs(s1[:i], s2[-i:]) and dfs(s1[i:], s2[:-i]):\r\n return True\r\n return False\r\n\r\n return dfs(s1, s2) ","runtime":"56"},{"code":"import time\r\nclass Solution:\r\n cache = {}\r\n cach2 = {}\r\n def isScramble(self, s1: str, s2: str) -> bool: \r\n def hashmatch(s1, s2):\r\n key = f'{s1}0{s2}'\r\n if key in self.cach2:\r\n return self.cach2[key]\r\n s1map = {}\r\n s2map = {}\r\n for s in s1:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n for s in s2:\r\n if s not in s2map:\r\n s2map[s] = 1\r\n else:\r\n s2map[s] += 1\r\n for key in s1map.keys():\r\n if key not in s2map or s2map[key] != s1map[key]:\r\n self.cach2[key] = False\r\n return False\r\n self.cach2[key] = True\r\n return True \r\n if len(s1) == 1:\r\n return s1 == s2\r\n key = f'{s1}-{s2}'\r\n if key in self.cache:\r\n return self.cache[key]\r\n n = len(s1)\r\n for i in range(n):\r\n if i+1<n-i-1:\r\n s1_l = s1[:i+1]\r\n s2_l = s2[:i+1]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[i+1:]\r\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n s1_l = s1[:i+1]\r\n s2_l = s2[-i-1:]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[:-i-1]\r\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n else:\r\n s1_l = s1[i+1:]\r\n s2_l = s2[i+1:]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[:i+1]\r\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n s1_l = s1[i+1:]\r\n s2_l = s2[:-i-1]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[-i-1:]\r\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n self.cache[key] = False\r\n return False","runtime":"60"},{"code":"import time\r\nclass Solution:\r\n cache = {}\r\n def isScramble(self, s1: str, s2: str) -> bool: \r\n def hashmatch(s1map, s2):\r\n s2map = {}\r\n for s in s2:\r\n if s not in s2map:\r\n s2map[s] = 1\r\n else:\r\n s2map[s] += 1\r\n for key in s1map.keys():\r\n if key not in s2map or s2map[key] != s1map[key]:\r\n return False\r\n return True \r\n if len(s1) == 1:\r\n return s1 == s2\r\n key = f'{s1}-{s2}'\r\n if key in self.cache:\r\n return self.cache[key]\r\n n = len(s1)\r\n for i in range(n):\r\n if i+1<n-i-1:\r\n s1_l = s1[:i+1]\r\n s2_l = s2[:i+1]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[i+1:]\r\n s1map = {}\r\n for s in s1_l:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n s1rmap = {}\r\n for s in s1_r:\r\n if s not in s1rmap:\r\n s1rmap[s] = 1\r\n else:\r\n s1rmap[s] += 1\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n s1_l = s1[:i+1]\r\n s2_l = s2[-i-1:]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[:-i-1]\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n else:\r\n s1_l = s1[i+1:]\r\n s2_l = s2[i+1:]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[:i+1]\r\n s1map = {}\r\n for s in s1_l:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n s1rmap = {}\r\n for s in s1_r:\r\n if s not in s1rmap:\r\n s1rmap[s] = 1\r\n else:\r\n s1rmap[s] += 1 \r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n s1_l = s1[i+1:]\r\n s2_l = s2[:-i-1]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[-i-1:]\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n self.cache[key] = False\r\n return False\r\n\r\n def isScramble2(self, s1: str, s2: str) -> bool:\r\n from functools import lru_cache\r\n\r\n @lru_cache(None)\r\n def dfs(s1, s2):\r\n if s1 == s2:\r\n return True\r\n if sorted(s1) != sorted(s2):\r\n return False\r\n n = len(s1)\r\n for i in range(1, n):\r\n # Check without swap\r\n if dfs(s1[:i], s2[:i]) and dfs(s1[i:], s2[i:]):\r\n return True\r\n # Check with swap\r\n if dfs(s1[:i], s2[-i:]) and dfs(s1[i:], s2[:-i]):\r\n return True\r\n return False\r\n\r\n return dfs(s1, s2) ","runtime":"60"},{"code":"class Solution:\n @functools.lru_cache(None)\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n if collections.Counter(s1) != collections.Counter(s2):\n return False\n\n for i in range(1, len(s1)):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n return True\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\n self.isScramble(s1[i:], s2[: len(s2) - i])):\n return True\n\n return False","runtime":"64"},{"code":"class Solution:\n @functools.lru_cache(None)\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n if collections.Counter(s1) != collections.Counter(s2):\n return False\n\n for i in range(1, len(s1)):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n return True\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\n self.isScramble(s1[i:], s2[: len(s2) - i])):\n return True\n\n return False\n ","runtime":"64"},{"code":"class Solution:\n @functools.lru_cache(None)\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n if collections.Counter(s1) != collections.Counter(s2):\n return False\n\n for i in range(1, len(s1)):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n return True\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\n self.isScramble(s1[i:], s2[: len(s2) - i])):\n return True\n\n return False","runtime":"68"},{"code":"class Solution:\n @functools.lru_cache(None)\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n if collections.Counter(s1) != collections.Counter(s2):\n return False\n\n for i in range(1, len(s1)):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n return True\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\n self.isScramble(s1[i:], s2[: len(s2) - i])):\n return True\n\n return False ","runtime":"68"},{"code":"class Solution:\n @functools.lru_cache(None)\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n if collections.Counter(s1) != collections.Counter(s2):\n return False\n\n for i in range(1, len(s1)):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n return True\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\n self.isScramble(s1[i:], s2[: len(s2) - i])):\n return True\n\n return False","runtime":"72"},{"code":"from functools import lru_cache\nfrom collections import Counter\n\nclass Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \"\"\"\n Determine if s2 is a scrambled string of s1.\n \n :param s1: The first string\n :param s2: The second string\n :return: True if s2 is a scramble of s1, False otherwise\n \"\"\"\n # Helper function to check if two strings have the same character frequencies\n def have_same_chars(a: str, b: str) -> bool:\n return Counter(a) == Counter(b)\n \n @lru_cache(None)\n def dp(a: str, b: str) -> bool:\n # Base cases\n if len(a) != len(b):\n return False\n if len(a) == 1:\n return a == b\n if a == b:\n return True\n if not have_same_chars(a, b):\n return False\n \n # Check all possible splits\n for i in range(1, len(a)):\n # Case 1: No swap\n if (dp(a[:i], b[:i]) and dp(a[i:], b[i:])):\n return True\n # Case 2: Swap\n if (dp(a[:i], b[-i:]) and dp(a[i:], b[:-i])):\n return True\n \n return False\n \n return dp(s1, s2)\n","runtime":"72"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # self.cache = {}\n return self.__dfs(s1, s2 , 0, len(s1), 0, len(s2))\n \n @cache\n def __dfs(self, s1, s2, x1, x2, y1, y2):\n # print(s1[x1:x2], s2[y1:y2])\n\n if s1[x1:x2]== s2[y1:y2]: return True\n # if (x1, x2, y1, y2) in self.cache: return self.cache[(x1, x2, y1, y2)]\n a1 = collections.Counter(s1[x1:x2])\n b1 = collections.Counter(s2[y1:y2])\n\n if a1!=b1:\n return False\n \n if x2 -x1 ==1:\n return True\n \n len_item = x2-x1\n for i in range(1, x2-x1):\n a1 = (self.__dfs(s1, s2, x1, x1+i, y1, y1+i ) \n and self.__dfs (s1, s2, x1+i,x2, y1+i, y2) )\n # print(\"a1\", a1)\n b1 = ((self.__dfs(s1,s2, x1+i, x2, y1, y1+ (y2-y1-i) ) \n and self.__dfs(s1 , s2, x1, x1+i, y1+ (y2-y1-i) , y2)))\n \n \n if a1 or b1: \n # self.cache[(x1, x2, y1, y2)] = a1 or b1\n return a1 or b1\n # self.cache[(x1, x2, y1, y2)] = False\n return False\n\n\n \n\n ","runtime":"76"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n if n != len(s2):\n return False\n if n == 1:\n return s1 == s2\n \n @lru_cache(None)\n def dp(i, j, k):\n if k == 1:\n return s1[i] == s2[j]\n \n for l in range(1, k):\n if (dp(i, j, l) and dp(i+l, j+l, k-l)) or \\\n (dp(i, j+k-l, l) and dp(i+l, j, k-l)):\n return True\n return False\n \n return dp(0, 0, n)","runtime":"76"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(i: int, j: int, k: int) -> bool:\n if k == 1:\n return s1[i] == s2[j]\n for h in range(1, k):\n if dfs(i, j, h) and dfs(i + h, j + h, k - h):\n return True\n if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):\n return True\n return False\n\n return dfs(0, 0, len(s1))","runtime":"80"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dp(i1: int, i2: int, l: int) -> bool:\n if l == 1:\n return s1[i1] == s2[i2]\n \n for new_l in range(1, l):\n if dp(i1, i2, new_l) and dp(i1 + new_l, i2 + new_l, l - new_l):\n return True\n if dp(i1, i2 + l - new_l, new_l) and dp(i1 + new_l, i2, l - new_l):\n return True\n return False\n \n return dp(0, 0, len(s1))\n","runtime":"80"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(l0, l1, _len):\n if _len == 1 and s1[l0] != s2[l1]:\n return False\n if s1[l0 : l0 + _len] == s2[l1 : l1 + _len]:\n return True\n ##\n for k in range(1, _len):\n if dfs(l0, l1, k) and dfs(l0 + k, l1 + k, _len - k):\n return True\n if dfs(l0, l1 + _len - k, k) and dfs(l0 + k, l1, _len - k):\n return True\n ##\n return False\n\n ##\n return dfs(0, 0, len(s2))\n","runtime":"84"},{"code":"from collections import Counter\n\nfrom functools import cache\n\nclass Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n def _is_candidate(val, target):\n return Counter(val) == Counter(target)\n @cache\n def _fn(a, b):\n assert len(a) == len(b)\n\n l = len(a)\n if l == 1:\n return a == b\n\n for i in range(1, l):\n p2, p1 = a[:i], a[i:]\n t1, t2 = b[:-i], b[-i:]\n #print(f\"swap p1 : {p1} / t1 : {t1} / p2 : {p2} / t2 : {t2} \")\n if _is_candidate(p1, t1) and _is_candidate(p2, t2):\n \n out = _fn(p1, t1) and _fn(p2, t2)\n if out:\n return True\n\n p1, p2 = a[:i], a[i:]\n t1, t2 = b[:i], b[i:]\n #print(f\"no swap p1 : {p1} / t1 : {t1} / p2 : {p2} / t2 : {t2} \")\n\n if _is_candidate(p1, t1) and _is_candidate(p2, t2):\n out = _fn(p1, t1) and _fn(p2, t2)\n if out:\n return True\n\n return False\n return _fn(s1, s2)\n\n","runtime":"84"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n s1, s2 = list(s1), list(s2)\n n = len(s1)\n dp = [[[0] * (n + 1) for _ in range(n) ] for _ in range(n)]\n\n def f(l1, l2, length, dp):\n if length == 1:\n return s1[l1] == s2[l2]\n\n if dp[l1][l2][length] != 0:\n return dp[l1][l2][length] == 1\n\n ans = False\n for k in range(1, length):\n # Check non-swapped case\n if f(l1, l2, k, dp) and f(l1 + k, l2 + k, length - k, dp):\n ans = True\n break\n\n # Check swapped case\n if f(l1, l2 + length - k, k, dp) and f(l1 + k, l2, length - k, dp):\n ans = True\n break\n\n dp[l1][l2][length] = 1 if ans else -1\n return ans\n\n return f(0, 0, n, dp)\n\n#The dynamic programming table dp[l1][l2][len] stores results of subproblems of size len. Since the length can vary from 1 to n, the number of possible subproblems is O(n^3) (since l1, l2, and len can each take n values). # For each subproblem, there are O(n) possible splits, and each recursive call involves comparing two strings of size len.\n# Time Complexity:\n# The overall time complexity is O(n^4). This comes from iterating over all possible subproblems (O(n^3)) and for each, performing up to O(n) comparisons.\n \n\n# The 3D dynamic programming table dp[l1][l2][len] has dimensions n x n x (n+1), which requires O(n^3) space.\n# Additionally, the recursion stack may go as deep as O(n) in the worst case.\n# Space Complexity:\n# The total space complexity is O(n^3) due to the dynamic programming table. The recursion stack contributes O(n) but is dominated by the table.\n \n","runtime":"88"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(i: int, j: int, k: int) -> bool:\n if k == 1:\n return s1[i] == s2[j]\n for h in range(1, k):\n if dfs(i, j, h) and dfs(i + h, j + h, k - h):\n return True\n if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):\n return True\n return False\n\n return dfs(0, 0, len(s1))","runtime":"88"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(i: int, j: int, k: int) -> bool:\n if k == 1:\n return s1[i] == s2[j]\n for h in range(1, k):\n if dfs(i, j, h) and dfs(i + h, j + h, k - h):\n return True\n if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):\n return True\n return False\n\n return dfs(0, 0, len(s1))","runtime":"92"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \n dp = {}\n def helper(s, t):\n if (s, t) in dp:\n return dp[(s, t)]\n if Counter(s) != Counter(t):\n return False\n if len(s) == 1:\n return True\n \n for i in range(1, len(s)):\n if (helper(s[:i], t[-i:]) and helper(s[i:], t[:-i])) or (helper(s[i:], t[i:]) and helper(s[:i], t[:i])):\n dp[(s, t)] = True\n return True\n dp[(s, t)] = False\n return False\n \n return helper(s1, s2)","runtime":"92"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(i: int, j: int, k: int) -> bool:\n if k == 1:\n return s1[i] == s2[j]\n for h in range(1, k):\n if dfs(i, j, h) and dfs(i + h, j + h, k - h):\n return True\n if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):\n return True\n return False\n\n return dfs(0, 0, len(s1))","runtime":"96"},{"code":"map={}\nclass Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n\n if sorted(s1) != sorted(s2):\n return False\n\n if s1 == s2:\n return True\n\n if (s1+' '+s2) in map:\n return map[s1+' '+s2]\n\n n = len(s1)\n flag=False\n for i in range(1, n):\n # Check without swapping\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n flag=True\n # Check with swapping\n if self.isScramble(s1[:i], s2[-i:]) and self.isScramble(s1[i:], s2[:-i]):\n flag=True\n\n map[s1+' '+s2]=flag\n return flag\n\n","runtime":"96"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n\n N = len(s1)\n @cache\n def dp(length,i,j):\n if i>=N or j>=N: return False\n if length == 1: return s1[i] == s2[j]\n\n for new_len in range(1, length):\n not_swap = dp(new_len,i,j) and dp(length - new_len, i + new_len, j + new_len)\n swap = dp(length-new_len, i + new_len, j) and dp(new_len, i, j + (length-new_len))\n if swap or not_swap: return True\n \n return False\n \n return dp(len(s1), 0,0)\n\n ","runtime":"100"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n\n @lru_cache(None)\n def loop(i, j, x, y):\n if x + 1 == y:\n return s1[i] == s2[x]\n\n size = j - i\n for k in range(1, size):\n k_ = size - k\n if (\n loop(i, i + k, x, x + k)\n and loop(i + k, j, x + k, y)\n or loop(i + k, j, x, x + k_)\n and loop(i, i + k, x + k_, y)\n ):\n return True\n return False\n\n n = len(s1)\n\n return loop(0, n, 0, n)\n","runtime":"100"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n\n @cache\n def canScramble(i1, j1, i2, j2):\n if i1 > j1:\n return True\n if i1 == j1:\n return s1[i1] == s2[i2]\n if s1[i1: j1 + 1] == s2[i2: j2 + 1] or s1[i1: j1 + 1] == s2[i2: j2 + 1][::-1]:\n return True\n\n for x in range(i1, j1):\n y = x - i1 + i2\n if canScramble(i1, x, i2, y) and canScramble(x + 1, j1, y + 1, j2):\n return True\n z = j2 + i1 - x\n if canScramble(i1, x, z, j2) and canScramble(x + 1, j1, i2, z - 1):\n return True\n \n return False\n\n return canScramble(0, len(s1) - 1, 0, len(s2) - 1)\n\n ","runtime":"104"},{"code":"class Solution:\n def f(self, s, t, i, j, len, memo ):\n # print(f\"checking for {i} {j} {len} \")\n if memo[i][j][len] != None:\n return memo[i][j][len]\n \n if len == 1:\n memo[i][j][len] = s[i]==t[j]\n return s[i]==t[j]\n \n\n for k in range(1, len):\n if self.f(s, t, i, j, k, memo ) and self.f(s,t , i+k, j+k, len-k, memo ):\n memo[i][j][len] = True\n return True\n if self.f(s, t, i, j + len-k, k, memo ) and self.f(s,t, i+k, j, len-k, memo ):\n memo[i][j][len] = True\n return True\n \n \n memo[i][j][len] = False\n return False\n\n\n\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n memo =[ [ [None]*(n+1) for _ in range(n+1) ] for i in range(n+1)]\n return self.f(s1, s2, 0, 0, n, memo )","runtime":"104"},{"code":"import collections\nclass Solution:\n\n cache = {}\n\n def equal_counts(self, s1, s2):\n return collections.Counter(s1) == collections.Counter(s2)\n\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n elif s1 == s2:\n return True\n elif not self.equal_counts(s1, s2):\n return False\n elif len(s1) == 0 or len(s1) == 1:\n return True\n if s1+s2 in self.cache:\n return self.cache[s1+s2]\n\n for split1 in range(1, len(s1)):\n for split2 in range(1, len(s2)):\n left_s1 = s1[:split1]\n right_s1 = s1[split1:]\n\n left_s2 = s2[:split2]\n right_s2 = s2[split2:]\n\n #print(\"s1\", left_s1, right_s1)\n #print(\"s2\", left_s2, right_s2)\n\n if self.isScramble(left_s1, left_s2) and self.isScramble(right_s1, right_s2):\n self.cache[s1+s2] = True\n return True\n elif self.isScramble(left_s1, right_s2) and self.isScramble(right_s1, left_s2):\n self.cache[s1+s2] = True\n return True\n\n self.cache[s1+s2] = False\n return False\n\n ","runtime":"108"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n dp = defaultdict(dict)\n def helper(l1, r1, l2, r2):\n if r1 - l1 == 1:\n return s1[l1:r1] == s2[l2:r2]\n params = (l1, r1, l2, r2)\n if params in dp:\n return dp[params]\n for xlen in range(1, r1 - l1):\n if (helper(l1, l1 + xlen, l2, l2 + xlen) and helper(l1 + xlen, r1, l2 + xlen, r2) or\n helper(l1, l1 + xlen, r2 - xlen, r2) and helper(l1 + xlen, r1, l2, r2 - xlen)):\n dp[params] = True\n return True\n dp[params] = False\n return False\n return helper(0, len(s1), 0, len(s2))","runtime":"108"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n memo = {}\n def back(s1, s2):\n if (s1, s2) in memo:\n return memo[(s1, s2)]\n if not set(s1) == set(s2):\n return False\n if len(s1) == 1:\n return True\n for i in range(1, len(s1)):\n if back(s1[i:],s2[i:]) and back(s1[:i],s2[:i]) or back(s1[i:],s2[:-i]) and back(s1[:i],s2[-i:]):\n memo[(s1, s2)] = True\n return True\n memo[(s1, s2)] = False\n return False\n return back(s1, s2)","runtime":"112"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n\n cache = {} # ()\n\n def dfs(cur_s, cur_e, tar_s, tar_e):\n if (cur_s, cur_e, tar_s, tar_e) in cache:\n return cache[(cur_s, cur_e, tar_s, tar_e)]\n\n lenn = cur_e - cur_s \n \n is_scramble = False\n if s1[cur_s:cur_e] == s2[tar_s:tar_e]:\n is_scramble = True\n elif lenn == 1 and s1[cur_s:cur_e] != s2[tar_s:tar_e]:\n is_scramble = False\n else:\n # We need to split\n for i in range(1, lenn):\n #no-swap\n if dfs(cur_s, cur_s + i, tar_s, tar_s + i) and dfs(cur_s + i, cur_e, tar_s + i, tar_e):\n is_scramble = True\n break\n #swap\n if dfs(cur_s, cur_s + i, tar_e - i, tar_e) and dfs(cur_s + i, cur_e, tar_s, tar_e - i):\n is_scramble = True\n break\n\n cache[(cur_s, cur_e, tar_s, tar_e)] = is_scramble\n return cache[(cur_s, cur_e, tar_s, tar_e)]\n\n return dfs(0, len(s1), 0, len(s2))","runtime":"112"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n \n if s1 == s2:\n return True\n \n if sorted(s1) != sorted(s2):\n return False\n memo = {}\n def scramble(i1,i2,length):\n if length == 1:\n return s1[i1] == s2[i2]\n \n if (i1,i2,length) in memo:\n return memo[(i1,i2,length)]\n res = False\n for i in range(1,length):\n # No Swap\n \n # Swap\n if (scramble(i1,i2,i) and scramble(i1+i,i2+i,length - i)) or \\\n (scramble(i1,i2+length - i,i) and scramble(i1+i,i2,length-i)):\n res = True\n break\n memo[(i1,i2,length)] = res\n return res\n \n return scramble(0,0,len(s1))","runtime":"116"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n cache: dict[tuple[int, int]: bool] = {}\n\n def dp(left1: int, right1: int, left2: int, right2: int) -> bool:\n if left1 == right1:\n return s1[left1] == s2[left2]\n key: tuple[int, int, int, int] = (left1, right1, left2, right2)\n if key in cache:\n return cache[key]\n cache[key] = False\n for i in range(right1 - left1):\n cache[key] = (cache[key] or (\n dp(left1, left1 + i, left2, left2 + i) and dp(left1 + i + 1, right1, left2 + i + 1, right2)\n ) or (\n dp(left1, left1 + i, right2 - i, right2) and dp(left1 + i + 1, right1, left2, right2 - i - 1)\n ))\n return cache[key]\n \n\n\n return dp(0, len(s1) -1 , 0, len(s2) - 1)","runtime":"116"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n \n if s1 == s2:\n return True\n \n if sorted(s1) != sorted(s2):\n return False\n memo = {}\n def scramble(i1,i2,length):\n if length == 1:\n return s1[i1] == s2[i2]\n \n if (i1,i2,length) in memo:\n return memo[(i1,i2,length)]\n res = False\n for i in range(1,length):\n # No Swap\n \n # Swap\n if (scramble(i1,i2,i) and scramble(i1+i,i2+i,length - i)) or \\\n (scramble(i1,i2+length - i,i) and scramble(i1+i,i2,length-i)):\n res = True\n break\n memo[(i1,i2,length)] = res\n return res\n \n return scramble(0,0,len(s1))","runtime":"120"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # Memomiazation \n # O(n^4) time, O(n^3) space\n if len(s1) != len(s2):\n return False\n \n n = len(s1)\n\n # (ls1, ls2, sslen). ls1 is starting index in s1. ls2 is starting index in s2, sslen is substring length we are testing.\n # where memo[(ls1, ls2, sslen)] = isScramble(s1[ls1..ls1+sslen-1], s2[ls2..ls2+sslen-1])\n memo = {}\n\n def recurse_is_scramble(ls1, ls2, sslen):\n if (ls1, ls2, sslen) in memo:\n return memo[(ls1, ls2, sslen)]\n if sslen == 1:\n memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\n return memo[(ls1, ls2, sslen)]\n \n for xlen in range(1, sslen):\n ylen = sslen - xlen\n # x + y\n res = recurse_is_scramble(ls1, ls2, xlen) and recurse_is_scramble(ls1 + xlen, ls2 + xlen, ylen)\n if not res:\n # y + x\n res = res or (recurse_is_scramble(ls1 + xlen, ls2, ylen) and recurse_is_scramble(ls1, ls2 + ylen, xlen))\n if res:\n memo[(ls1, ls2, sslen)] = True\n return True\n\n memo[(ls1, ls2, sslen)] = False\n return False\n \n return recurse_is_scramble(0, 0, n)\n\n # # DP iterative solution (still O(n^4) time, O(n^3) space). Start with smaller length to guarantee subproblems are solved\n # memo = {}\n # n = len(s1)\n\n # for sslen in range(1, n + 1):\n # for ls1 in range(n - sslen + 1):\n # for ls2 in range(n - sslen + 1):\n # if sslen == 1:\n # memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\n # continue\n\n # res = False\n # for xlen in range(1, sslen):\n # ylen = sslen - xlen\n # # x + y\n # res = memo[(ls1, ls2, xlen)] and memo[(ls1 + xlen, ls2 + xlen, ylen)]\n # if not res:\n # # y + x\n # res = res or (memo[(ls1 + xlen, ls2, ylen)] and memo[(ls1, ls2 + ylen, xlen)])\n # if res:\n # memo[(ls1, ls2, sslen)] = True\n # break\n # if not res:\n # memo[(ls1, ls2, sslen)] = False\n\n # return memo[(0, 0, n)]","runtime":"120"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n \n n = len(s1)\n\n # (ls1, ls2, sslen). ls1 is starting index in s1. ls2 is starting index in s2, sslen is substring length we are testing.\n # where memo[(ls1, ls2, sslen)] = isScramble(s1[ls1..ls1+sslen-1], s2[ls2..ls2+sslen-1])\n memo = {}\n\n def recurse_is_scramble(ls1, ls2, sslen):\n if (ls1, ls2, sslen) in memo:\n return memo[(ls1, ls2, sslen)]\n if sslen == 1:\n memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\n return memo[(ls1, ls2, sslen)]\n \n for xlen in range(1, sslen):\n ylen = sslen - xlen\n # x + y\n res = recurse_is_scramble(ls1, ls2, xlen) and recurse_is_scramble(ls1 + xlen, ls2 + xlen, ylen)\n if not res:\n # y + x\n res = res or (recurse_is_scramble(ls1 + xlen, ls2, ylen) and recurse_is_scramble(ls1, ls2 + ylen, xlen))\n if res:\n memo[(ls1, ls2, sslen)] = True\n return True\n\n memo[(ls1, ls2, sslen)] = False\n return False\n \n return recurse_is_scramble(0, 0, n)\n\n # # wip iterative\n # memo = {}\n # n = len(s1)\n\n # for sslen in range(n + 1):\n # for ls1 in range(n):\n # for ls2 in range(n):\n # # print(\"ls1, ls2, sslen\", ls1, ls2, sslen)\n # if sslen == 1:\n # memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\n # continue\n\n # for xlen in range(1, sslen):\n # ylen = sslen - xlen\n # # x + y\n # res = memo[(ls1, ls2, xlen)] and memo[(ls1 + xlen, ls2 + xlen, ylen)]\n # if not res:\n # # y + x\n # res = res or (memo[(ls1 + xlen, ls2, ylen)] and memo[(ls1, ls2 + ylen, xlen)])\n # if res:\n # memo[(ls1, ls2, sslen)] = True\n # break\n # memo[(ls1, ls2, sslen)] = False\n\n # return memo[(0, 0, n)]","runtime":"124"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # Memomiazation \n # O(n^4) time, O(n^3) space\n if len(s1) != len(s2):\n return False\n \n n = len(s1)\n\n # (ls1, ls2, sslen). ls1 is starting index in s1. ls2 is starting index in s2, sslen is substring length we are testing.\n # where memo[(ls1, ls2, sslen)] = isScramble(s1[ls1..ls1+sslen-1], s2[ls2..ls2+sslen-1])\n memo = {}\n\n def recurse_is_scramble(ls1, ls2, sslen):\n if (ls1, ls2, sslen) in memo:\n return memo[(ls1, ls2, sslen)]\n if sslen == 1:\n memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\n return memo[(ls1, ls2, sslen)]\n \n for xlen in range(1, sslen):\n ylen = sslen - xlen\n # x + y\n res = recurse_is_scramble(ls1, ls2, xlen) and recurse_is_scramble(ls1 + xlen, ls2 + xlen, ylen)\n if not res:\n # y + x\n res = res or (recurse_is_scramble(ls1 + xlen, ls2, ylen) and recurse_is_scramble(ls1, ls2 + ylen, xlen))\n if res:\n memo[(ls1, ls2, sslen)] = True\n return True\n\n memo[(ls1, ls2, sslen)] = False\n return False\n \n return recurse_is_scramble(0, 0, n)\n\n # # Iterative solution (still O(n^4) time, O(n^3) space). Start with smaller length to guarantee subproblems are solved\n # memo = {}\n # n = len(s1)\n\n # for sslen in range(1, n + 1):\n # for ls1 in range(n - sslen + 1):\n # for ls2 in range(n - sslen + 1):\n # if sslen == 1:\n # memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\n # continue\n\n # res = False\n # for xlen in range(1, sslen):\n # ylen = sslen - xlen\n # # x + y\n # res = memo[(ls1, ls2, xlen)] and memo[(ls1 + xlen, ls2 + xlen, ylen)]\n # if not res:\n # # y + x\n # res = res or (memo[(ls1 + xlen, ls2, ylen)] and memo[(ls1, ls2 + ylen, xlen)])\n # if res:\n # memo[(ls1, ls2, sslen)] = True\n # break\n # if not res:\n # memo[(ls1, ls2, sslen)] = False\n\n # return memo[(0, 0, n)]","runtime":"124"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dp(i, j, k, l):\n print(i, j, k, l)\n if s1[i:j+1] == s2[k:l+1]:\n return True\n\n for mid in range(i, j):\n if dp(i, mid, k, k+(mid-i)) and dp(mid+1, j, k+(mid-i)+1, l):\n return True\n if dp(i, mid, l-(mid-i), l) and dp(mid+1, j, k, l-(mid-i)-1):\n return True\n\n return False\n\n n = len(s1)\n return dp(0, n-1, 0, n-1)","runtime":"128"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dp(s1: str, s2: str) -> bool:\n if s1 == s2: return True\n\n for i in range(1, len(s1)):\n if (dp(s1[:i], s2[:i]) and dp(s1[i:], s2[i:])) or \\\n (dp(s1[:i], s2[-i:]) and dp(s1[i:], s2[:-i])): return True\n return False\n\n return dp(s1,s2)","runtime":"128"},{"code":"class Solution:\n @lru_cache(None)\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n\n l = len(s1)\n\n for i in range(1, l):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n return True\n if self.isScramble(s1[:i], s2[l-i:]) and self.isScramble(s1[i:], s2[:l-i]):\n return True\n return False","runtime":"132"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(s1, s2):\n if s1 == s2:\n return True\n \n for i in range(1 , len(s1)):\n if dfs(s1[ : i], s2[ : i]) and dfs(s1[i : ], s2[i : ]):\n return True\n if dfs(s1[ : i], s2[-i : ]) and dfs(s1[i : ], s2[ : -i]):\n return True\n \n return False\n\n return dfs(s1, s2)","runtime":"132"},{"code":"class Solution(object):\n def isScramble(self, s1, s2):\n \"\"\"\n :type s1: str\n :type s2: str\n :rtype: bool\n \"\"\"\n @cache\n def dp(s1: str, s2: str) -> bool:\n if s1 == s2: return True\n\n for i in range(1, len(s1)):\n if (dp(s1[:i], s2[:i]) and dp(s1[i:], s2[i:])) or \\\n (dp(s1[:i], s2[-i:]) and dp(s1[i:], s2[:-i])): return True\n return False\n\n return dp(s1,s2)\n \n \n\n\n \n\n \n\n ","runtime":"136"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n dp = {}; n = len(s1)\n def solve(i1,j1,i2,j2):\n if i1>=j1: return True\n state = (i1,j1,i2,j2)\n if state not in dp:\n dp[state] = False\n if s1[i1:j1]==s2[i2:j2]:\n dp[state] = True\n else:\n for split in range(i1+1,j1):\n d1 = split-i1\n d2 = j1-split\n if solve(i1,i1+d1,i2,i2+d1) and solve(j1-d2,j1,j2-d2,j2):\n dp[state] = True; break\n if solve(j1-d2,j1,i2,i2+d2) and solve(i1,i1+d1,j2-d1,j2):\n dp[state] = True; break\n return dp[state]\n return solve(0,n,0,n)\n\n\n ","runtime":"136"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(s1, s2): # a b a b a b b a\n if s1 == s2: # / \\ / \\ / \\ / \\\n return True # a a b b a a b b\n \n for i in range(1 , len(s1)):\n if dfs(s1[ : i], s2[ : i]) and dfs(s1[i : ], s2[i : ]):\n return True\n if dfs(s1[ : i], s2[-i : ]) and dfs(s1[i : ], s2[ : -i]):\n return True\n \n return False\n\n return dfs(s1, s2)","runtime":"140"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n return self.scramble(s1, s2)\n \n @cache\n def scramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n if len(s1) != len(s2):\n return False\n \n for i in range(1, len(s1)):\n s11 = s1[:i]\n s12 = s1[i:]\n s21 = s2[:i]\n s22 = s2[i:]\n\n if self.scramble(s11, s21) and self.scramble(s12, s22):\n return True\n if self.scramble(s11, s2[len(s1) - i:]) and self.scramble(s12, s2[:len(s1) - i]):\n return True\n\n return False","runtime":"140"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n\n cache = {} # ()\n\n def dfs(current, target):\n if (current, target) in cache:\n return cache[(current, target)]\n\n is_scramble = False\n # print(current, target)\n if current == target:\n is_scramble = True\n elif len(current) == 1 and current != target:\n is_scramble = False\n else:\n # We need to split\n for i in range(1, len(current)):\n front = current[0: i]\n back = current[i:]\n\n #no-swap\n if dfs(front, target[0: i]) and dfs(back, target[i:]):\n is_scramble = True\n break\n end = len(current) - i\n if dfs(front, target[end:]) and dfs(back, target[0: end]):\n is_scramble = True\n break\n\n cache[(current, target)] = is_scramble\n return cache[(current, target)]\n\n return dfs(s1, s2)","runtime":"144"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n dp = {}\n def rec(sub1, sub2):\n if sub1==sub2:\n return True\n if len(sub1)<=1:\n return False\n key = sub1 + '_' + sub2\n val = dp.get(key, -1)\n if val!=-1:\n return val\n flag = False\n n1, n2 = len(sub1), len(sub2)\n for k in range(1, len(sub1)):\n cond_1 = rec(sub1[:k], sub2[-k:]) and rec(sub1[k:], sub2[:-k])\n cond_2 = rec(sub1[:k], sub2[:k]) and rec(sub1[k:], sub2[k:])\n if cond_1 or cond_2:\n dp[key] = True\n return dp[key]\n dp[key] = flag\n return dp[key]\n return rec(s1, s2)","runtime":"152"},{"code":"class Solution:\n # def isScramble(self, s1: str, s2: str) -> bool:\n # s1, s2 = list(s1), list(s2)\n # n = len(s1)\n # dp = [[[0] * (n + 1) for _ in range(n)] for _ in range(n)]\n\n # def f(l1, l2, length):\n # if length == 1:\n # return s1[l1] == s2[l2]\n \n # if dp[l1][l2][length] != 0:\n # return dp[l1][l2][length] == 1\n\n # ans = False\n\n # for k in range(1, length):\n # # no swap\n # if f(l1, l2, k) and f(l1 + k, l2 + k, length - k):\n # ans = True\n # break\n\n # #swap\n # if f(l1, l2 + length - k, k) and f(l1 + k, l2, length - k):\n # ans = True\n # break\n\n # dp[l1][l2][length] = 1 if ans else -1\n\n # return ans\n\n # return f(0, 0, n)\n\n#The dynamic programming table dp[l1][l2][len] stores results of subproblems of size len. Since the length can vary from 1 to n, the number of possible subproblems is O(n^3) (since l1, l2, and len can each take n values). # For each subproblem, there are O(n) possible splits, and each recursive call involves comparing two strings of size len.\n# Time Complexity:\n# The overall time complexity is O(n^4). This comes from iterating over all possible subproblems (O(n^3)) and for each, performing up to O(n) comparisons.\n \n\n# The 3D dynamic programming table dp[l1][l2][len] has dimensions n x n x (n+1), which requires O(n^3) space.\n# Additionally, the recursion stack may go as deep as O(n) in the worst case.\n# Space Complexity:\n# The total space complexity is O(n^3) due to the dynamic programming table. The recursion stack contributes O(n) but is dominated by the table.\n \n def isScramble(self, s1: str, s2: str) -> bool:\n s1, s2 = list(s1), list(s2)\n n = len(s1)\n dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]\n\n for l1 in range(n):\n for l2 in range(n):\n dp[l1][l2][1] = s1[l1] == s2[l2]\n\n for length in range(2, n + 1):\n for l1 in range(n - length + 1):\n for l2 in range(n - length + 1):\n for k in range(1, length):\n if dp[l1][l2][k] and dp[l1 + k][l2 + k][length - k]:\n dp[l1][l2][length] = True\n break\n\n if dp[l1 + k][l2][length - k] and dp[l1][l2 + length - k][k]:\n dp[l1][l2][length] = True\n break\n return dp[0][0][n]\n\n#dp[l1][l2][length] == True means that the substring s1[l1:l1+length] is a scrambled version of the substring s2[l2:l2+length]\n#Non-Swapped Case: If the first part of s1 (s1[l1:l1+k]) matches the first part of s2 (s2[l2:l2+k]), and the second part of s1 matches the second part of s2 (s1[l1+k:l1+length] == s2[l2+k:l2+length]).\n#Swapped Case: If the first part of s1 matches the second part of s2 (s1[l1:l1+k] == s2[l2+length-k:l2+length]), and the second part of s1 matches the first part of s2 (s1[l1+k:l1+length] == s2[l2:l2+length-k])","runtime":"152"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n \n # Create 3D DP array\n dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]\n \n # Initialize DP for single characters\n for i in range(n):\n for j in range(n):\n dp[i][j][1] = (s1[i] == s2[j])\n \n # Fill DP array for substrings of length 2 to n\n for length in range(2, n + 1): # length ranges from 2 to n\n for i in range(n - length + 1): # starting index in s1\n for j in range(n - length + 1): # starting index in s2\n for k in range(1, length): \n if (dp[i][j][k] and dp[i + k][j + k][length - k]) or \\\n (dp[i][j + length - k][k] and dp[i + k][j][length - k]):\n dp[i][j][length] = True\n break\n \n return dp[0][0][n]\n ","runtime":"156"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1)!=len(s2):\n return False\n\n def solve(s1,s2, memo):\n if s1==s2:\n return True\n if memo[s1][s2]!=-1:\n return memo[s1][s2]\n \n n=len(s1)\n for k in range(1,n):\n if (solve(s1[:k],s2[n-k:],memo) and solve(s1[k:],s2[:n-k],memo)) or (solve(s1[:k],s2[:k],memo) and solve(s1[k:],s2[k:],memo)):\n memo[s1][s2] = True\n return True\n break\n memo[s1][s2] = False\n return False\n\n return solve(s1,s2,memo=defaultdict(lambda:defaultdict(lambda:-1)))\n ","runtime":"156"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n \n # Create a 3D DP table to store the results of subproblems\n # dp[i][j][k] will be True if s1[i:i+k] is a scramble of s2[j:j+k]\n dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]\n \n # Initialize the base case where k = 1 (single character)\n for i in range(n):\n for j in range(n):\n dp[i][j][1] = s1[i] == s2[j]\n \n # Fill the DP table for k > 1\n for k in range(2, n + 1):\n for i in range(n - k + 1):\n for j in range(n - k + 1):\n for l in range(1, k):\n if (dp[i][j][l] and dp[i + l][j + l][k - l]) or (dp[i][j + k - l][l] and dp[i + l][j][k - l]):\n dp[i][j][k] = True\n break\n \n return dp[0][0][n]\n\n# Example usage:\nsolution = Solution()\ns1 = \"great\"\ns2 = \"rgeat\"\nprint(solution.isScramble(s1, s2)) # Output: True","runtime":"160"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def is_scramble(a, b):\n if a == b:\n return True\n\n if len(a) == 1:\n return False\n \n for i in range(1, len(a)):\n a1, a2 = a[:i], a[i:]\n b1, b2 = b[:i], b[i:]\n if is_scramble(a1, b1) and is_scramble(a2, b2):\n return True\n \n b1, b2 = b[:len(a2)], b[len(a2):]\n if is_scramble(a2, b1) and is_scramble(a1, b2):\n return True\n\n return False\n \n return is_scramble(s1, s2)\n","runtime":"160"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n N = len(s1)\n \n # F[i][j][len] will be True if s1[i:i+len] is a scramble of s2[j:j+len]\n F = [[[False] * (N + 1) for _ in range(N)] for _ in range(N)]\n \n # Base case: when len == 1, check if characters are equal\n for length in range(1, N + 1):\n for i in range(N - length + 1):\n for j in range(N - length + 1):\n if length == 1:\n F[i][j][length] = s1[i] == s2[j]\n else:\n for q in range(1, length):\n if (F[i][j][q] and F[i + q][j + q][length - q]) or (F[i][j + length - q][q] and F[i + q][j][length - q]):\n F[i][j][length] = True\n break\n \n return F[0][0][N]\n\n \n\n \n ","runtime":"164"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n\n n = len(s1)\n matrix = [[[False for _ in range(n)] for _ in range(n)] for _ in range(n + 1)]\n\n for i in range(n):\n for j in range(n):\n if s1[i] == s2[j]:\n matrix[1][i][j] = True\n\n for l in range(2, n+1):\n for i in range(n + 1 - l):\n for j in range(n + 1 - l):\n for nl in range(1, l):\n if (matrix[nl][i][j] and matrix[l-nl][i+nl][j+nl]) or \\\n (matrix[nl][i][j+l-nl] and matrix[l-nl][i+nl][j]):\n matrix[l][i][j] = True\n return matrix[n][0][0]\n ","runtime":"164"},{"code":"class Solution(object):\n def isScramble(self, s1, s2):\n \"\"\"\n :type s1: str\n :type s2: str\n :rtype: bool\n \"\"\"\n # Base cases\n\n n = len(s1)\n\n # If both strings are not equal in size\n if len(s2) != n:\n return False\n\n # If both strings are equal\n if s1 == s2:\n return True\n\n # If code is reached to this condition then following this are sure:\n # 1. size of both string is equal\n # 2. string are not equal\n # so size is equal (where size==1) and they are not equal then obviously false\n # example 'a' and 'b' size is equal, string are not equal\n if n == 1:\n return False\n\n key = s1 + \" \" + s2\n\n # Check if this problem has already been solved\n if key in self.mp:\n return self.mp[key]\n\n # For every iteration it can two condition\n # 1. We should proceed without swapping\n # 2. We should swap before looking next\n for i in range(1, n):\n # ex of without swap: gr|eat and rg|eat\n without_swap = (\n # Left part of first and second string\n self.isScramble(s1[:i], s2[:i])\n and\n # Right part of first and second string;\n self.isScramble(s1[i:], s2[i:])\n )\n\n # If without swap gives us the right answer then we do not need\n # to call the recursion with swap\n if without_swap:\n return True\n\n # ex of with swap: gr|eat rge|at\n # here we compare \"gr\" with \"at\" and \"eat\" with \"rge\"\n with_swap = (\n # Left part of first and right part of second\n self.isScramble(s1[:i], s2[n-i:])\n and\n # Right part of first and left part of second\n self.isScramble(s1[i:], s2[:n-i])\n )\n\n # If with swap gives us the right answer then we return True\n # otherwise, the for loop does its work\n if with_swap:\n return True\n\n self.mp[key] = False\n return False\n\n # for storing already solved problems\n mp = {}","runtime":"168"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n if n != len(s2):\n return False\n\n dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]\n\n for i in range(n):\n for j in range(n):\n dp[i][j][1] = s1[i] == s2[j]\n\n for length in range(2, n + 1): # Length of the substring\n for i in range(n - length + 1):\n for j in range(n - length + 1):\n for k in range(1, length): # Split point\n if (dp[i][j][k] and dp[i + k][j + k][length - k]) or \\\n (dp[i][j + length - k][k] and dp[i + k][j][length - k]):\n dp[i][j][length] = True\n break\n\n return dp[0][0][n]","runtime":"168"},{"code":"class Solution(object):\n def isScramble(self, s1, s2):\n \"\"\"\n :type s1: str\n :type s2: str\n :rtype: bool\n \"\"\"\n n = len(s1)\n if len(s2) != n:\n return False\n if s1 == s2:\n return True\n if n == 1:\n return False\n\n key = s1 + \" \" + s2\n if key in self.mp:\n return self.mp[key]\n for i in range(1, n):\n without_swap = (\n self.isScramble(s1[:i], s2[:i])\n and\n self.isScramble(s1[i:], s2[i:])\n )\n if without_swap:\n return True\n with_swap = (\n self.isScramble(s1[:i], s2[n-i:])\n and\n self.isScramble(s1[i:], s2[:n-i])\n )\n if with_swap:\n return True\n\n self.mp[key] = False\n return False\n mp = {}","runtime":"172"},{"code":"class Solution:\n def isScramble(self, s: str, t: str) -> bool:\n memo={}\n if len(s) != len(t):\n return False\n \n\n if s == t:\n return True\n \n def solve(s, t):\n n = len(s)\n\n if s == t:\n memo[(s,t)] = True\n return True\n if (s,t) in memo:\n return memo[(s,t)]\n for j in range(1, n):\n # Case 1: No swap\n if solve(s[:j], t[:j]) and solve(s[j:], t[j:]):\n memo[(s,t)] = True\n return True\n # Case 2: Swap\n if solve(s[:j], t[-j:]) and solve(s[j:], t[:-j]):\n memo[(s,t)] = True\n return True\n memo[(s,t)] = False\n return False\n return solve(s, t)\n","runtime":"172"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n memo = defaultdict(bool)\n def helper(a, b):\n nonlocal memo\n if (a, b) in memo:\n return memo[(a, b)]\n if len(a) != len(b):\n memo[(a, b)] = False\n return False\n if a == b:\n memo[(a, b)] = True\n return True\n if len(a) <= 1:\n memo[(a, b)] = False\n return False\n n = len(a)\n for i in range(1, n):\n c1 = (helper(a[0:i], b[n-i:n]) and helper(a[i:n], b[0:n-i]))\n c2 = (helper(a[0:i], b[0:i]) and helper(a[i:n], b[i:n]))\n if (c1 or c2):\n memo[(a, b)] = True\n return True\n memo[(a, b)] = False\n return False\n return helper(s1, s2)\n","runtime":"176"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # base case: if s1 == s2 or if some split in s1 and swap == s2: return True\n \n def solve(s1, s2, memo):\n if (s1, s2) in memo:\n return memo[(s1, s2)]\n \n elif s1 == s2:\n memo[(s1, s2)] = True\n return True\n \n memo[(s1, s2)] = False\n n = len(s1)\n # case 1: split at 2, s1 = gr / eat, s2 = rg / eat\n for i in range(1, n):\n\n memo[(s1, s2)] = memo[(s1, s2)] or solve(s1[:i], s2[:i], memo) and solve(s1[i:], s2[i:], memo) or solve(s1[:i], s2[n-i:], memo) and solve(s1[i:], s2[:n-i], memo)\n \n return memo[(s1, s2)]\n\n return solve(s1, s2, {})","runtime":"176"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n dp = []\n for i in range(len(s1)):\n dp.append([0]*len(s1))\n for j in range(len(s1)):\n dp[i][j] = [False]*len(s1)\n\n\n def validate(start, start2, m):\n for i in range(m):\n if dp[start][start + i][start2] and dp[start + i + 1][start + m][start2 + i + 1]:\n return True\n \n if dp[start][start + i][start2 + m - i] and dp[start + i + 1][start + m][start2]:\n return True\n \n return False\n\n for m in range(len(s1)):\n for start1 in range(len(s1) - m):\n for start2 in range(len(s2) - m):\n if m == 0:\n if s1[start1] == s2[start2]:\n dp[start1][start1 + m][start2] = True\n \n if validate(start1, start2, m):\n dp[start1][start1 + m][start2] = True\n return dp[0][len(s1) - 1][0]\n \n\n\n\n","runtime":"180"},{"code":"class Solution(object):\n def isScramble(self, s1, s2):\n n = len(s1)\n if len(s2) != n: return False\n if s1 == s2: return True\n if n == 1: return False\n key = s1 + \" \" + s2\n if key in self.mp: return self.mp[key]\n for i in range(1, n):\n WOS = (self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]))\n if WOS: return True\n WS = (self.isScramble(s1[:i], s2[n-i:]) and self.isScramble(s1[i:], s2[:n-i]))\n if WS: return True\n self.mp[key] = False\n return False\n mp = {}","runtime":"180"},{"code":"class Solution:\n def f(self, s1, s2):\n \n if s1 == s2:\n self.cache[(s1, s2)] = True\n return True\n\n if len(s1) == 1 and len(s2) == 1:\n self.cache[(s1, s2)] = (s1 == s2)\n return s1 == s2\n\n if (s1, s2) in self.cache:\n return self.cache[(s1, s2)]\n\n N = len(s1)\n \n for i in range(1, N):\n p1 = s1[:i]\n p2 = s1[i:]\n q1 = s2[:i]\n q2 = s2[i:]\n if self.f(p1, q1) and self.f(p2, q2):\n self.cache[(s1, s2)] = True\n print(s1, s2)\n return True\n \n q1 = s2[:N - i]\n q2 = s2[N - i:]\n if self.f(p1, q2) and self.f(p2, q1):\n self.cache[(s1, s2)] = True\n return True\n \n\n \n self.cache[(s1, s2)] = False\n\n return self.cache[(s1, s2)]\n\n def isScramble(self, s1: str, s2: str) -> bool:\n self.cache = {}\n return self.f(s1, s2)\n ","runtime":"184"},{"code":"class Solution:\n def rec(self, s1, s2, memo):\n # I didn't even optimize the solution and it passes\n if s1 == s2:\n return True\n if len(s1) <= 1 and len(s2) <= 1 and s1 != s2:\n return False\n key = (\"\".join(s1), \"\".join(s2))\n if key in memo:\n return memo[key]\n \n isPassed = False\n\n for i in range(len(s1)-1):\n if isPassed:\n break\n sub11 = s1[:i+1]\n sub12 = s1[i+1:]\n for j in range(len(s2)-1):\n sub21 = s2[:j+1]\n sub22 = s2[j+1:]\n \n if (sorted(sub11) == sorted(sub21) and sorted(sub12) == sorted(sub22)):\n ans1 = self.rec(sub11, sub21, memo)\n ans2 = self.rec(sub12, sub22, memo)\n if ans1 and ans2:\n isPassed = True\n break\n if (sorted(sub11) == sorted(sub22) and sorted(sub12) == sorted(sub21)):\n ans1 = self.rec(sub11, sub22, memo)\n ans2 = self.rec(sub12, sub21, memo)\n if ans1 and ans2:\n isPassed = True\n break\n memo[key] = isPassed\n\n return isPassed\n \n def isScramble(self, s1: str, s2: str) -> bool:\n memo = dict()\n return self.rec(s1, s2, memo)","runtime":"184"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n\n visitedDict = {}\n def check(src,tar):\n # print(src, tar)\n if(src == tar):\n return 1\n if(len(src) == 1):\n return 0\n\n if((src, tar) in visitedDict):\n return visitedDict[(src, tar)]\n\n for i in range(1,len(src)):\n # if(len(src) == len(s1)):\n # print(src[:i], tar[:i], src[i:], tar[i:])\n if(src[i:] + src[:i] == tar):\n visitedDict[(src, tar)] = 1\n return 1\n leftSrcLeftTar = check(src[:i], tar[:i])\n if(not leftSrcLeftTar):\n leftSrcRightTar = check(src[:i], tar[len(src)-i:])\n if(not leftSrcRightTar):\n continue\n rightSrcLeftTar = check(src[i:], tar[:len(src)-i:])\n if(leftSrcRightTar & rightSrcLeftTar):\n visitedDict[(src, tar)] = 1\n return 1\n continue\n rightSrcRightTar = check(src[i:], tar[i:])\n if(not rightSrcRightTar):\n continue\n if(leftSrcLeftTar & rightSrcRightTar):\n visitedDict[(src, tar)] = 1\n return 1\n visitedDict[(src, tar)] = 0\n return 0\n\n ans = check(s1,s2)\n return ans\n\n ","runtime":"188"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1)!=len(s2):\n return False\n if len(s1)==0 and len(s2)==0:\n return True\n d={}\n def helper(s1,s2):\n if s1==s2:\n return True\n if len(s1)<=1:\n return False\n if (s1,s2) in d:\n return d[(s1,s2)]\n flag=False\n for i in range(1,len(s1)):\n case1 = (helper(s1[0:i], s2[0:i]) and helper(s1[i:], s2[i:]))\n case2 = (helper(s1[0:i], s2[-i:]) and helper(s1[i:], s2[0:-i]))\n if (case1 or case2):\n flag=True\n break\n d[(s1,s2)]=flag\n return d[(s1,s2)]\n return helper(s1,s2)\n\n ","runtime":"188"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n\n n = len(s1)\n dp = [[[False] * n for _ in range(n)] for _ in range(n)]\n\n for i in range(n):\n for j in range(n):\n dp[0][i][j] = s1[i] == s2[j]\n\n for length in range(2, n + 1):\n for i in range(n - length + 1):\n for j in range(n - length + 1):\n for k in range(1, length):\n if (dp[k - 1][i][j] and dp[length - k - 1][i + k][j + k]) or \\\n (dp[k - 1][i][j + length - k] and dp[length - k - 1][i + k][j]):\n dp[length - 1][i][j] = True\n\n return dp[n - 1][0][0]\n","runtime":"192"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n if len(s1) == 1:\n return False\n\n cache = {}\n def helper(s1, s2):\n if s1 == s2:\n return True\n if len(s1) == 1:\n return False\n if s1+s2 in cache:\n return cache[s1+s2]\n\n for i in range(1, len(s1)):\n if (helper(s1[:i], s2[:i]) and helper(s1[i:], s2[i:])) or (helper(s1[len(s1) - i:], s2[:i]) and helper(s1[:len(s1) - i], s2[i:])):\n cache[s1+s2] = True\n return True\n cache[s1+s2] = False\n return False\n return helper(s1, s2)\n\n ","runtime":"196"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2) or sorted(s1) != sorted(s2):\n return False\n if len(s1) == 1:\n return s1 == s2\n \n n = len(s1)\n dp = [[[False] * (n + 1) for _ in range(n)] for __ in range(n)]\n for i in range(n):\n for j in range(n):\n if s1[i] == s2[j]:\n dp[i][j][1] = True\n \n for l in range(2, n + 1):\n for i in range(n - l + 1):\n for j in range(n - l + 1):\n for k in range(1, l):\n if (dp[i][j][k] and dp[i + k][j + k][l - k]) or (dp[i][j + l - k][k] and dp[i + k][j][l - k]):\n dp[i][j][l] = True\n break\n return dp[0][0][n]","runtime":"200"},{"code":"class Solution:\n def __init__(self):\n self.sk = SolutionK()\n\n def isScramble(self, s1: str, s2: str) -> bool:\n return self.sk.isScramble(s1, s2)\n \n\n\nclass SolutionK:\n # Approach:\n # Once we cut the string in two parts and swap (or not swap) them,\n # the characters in those two parts do not cross the boundary therefore,\n # We can use divide and conquer method here.\n # \n # Let's say we cut s1 into x1, y1.\n # Now also cut s2 into same sized parts x2 and y2.\n # s1 = x1 + y1 (or y1 + x1)\n # s2 = x2 + y2 (or y2 + x2)\n # If s2 is indeed a scrambled version of s1 then the following must hold:\n # y2 is scrambled version of y1 and x2 is scrambled version of x1.\n def isScramble(self, s1: str, s2: str) -> bool:\n ans = {}\n return self._isScramble(s1, s2, ans)\n\n def _isScramble(self, s1, s2, ans):\n N = len(s1)\n if N == 1:\n return s1 == s2\n\n key = (s1, s2)\n if key in ans:\n return ans[key]\n\n result = False\n\n def split(s, i):\n return s[:i], s[i:]\n\n for i in range(1, N):\n x1, y1 = split(s1, i)\n x2, y2 = split(s2, i)\n y3, x3 = split(s2, N - i)\n\n if self._isScramble(x1, x2, ans) and self._isScramble(y1, y2, ans):\n result = True\n break\n\n if self._isScramble(x1, x3, ans) and self._isScramble(y1, y3, ans):\n result = True\n break\n\n ans[key] = result\n\n # print(f\"{s1} ~ {s2} => {result}\")\n return result\n ","runtime":"200"},{"code":"class Solution:\n table = dict()\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n if s1 == s2:\n return True\n if len(s1) <= 1:\n return False \n temp = \"{}-{}\".format(s1,s2)\n if temp in self.table:\n return self.table[temp]\n n = len(s1)\n for i in range(1,n):\n cond1 = self.isScramble(s1[0:i],s2[(n-i):n]) and self.isScramble(s1[i:n],s2[0:(n-i)])\n cond2 = self.isScramble(s1[0:i],s2[0:i]) and self.isScramble(s1[i:n],s2[i:n])\n if cond1 or cond2:\n self.table[temp] = True\n return True\n self.table[temp] = False\n return False\n ","runtime":"204"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n\n dp = [\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\n ]\n\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n \n for length in range(2, n + 1):\n for i in range(n - length + 1):\n for j in range(n - length + 1):\n for new_length in range(1, length):\n dp[length][i][j] = dp[length][i][j] or (dp[new_length][i][j] and dp[length - new_length][i + new_length][j + new_length]) or (dp[new_length][i][j + length - new_length] and dp[length - new_length][i + new_length][j])\n \n return dp[n][0][0]\n","runtime":"208"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1==s2:\n return True\n s1len=len(s1)\n s2len=len(s2)\n if not s1len==s2len:\n return False\n if not sorted(s1)==sorted(s2):\n return False\n dpt=[]\n for loop1 in range(s1len+1):\n block=[]\n for loop2 in range(s1len):\n block.append([False]*s1len)\n dpt.append(block)\n for splptr in range(1,s1len+1):\n for s1ptr in range(s1len-splptr+1):\n for s2ptr in range(s2len-splptr+1):\n if splptr==1:\n if s1[s1ptr]==s2[s2ptr]:\n dpt[splptr][s1ptr][s2ptr]=True\n else:\n for aftersplptr in range(1,splptr):\n leftmatchleft=dpt[aftersplptr][s1ptr][s2ptr] and dpt[splptr-aftersplptr][s1ptr+aftersplptr][s2ptr+aftersplptr]\n leftmatchright=dpt[aftersplptr][s1ptr][s2ptr+(splptr-aftersplptr)] and dpt[splptr-aftersplptr][s1ptr+aftersplptr][s2ptr]\n dpt[splptr][s1ptr][s2ptr]=leftmatchleft or leftmatchright\n if leftmatchleft or leftmatchright:\n break\n return dpt[s1len][0][0]","runtime":"212"},{"code":"class Solution:\n def isScramble(self, s: str, t: str) -> bool:\n N = len(s)\n dp = [set(), set()] # index is length, contains (s_index, t_index) => subproblem is scramble\n for i in range(N):\n for j in range(N):\n if s[i] == t[j]:\n dp[1].add((i,j))\n\n for l in range(2, N+1):#2\n dp.append(set())\n for i in range(N-l+1):\n for j in range(N-l+1):\n for prefix_len in range(1, l):\n suffix_len = l - prefix_len\n if (i,j) in dp[prefix_len] and (i+prefix_len,j+prefix_len) in dp[suffix_len] or (i,j+suffix_len) in dp[prefix_len] and (i+prefix_len,j) in dp[suffix_len]: \n dp[l].add((i,j))\n\n \n return len(dp[N]) > 0","runtime":"216"},{"code":"checked = {}\n\nclass Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if (s1, s2) in checked:\n return checked[(s1, s2)]\n if len(s1) == 1:\n return s1 == s2\n\n for i in range(1, len(s1)):\n ss1 = s1[:i]\n ss2 = s1[i:]\n # print(ss1, ss2, s2)\n if self.isScramble(ss2, s2[:len(s2) - i]) and self.isScramble(ss1, s2[len(s2) - i:]):\n checked[(s1, s2)] = True\n return True\n if self.isScramble(ss1, s2[:i]) and self.isScramble(ss2, s2[i:]):\n checked[(s1, s2)] = True\n return True\n checked[(s1, s2)] = False\n return False","runtime":"220"},{"code":"class Solution:\n table = dict()\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n if s1 == s2:\n return True\n if len(s1) <= 1:\n return False \n temp = \"{}-{}\".format(s1,s2)\n if temp in self.table:\n return self.table[temp]\n n = len(s1)\n for i in range(1,n):\n cond1 = self.isScramble(s1[0:i],s2[(n-i):n]) and self.isScramble(s1[i:n],s2[0:(n-i)])\n cond2 = self.isScramble(s1[0:i],s2[0:i]) and self.isScramble(s1[i:n],s2[i:n])\n if cond1 or cond2:\n self.table[temp] = True\n return True\n self.table[temp] = False\n return False\n ","runtime":"224"},{"code":"import numpy as np\nclass Solution:\n debugging: bool = True\n '''True iff I want print messages'''\n\n def four_dimensional_initialization(self, scramble: np.ndarray,\n s1: str, s2: str):\n '''pg 63: We can scramble pairs of chars iff they're equal'''\n for i in range(len(s1)):\n for j in range(len(s2)):\n scramble[i, i+1, j, j+1] = int(s1[i] == s2[j])\n\n def four_dimensional_dp(self, s1: str, s2: str) -> bool:\n '''scramble[i, j, k, l] == 1 iff s1[i:j] can be scrambled to s2[k:l]'''\n if self.debugging:\n print(f'{np.__version__=}')\n scramble = np.zeros((len(s1)+1, len(s1)+1, len(s2)+1, len(s2)+1), dtype=int)\n self.four_dimensional_initialization(scramble, s1, s2)\n if self.debugging:\n print(f'{scramble.sum()=} after initialization')\n\n for substring_lengths in range(2, len(s1)+1):\n if self.debugging:\n print(f'{substring_lengths=}')\n for s1_start in range(0, len(s1)-substring_lengths+1):\n for s2_start in range(0, len(s2)-substring_lengths+1):\n can_scramble = 0\n for k in range(1, substring_lengths):\n no_swap_scramble = bool(\n scramble[s1_start, s1_start+k, s2_start, s2_start+k] and\n scramble[s1_start+k, s1_start+substring_lengths,\n s2_start+k, s2_start+substring_lengths]\n )\n swap_scramble = bool(\n scramble[s1_start, s1_start+k, \n s2_start+substring_lengths-k, s2_start+substring_lengths] and\n scramble[s1_start+k, s1_start+substring_lengths,\n s2_start, s2_start+(substring_lengths-k)]\n )\n can_scramble = int(no_swap_scramble or swap_scramble)\n if can_scramble:\n if self.debugging:\n print(f'\\t\\tCan scramble s1{s1_start, s1_start+substring_lengths} and '\n f's2{s2_start, s2_start+substring_lengths} by cutting at {k=}')\n print(f'\\t\\t{no_swap_scramble=}, {swap_scramble=}')\n break\n scramble[s1_start, s1_start+substring_lengths,\n s2_start, s2_start+substring_lengths] = can_scramble\n \n return bool(scramble[0, len(s1), 0, len(s2)])\n\n def recursion_with_memoization(self, s1: str, s2: str) -> bool:\n '''Above DP solution works, but it's faster to just do a top-down recursion\n Cache intermediate results using tuple of strings (function args) as a key'''\n scramble: dict[tuple[str, str], bool] = {}\n\n def try_scrambling_substrings(s_1: str, s_2: str) -> bool:\n '''Return True iff we can scramble s_1 into s_2'''\n if (s_1, s_2) in scramble: \n return scramble[(s_1, s_2)]\n if not sorted(s_1) == sorted(s_2):\n # Don't have the same chars -> no way to scramble\n scramble[(s_1, s_2)] = False\n return False\n if len(s_1) == 1:\n # One char base case\n one_char_equal = (s_1 == s_2)\n scramble[(s_1, s_2)] = one_char_equal\n return one_char_equal\n\n can_scramble = False\n for k in range(1, len(s_1)):\n no_swap_scramble = (try_scrambling_substrings(s_1[:k], s_2[:k]) and\n try_scrambling_substrings(s_1[k:], s_2[k:]))\n if no_swap_scramble:\n scramble[(s_1, s_2)] = True\n return True\n swap_scramble = (try_scrambling_substrings(s_1[:k], s_2[len(s_2)-k:]) and\n try_scrambling_substrings(s_1[k:], s_2[:len(s_2)-k]))\n if swap_scramble:\n scramble[(s_1, s_2)] = True\n return True\n\n scramble[(s_1, s_2)] = False\n return False\n \n overall_scramble = try_scrambling_substrings(s1, s2)\n if self.debugging:\n print(f'{scramble=}')\n return overall_scramble\n\n def isScramble(self, s1: str, s2: str) -> bool:\n self.debugging = False\n # return self.four_dimensional_dp(s1, s2)\n return self.recursion_with_memoization(s1, s2)\n ","runtime":"224"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n len_s1 = len(s1)\n F = [[[False for _ in range(len_s1 + 1)] for _ in range(len_s1)] for _ in range(len_s1)]\n\n for k in range(1, len_s1 + 1):\n for i in range(len_s1 - k + 1):\n for j in range(len_s1 - k + 1):\n if k == 1:\n F[i][j][k] = s1[i] == s2[j]\n else:\n for q in range(1, k):\n F[i][j][k] = (F[i][j][q] and F[i + q][j + q][k - q]) or (F[i][j + k - q][q] and F[i + q][j][k - q])\n if F[i][j][k]:\n break\n return F[0][0][len_s1]","runtime":"228"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \n @cache\n \n def dfs(s1, s2): \n \n if s1 == s2: return True\n \n for i in range(1, len(s1)): \n if dfs(s1[i:], s2[i:]) and dfs(s1[:i], s2[:i]):\n return True\n if dfs(s1[i:], s2[:-i]) and dfs(s1[:i], s2[-i:]):\n return True\n \n return False\n \n return dfs(s1, s2)","runtime":"232"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # let f[a][b][c][d] = True / False to check whether s2[c:d] can be scambled to s1[a:b]\n # if c - d != b - a: f[a][b][c][d] = False\n # if s1[a:b] == s2[c:d]: f[a][b][c][d] = True\n # if find t, where 0 < t < d - c:\n # f[a][b][c][d] = True if exist t:\n # f[a][a+t][c][c+t] and f[a+t][b][c+t][d] or\n # f[a][a+n-t][c][c+n-t] and f[a+n-t+1][b][c+n-t+1][d]\n\n f = {}\n\n def dp(a, b, c, d):\n if (a, b, c, d) in f:\n return f[(a, b, c, d)]\n \n # print(a, b, c, d)\n\n if b - a != d - c:\n return False\n\n if s1[a:b] == s2[c:d]:\n return True\n\n n = b - a\n for t in range(1, n):\n if (dp(a, a+t, c, c+t) and dp(a+t, b, c+t, d)) or (dp(a, a+n-t, d-n+t, d) and dp(a+n-t, b, c, d-n+t)):\n f[(a, b, c, d)] = True\n return True\n \n f[(a, b, c, d)] = False\n return False\n\n\n return dp(0, len(s1), 0, len(s2))","runtime":"232"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dp(s1, s2):\n if s1 == s2: return True\n for i in range(1, len(s1)):\n if dp(s1[i:], s2[i:]) and dp(s1[:i], s2[:i]):\n return True\n if dp(s1[i:], s2[:-i]) and dp(s1[:i], s2[-i:]):\n return True\n return False\n return dp(s1, s2)\n\n \n ","runtime":"236"},{"code":"class Solution:\n def scrambleHelp(self, s1, s2):\n if s1 == s2:\n return True\n if len(s1) == 1:\n return False\n n = len(s1)\n for j in range(1, n):\n #swap option\n if (sorted(s1[:j]) == sorted(s2[n-j:])\n and sorted(s1[j:]) == sorted(s2[:n-j])\n and self.scrambleHelp(s1[:j], s2[n - j:]) \n and self.scrambleHelp(s1[j:], s2[:n - j])):\n return True\n if (sorted(s1[:j]) == sorted(s2[:j])\n and sorted(s1[j:]) == sorted(s2[j:])\n and self.scrambleHelp(s1[:j], s2[:j]) \n and self.scrambleHelp(s1[j:], s2[j:])):\n return True\n return False\n\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2) or sorted(s1) != sorted(s2):\n return False\n n = len(s1)\n memo = [[[False] * (n + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n for l in range(1, n + 1):\n for i in range(n):\n for j in range(n):\n if i + l > n or j + l > n:\n memo[i][j][l] = False\n elif l == 1:\n memo[i][j][l] = (s1[i] == s2[j])\n else:\n for p in range(i + 1, i + l):\n l1 = p - i\n l2 = (i + l) - p\n if memo[i][j][l1] and memo[p][j + l1][l2]:\n memo[i][j][l] = True\n break\n elif memo[p][j][l2] and memo[i][j + l2][l1]:\n memo[i][j][l] = True\n break\n return memo[0][0][n]","runtime":"236"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \n @cache\n \n def dfs(s1, s2): \n \n if s1 == s2: return True\n \n for i in range(1, len(s1)): \n if dfs(s1[i:], s2[i:]) and dfs(s1[:i], s2[:i]):\n return True\n if dfs(s1[i:], s2[:-i]) and dfs(s1[:i], s2[-i:]):\n return True\n \n return False\n \n return dfs(s1, s2)","runtime":"240"},{"code":"checked = {}\n\nclass Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if (s1, s2) in checked:\n return checked[(s1, s2)]\n if len(s1) == 1:\n return s1 == s2\n\n for i in range(1, len(s1)):\n ss1 = s1[:i]\n ss2 = s1[i:]\n # print(ss1, ss2, s2)\n if self.isScramble(ss2, s2[:len(s2) - i]) and self.isScramble(ss1, s2[len(s2) - i:]):\n checked[(s1, s2)] = True\n return True\n if self.isScramble(ss1, s2[:i]) and self.isScramble(ss2, s2[i:]):\n checked[(s1, s2)] = True\n return True\n checked[(s1, s2)] = False\n return False","runtime":"240"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str, dctx = {}) -> bool:\n if (s1,s2) in dctx:\n return dctx[(s1,s2)]\n if len(s1) != len(s2):\n return False\n elif s1 == s2:\n return True\n elif set(s1) != set(s2):\n return False\n \n for i in range(1,len(s1)):\n # No Swap\n a = self.isScramble(s1[:i], s2[:i], dctx)\n b = self.isScramble(s1[i:], s2[i:], dctx)\n if a and b:\n dctx[(s1,s2)] = True\n return True\n\n # With Swap\n # print(s1[i:] + \" \" + s1[:i])\n # print(s2[:len(s1)-i] + \" \" + s2[len(s1)-i:])\n a = self.isScramble(s1[i:], s2[:len(s1)-i], dctx)\n b = self.isScramble(s1[:i], s2[len(s1)-i:], dctx)\n if a and b:\n dctx[(s1,s2)] = True\n return True\n dctx[(s1,s2)] = False\n return False\n \n ","runtime":"244"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n\n @cache\n def dp(s1, s2):\n if s1 == s2: return True\n\n for i in range(1, len(s1)):\n if dp(s1[i:], s2[i:]) and dp(s1[:i], s2[:i]):\n return True\n if dp(s1[i:], s2[:-i]) and dp(s1[:i], s2[-i:]):\n return True\n \n return False\n \n return dp(s1, s2)\n\n\n ","runtime":"244"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dp(s1,s2):\n if s1==s2:\n return True\n for i in range(1,len(s1)):\n if dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i]):\n return True\n if dp(s1[i:],s2[:-i]) and dp(s1[:i],s2[-i:]):\n return True\n return False\n return dp(s1,s2)\n \n ","runtime":"248"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dp(s1,s2):\n if(s1==s2):\n return True\n for i in range(1,len(s1)):\n if dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i]):\n return True\n if dp(s1[i:],s2[:-i]) and dp(s1[:i],s2[-i:]):\n return True\n return False\n return dp(s1,s2)\n\n","runtime":"248"},{"code":"import numpy as np\nclass Solution:\n debugging: bool = True\n '''True iff I want print messages'''\n\n def four_dimensional_initialization(self, scramble: np.ndarray,\n s1: str, s2: str):\n '''pg 63: We can scramble pairs of chars iff they're equal'''\n for i in range(len(s1)):\n for j in range(len(s2)):\n scramble[i, i+1, j, j+1] = int(s1[i] == s2[j])\n\n def four_dimensional_dp(self, s1: str, s2: str) -> bool:\n '''scramble[i, j, k, l] == 1 iff s1[i:j] can be scrambled to s2[k:l]'''\n if self.debugging:\n print(f'{np.__version__=}')\n scramble = np.zeros((len(s1)+1, len(s1)+1, len(s2)+1, len(s2)+1), dtype=int)\n self.four_dimensional_initialization(scramble, s1, s2)\n if self.debugging:\n print(f'{scramble.sum()=} after initialization')\n\n for substring_lengths in range(2, len(s1)+1):\n if self.debugging:\n print(f'{substring_lengths=}')\n for s1_start in range(0, len(s1)-substring_lengths+1):\n for s2_start in range(0, len(s2)-substring_lengths+1):\n can_scramble = 0\n for k in range(1, substring_lengths):\n no_swap_scramble = bool(\n scramble[s1_start, s1_start+k, s2_start, s2_start+k] and\n scramble[s1_start+k, s1_start+substring_lengths,\n s2_start+k, s2_start+substring_lengths]\n )\n swap_scramble = bool(\n scramble[s1_start, s1_start+k, \n s2_start+substring_lengths-k, s2_start+substring_lengths] and\n scramble[s1_start+k, s1_start+substring_lengths,\n s2_start, s2_start+(substring_lengths-k)]\n )\n can_scramble = int(no_swap_scramble or swap_scramble)\n if can_scramble:\n if self.debugging:\n print(f'\\t\\tCan scramble s1{s1_start, s1_start+substring_lengths} and '\n f's2{s2_start, s2_start+substring_lengths} by cutting at {k=}')\n print(f'\\t\\t{no_swap_scramble=}, {swap_scramble=}')\n break\n scramble[s1_start, s1_start+substring_lengths,\n s2_start, s2_start+substring_lengths] = can_scramble\n \n return bool(scramble[0, len(s1), 0, len(s2)])\n\n def recursion_with_memoization(self, s1: str, s2: str) -> bool:\n '''Above DP solution works, but it's faster to just do a top-down recursion\n Cache intermediate results using tuple of strings (function args) as a key'''\n scramble: dict[tuple[str, str], bool] = {}\n\n def try_scrambling_substrings(s_1: str, s_2: str) -> bool:\n '''Return True iff we can scramble s_1 into s_2'''\n if (s_1, s_2) in scramble: \n return scramble[(s_1, s_2)]\n if not sorted(s_1) == sorted(s_2):\n # Don't have the same chars -> no way to scramble\n # scramble[(s_1, s_2)] = False...no need to cache this. Saves space and time\n return False\n if len(s_1) == 1:\n # One char base case\n # one_char_equal = (s_1 == s_2)...not needed, since we just checked\n # \"sorted(s_1) == sorted(s_2)\". If we're here, s_1 == s_2\n # scramble[(s_1, s_2)] = one_char_equal...no need to cache. Saves space and time\n return True\n\n can_scramble = False\n for k in range(1, len(s_1)):\n no_swap_scramble = (try_scrambling_substrings(s_1[:k], s_2[:k]) and\n try_scrambling_substrings(s_1[k:], s_2[k:]))\n if no_swap_scramble:\n scramble[(s_1, s_2)] = True\n return True\n swap_scramble = (try_scrambling_substrings(s_1[:k], s_2[len(s_2)-k:]) and\n try_scrambling_substrings(s_1[k:], s_2[:len(s_2)-k]))\n if swap_scramble:\n scramble[(s_1, s_2)] = True\n return True\n\n scramble[(s_1, s_2)] = False\n return False\n \n overall_scramble = try_scrambling_substrings(s1, s2)\n if self.debugging:\n print(f'{scramble=}')\n return overall_scramble\n\n def isScramble(self, s1: str, s2: str) -> bool:\n self.debugging = False\n # return self.four_dimensional_dp(s1, s2)\n return self.recursion_with_memoization(s1, s2)\n ","runtime":"252"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n if n != len(s2):\n return False\n \n # Initialize the dp table\n dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]\n \n # Base case: single characters\n for i in range(n):\n for j in range(n):\n dp[i][j][1] = s1[i] == s2[j]\n \n # Fill the dp table for lengths greater than 1\n for length in range(2, n + 1):\n for i in range(n - length + 1):\n for j in range(n - length + 1):\n for new_length in range(1, length):\n dp1 = dp[i][j][new_length]\n dp2 = dp[i + new_length][j + new_length][length - new_length]\n \n dp3 = dp[i][j + length - new_length][new_length]\n dp4 = dp[i + new_length][j][length - new_length]\n \n if (dp1 and dp2) or (dp3 and dp4):\n dp[i][j][length] = True\n break\n \n return dp[0][0][n]\n\n# Example usage:\nsolution = Solution()\ns1 = \"great\"\ns2 = \"rgeat\"\nprint(solution.isScramble(s1, s2)) # Output: True","runtime":"256"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n=len(s1)\n dp=[[[False for j in range(n)]for i in range(n)]for l in \n range(n+1)];\n for i in range(n):\n for j in range(n):\n dp[1][i][j]=s1[i]==s2[j]\n for length in range(2,n+1):\n for i in range(n+1-length):\n for j in range(n+1-length):\n for new in range(1,length):\n dp1=dp[new][i]\n dp2=dp[length-new][i+new]\n dp[length][i][j]|=(\n dp1[j] and dp2[j+new]\n )\n dp[length][i][j]|=(\n dp2[j] and dp1[j+length-new]\n )\n return dp[n][0][0]","runtime":"260"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n # dp[length][i][j]\n # recurring eq\n # dp[length][i][j] = dp[sublength1][i][j] and dp[length - sublength1][i+sublength1][j+sublength1]\n # or\n # dp[length][i][j] = dp[sublength1][i+length - sublength1][j] and dp[length - sublength1][i][j+sublength1]\n dp = [[[False] * n for _ in range(n)] for _ in range(n+1)]\n # base case\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = True if s1[i] == s2[j] else False\n for l in range(2,n+1):\n for i in range(n-l+1):\n for j in range(n-l+1):\n for subl in range(1,l):\n dp[l][i][j] |= dp[subl][i][j] and dp[l - subl][i+subl][j+subl]\n dp[l][i][j] |= dp[subl][i+l - subl][j] and dp[l - subl][i][j+subl]\n return dp[n][0][0]\n\n","runtime":"264"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n dp = [[[False for _ in range(n)] for _ in range(n)] for _ in range(n + 1)]\n l = 1\n for idx1 in range(n):\n for idx2 in range(n):\n dp[l][idx1][idx2] = s1[idx1] == s2[idx2]\n\n for l in range(2, n + 1):\n for idx1 in range(n - l + 1):\n for idx2 in range(n - l + 1):\n for split_len in range(1, l):\n dp[l][idx1][idx2] |= dp[split_len][idx1][idx2] and dp[l - split_len][idx1 + split_len][idx2 + split_len]\n dp[l][idx1][idx2] |= dp[split_len][idx1][idx2 + (l - split_len)] and dp[l - split_len][idx1 + split_len][idx2]\n return dp[n][0][0]","runtime":"268"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n \n # DP table to store results of subproblems\n # dp[i][j][k] will be true if s2[j:j+k] is a scrambled string of s1[i:i+k]\n dp = [[[False for _ in range(n + 1)] for _ in range(n)] for _ in range(n)]\n \n # Initialize the base case when length of substring is 1\n for i in range(n):\n for j in range(n):\n dp[i][j][1] = (s1[i] == s2[j])\n \n # Fill the DP table for lengths greater than 1\n for length in range(2, n + 1):\n for i in range(n - length + 1):\n for j in range(n - length + 1):\n for new_length in range(1, length):\n # Check if there is any split position that makes s2 a scrambled string of s1\n dp[i][j][length] |= (dp[i][j][new_length] and dp[i + new_length][j + new_length][length - new_length]) or \\\n (dp[i][j + length - new_length][new_length] and dp[i + new_length][j][length - new_length])\n \n # If the current substring is a scrambled string, no need to check further splits\n if dp[i][j][length]:\n break\n \n # The result will be stored in dp[0][0][n]\n return dp[0][0][n]\n\n# Example usage:\nsolution = Solution()\ns1 = \"great\"\ns2 = \"rgeat\"\nprint(solution.isScramble(s1, s2)) # Output: True","runtime":"272"},{"code":"class Solution:\n def is_valid(self, s: str, t: str) -> bool:\n mask1 = mask2 = 0\n for ch in s:\n mask1 = (mask1 | (1<<(ord(ch)-ord(\"a\"))))\n for ch in t:\n mask2 = (mask2 | (1<<(ord(ch)-ord(\"a\"))))\n return mask1 == mask2\n \n def compare(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n elif len(s) == 1:\n return s==t\n elif (s,t) in self.cache:\n return self.cache[(s,t)]\n else:\n res = False\n for i in range(1, len(s)):\n # 1. not swap\n s_l, s_r = s[:i], s[i:]\n t_l, t_r = t[:i], t[i:]\n if self.is_valid(s_l, t_l):\n tmp = self.compare(s_l, t_l) and self.compare(s_r, t_r)\n res = res or tmp\n # 2. swap\n s_l, s_r = s[:i], s[i:]\n t_l, t_r = t[:len(t)-i], t[len(t)-i:]\n if self.is_valid(s_l, t_r):\n tmp = self.compare(s_l, t_r) and self.compare(s_r, t_l)\n res = res or tmp\n self.cache[(s, t)] = res\n return res\n \n def isScramble(self, s1: str, s2: str) -> bool:\n self.cache = {}\n \n res = self.compare(s1, s2)\n \n return res","runtime":"276"},{"code":"class Solution:\n def getCounts(self, s):\n counts = [0 for _ in range(26)]\n for c in s:\n counts[ord(c) - ord(\"a\")] += 1\n return counts\n def isScramble(self, s1: str, s2: str) -> bool:\n return self.helper(s1, s2)\n\n def helper(self, s1, s2, memo={}):\n combo1 = (s1, s2)\n combo2 = (s2, s1)\n if combo1 in memo:\n return memo[combo1]\n if len(s1) == len(s2) == 1:\n rval = s1 == s2\n memo[combo1] = rval\n memo[combo2] = rval\n return rval\n n = len(s1)\n counts1 = [0 for _ in range(26)]\n counts2 = [0 for _ in range(26)]\n abs_diff = 0\n for split_idx, (c1, c2) in enumerate(zip(s1, s2[::-1])):\n if 1 <= split_idx and abs_diff == 0:\n if self.helper(s1[:split_idx], s2[:split_idx], memo) and self.helper(s1[split_idx:], s2[split_idx:], memo):\n rval = True\n memo[combo1] = rval\n memo[combo2] = rval\n return rval\n if self.helper(s1[:split_idx], s2[n - split_idx:], memo) and self.helper(s1[split_idx:], s2[:n - split_idx], memo):\n rval = True\n memo[combo1] = rval\n memo[combo2] = rval\n return rval\n ic1 = ord(c1) - ord(\"a\")\n ic2 = ord(c2) - ord(\"a\")\n p_abs_diff = abs(counts1[ic1] - counts2[ic2]) + abs(counts1[ic1] - counts2[ic2])\n counts1[ic1] += 1\n counts2[ic2] += 1\n n_abs_diff = abs(counts1[ic1] - counts2[ic2]) + abs(counts1[ic1] - counts2[ic2])\n abs_diff += n_abs_diff - p_abs_diff\n rval = False\n memo[combo1] = rval\n memo[combo2] = rval\n return rval\n ","runtime":"280"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n dp = [\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\n ]\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n for length in range(2, n + 1):\n for i in range(n + 1 - length):\n for j in range(n + 1 - length):\n for new_length in range(1, length):\n dp1 = dp[new_length][i]\n dp2 = dp[length - new_length][i + new_length]\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\n dp[length][i][j] |= (\n dp1[j + length - new_length] and dp2[j]\n )\n return dp[n][0][0]","runtime":"284"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n \n # If both strings are equal, they are scrambled strings of each other\n if s1 == s2:\n return True\n \n # If the sorted strings are not equal, they cannot be scrambled strings of each other\n if sorted(s1) != sorted(s2):\n return False\n \n # Initialize a 3D DP table to store intermediate results\n dp = [[[False for _ in range(n + 1)] for _ in range(n)] for _ in range(n)]\n \n # Base case: If the length of the substring is 1, check if the characters are equal\n for i in range(n):\n for j in range(n):\n dp[i][j][1] = s1[i] == s2[j]\n \n # Fill the DP table for substrings of length 2 to n\n for length in range(2, n + 1):\n for i in range(n - length + 1):\n for j in range(n - length + 1):\n for new_length in range(1, length):\n dp1 = dp[i][j][new_length]\n dp2 = dp[i + new_length][j + new_length][length - new_length]\n dp3 = dp[i][j + length - new_length][new_length]\n dp4 = dp[i + new_length][j][length - new_length]\n \n if (dp1 and dp2) or (dp3 and dp4):\n dp[i][j][length] = True\n break\n \n return dp[0][0][n]\n\n# Example usage:\nsolution = Solution()\ns1 = \"great\"\ns2 = \"rgeat\"\nprint(solution.isScramble(s1, s2)) # Output: True","runtime":"284"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n # Initialize a 3D table to store the results of all possible substrings of the two strings\n dp = [[[False for _ in range(n)] for _ in range(n)] for _ in range(n+1)]\n\n # Initialize the table for substrings of length 1\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n\n # Fill the table for substrings of length 2 to n\n for length in range(2, n+1):\n for i in range(n+1-length):\n for j in range(n+1-length):\n # Iterate over all possible lengths of the first substring\n for newLength in range(1, length):\n # Check if the two possible splits of the substrings are scrambled versions of each other\n dp1 = dp[newLength][i]\n dp2 = dp[length-newLength][i+newLength]\n dp[length][i][j] |= dp1[j] and dp2[j+newLength]\n dp[length][i][j] |= dp1[j+length-newLength] and dp2[j]\n\n # Return whether the entire strings s1 and s2 are scrambled versions of each other\n return dp[n][0][0]","runtime":"288"},{"code":"class Solution:\n def is_valid(self, s: str, t: str) -> bool:\n mask1 = mask2 = 0\n for ch in s:\n mask1 = (mask1 | (1<<(ord(ch)-ord(\"a\"))))\n for ch in t:\n mask2 = (mask2 | (1<<(ord(ch)-ord(\"a\"))))\n return mask1 == mask2\n \n def compare(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n elif len(s) == 1:\n return s==t\n elif (s,t) in self.cache:\n return self.cache[(s,t)]\n else:\n res = False\n for i in range(1, len(s)):\n # 1. not swap\n s_l, s_r = s[:i], s[i:]\n t_l, t_r = t[:i], t[i:]\n if self.is_valid(s_l, t_l):\n tmp = self.compare(s_l, t_l) and self.compare(s_r, t_r)\n res = res or tmp\n # 2. swap\n s_l, s_r = s[:i], s[i:]\n t_l, t_r = t[:len(t)-i], t[len(t)-i:]\n if self.is_valid(s_l, t_r):\n tmp = self.compare(s_l, t_r) and self.compare(s_r, t_l)\n res = res or tmp\n self.cache[(s, t)] = res\n return res\n \n def isScramble(self, s1: str, s2: str) -> bool:\n self.cache = {}\n \n res = self.compare(s1, s2)\n \n return res","runtime":"292"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # Solution: in editorial\n # Real solution: Give up\n n = len(s1)\n dp = [\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\n ]\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n for length in range(2, n + 1):\n for i in range(n + 1 - length):\n for j in range(n + 1 - length):\n for new_length in range(1, length):\n dp1 = dp[new_length][i]\n dp2 = dp[length - new_length][i + new_length]\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\n dp[length][i][j] |= (\n dp1[j + length - new_length] and dp2[j]\n )\n return dp[n][0][0]","runtime":"292"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n\n n = len(s1)\n\n dp = [\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\n ] \n\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n \n for length in range(2, n + 1):\n for i in range(n + 1 - length):\n for j in range(n + 1 - length):\n for new_length in range(1, length):\n dp1 = dp[new_length][i]\n dp2 = dp[length - new_length][i + new_length]\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\n dp[length][i][j] |= (\n dp1[j + length - new_length] and dp2[j]\n )\n \n return dp[n][0][0]","runtime":"296"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n \n # If lengths are different, they cannot be scrambled strings\n if len(s2) != n:\n return False\n \n # Initialize the DP table\n dp = [[[False for _ in range(n + 1)] for _ in range(n)] for _ in range(n)]\n \n # Base case: single characters\n for i in range(n):\n for j in range(n):\n dp[i][j][1] = (s1[i] == s2[j])\n \n # Fill the DP table for lengths greater than 1\n for length in range(2, n + 1):\n for i in range(n - length + 1):\n for j in range(n - length + 1):\n for new_length in range(1, length):\n dp1 = dp[i][j][new_length]\n dp2 = dp[i + new_length][j + new_length][length - new_length]\n dp3 = dp[i][j + length - new_length][new_length]\n dp4 = dp[i + new_length][j][length - new_length]\n \n if (dp1 and dp2) or (dp3 and dp4):\n dp[i][j][length] = True\n break\n \n return dp[0][0][n]\n\n# Example usage:\nsolution = Solution()\ns1 = \"great\"\ns2 = \"rgeat\"\nprint(solution.isScramble(s1, s2)) # Output: True","runtime":"296"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n\n dp = [[[False] * (n+1) for _ in range(n)] for _ in range(n)]\n for i in range(n):\n for j in range(n):\n if s1[i] == s2[j]:\n dp[i][j][1] = True\n \n for l in range(2, n+1):\n # i = 0, ..., n-1\n for l1 in range(n-l+1):\n for l2 in range(n-l+1):\n for i in range(1, l):\n dp[l1][l2][l] |= (dp[l1][l2][i] and dp[l1+i][l2+i][l-i])\n for i in range(1, l):\n dp[l1][l2][l] |= (dp[l1][l2+l-i][i] and dp[l1+i][l2][l-i])\n return dp[0][0][n]","runtime":"300"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n dp = [\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\n ]\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n for length in range(2, n + 1):\n for i in range(n + 1 - length):\n for j in range(n + 1 - length):\n for new_length in range(1, length):\n dp1 = dp[new_length][i]\n dp2 = dp[length - new_length][i + new_length]\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\n dp[length][i][j] |= (\n dp1[j + length - new_length] and dp2[j]\n )\n return dp[n][0][0]","runtime":"300"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n dp = [\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\n ]\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n for length in range(2, n + 1):\n for i in range(n + 1 - length):\n for j in range(n + 1 - length):\n for new_length in range(1, length):\n dp1 = dp[new_length][i]\n dp2 = dp[length - new_length][i + new_length]\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\n dp[length][i][j] |= (\n dp1[j + length - new_length] and dp2[j]\n )\n return dp[n][0][0]","runtime":"304"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \n n = len(s1)\n\n dp = []\n # Length of section\n for l in range(n + 1):\n is_ = []\n # Start of section for s1\n for i in range(n):\n js = []\n # Start of section for s2\n for j in range(n):\n js.append(False)\n is_.append(js)\n dp.append(is_)\n \n # Base case: 1 characters and both are the same character\n # s1 index\n for i in range(n):\n # s2 index\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n\n # 2 because length 1 checked in base case\n for length in range(2, n + 1):\n # One part for s1\n for i in range(n + 1 - length):\n # One part for s2\n for j in range(n + 1 - length):\n # The other part\n for new_length in range(1, length):\n\n # Left\n dp1 = dp[new_length][i]\n # Right\n dp2 = dp[length - new_length][i + new_length]\n\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\n\n # Swap\n dp[length][i][j] |= dp1[j + length - new_length] and dp2[j]\n\n # print(dp)\n\n return dp[n][0][0]","runtime":"312"},{"code":"from functools import cache\n\n\nclass Solution:\n @cache\n def isScramble(self, s1: str, s2: str) -> bool:\n if s2 < s1:\n return self.isScramble(s2, s1)\n\n if s1 == s2:\n return True\n \n if len(s1) == 1:\n return False\n \n for i in range(len(s1) - 1):\n split_index = i + 1\n if self.isScramble(s1[:split_index], s2[:split_index]) and self.isScramble(s1[split_index:], s2[split_index:]):\n return True\n if self.isScramble(s1[:split_index], s2[len(s1) - split_index:]) and self.isScramble(s1[split_index:], s2[:len(s1) - split_index]):\n return True\n \n return False","runtime":"312"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n\n dp = [[[False for j in range(n)] for i in range(n)] for l in range(n+1)]\n\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n \n for length in range(2, n+1):\n for i in range(n+1 - length):\n for j in range(n+1 - length):\n for new_length in range(1, length):\n dp1 = dp[new_length][i]\n dp2 = dp[length - new_length][i+new_length]\n dp[length][i][j] |= dp1[j] and dp2[j+new_length]\n dp[length][i][j] |= (dp1[j + length - new_length] and dp2[j])\n\n return dp[n][0][0]\n # memo = {}\n # def dfs(s1, s2):\n # if s1 == s2:\n # return True\n # if (s1, s2) in memo:\n # return memo[(s1, s2)]\n \n # if Counter(s1) != Counter(s2):\n # memo[(s1, s2)] = False\n # return False\n\n # n = len(s1)\n # memo[(s1, s2)] = False\n # for k in range(1, n):\n # if dfs(s1[:k], s2[:k]) and dfs(s1[k:], s2[k:]) or dfs(s1[:k], s2[n-k:]) and dfs(s1[k:], s2[:n-k]):\n # memo[(s1, s2)] = True\n # return memo[(s1, s2)]\n\n # return dfs(s1, s2)","runtime":"316"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n dp = [[[False for j in range(n)] for i in range(n)] for l in range(n + 1)]\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n for length in range(2, n + 1):\n for i in range(n + 1 - length):\n for j in range(n + 1 - length):\n for n_length in range(1, length):\n dp1 = dp[n_length][i]\n dp2 = dp[length - n_length][i + n_length]\n dp[length][i][j] |= dp1[j] and dp2[j + n_length]\n dp[length][i][j] |= (dp1[j + length - n_length] and dp2[j])\n return dp[n][0][0]","runtime":"316"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n from functools import cache\n\n @cache\n def scramble(x: str, y: str):\n if (n := len(x)) == 1:\n return x == y\n\n check = False\n for i in range(n-1):\n x1 = x[:i+1]\n x2 = x[i+1:]\n y1 = y[:i+1]\n y2 = y[i+1:]\n y3 = y[:n-i-1]\n y4 = y[n-i-1:]\n check1 = scramble(x1, y1) and scramble(x2, y2)\n check2 = scramble(x2, y3) and scramble(x1, y4)\n check = check or check1 or check2\n \n return check\n\n return scramble(s1, s2)","runtime":"320"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \n @lru_cache(None)\n def compute(a,b):\n # abcd bcda\n n = len(a)\n if n != len(b):\n return False\n if a == b:\n return True\n # if sorted(a) != sorted(b): \n # return False\n res = False\n for k in range(1,n):\n # case0\n res|=(compute(a[0:k],b[0:k]) and compute(a[k:],b[k:]))\n #case1\n res|=(compute(a[0 : k],b[n-k: ]) and compute(a[k : ],b[0 : n-k]))\n \n return res\n res = compute(s1,s2)\n compute.cache_clear()\n return res","runtime":"320"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n dp = [[[False] * n for _ in range(n)] for _ in range(n+1)]\n if not sorted(s1) == sorted(s2):\n return False\n\n for i in range(n):\n for j in range(n):\n dp[1][i][j] = s1[i] == s2[j]\n \n for length in range(2, n+1):\n for i in range(n+1-length):\n for j in range(n+1-length):\n for new_length in range(1, length):\n dp1 = dp[new_length][i]\n dp2 = dp[length - new_length][i+new_length]\n dp[length][i][j] |= dp1[j] and dp2[j+new_length]\n dp[length][i][j] |= (dp1[j+length-new_length] and dp2[j])\n if dp[length][i][j]:\n break\n \n return dp[n][0][0]","runtime":"324"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n def dp(s1, s2, memo):\n if s1+\",\"+s2 in memo:\n return memo[s1+\",\"+s2]\n if s1 == s2:\n memo[s1+\",\"+s2] = True\n return True\n\n for i in range(1, len(s1)):\n if dp(s1[i:], s2[i:], memo) and dp(s1[:i], s2[:i], memo):\n memo[s1+\",\"+s2] = True\n return True\n if dp(s1[i:], s2[:-i], memo) and dp(s1[:i], s2[-i:], memo):\n memo[s1+\",\"+s2] = True\n return True\n memo[s1+\",\"+s2] = False\n return False\n return dp(s1, s2, {})","runtime":"324"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # # Memomiazation \n # # O(n^4) time, O(n^3) space\n # if len(s1) != len(s2):\n # return False\n \n # n = len(s1)\n\n # # (ls1, ls2, sslen). ls1 is starting index in s1. ls2 is starting index in s2, sslen is substring length we are testing.\n # # where memo[(ls1, ls2, sslen)] = isScramble(s1[ls1..ls1+sslen-1], s2[ls2..ls2+sslen-1])\n # memo = {}\n\n # def recurse_is_scramble(ls1, ls2, sslen):\n # if (ls1, ls2, sslen) in memo:\n # return memo[(ls1, ls2, sslen)]\n # if sslen == 1:\n # memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\n # return memo[(ls1, ls2, sslen)]\n \n # for xlen in range(1, sslen):\n # ylen = sslen - xlen\n # # x + y\n # res = recurse_is_scramble(ls1, ls2, xlen) and recurse_is_scramble(ls1 + xlen, ls2 + xlen, ylen)\n # if not res:\n # # y + x\n # res = res or (recurse_is_scramble(ls1 + xlen, ls2, ylen) and recurse_is_scramble(ls1, ls2 + ylen, xlen))\n # if res:\n # memo[(ls1, ls2, sslen)] = True\n # return True\n\n # memo[(ls1, ls2, sslen)] = False\n # return False\n \n # return recurse_is_scramble(0, 0, n)\n\n # Iterative solution\n memo = {}\n n = len(s1)\n\n for sslen in range(1, n + 1):\n for ls1 in range(n):\n if ls1 + sslen > n:\n continue\n for ls2 in range(n):\n if ls2 + sslen > n:\n continue\n # print(\"ls1, ls2, sslen\", ls1, ls2, sslen)\n if sslen == 1:\n memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\n continue\n\n res = False\n for xlen in range(1, sslen):\n ylen = sslen - xlen\n # x + y\n res = memo[(ls1, ls2, xlen)] and memo[(ls1 + xlen, ls2 + xlen, ylen)]\n if not res:\n # y + x\n res = res or (memo[(ls1 + xlen, ls2, ylen)] and memo[(ls1, ls2 + ylen, xlen)])\n if res:\n memo[(ls1, ls2, sslen)] = True\n break\n if not res:\n memo[(ls1, ls2, sslen)] = False\n\n return memo[(0, 0, n)]","runtime":"328"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def scramble(p1, p2):\n print(p1)\n print(p2)\n if len(p1) == 1:\n return p1 == p2\n \n for k in range(1, len(p1)):\n rev = len(p1) - k\n unscrambled = scramble(p1[:k], p2[:k]) and scramble(p1[k:], p2[k:])\n scrambled = scramble(p1[:rev], p2[k:]) and scramble(p1[rev:], p2[:k])\n if unscrambled or scrambled:\n return True\n\n return False\n\n return scramble(s1, s2)","runtime":"332"},{"code":"class Solution:\n @cache\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) == 1:\n return s1 == s2\n \n for k in range(1, len(s1)):\n unscrambled = self.isScramble(s1[:k], s2[:k]) and self.isScramble(s1[k:], s2[k:])\n scrambled = self.isScramble(s1[:-k], s2[k:]) and self.isScramble(s1[-k:], s2[:k])\n if unscrambled or scrambled:\n return True\n\n return False","runtime":"332"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # # Memomiazation \n # # O(n^4) time, O(n^3) space\n # if len(s1) != len(s2):\n # return False\n \n # n = len(s1)\n\n # # (ls1, ls2, sslen). ls1 is starting index in s1. ls2 is starting index in s2, sslen is substring length we are testing.\n # # where memo[(ls1, ls2, sslen)] = isScramble(s1[ls1..ls1+sslen-1], s2[ls2..ls2+sslen-1])\n # memo = {}\n\n # def recurse_is_scramble(ls1, ls2, sslen):\n # if (ls1, ls2, sslen) in memo:\n # return memo[(ls1, ls2, sslen)]\n # if sslen == 1:\n # memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\n # return memo[(ls1, ls2, sslen)]\n \n # for xlen in range(1, sslen):\n # ylen = sslen - xlen\n # # x + y\n # res = recurse_is_scramble(ls1, ls2, xlen) and recurse_is_scramble(ls1 + xlen, ls2 + xlen, ylen)\n # if not res:\n # # y + x\n # res = res or (recurse_is_scramble(ls1 + xlen, ls2, ylen) and recurse_is_scramble(ls1, ls2 + ylen, xlen))\n # if res:\n # memo[(ls1, ls2, sslen)] = True\n # return True\n\n # memo[(ls1, ls2, sslen)] = False\n # return False\n \n # return recurse_is_scramble(0, 0, n)\n\n # Iterative solution\n memo = {}\n n = len(s1)\n\n for sslen in range(1, n + 1):\n for ls1 in range(n - sslen + 1):\n for ls2 in range(n - sslen + 1):\n # print(\"ls1, ls2, sslen\", ls1, ls2, sslen)\n if sslen == 1:\n memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\n continue\n\n res = False\n for xlen in range(1, sslen):\n ylen = sslen - xlen\n # x + y\n res = memo[(ls1, ls2, xlen)] and memo[(ls1 + xlen, ls2 + xlen, ylen)]\n if not res:\n # y + x\n res = res or (memo[(ls1 + xlen, ls2, ylen)] and memo[(ls1, ls2 + ylen, xlen)])\n if res:\n memo[(ls1, ls2, sslen)] = True\n break\n if not res:\n memo[(ls1, ls2, sslen)] = False\n\n return memo[(0, 0, n)]","runtime":"336"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n def dp(s1, s2, memo):\n if s1+\",\"+s2 in memo:\n return memo[s1+\",\"+s2]\n if s1 == s2:\n return True\n for i in range(1, len(s1)):\n if dp(s1[i:], s2[i:], memo) and dp(s1[:i], s2[:i], memo):\n memo[s1+\",\"+s2] = True\n return True\n if dp(s1[i:], s2[:-i], memo) and dp(s1[:i], s2[-i:], memo):\n memo[s1+\",\"+s2] = True\n return True\n memo[s1+\",\"+s2] = False\n return False\n return dp(s1, s2, {})","runtime":"336"}],"string":"[\n {\n \"code\": \"class Solution:\\n # dictionary to store previously computed substrings\\n map = {}\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n # check if the two strings are equal\\n if s1 == s2:\\n return True\\n # initialize frequency lists for s1, s2, and current substring\\n a, b, c = [0] * 26, [0] * 26, [0] * 26\\n # check if the current substring has already been computed\\n if (s1 + s2) in self.map:\\n return self.map[s1 + s2]\\n # check all possible splits of the two strings\\n for i in range(1, n):\\n j = n - i\\n # update frequency lists for s1, s2, and current substring\\n a[ord(s1[i - 1]) - ord('a')] += 1\\n b[ord(s2[i - 1]) - ord('a')] += 1\\n c[ord(s2[j]) - ord('a')] += 1\\n # check if the current substring has the same characters\\n if a == b and self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n # if the substrings are scrambled versions of each other, return True\\n self.map[s1 + s2] = True\\n return True\\n # check if the current substring and its complement have the same characters\\n if a == c and self.isScramble(s1[:i], s2[j:]) and self.isScramble(s1[i:], s2[:j]):\\n # if the substrings are scrambled versions of each other, return True\\n self.map[s1 + s2] = True\\n return True\\n # if none of the splits result in scrambled versions, return False\\n self.map[s1 + s2] = False\\n return False\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n map = {}\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n # check if the two strings are equal\\n if s1 == s2:\\n return True\\n # initialize frequency lists for s1, s2, and current substring\\n a, b, c = [0] * 26, [0] * 26, [0] * 26\\n # check if the current substring has already been computed\\n if (s1 + s2) in self.map:\\n return self.map[s1 + s2]\\n # check all possible splits of the two strings\\n for i in range(1, n):\\n j = n - i\\n # update frequency lists for s1, s2, and current substring\\n a[ord(s1[i - 1]) - ord('a')] += 1\\n b[ord(s2[i - 1]) - ord('a')] += 1\\n c[ord(s2[j]) - ord('a')] += 1\\n # check if the current substring has the same characters\\n if a == b and self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n # if the substrings are scrambled versions of each other, return True\\n self.map[s1 + s2] = True\\n return True\\n # check if the current substring and its complement have the same characters\\n if a == c and self.isScramble(s1[:i], s2[j:]) and self.isScramble(s1[i:], s2[:j]):\\n # if the substrings are scrambled versions of each other, return True\\n self.map[s1 + s2] = True\\n return True\\n # if none of the splits result in scrambled versions, return False\\n self.map[s1 + s2] = False\\n return False\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n map = {}\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n # check if the two strings are equal\\n if s1 == s2:\\n return True\\n # initialize frequency lists for s1, s2, and current substring\\n a, b, c = [0] * 26, [0] * 26, [0] * 26\\n # check if the current substring has already been computed\\n if (s1 + s2) in self.map:\\n return self.map[s1 + s2]\\n # check all possible splits of the two strings\\n for i in range(1, n):\\n j = n - i\\n # update frequency lists for s1, s2, and current substring\\n a[ord(s1[i - 1]) - ord('a')] += 1\\n b[ord(s2[i - 1]) - ord('a')] += 1\\n c[ord(s2[j]) - ord('a')] += 1\\n # check if the current substring has the same characters\\n if a == b and self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n # if the substrings are scrambled versions of each other, return True\\n self.map[s1 + s2] = True\\n return True\\n # check if the current substring and its complement have the same characters\\n if a == c and self.isScramble(s1[:i], s2[j:]) and self.isScramble(s1[i:], s2[:j]):\\n # if the substrings are scrambled versions of each other, return True\\n self.map[s1 + s2] = True\\n return True\\n # if none of the splits result in scrambled versions, return False\\n self.map[s1 + s2] = False\\n return False\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n # dictionary to store previously computed substrings\\n map = {}\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n # check if the two strings are equal\\n if s1 == s2:\\n return True\\n # initialize frequency lists for s1, s2, and current substring\\n a, b, c = [0] * 26, [0] * 26, [0] * 26\\n # check if the current substring has already been computed\\n if (s1 + s2) in self.map:\\n return self.map[s1 + s2]\\n # check all possible splits of the two strings\\n for i in range(1, n):\\n j = n - i\\n # update frequency lists for s1, s2, and current substring\\n a[ord(s1[i - 1]) - ord('a')] += 1\\n b[ord(s2[i - 1]) - ord('a')] += 1\\n c[ord(s2[j]) - ord('a')] += 1\\n # check if the current substring has the same characters\\n if a == b and self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n # if the substrings are scrambled versions of each other, return True\\n self.map[s1 + s2] = True\\n return True\\n # check if the current substring and its complement have the same characters\\n if a == c and self.isScramble(s1[:i], s2[j:]) and self.isScramble(s1[i:], s2[:j]):\\n # if the substrings are scrambled versions of each other, return True\\n self.map[s1 + s2] = True\\n return True\\n # if none of the splits result in scrambled versions, return False\\n self.map[s1 + s2] = False\\n return False\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n '''\\nThe solution uses recursion with memoization to check all possible partitions of the two strings and determine if they are scrambled versions of each other. The memoization is achieved using a dictionary m that stores the result of previous computations for the same inputs.\\n\\nThe func function takes in two strings s1 and s2, and returns a boolean value indicating whether they are scrambled versions of each other. The function first checks the length of the strings - if they are both of length 1, it simply compares the characters. If the sorted characters in the two strings are not equal, it returns False.\\n\\nOtherwise, the function loops through all possible partitions of s1 and checks if they are valid scrambles of corresponding partitions in s2. The partitions are formed by looping through the length of s1 from index 1 to the end. If a valid partition is found, the function recursively checks the remaining partitions to see if they are also valid scrambles.\\n\\nIf at least one valid partition is found, the function returns True and stores the result in the m dictionary. If no valid partitions are found, the function returns False and stores the result in the m dictionary.\\n\\nFinally, the isScramble function calls the func function with the two input strings and returns the resulting boolean value.\\n\\n '''\\n m ={}\\n def func(s1, s2):\\n if (s1, s2) in m:\\n return m[(s1, s2)]\\n if not sorted(s1) == sorted(s2):\\n return False\\n if len(s1) == 1:\\n return True\\n \\n\\n for i in range(1, len(s1)):\\n if func(s1[:i], s2[-i:]) and func(s1[i:], s2[:-i]) or func(s1[:i], s2[:i]) and func(s1[i:], s2[i:]):\\n m[(s1, s2)] = True\\n return True\\n m[(s1, s2)] = False\\n return False\\n return func(s1, s2)\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self,s1, s2):\\n from functools import lru_cache\\n\\n n = len(s1)\\n if n != len(s2):\\n return False\\n\\n @lru_cache(None)\\n def isScrambleRec(s1, s2):\\n # Base cases\\n if s1 == s2:\\n return True\\n if sorted(s1) != sorted(s2):\\n return False\\n\\n n = len(s1)\\n for i in range(1, n):\\n # Without Swap\\n if (isScrambleRec(s1[:i], s2[:i]) and isScrambleRec(s1[i:], s2[i:])):\\n return True\\n # With Swap\\n if (isScrambleRec(s1[:i], s2[-i:]) and isScrambleRec(s1[i:], s2[:-i])):\\n return True\\n return False\\n\\n return isScrambleRec(s1, s2)\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n\\n def __init__(self):\\n self.scramble_dict = dict()\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if not self.is_permutation(s1, s2):\\n return False\\n return self.is_scramble_rec(s1, s2)\\n\\n def is_permutation(self, s1, s2) -> bool:\\n return sorted(s1) == sorted(s2)\\n\\n def is_scramble_rec(self, s1, s2) -> bool:\\n if len(s1) <= 3 or s1 == s2:\\n return True\\n if (s1, s2) in self.scramble_dict:\\n return self.scramble_dict[(s1, s2)]\\n N = len(s1)\\n for pos in range(1, N):\\n x1 = s1[:pos]\\n x2 = s2[:pos]\\n if self.is_permutation(x1, x2):\\n x1_rest = s1[pos:]\\n x2_rest = s2[pos:]\\n if self.is_scramble_rec(x1, x2) and self.is_scramble_rec(x1_rest, x2_rest):\\n self.scramble_dict[(s1, s2)] = True\\n return True\\n x2_back = s2[N - pos:]\\n if self.is_permutation(x1, x2_back):\\n x1_rest = s1[pos:]\\n x2_back_rest = s2[: N - pos]\\n if self.is_scramble_rec(x1, x2_back) and self.is_scramble_rec(x1_rest, x2_back_rest):\\n self.scramble_dict[(s1, s2)] = True\\n return True\\n\\n self.scramble_dict[(s1, s2)] = False\\n return False\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n MAP = {}\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if (s1, s2) in self.MAP:\\n return self.MAP[(s1, s2)]\\n if len(s1) != len(s2) or sorted(s1) != sorted(s2):\\n self.MAP[(s1, s2)] = False\\n return self.MAP[(s1, s2)]\\n if s1 == s2:\\n self.MAP[(s1, s2)] = True\\n return self.MAP[(s1, s2)]\\n for i in range(1, len(s1)):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n return True\\n swap_i = len(s2) - i\\n if self.isScramble(s1[:i], s2[swap_i:]) and self.isScramble(s1[i:], s2[:swap_i]):\\n return True\\n self.MAP[(s1, s2)] = False\\n return self.MAP[(s1, s2)]\\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # Dictionary to store results for memoization\\n memo = {}\\n \\n # Helper function to recursively check for scrambled strings\\n def solve(s1, s2):\\n if s1 == s2:\\n return True\\n if len(s1) != len(s2):\\n return False\\n \\n # Check memo table for already computed results\\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n \\n # If sorted characters of both strings don't match, no scramble is possible\\n if sorted(s1) != sorted(s2):\\n memo[(s1, s2)] = False\\n return False\\n \\n n = len(s1)\\n for k in range(1, n):\\n # Case 1: s1[0:k] matches s2[0:k] and s1[k:n] matches s2[k:n]\\n if solve(s1[:k], s2[:k]) and solve(s1[k:], s2[k:]):\\n memo[(s1, s2)] = True\\n return True\\n \\n # Case 2: s1[0:k] matches s2[n-k:n] and s1[k:n] matches s2[0:n-k]\\n if solve(s1[:k], s2[n-k:]) and solve(s1[k:], s2[:n-k]):\\n memo[(s1, s2)] = True\\n return True\\n \\n memo[(s1, s2)] = False\\n return False\\n \\n return solve(s1, s2)\\n\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n def mm(dct1,dct2):\\n mmCnt=0\\n for l,cnt in dct1.items():\\n try:\\n cnt2=dct2[l]\\n except KeyError:\\n cnt2=0\\n if cnt>cnt2: \\n mmCnt+=cnt-cnt2\\n return mmCnt \\n\\n def count(s):\\n dct={}\\n for l in s:\\n try:\\n dct[l]+=1\\n except KeyError:\\n dct[l]=1\\n return dct \\n\\n def upd(s,i,dcts):\\n l=s[i]\\n cnt=dcts[1].pop(l)\\n if cnt >1:\\n dcts[1][l]=cnt-1\\n try:\\n dcts[0][l]+=1\\n except KeyError:\\n dcts[0][l]=1\\n def upd2(s,i,dcts):\\n #print(dcts)\\n l=s[-1-i]\\n cnt=dcts[0].pop(l)\\n if cnt >1:\\n dcts[0][l]=cnt-1\\n try:\\n dcts[1][l]+=1\\n except KeyError:\\n dcts[1][l]=1 \\n\\n cache={}\\n def check(s1,s2,dct1=None,dct2=None,n=0):\\n try:\\n r= cache[(s1,s2)]\\n #print(' '*n,s1,s2, 'HIT!')\\n return r\\n except KeyError:\\n pass \\n \\n\\n #print(' '*n,s1,s2)\\n if s1==s2:\\n return True\\n if dct1 is None:\\n dcts1={},count(s1)\\n dcts2={},count(s2)\\n dcts2x=dcts2[1].copy(),{}\\n\\n if dcts1[1]!=dcts2[1]:\\n return False\\n else:\\n if len(s1)<=3:\\n return True\\n dcts1={},dct1.copy()\\n dcts2={},dct2.copy()\\n dcts2x=dct2.copy(),{} \\n\\n for i in range(0,len(s1)-1):\\n upd(s1,i,dcts1)\\n upd(s2,i,dcts2)\\n upd2(s2,i,dcts2x)\\n if dcts1==dcts2:\\n if check(s1[:i+1],s2[:i+1],dcts1[0],dcts2[0] , n+1 ) and check(s1[i+1:],s2[i+1:],dcts1[1],dcts2[1],n+1):\\n cache[s1,s2]=True\\n return True \\n if dcts1==dcts2x[::-1]:\\n if check( s1[:i+1],s2[-1-i:], dcts1[0],dcts2x[1] , n+1) and check(s1[i+1:],s2[:-1-i],dcts1[1],dcts2x[0],n+1):\\n cache[s1,s2]=True\\n return True\\n cache[s1,s2]=False \\n return False \\n\\n\\n return check(s1,s2)\\n\\n\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# intuition is that s2 can be scrabled by s1 as long as they have the same letters.\\n\\n# for example \\n\\n# 12345 -> 54321\\n# 12 / 345\\n# 12 -> 2 / 1\\n# 345 -> 5 / 34\\n# 34 -> 4/3\\n\\n# oh here is a counter example \\n\\n# abcde -> caebd\\n\\n# abcde -> bcde / a to move c before a\\n\\n# but now we have no way to move b/d/e after a \\n\\n# every scrable moves a substring s1 permanently after s2\\n\\n# cadbe won't work either, because when you move c before a, you must be moving de before a and no way back\\n\\n# so the first split must happen between the first letters of s1 and s2, the scramble is promising only when \\n# all letter after s2's first letter is always in front of s1's letter\\n\\n# brute force is to enumerate all scrambled s2, for a string of length n, each split is O(n), and there are n-1 positions to split\\n\\n# so O(n) = n(n-1)*T(n-1) = O(n^2n)\\n# theta(n) = n(n-1)*T(n/2) = O(n^(2*log_2^n))\\n\\n\\n# so basically we can divide and conqure the problem: \\n\\n# for s1 = abcde and s2 = cdeba, we have 4 split\\n\\n# a/bcde, ab/cde, abc/de, abcd/e\\n\\n# now for s2 to be a scramble string, it must be any of the following split match the those for s1's split\\n\\n# c/deba, cd/eba, cde/ba, cdeb/a\\n\\n# by match we means the two part of at least one s2 spllits can be scramble, individualy by the two part of at least one s1 splits\\n# we know that when letters doesn't match, or length doesn't match, it won't be scramble. This help eliminate many cases. \\n\\n# Effectively, we only need to check: \\n# a/bcde v.s. c/deba and cdeb/a => i=1, s1[:1] v.s. s2[:i] && s1[1:5] v.s. s2[1:5] | s1[:1] v.s. s2[5-1:5] && s1[1:5] v.s. s2[:5-1]\\n# ab/cde v.s. cd/eba and cde/ba\\n# abc/de v.s. cd/eba and cde/ba\\n# abcd/e v.s. c/deba and cdeb/a\\n\\n# and we can also expect many substrings comparison will be repeated and we can memorize for quicker solution.\\n\\nclass Solution:\\n @functools.lru_cache(maxsize=1024*1024, typed=False)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # print(s1, s2)\\n if s1 == s2:\\n return True\\n if sorted(s1) != sorted(s2):\\n return False;\\n n = len(s1)\\n for i in range(1,n):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:n], s2[i:n]):\\n return True\\n if self.isScramble(s1[:i], s2[n-i:n]) and self.isScramble(s1[i:n], s2[:n-i]):\\n return True\\n return False\\n\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n memo = {}\\n \\n def dfs(s1, s2):\\n \\n if s1 == s2:\\n return True\\n \\n if sorted(s1) != sorted(s2):\\n return False\\n \\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n \\n n = len(s1)\\n for i in range(1, n):\\n \\n if (dfs(s1[:i], s2[:i]) and dfs(s1[i:], s2[i:])) or \\\\\\n (dfs(s1[:i], s2[-i:]) and dfs(s1[i:], s2[:-i])):\\n memo[(s1, s2)] = True\\n return True\\n \\n memo[(s1, s2)] = False\\n return False\\n \\n return dfs(s1, s2)\\n\\n\\nsol = Solution()\\nprint(sol.isScramble(\\\"great\\\", \\\"rgeat\\\")) \\nprint(sol.isScramble(\\\"abcde\\\", \\\"caebd\\\")) \\nprint(sol.isScramble(\\\"a\\\", \\\"a\\\")) \\n\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"import time\\r\\nclass Solution:\\r\\n cache = {}\\r\\n cach2 = {}\\r\\n def isScramble(self, s1: str, s2: str) -> bool: \\r\\n def hashmatch(s1, s2):\\r\\n key = f'{s1}0{s2}'\\r\\n if key in self.cach2:\\r\\n return self.cach2[key]\\r\\n s1map = {}\\r\\n s2map = {}\\r\\n for s in s1:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n for s in s2:\\r\\n if s not in s2map:\\r\\n s2map[s] = 1\\r\\n else:\\r\\n s2map[s] += 1\\r\\n for key in s1map.keys():\\r\\n if key not in s2map or s2map[key] != s1map[key]:\\r\\n self.cach2[key] = False\\r\\n return False\\r\\n self.cach2[key] = True\\r\\n return True \\r\\n if len(s1) == 1:\\r\\n return s1 == s2\\r\\n key = f'{s1}-{s2}'\\r\\n if key in self.cache:\\r\\n return self.cache[key]\\r\\n n = len(s1)\\r\\n for i in range(n):\\r\\n if i+1<n-i-1:\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[:i+1]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[i+1:]\\r\\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[-i-1:]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[:-i-1]\\r\\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n else:\\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[i+1:]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[:i+1]\\r\\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[:-i-1]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[-i-1:]\\r\\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n self.cache[key] = False\\r\\n return False\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"import time\\r\\nclass Solution:\\r\\n cache = {}\\r\\n def isScramble(self, s1: str, s2: str) -> bool: \\r\\n def hashmatch(s1map, s2):\\r\\n s2map = {}\\r\\n for s in s2:\\r\\n if s not in s2map:\\r\\n s2map[s] = 1\\r\\n else:\\r\\n s2map[s] += 1\\r\\n for key in s1map.keys():\\r\\n if key not in s2map or s2map[key] != s1map[key]:\\r\\n return False\\r\\n return True \\r\\n if len(s1) == 1:\\r\\n return s1 == s2\\r\\n key = f'{s1}-{s2}'\\r\\n if key in self.cache:\\r\\n return self.cache[key]\\r\\n n = len(s1)\\r\\n for i in range(n):\\r\\n if i+1<n-i-1:\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[:i+1]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[i+1:]\\r\\n s1map = {}\\r\\n for s in s1_l:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n s1rmap = {}\\r\\n for s in s1_r:\\r\\n if s not in s1rmap:\\r\\n s1rmap[s] = 1\\r\\n else:\\r\\n s1rmap[s] += 1\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[-i-1:]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[:-i-1]\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n else:\\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[i+1:]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[:i+1]\\r\\n s1map = {}\\r\\n for s in s1_l:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n s1rmap = {}\\r\\n for s in s1_r:\\r\\n if s not in s1rmap:\\r\\n s1rmap[s] = 1\\r\\n else:\\r\\n s1rmap[s] += 1 \\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[:-i-1]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[-i-1:]\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n self.cache[key] = False\\r\\n return False\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"import time\\r\\nclass Solution:\\r\\n cache = {}\\r\\n def isScramble(self, s1: str, s2: str) -> bool: \\r\\n def hashmatch(s1map, s2):\\r\\n s2map = {}\\r\\n for s in s2:\\r\\n if s not in s2map:\\r\\n s2map[s] = 1\\r\\n else:\\r\\n s2map[s] += 1\\r\\n for key in s1map.keys():\\r\\n if key not in s2map or s2map[key] != s1map[key]:\\r\\n return False\\r\\n return True \\r\\n if len(s1) == 1:\\r\\n return s1 == s2\\r\\n key = f'{s1}-{s2}'\\r\\n if key in self.cache:\\r\\n return self.cache[key]\\r\\n n = len(s1)\\r\\n for i in range(n):\\r\\n if i+1<n-i-1:\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[:i+1]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[i+1:]\\r\\n s1map = {}\\r\\n for s in s1_l:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n s1rmap = {}\\r\\n for s in s1_r:\\r\\n if s not in s1rmap:\\r\\n s1rmap[s] = 1\\r\\n else:\\r\\n s1rmap[s] += 1\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[-i-1:]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[:-i-1]\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n else:\\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[i+1:]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[:i+1]\\r\\n s1map = {}\\r\\n for s in s1_l:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n s1rmap = {}\\r\\n for s in s1_r:\\r\\n if s not in s1rmap:\\r\\n s1rmap[s] = 1\\r\\n else:\\r\\n s1rmap[s] += 1 \\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[:-i-1]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[-i-1:]\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n self.cache[key] = False\\r\\n return False\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"import time\\r\\nclass Solution:\\r\\n cache = {}\\r\\n def isScramble(self, s1: str, s2: str) -> bool: \\r\\n def hashmatch(s1map, s2):\\r\\n s2map = {}\\r\\n for s in s2:\\r\\n if s not in s2map:\\r\\n s2map[s] = 1\\r\\n else:\\r\\n s2map[s] += 1\\r\\n for key in s1map.keys():\\r\\n if key not in s2map or s2map[key] != s1map[key]:\\r\\n return False\\r\\n return True \\r\\n if len(s1) == 1:\\r\\n return s1 == s2\\r\\n key = f'{s1}-{s2}'\\r\\n if key in self.cache:\\r\\n return self.cache[key]\\r\\n n = len(s1)\\r\\n for i in range(n):\\r\\n if i+1<n-i-1:\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[:i+1]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[i+1:]\\r\\n s1map = {}\\r\\n for s in s1_l:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n s1rmap = {}\\r\\n for s in s1_r:\\r\\n if s not in s1rmap:\\r\\n s1rmap[s] = 1\\r\\n else:\\r\\n s1rmap[s] += 1\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[-i-1:]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[:-i-1]\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n else:\\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[i+1:]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[:i+1]\\r\\n s1map = {}\\r\\n for s in s1_l:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n s1rmap = {}\\r\\n for s in s1_r:\\r\\n if s not in s1rmap:\\r\\n s1rmap[s] = 1\\r\\n else:\\r\\n s1rmap[s] += 1 \\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[:-i-1]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[-i-1:]\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n self.cache[key] = False\\r\\n return False\\r\\n\\r\\n def isScramble2(self, s1: str, s2: str) -> bool:\\r\\n from functools import lru_cache\\r\\n\\r\\n @lru_cache(None)\\r\\n def dfs(s1, s2):\\r\\n if s1 == s2:\\r\\n return True\\r\\n if sorted(s1) != sorted(s2):\\r\\n return False\\r\\n n = len(s1)\\r\\n for i in range(1, n):\\r\\n # Check without swap\\r\\n if dfs(s1[:i], s2[:i]) and dfs(s1[i:], s2[i:]):\\r\\n return True\\r\\n # Check with swap\\r\\n if dfs(s1[:i], s2[-i:]) and dfs(s1[i:], s2[:-i]):\\r\\n return True\\r\\n return False\\r\\n\\r\\n return dfs(s1, s2) \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"import time\\r\\nclass Solution:\\r\\n cache = {}\\r\\n cach2 = {}\\r\\n def isScramble(self, s1: str, s2: str) -> bool: \\r\\n def hashmatch(s1, s2):\\r\\n key = f'{s1}0{s2}'\\r\\n if key in self.cach2:\\r\\n return self.cach2[key]\\r\\n s1map = {}\\r\\n s2map = {}\\r\\n for s in s1:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n for s in s2:\\r\\n if s not in s2map:\\r\\n s2map[s] = 1\\r\\n else:\\r\\n s2map[s] += 1\\r\\n for key in s1map.keys():\\r\\n if key not in s2map or s2map[key] != s1map[key]:\\r\\n self.cach2[key] = False\\r\\n return False\\r\\n self.cach2[key] = True\\r\\n return True \\r\\n if len(s1) == 1:\\r\\n return s1 == s2\\r\\n key = f'{s1}-{s2}'\\r\\n if key in self.cache:\\r\\n return self.cache[key]\\r\\n n = len(s1)\\r\\n for i in range(n):\\r\\n if i+1<n-i-1:\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[:i+1]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[i+1:]\\r\\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[-i-1:]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[:-i-1]\\r\\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n else:\\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[i+1:]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[:i+1]\\r\\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[:-i-1]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[-i-1:]\\r\\n if hashmatch(s1_l, s2_l) and hashmatch(s1_r, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n self.cache[key] = False\\r\\n return False\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"import time\\r\\nclass Solution:\\r\\n cache = {}\\r\\n def isScramble(self, s1: str, s2: str) -> bool: \\r\\n def hashmatch(s1map, s2):\\r\\n s2map = {}\\r\\n for s in s2:\\r\\n if s not in s2map:\\r\\n s2map[s] = 1\\r\\n else:\\r\\n s2map[s] += 1\\r\\n for key in s1map.keys():\\r\\n if key not in s2map or s2map[key] != s1map[key]:\\r\\n return False\\r\\n return True \\r\\n if len(s1) == 1:\\r\\n return s1 == s2\\r\\n key = f'{s1}-{s2}'\\r\\n if key in self.cache:\\r\\n return self.cache[key]\\r\\n n = len(s1)\\r\\n for i in range(n):\\r\\n if i+1<n-i-1:\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[:i+1]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[i+1:]\\r\\n s1map = {}\\r\\n for s in s1_l:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n s1rmap = {}\\r\\n for s in s1_r:\\r\\n if s not in s1rmap:\\r\\n s1rmap[s] = 1\\r\\n else:\\r\\n s1rmap[s] += 1\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[-i-1:]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[:-i-1]\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n else:\\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[i+1:]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[:i+1]\\r\\n s1map = {}\\r\\n for s in s1_l:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n s1rmap = {}\\r\\n for s in s1_r:\\r\\n if s not in s1rmap:\\r\\n s1rmap[s] = 1\\r\\n else:\\r\\n s1rmap[s] += 1 \\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[:-i-1]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[-i-1:]\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n self.cache[key] = False\\r\\n return False\\r\\n\\r\\n def isScramble2(self, s1: str, s2: str) -> bool:\\r\\n from functools import lru_cache\\r\\n\\r\\n @lru_cache(None)\\r\\n def dfs(s1, s2):\\r\\n if s1 == s2:\\r\\n return True\\r\\n if sorted(s1) != sorted(s2):\\r\\n return False\\r\\n n = len(s1)\\r\\n for i in range(1, n):\\r\\n # Check without swap\\r\\n if dfs(s1[:i], s2[:i]) and dfs(s1[i:], s2[i:]):\\r\\n return True\\r\\n # Check with swap\\r\\n if dfs(s1[:i], s2[-i:]) and dfs(s1[i:], s2[:-i]):\\r\\n return True\\r\\n return False\\r\\n\\r\\n return dfs(s1, s2) \",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n @functools.lru_cache(None)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n if collections.Counter(s1) != collections.Counter(s2):\\n return False\\n\\n for i in range(1, len(s1)):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n return True\\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\\n self.isScramble(s1[i:], s2[: len(s2) - i])):\\n return True\\n\\n return False\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n @functools.lru_cache(None)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n if collections.Counter(s1) != collections.Counter(s2):\\n return False\\n\\n for i in range(1, len(s1)):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n return True\\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\\n self.isScramble(s1[i:], s2[: len(s2) - i])):\\n return True\\n\\n return False\\n \",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n @functools.lru_cache(None)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n if collections.Counter(s1) != collections.Counter(s2):\\n return False\\n\\n for i in range(1, len(s1)):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n return True\\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\\n self.isScramble(s1[i:], s2[: len(s2) - i])):\\n return True\\n\\n return False\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n @functools.lru_cache(None)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n if collections.Counter(s1) != collections.Counter(s2):\\n return False\\n\\n for i in range(1, len(s1)):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n return True\\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\\n self.isScramble(s1[i:], s2[: len(s2) - i])):\\n return True\\n\\n return False \",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n @functools.lru_cache(None)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n if collections.Counter(s1) != collections.Counter(s2):\\n return False\\n\\n for i in range(1, len(s1)):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n return True\\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\\n self.isScramble(s1[i:], s2[: len(s2) - i])):\\n return True\\n\\n return False\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"from functools import lru_cache\\nfrom collections import Counter\\n\\nclass Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\\"\\\"\\\"\\n Determine if s2 is a scrambled string of s1.\\n \\n :param s1: The first string\\n :param s2: The second string\\n :return: True if s2 is a scramble of s1, False otherwise\\n \\\"\\\"\\\"\\n # Helper function to check if two strings have the same character frequencies\\n def have_same_chars(a: str, b: str) -> bool:\\n return Counter(a) == Counter(b)\\n \\n @lru_cache(None)\\n def dp(a: str, b: str) -> bool:\\n # Base cases\\n if len(a) != len(b):\\n return False\\n if len(a) == 1:\\n return a == b\\n if a == b:\\n return True\\n if not have_same_chars(a, b):\\n return False\\n \\n # Check all possible splits\\n for i in range(1, len(a)):\\n # Case 1: No swap\\n if (dp(a[:i], b[:i]) and dp(a[i:], b[i:])):\\n return True\\n # Case 2: Swap\\n if (dp(a[:i], b[-i:]) and dp(a[i:], b[:-i])):\\n return True\\n \\n return False\\n \\n return dp(s1, s2)\\n\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # self.cache = {}\\n return self.__dfs(s1, s2 , 0, len(s1), 0, len(s2))\\n \\n @cache\\n def __dfs(self, s1, s2, x1, x2, y1, y2):\\n # print(s1[x1:x2], s2[y1:y2])\\n\\n if s1[x1:x2]== s2[y1:y2]: return True\\n # if (x1, x2, y1, y2) in self.cache: return self.cache[(x1, x2, y1, y2)]\\n a1 = collections.Counter(s1[x1:x2])\\n b1 = collections.Counter(s2[y1:y2])\\n\\n if a1!=b1:\\n return False\\n \\n if x2 -x1 ==1:\\n return True\\n \\n len_item = x2-x1\\n for i in range(1, x2-x1):\\n a1 = (self.__dfs(s1, s2, x1, x1+i, y1, y1+i ) \\n and self.__dfs (s1, s2, x1+i,x2, y1+i, y2) )\\n # print(\\\"a1\\\", a1)\\n b1 = ((self.__dfs(s1,s2, x1+i, x2, y1, y1+ (y2-y1-i) ) \\n and self.__dfs(s1 , s2, x1, x1+i, y1+ (y2-y1-i) , y2)))\\n \\n \\n if a1 or b1: \\n # self.cache[(x1, x2, y1, y2)] = a1 or b1\\n return a1 or b1\\n # self.cache[(x1, x2, y1, y2)] = False\\n return False\\n\\n\\n \\n\\n \",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n if n != len(s2):\\n return False\\n if n == 1:\\n return s1 == s2\\n \\n @lru_cache(None)\\n def dp(i, j, k):\\n if k == 1:\\n return s1[i] == s2[j]\\n \\n for l in range(1, k):\\n if (dp(i, j, l) and dp(i+l, j+l, k-l)) or \\\\\\n (dp(i, j+k-l, l) and dp(i+l, j, k-l)):\\n return True\\n return False\\n \\n return dp(0, 0, n)\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(i: int, j: int, k: int) -> bool:\\n if k == 1:\\n return s1[i] == s2[j]\\n for h in range(1, k):\\n if dfs(i, j, h) and dfs(i + h, j + h, k - h):\\n return True\\n if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):\\n return True\\n return False\\n\\n return dfs(0, 0, len(s1))\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dp(i1: int, i2: int, l: int) -> bool:\\n if l == 1:\\n return s1[i1] == s2[i2]\\n \\n for new_l in range(1, l):\\n if dp(i1, i2, new_l) and dp(i1 + new_l, i2 + new_l, l - new_l):\\n return True\\n if dp(i1, i2 + l - new_l, new_l) and dp(i1 + new_l, i2, l - new_l):\\n return True\\n return False\\n \\n return dp(0, 0, len(s1))\\n\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(l0, l1, _len):\\n if _len == 1 and s1[l0] != s2[l1]:\\n return False\\n if s1[l0 : l0 + _len] == s2[l1 : l1 + _len]:\\n return True\\n ##\\n for k in range(1, _len):\\n if dfs(l0, l1, k) and dfs(l0 + k, l1 + k, _len - k):\\n return True\\n if dfs(l0, l1 + _len - k, k) and dfs(l0 + k, l1, _len - k):\\n return True\\n ##\\n return False\\n\\n ##\\n return dfs(0, 0, len(s2))\\n\",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nfrom functools import cache\\n\\nclass Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n def _is_candidate(val, target):\\n return Counter(val) == Counter(target)\\n @cache\\n def _fn(a, b):\\n assert len(a) == len(b)\\n\\n l = len(a)\\n if l == 1:\\n return a == b\\n\\n for i in range(1, l):\\n p2, p1 = a[:i], a[i:]\\n t1, t2 = b[:-i], b[-i:]\\n #print(f\\\"swap p1 : {p1} / t1 : {t1} / p2 : {p2} / t2 : {t2} \\\")\\n if _is_candidate(p1, t1) and _is_candidate(p2, t2):\\n \\n out = _fn(p1, t1) and _fn(p2, t2)\\n if out:\\n return True\\n\\n p1, p2 = a[:i], a[i:]\\n t1, t2 = b[:i], b[i:]\\n #print(f\\\"no swap p1 : {p1} / t1 : {t1} / p2 : {p2} / t2 : {t2} \\\")\\n\\n if _is_candidate(p1, t1) and _is_candidate(p2, t2):\\n out = _fn(p1, t1) and _fn(p2, t2)\\n if out:\\n return True\\n\\n return False\\n return _fn(s1, s2)\\n\\n\",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n s1, s2 = list(s1), list(s2)\\n n = len(s1)\\n dp = [[[0] * (n + 1) for _ in range(n) ] for _ in range(n)]\\n\\n def f(l1, l2, length, dp):\\n if length == 1:\\n return s1[l1] == s2[l2]\\n\\n if dp[l1][l2][length] != 0:\\n return dp[l1][l2][length] == 1\\n\\n ans = False\\n for k in range(1, length):\\n # Check non-swapped case\\n if f(l1, l2, k, dp) and f(l1 + k, l2 + k, length - k, dp):\\n ans = True\\n break\\n\\n # Check swapped case\\n if f(l1, l2 + length - k, k, dp) and f(l1 + k, l2, length - k, dp):\\n ans = True\\n break\\n\\n dp[l1][l2][length] = 1 if ans else -1\\n return ans\\n\\n return f(0, 0, n, dp)\\n\\n#The dynamic programming table dp[l1][l2][len] stores results of subproblems of size len. Since the length can vary from 1 to n, the number of possible subproblems is O(n^3) (since l1, l2, and len can each take n values). # For each subproblem, there are O(n) possible splits, and each recursive call involves comparing two strings of size len.\\n# Time Complexity:\\n# The overall time complexity is O(n^4). This comes from iterating over all possible subproblems (O(n^3)) and for each, performing up to O(n) comparisons.\\n \\n\\n# The 3D dynamic programming table dp[l1][l2][len] has dimensions n x n x (n+1), which requires O(n^3) space.\\n# Additionally, the recursion stack may go as deep as O(n) in the worst case.\\n# Space Complexity:\\n# The total space complexity is O(n^3) due to the dynamic programming table. The recursion stack contributes O(n) but is dominated by the table.\\n \\n\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(i: int, j: int, k: int) -> bool:\\n if k == 1:\\n return s1[i] == s2[j]\\n for h in range(1, k):\\n if dfs(i, j, h) and dfs(i + h, j + h, k - h):\\n return True\\n if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):\\n return True\\n return False\\n\\n return dfs(0, 0, len(s1))\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(i: int, j: int, k: int) -> bool:\\n if k == 1:\\n return s1[i] == s2[j]\\n for h in range(1, k):\\n if dfs(i, j, h) and dfs(i + h, j + h, k - h):\\n return True\\n if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):\\n return True\\n return False\\n\\n return dfs(0, 0, len(s1))\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n dp = {}\\n def helper(s, t):\\n if (s, t) in dp:\\n return dp[(s, t)]\\n if Counter(s) != Counter(t):\\n return False\\n if len(s) == 1:\\n return True\\n \\n for i in range(1, len(s)):\\n if (helper(s[:i], t[-i:]) and helper(s[i:], t[:-i])) or (helper(s[i:], t[i:]) and helper(s[:i], t[:i])):\\n dp[(s, t)] = True\\n return True\\n dp[(s, t)] = False\\n return False\\n \\n return helper(s1, s2)\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(i: int, j: int, k: int) -> bool:\\n if k == 1:\\n return s1[i] == s2[j]\\n for h in range(1, k):\\n if dfs(i, j, h) and dfs(i + h, j + h, k - h):\\n return True\\n if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):\\n return True\\n return False\\n\\n return dfs(0, 0, len(s1))\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"map={}\\nclass Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n\\n if sorted(s1) != sorted(s2):\\n return False\\n\\n if s1 == s2:\\n return True\\n\\n if (s1+' '+s2) in map:\\n return map[s1+' '+s2]\\n\\n n = len(s1)\\n flag=False\\n for i in range(1, n):\\n # Check without swapping\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n flag=True\\n # Check with swapping\\n if self.isScramble(s1[:i], s2[-i:]) and self.isScramble(s1[i:], s2[:-i]):\\n flag=True\\n\\n map[s1+' '+s2]=flag\\n return flag\\n\\n\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n\\n N = len(s1)\\n @cache\\n def dp(length,i,j):\\n if i>=N or j>=N: return False\\n if length == 1: return s1[i] == s2[j]\\n\\n for new_len in range(1, length):\\n not_swap = dp(new_len,i,j) and dp(length - new_len, i + new_len, j + new_len)\\n swap = dp(length-new_len, i + new_len, j) and dp(new_len, i, j + (length-new_len))\\n if swap or not_swap: return True\\n \\n return False\\n \\n return dp(len(s1), 0,0)\\n\\n \",\n \"runtime\": \"100\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n\\n @lru_cache(None)\\n def loop(i, j, x, y):\\n if x + 1 == y:\\n return s1[i] == s2[x]\\n\\n size = j - i\\n for k in range(1, size):\\n k_ = size - k\\n if (\\n loop(i, i + k, x, x + k)\\n and loop(i + k, j, x + k, y)\\n or loop(i + k, j, x, x + k_)\\n and loop(i, i + k, x + k_, y)\\n ):\\n return True\\n return False\\n\\n n = len(s1)\\n\\n return loop(0, n, 0, n)\\n\",\n \"runtime\": \"100\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n\\n @cache\\n def canScramble(i1, j1, i2, j2):\\n if i1 > j1:\\n return True\\n if i1 == j1:\\n return s1[i1] == s2[i2]\\n if s1[i1: j1 + 1] == s2[i2: j2 + 1] or s1[i1: j1 + 1] == s2[i2: j2 + 1][::-1]:\\n return True\\n\\n for x in range(i1, j1):\\n y = x - i1 + i2\\n if canScramble(i1, x, i2, y) and canScramble(x + 1, j1, y + 1, j2):\\n return True\\n z = j2 + i1 - x\\n if canScramble(i1, x, z, j2) and canScramble(x + 1, j1, i2, z - 1):\\n return True\\n \\n return False\\n\\n return canScramble(0, len(s1) - 1, 0, len(s2) - 1)\\n\\n \",\n \"runtime\": \"104\"\n },\n {\n \"code\": \"class Solution:\\n def f(self, s, t, i, j, len, memo ):\\n # print(f\\\"checking for {i} {j} {len} \\\")\\n if memo[i][j][len] != None:\\n return memo[i][j][len]\\n \\n if len == 1:\\n memo[i][j][len] = s[i]==t[j]\\n return s[i]==t[j]\\n \\n\\n for k in range(1, len):\\n if self.f(s, t, i, j, k, memo ) and self.f(s,t , i+k, j+k, len-k, memo ):\\n memo[i][j][len] = True\\n return True\\n if self.f(s, t, i, j + len-k, k, memo ) and self.f(s,t, i+k, j, len-k, memo ):\\n memo[i][j][len] = True\\n return True\\n \\n \\n memo[i][j][len] = False\\n return False\\n\\n\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n memo =[ [ [None]*(n+1) for _ in range(n+1) ] for i in range(n+1)]\\n return self.f(s1, s2, 0, 0, n, memo )\",\n \"runtime\": \"104\"\n },\n {\n \"code\": \"import collections\\nclass Solution:\\n\\n cache = {}\\n\\n def equal_counts(self, s1, s2):\\n return collections.Counter(s1) == collections.Counter(s2)\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n elif s1 == s2:\\n return True\\n elif not self.equal_counts(s1, s2):\\n return False\\n elif len(s1) == 0 or len(s1) == 1:\\n return True\\n if s1+s2 in self.cache:\\n return self.cache[s1+s2]\\n\\n for split1 in range(1, len(s1)):\\n for split2 in range(1, len(s2)):\\n left_s1 = s1[:split1]\\n right_s1 = s1[split1:]\\n\\n left_s2 = s2[:split2]\\n right_s2 = s2[split2:]\\n\\n #print(\\\"s1\\\", left_s1, right_s1)\\n #print(\\\"s2\\\", left_s2, right_s2)\\n\\n if self.isScramble(left_s1, left_s2) and self.isScramble(right_s1, right_s2):\\n self.cache[s1+s2] = True\\n return True\\n elif self.isScramble(left_s1, right_s2) and self.isScramble(right_s1, left_s2):\\n self.cache[s1+s2] = True\\n return True\\n\\n self.cache[s1+s2] = False\\n return False\\n\\n \",\n \"runtime\": \"108\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n dp = defaultdict(dict)\\n def helper(l1, r1, l2, r2):\\n if r1 - l1 == 1:\\n return s1[l1:r1] == s2[l2:r2]\\n params = (l1, r1, l2, r2)\\n if params in dp:\\n return dp[params]\\n for xlen in range(1, r1 - l1):\\n if (helper(l1, l1 + xlen, l2, l2 + xlen) and helper(l1 + xlen, r1, l2 + xlen, r2) or\\n helper(l1, l1 + xlen, r2 - xlen, r2) and helper(l1 + xlen, r1, l2, r2 - xlen)):\\n dp[params] = True\\n return True\\n dp[params] = False\\n return False\\n return helper(0, len(s1), 0, len(s2))\",\n \"runtime\": \"108\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n memo = {}\\n def back(s1, s2):\\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n if not set(s1) == set(s2):\\n return False\\n if len(s1) == 1:\\n return True\\n for i in range(1, len(s1)):\\n if back(s1[i:],s2[i:]) and back(s1[:i],s2[:i]) or back(s1[i:],s2[:-i]) and back(s1[:i],s2[-i:]):\\n memo[(s1, s2)] = True\\n return True\\n memo[(s1, s2)] = False\\n return False\\n return back(s1, s2)\",\n \"runtime\": \"112\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n\\n cache = {} # ()\\n\\n def dfs(cur_s, cur_e, tar_s, tar_e):\\n if (cur_s, cur_e, tar_s, tar_e) in cache:\\n return cache[(cur_s, cur_e, tar_s, tar_e)]\\n\\n lenn = cur_e - cur_s \\n \\n is_scramble = False\\n if s1[cur_s:cur_e] == s2[tar_s:tar_e]:\\n is_scramble = True\\n elif lenn == 1 and s1[cur_s:cur_e] != s2[tar_s:tar_e]:\\n is_scramble = False\\n else:\\n # We need to split\\n for i in range(1, lenn):\\n #no-swap\\n if dfs(cur_s, cur_s + i, tar_s, tar_s + i) and dfs(cur_s + i, cur_e, tar_s + i, tar_e):\\n is_scramble = True\\n break\\n #swap\\n if dfs(cur_s, cur_s + i, tar_e - i, tar_e) and dfs(cur_s + i, cur_e, tar_s, tar_e - i):\\n is_scramble = True\\n break\\n\\n cache[(cur_s, cur_e, tar_s, tar_e)] = is_scramble\\n return cache[(cur_s, cur_e, tar_s, tar_e)]\\n\\n return dfs(0, len(s1), 0, len(s2))\",\n \"runtime\": \"112\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n \\n if s1 == s2:\\n return True\\n \\n if sorted(s1) != sorted(s2):\\n return False\\n memo = {}\\n def scramble(i1,i2,length):\\n if length == 1:\\n return s1[i1] == s2[i2]\\n \\n if (i1,i2,length) in memo:\\n return memo[(i1,i2,length)]\\n res = False\\n for i in range(1,length):\\n # No Swap\\n \\n # Swap\\n if (scramble(i1,i2,i) and scramble(i1+i,i2+i,length - i)) or \\\\\\n (scramble(i1,i2+length - i,i) and scramble(i1+i,i2,length-i)):\\n res = True\\n break\\n memo[(i1,i2,length)] = res\\n return res\\n \\n return scramble(0,0,len(s1))\",\n \"runtime\": \"116\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n cache: dict[tuple[int, int]: bool] = {}\\n\\n def dp(left1: int, right1: int, left2: int, right2: int) -> bool:\\n if left1 == right1:\\n return s1[left1] == s2[left2]\\n key: tuple[int, int, int, int] = (left1, right1, left2, right2)\\n if key in cache:\\n return cache[key]\\n cache[key] = False\\n for i in range(right1 - left1):\\n cache[key] = (cache[key] or (\\n dp(left1, left1 + i, left2, left2 + i) and dp(left1 + i + 1, right1, left2 + i + 1, right2)\\n ) or (\\n dp(left1, left1 + i, right2 - i, right2) and dp(left1 + i + 1, right1, left2, right2 - i - 1)\\n ))\\n return cache[key]\\n \\n\\n\\n return dp(0, len(s1) -1 , 0, len(s2) - 1)\",\n \"runtime\": \"116\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n \\n if s1 == s2:\\n return True\\n \\n if sorted(s1) != sorted(s2):\\n return False\\n memo = {}\\n def scramble(i1,i2,length):\\n if length == 1:\\n return s1[i1] == s2[i2]\\n \\n if (i1,i2,length) in memo:\\n return memo[(i1,i2,length)]\\n res = False\\n for i in range(1,length):\\n # No Swap\\n \\n # Swap\\n if (scramble(i1,i2,i) and scramble(i1+i,i2+i,length - i)) or \\\\\\n (scramble(i1,i2+length - i,i) and scramble(i1+i,i2,length-i)):\\n res = True\\n break\\n memo[(i1,i2,length)] = res\\n return res\\n \\n return scramble(0,0,len(s1))\",\n \"runtime\": \"120\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # Memomiazation \\n # O(n^4) time, O(n^3) space\\n if len(s1) != len(s2):\\n return False\\n \\n n = len(s1)\\n\\n # (ls1, ls2, sslen). ls1 is starting index in s1. ls2 is starting index in s2, sslen is substring length we are testing.\\n # where memo[(ls1, ls2, sslen)] = isScramble(s1[ls1..ls1+sslen-1], s2[ls2..ls2+sslen-1])\\n memo = {}\\n\\n def recurse_is_scramble(ls1, ls2, sslen):\\n if (ls1, ls2, sslen) in memo:\\n return memo[(ls1, ls2, sslen)]\\n if sslen == 1:\\n memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\\n return memo[(ls1, ls2, sslen)]\\n \\n for xlen in range(1, sslen):\\n ylen = sslen - xlen\\n # x + y\\n res = recurse_is_scramble(ls1, ls2, xlen) and recurse_is_scramble(ls1 + xlen, ls2 + xlen, ylen)\\n if not res:\\n # y + x\\n res = res or (recurse_is_scramble(ls1 + xlen, ls2, ylen) and recurse_is_scramble(ls1, ls2 + ylen, xlen))\\n if res:\\n memo[(ls1, ls2, sslen)] = True\\n return True\\n\\n memo[(ls1, ls2, sslen)] = False\\n return False\\n \\n return recurse_is_scramble(0, 0, n)\\n\\n # # DP iterative solution (still O(n^4) time, O(n^3) space). Start with smaller length to guarantee subproblems are solved\\n # memo = {}\\n # n = len(s1)\\n\\n # for sslen in range(1, n + 1):\\n # for ls1 in range(n - sslen + 1):\\n # for ls2 in range(n - sslen + 1):\\n # if sslen == 1:\\n # memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\\n # continue\\n\\n # res = False\\n # for xlen in range(1, sslen):\\n # ylen = sslen - xlen\\n # # x + y\\n # res = memo[(ls1, ls2, xlen)] and memo[(ls1 + xlen, ls2 + xlen, ylen)]\\n # if not res:\\n # # y + x\\n # res = res or (memo[(ls1 + xlen, ls2, ylen)] and memo[(ls1, ls2 + ylen, xlen)])\\n # if res:\\n # memo[(ls1, ls2, sslen)] = True\\n # break\\n # if not res:\\n # memo[(ls1, ls2, sslen)] = False\\n\\n # return memo[(0, 0, n)]\",\n \"runtime\": \"120\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n \\n n = len(s1)\\n\\n # (ls1, ls2, sslen). ls1 is starting index in s1. ls2 is starting index in s2, sslen is substring length we are testing.\\n # where memo[(ls1, ls2, sslen)] = isScramble(s1[ls1..ls1+sslen-1], s2[ls2..ls2+sslen-1])\\n memo = {}\\n\\n def recurse_is_scramble(ls1, ls2, sslen):\\n if (ls1, ls2, sslen) in memo:\\n return memo[(ls1, ls2, sslen)]\\n if sslen == 1:\\n memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\\n return memo[(ls1, ls2, sslen)]\\n \\n for xlen in range(1, sslen):\\n ylen = sslen - xlen\\n # x + y\\n res = recurse_is_scramble(ls1, ls2, xlen) and recurse_is_scramble(ls1 + xlen, ls2 + xlen, ylen)\\n if not res:\\n # y + x\\n res = res or (recurse_is_scramble(ls1 + xlen, ls2, ylen) and recurse_is_scramble(ls1, ls2 + ylen, xlen))\\n if res:\\n memo[(ls1, ls2, sslen)] = True\\n return True\\n\\n memo[(ls1, ls2, sslen)] = False\\n return False\\n \\n return recurse_is_scramble(0, 0, n)\\n\\n # # wip iterative\\n # memo = {}\\n # n = len(s1)\\n\\n # for sslen in range(n + 1):\\n # for ls1 in range(n):\\n # for ls2 in range(n):\\n # # print(\\\"ls1, ls2, sslen\\\", ls1, ls2, sslen)\\n # if sslen == 1:\\n # memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\\n # continue\\n\\n # for xlen in range(1, sslen):\\n # ylen = sslen - xlen\\n # # x + y\\n # res = memo[(ls1, ls2, xlen)] and memo[(ls1 + xlen, ls2 + xlen, ylen)]\\n # if not res:\\n # # y + x\\n # res = res or (memo[(ls1 + xlen, ls2, ylen)] and memo[(ls1, ls2 + ylen, xlen)])\\n # if res:\\n # memo[(ls1, ls2, sslen)] = True\\n # break\\n # memo[(ls1, ls2, sslen)] = False\\n\\n # return memo[(0, 0, n)]\",\n \"runtime\": \"124\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # Memomiazation \\n # O(n^4) time, O(n^3) space\\n if len(s1) != len(s2):\\n return False\\n \\n n = len(s1)\\n\\n # (ls1, ls2, sslen). ls1 is starting index in s1. ls2 is starting index in s2, sslen is substring length we are testing.\\n # where memo[(ls1, ls2, sslen)] = isScramble(s1[ls1..ls1+sslen-1], s2[ls2..ls2+sslen-1])\\n memo = {}\\n\\n def recurse_is_scramble(ls1, ls2, sslen):\\n if (ls1, ls2, sslen) in memo:\\n return memo[(ls1, ls2, sslen)]\\n if sslen == 1:\\n memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\\n return memo[(ls1, ls2, sslen)]\\n \\n for xlen in range(1, sslen):\\n ylen = sslen - xlen\\n # x + y\\n res = recurse_is_scramble(ls1, ls2, xlen) and recurse_is_scramble(ls1 + xlen, ls2 + xlen, ylen)\\n if not res:\\n # y + x\\n res = res or (recurse_is_scramble(ls1 + xlen, ls2, ylen) and recurse_is_scramble(ls1, ls2 + ylen, xlen))\\n if res:\\n memo[(ls1, ls2, sslen)] = True\\n return True\\n\\n memo[(ls1, ls2, sslen)] = False\\n return False\\n \\n return recurse_is_scramble(0, 0, n)\\n\\n # # Iterative solution (still O(n^4) time, O(n^3) space). Start with smaller length to guarantee subproblems are solved\\n # memo = {}\\n # n = len(s1)\\n\\n # for sslen in range(1, n + 1):\\n # for ls1 in range(n - sslen + 1):\\n # for ls2 in range(n - sslen + 1):\\n # if sslen == 1:\\n # memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\\n # continue\\n\\n # res = False\\n # for xlen in range(1, sslen):\\n # ylen = sslen - xlen\\n # # x + y\\n # res = memo[(ls1, ls2, xlen)] and memo[(ls1 + xlen, ls2 + xlen, ylen)]\\n # if not res:\\n # # y + x\\n # res = res or (memo[(ls1 + xlen, ls2, ylen)] and memo[(ls1, ls2 + ylen, xlen)])\\n # if res:\\n # memo[(ls1, ls2, sslen)] = True\\n # break\\n # if not res:\\n # memo[(ls1, ls2, sslen)] = False\\n\\n # return memo[(0, 0, n)]\",\n \"runtime\": \"124\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dp(i, j, k, l):\\n print(i, j, k, l)\\n if s1[i:j+1] == s2[k:l+1]:\\n return True\\n\\n for mid in range(i, j):\\n if dp(i, mid, k, k+(mid-i)) and dp(mid+1, j, k+(mid-i)+1, l):\\n return True\\n if dp(i, mid, l-(mid-i), l) and dp(mid+1, j, k, l-(mid-i)-1):\\n return True\\n\\n return False\\n\\n n = len(s1)\\n return dp(0, n-1, 0, n-1)\",\n \"runtime\": \"128\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dp(s1: str, s2: str) -> bool:\\n if s1 == s2: return True\\n\\n for i in range(1, len(s1)):\\n if (dp(s1[:i], s2[:i]) and dp(s1[i:], s2[i:])) or \\\\\\n (dp(s1[:i], s2[-i:]) and dp(s1[i:], s2[:-i])): return True\\n return False\\n\\n return dp(s1,s2)\",\n \"runtime\": \"128\"\n },\n {\n \"code\": \"class Solution:\\n @lru_cache(None)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n\\n l = len(s1)\\n\\n for i in range(1, l):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n return True\\n if self.isScramble(s1[:i], s2[l-i:]) and self.isScramble(s1[i:], s2[:l-i]):\\n return True\\n return False\",\n \"runtime\": \"132\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(s1, s2):\\n if s1 == s2:\\n return True\\n \\n for i in range(1 , len(s1)):\\n if dfs(s1[ : i], s2[ : i]) and dfs(s1[i : ], s2[i : ]):\\n return True\\n if dfs(s1[ : i], s2[-i : ]) and dfs(s1[i : ], s2[ : -i]):\\n return True\\n \\n return False\\n\\n return dfs(s1, s2)\",\n \"runtime\": \"132\"\n },\n {\n \"code\": \"class Solution(object):\\n def isScramble(self, s1, s2):\\n \\\"\\\"\\\"\\n :type s1: str\\n :type s2: str\\n :rtype: bool\\n \\\"\\\"\\\"\\n @cache\\n def dp(s1: str, s2: str) -> bool:\\n if s1 == s2: return True\\n\\n for i in range(1, len(s1)):\\n if (dp(s1[:i], s2[:i]) and dp(s1[i:], s2[i:])) or \\\\\\n (dp(s1[:i], s2[-i:]) and dp(s1[i:], s2[:-i])): return True\\n return False\\n\\n return dp(s1,s2)\\n \\n \\n\\n\\n \\n\\n \\n\\n \",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n dp = {}; n = len(s1)\\n def solve(i1,j1,i2,j2):\\n if i1>=j1: return True\\n state = (i1,j1,i2,j2)\\n if state not in dp:\\n dp[state] = False\\n if s1[i1:j1]==s2[i2:j2]:\\n dp[state] = True\\n else:\\n for split in range(i1+1,j1):\\n d1 = split-i1\\n d2 = j1-split\\n if solve(i1,i1+d1,i2,i2+d1) and solve(j1-d2,j1,j2-d2,j2):\\n dp[state] = True; break\\n if solve(j1-d2,j1,i2,i2+d2) and solve(i1,i1+d1,j2-d1,j2):\\n dp[state] = True; break\\n return dp[state]\\n return solve(0,n,0,n)\\n\\n\\n \",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(s1, s2): # a b a b a b b a\\n if s1 == s2: # / \\\\ / \\\\ / \\\\ / \\\\\\n return True # a a b b a a b b\\n \\n for i in range(1 , len(s1)):\\n if dfs(s1[ : i], s2[ : i]) and dfs(s1[i : ], s2[i : ]):\\n return True\\n if dfs(s1[ : i], s2[-i : ]) and dfs(s1[i : ], s2[ : -i]):\\n return True\\n \\n return False\\n\\n return dfs(s1, s2)\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n return self.scramble(s1, s2)\\n \\n @cache\\n def scramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n if len(s1) != len(s2):\\n return False\\n \\n for i in range(1, len(s1)):\\n s11 = s1[:i]\\n s12 = s1[i:]\\n s21 = s2[:i]\\n s22 = s2[i:]\\n\\n if self.scramble(s11, s21) and self.scramble(s12, s22):\\n return True\\n if self.scramble(s11, s2[len(s1) - i:]) and self.scramble(s12, s2[:len(s1) - i]):\\n return True\\n\\n return False\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n\\n cache = {} # ()\\n\\n def dfs(current, target):\\n if (current, target) in cache:\\n return cache[(current, target)]\\n\\n is_scramble = False\\n # print(current, target)\\n if current == target:\\n is_scramble = True\\n elif len(current) == 1 and current != target:\\n is_scramble = False\\n else:\\n # We need to split\\n for i in range(1, len(current)):\\n front = current[0: i]\\n back = current[i:]\\n\\n #no-swap\\n if dfs(front, target[0: i]) and dfs(back, target[i:]):\\n is_scramble = True\\n break\\n end = len(current) - i\\n if dfs(front, target[end:]) and dfs(back, target[0: end]):\\n is_scramble = True\\n break\\n\\n cache[(current, target)] = is_scramble\\n return cache[(current, target)]\\n\\n return dfs(s1, s2)\",\n \"runtime\": \"144\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n dp = {}\\n def rec(sub1, sub2):\\n if sub1==sub2:\\n return True\\n if len(sub1)<=1:\\n return False\\n key = sub1 + '_' + sub2\\n val = dp.get(key, -1)\\n if val!=-1:\\n return val\\n flag = False\\n n1, n2 = len(sub1), len(sub2)\\n for k in range(1, len(sub1)):\\n cond_1 = rec(sub1[:k], sub2[-k:]) and rec(sub1[k:], sub2[:-k])\\n cond_2 = rec(sub1[:k], sub2[:k]) and rec(sub1[k:], sub2[k:])\\n if cond_1 or cond_2:\\n dp[key] = True\\n return dp[key]\\n dp[key] = flag\\n return dp[key]\\n return rec(s1, s2)\",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"class Solution:\\n # def isScramble(self, s1: str, s2: str) -> bool:\\n # s1, s2 = list(s1), list(s2)\\n # n = len(s1)\\n # dp = [[[0] * (n + 1) for _ in range(n)] for _ in range(n)]\\n\\n # def f(l1, l2, length):\\n # if length == 1:\\n # return s1[l1] == s2[l2]\\n \\n # if dp[l1][l2][length] != 0:\\n # return dp[l1][l2][length] == 1\\n\\n # ans = False\\n\\n # for k in range(1, length):\\n # # no swap\\n # if f(l1, l2, k) and f(l1 + k, l2 + k, length - k):\\n # ans = True\\n # break\\n\\n # #swap\\n # if f(l1, l2 + length - k, k) and f(l1 + k, l2, length - k):\\n # ans = True\\n # break\\n\\n # dp[l1][l2][length] = 1 if ans else -1\\n\\n # return ans\\n\\n # return f(0, 0, n)\\n\\n#The dynamic programming table dp[l1][l2][len] stores results of subproblems of size len. Since the length can vary from 1 to n, the number of possible subproblems is O(n^3) (since l1, l2, and len can each take n values). # For each subproblem, there are O(n) possible splits, and each recursive call involves comparing two strings of size len.\\n# Time Complexity:\\n# The overall time complexity is O(n^4). This comes from iterating over all possible subproblems (O(n^3)) and for each, performing up to O(n) comparisons.\\n \\n\\n# The 3D dynamic programming table dp[l1][l2][len] has dimensions n x n x (n+1), which requires O(n^3) space.\\n# Additionally, the recursion stack may go as deep as O(n) in the worst case.\\n# Space Complexity:\\n# The total space complexity is O(n^3) due to the dynamic programming table. The recursion stack contributes O(n) but is dominated by the table.\\n \\n def isScramble(self, s1: str, s2: str) -> bool:\\n s1, s2 = list(s1), list(s2)\\n n = len(s1)\\n dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]\\n\\n for l1 in range(n):\\n for l2 in range(n):\\n dp[l1][l2][1] = s1[l1] == s2[l2]\\n\\n for length in range(2, n + 1):\\n for l1 in range(n - length + 1):\\n for l2 in range(n - length + 1):\\n for k in range(1, length):\\n if dp[l1][l2][k] and dp[l1 + k][l2 + k][length - k]:\\n dp[l1][l2][length] = True\\n break\\n\\n if dp[l1 + k][l2][length - k] and dp[l1][l2 + length - k][k]:\\n dp[l1][l2][length] = True\\n break\\n return dp[0][0][n]\\n\\n#dp[l1][l2][length] == True means that the substring s1[l1:l1+length] is a scrambled version of the substring s2[l2:l2+length]\\n#Non-Swapped Case: If the first part of s1 (s1[l1:l1+k]) matches the first part of s2 (s2[l2:l2+k]), and the second part of s1 matches the second part of s2 (s1[l1+k:l1+length] == s2[l2+k:l2+length]).\\n#Swapped Case: If the first part of s1 matches the second part of s2 (s1[l1:l1+k] == s2[l2+length-k:l2+length]), and the second part of s1 matches the first part of s2 (s1[l1+k:l1+length] == s2[l2:l2+length-k])\",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n \\n # Create 3D DP array\\n dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]\\n \\n # Initialize DP for single characters\\n for i in range(n):\\n for j in range(n):\\n dp[i][j][1] = (s1[i] == s2[j])\\n \\n # Fill DP array for substrings of length 2 to n\\n for length in range(2, n + 1): # length ranges from 2 to n\\n for i in range(n - length + 1): # starting index in s1\\n for j in range(n - length + 1): # starting index in s2\\n for k in range(1, length): \\n if (dp[i][j][k] and dp[i + k][j + k][length - k]) or \\\\\\n (dp[i][j + length - k][k] and dp[i + k][j][length - k]):\\n dp[i][j][length] = True\\n break\\n \\n return dp[0][0][n]\\n \",\n \"runtime\": \"156\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1)!=len(s2):\\n return False\\n\\n def solve(s1,s2, memo):\\n if s1==s2:\\n return True\\n if memo[s1][s2]!=-1:\\n return memo[s1][s2]\\n \\n n=len(s1)\\n for k in range(1,n):\\n if (solve(s1[:k],s2[n-k:],memo) and solve(s1[k:],s2[:n-k],memo)) or (solve(s1[:k],s2[:k],memo) and solve(s1[k:],s2[k:],memo)):\\n memo[s1][s2] = True\\n return True\\n break\\n memo[s1][s2] = False\\n return False\\n\\n return solve(s1,s2,memo=defaultdict(lambda:defaultdict(lambda:-1)))\\n \",\n \"runtime\": \"156\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n \\n # Create a 3D DP table to store the results of subproblems\\n # dp[i][j][k] will be True if s1[i:i+k] is a scramble of s2[j:j+k]\\n dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]\\n \\n # Initialize the base case where k = 1 (single character)\\n for i in range(n):\\n for j in range(n):\\n dp[i][j][1] = s1[i] == s2[j]\\n \\n # Fill the DP table for k > 1\\n for k in range(2, n + 1):\\n for i in range(n - k + 1):\\n for j in range(n - k + 1):\\n for l in range(1, k):\\n if (dp[i][j][l] and dp[i + l][j + l][k - l]) or (dp[i][j + k - l][l] and dp[i + l][j][k - l]):\\n dp[i][j][k] = True\\n break\\n \\n return dp[0][0][n]\\n\\n# Example usage:\\nsolution = Solution()\\ns1 = \\\"great\\\"\\ns2 = \\\"rgeat\\\"\\nprint(solution.isScramble(s1, s2)) # Output: True\",\n \"runtime\": \"160\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def is_scramble(a, b):\\n if a == b:\\n return True\\n\\n if len(a) == 1:\\n return False\\n \\n for i in range(1, len(a)):\\n a1, a2 = a[:i], a[i:]\\n b1, b2 = b[:i], b[i:]\\n if is_scramble(a1, b1) and is_scramble(a2, b2):\\n return True\\n \\n b1, b2 = b[:len(a2)], b[len(a2):]\\n if is_scramble(a2, b1) and is_scramble(a1, b2):\\n return True\\n\\n return False\\n \\n return is_scramble(s1, s2)\\n\",\n \"runtime\": \"160\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n N = len(s1)\\n \\n # F[i][j][len] will be True if s1[i:i+len] is a scramble of s2[j:j+len]\\n F = [[[False] * (N + 1) for _ in range(N)] for _ in range(N)]\\n \\n # Base case: when len == 1, check if characters are equal\\n for length in range(1, N + 1):\\n for i in range(N - length + 1):\\n for j in range(N - length + 1):\\n if length == 1:\\n F[i][j][length] = s1[i] == s2[j]\\n else:\\n for q in range(1, length):\\n if (F[i][j][q] and F[i + q][j + q][length - q]) or (F[i][j + length - q][q] and F[i + q][j][length - q]):\\n F[i][j][length] = True\\n break\\n \\n return F[0][0][N]\\n\\n \\n\\n \\n \",\n \"runtime\": \"164\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n\\n n = len(s1)\\n matrix = [[[False for _ in range(n)] for _ in range(n)] for _ in range(n + 1)]\\n\\n for i in range(n):\\n for j in range(n):\\n if s1[i] == s2[j]:\\n matrix[1][i][j] = True\\n\\n for l in range(2, n+1):\\n for i in range(n + 1 - l):\\n for j in range(n + 1 - l):\\n for nl in range(1, l):\\n if (matrix[nl][i][j] and matrix[l-nl][i+nl][j+nl]) or \\\\\\n (matrix[nl][i][j+l-nl] and matrix[l-nl][i+nl][j]):\\n matrix[l][i][j] = True\\n return matrix[n][0][0]\\n \",\n \"runtime\": \"164\"\n },\n {\n \"code\": \"class Solution(object):\\n def isScramble(self, s1, s2):\\n \\\"\\\"\\\"\\n :type s1: str\\n :type s2: str\\n :rtype: bool\\n \\\"\\\"\\\"\\n # Base cases\\n\\n n = len(s1)\\n\\n # If both strings are not equal in size\\n if len(s2) != n:\\n return False\\n\\n # If both strings are equal\\n if s1 == s2:\\n return True\\n\\n # If code is reached to this condition then following this are sure:\\n # 1. size of both string is equal\\n # 2. string are not equal\\n # so size is equal (where size==1) and they are not equal then obviously false\\n # example 'a' and 'b' size is equal, string are not equal\\n if n == 1:\\n return False\\n\\n key = s1 + \\\" \\\" + s2\\n\\n # Check if this problem has already been solved\\n if key in self.mp:\\n return self.mp[key]\\n\\n # For every iteration it can two condition\\n # 1. We should proceed without swapping\\n # 2. We should swap before looking next\\n for i in range(1, n):\\n # ex of without swap: gr|eat and rg|eat\\n without_swap = (\\n # Left part of first and second string\\n self.isScramble(s1[:i], s2[:i])\\n and\\n # Right part of first and second string;\\n self.isScramble(s1[i:], s2[i:])\\n )\\n\\n # If without swap gives us the right answer then we do not need\\n # to call the recursion with swap\\n if without_swap:\\n return True\\n\\n # ex of with swap: gr|eat rge|at\\n # here we compare \\\"gr\\\" with \\\"at\\\" and \\\"eat\\\" with \\\"rge\\\"\\n with_swap = (\\n # Left part of first and right part of second\\n self.isScramble(s1[:i], s2[n-i:])\\n and\\n # Right part of first and left part of second\\n self.isScramble(s1[i:], s2[:n-i])\\n )\\n\\n # If with swap gives us the right answer then we return True\\n # otherwise, the for loop does its work\\n if with_swap:\\n return True\\n\\n self.mp[key] = False\\n return False\\n\\n # for storing already solved problems\\n mp = {}\",\n \"runtime\": \"168\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n if n != len(s2):\\n return False\\n\\n dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]\\n\\n for i in range(n):\\n for j in range(n):\\n dp[i][j][1] = s1[i] == s2[j]\\n\\n for length in range(2, n + 1): # Length of the substring\\n for i in range(n - length + 1):\\n for j in range(n - length + 1):\\n for k in range(1, length): # Split point\\n if (dp[i][j][k] and dp[i + k][j + k][length - k]) or \\\\\\n (dp[i][j + length - k][k] and dp[i + k][j][length - k]):\\n dp[i][j][length] = True\\n break\\n\\n return dp[0][0][n]\",\n \"runtime\": \"168\"\n },\n {\n \"code\": \"class Solution(object):\\n def isScramble(self, s1, s2):\\n \\\"\\\"\\\"\\n :type s1: str\\n :type s2: str\\n :rtype: bool\\n \\\"\\\"\\\"\\n n = len(s1)\\n if len(s2) != n:\\n return False\\n if s1 == s2:\\n return True\\n if n == 1:\\n return False\\n\\n key = s1 + \\\" \\\" + s2\\n if key in self.mp:\\n return self.mp[key]\\n for i in range(1, n):\\n without_swap = (\\n self.isScramble(s1[:i], s2[:i])\\n and\\n self.isScramble(s1[i:], s2[i:])\\n )\\n if without_swap:\\n return True\\n with_swap = (\\n self.isScramble(s1[:i], s2[n-i:])\\n and\\n self.isScramble(s1[i:], s2[:n-i])\\n )\\n if with_swap:\\n return True\\n\\n self.mp[key] = False\\n return False\\n mp = {}\",\n \"runtime\": \"172\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s: str, t: str) -> bool:\\n memo={}\\n if len(s) != len(t):\\n return False\\n \\n\\n if s == t:\\n return True\\n \\n def solve(s, t):\\n n = len(s)\\n\\n if s == t:\\n memo[(s,t)] = True\\n return True\\n if (s,t) in memo:\\n return memo[(s,t)]\\n for j in range(1, n):\\n # Case 1: No swap\\n if solve(s[:j], t[:j]) and solve(s[j:], t[j:]):\\n memo[(s,t)] = True\\n return True\\n # Case 2: Swap\\n if solve(s[:j], t[-j:]) and solve(s[j:], t[:-j]):\\n memo[(s,t)] = True\\n return True\\n memo[(s,t)] = False\\n return False\\n return solve(s, t)\\n\",\n \"runtime\": \"172\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n memo = defaultdict(bool)\\n def helper(a, b):\\n nonlocal memo\\n if (a, b) in memo:\\n return memo[(a, b)]\\n if len(a) != len(b):\\n memo[(a, b)] = False\\n return False\\n if a == b:\\n memo[(a, b)] = True\\n return True\\n if len(a) <= 1:\\n memo[(a, b)] = False\\n return False\\n n = len(a)\\n for i in range(1, n):\\n c1 = (helper(a[0:i], b[n-i:n]) and helper(a[i:n], b[0:n-i]))\\n c2 = (helper(a[0:i], b[0:i]) and helper(a[i:n], b[i:n]))\\n if (c1 or c2):\\n memo[(a, b)] = True\\n return True\\n memo[(a, b)] = False\\n return False\\n return helper(s1, s2)\\n\",\n \"runtime\": \"176\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # base case: if s1 == s2 or if some split in s1 and swap == s2: return True\\n \\n def solve(s1, s2, memo):\\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n \\n elif s1 == s2:\\n memo[(s1, s2)] = True\\n return True\\n \\n memo[(s1, s2)] = False\\n n = len(s1)\\n # case 1: split at 2, s1 = gr / eat, s2 = rg / eat\\n for i in range(1, n):\\n\\n memo[(s1, s2)] = memo[(s1, s2)] or solve(s1[:i], s2[:i], memo) and solve(s1[i:], s2[i:], memo) or solve(s1[:i], s2[n-i:], memo) and solve(s1[i:], s2[:n-i], memo)\\n \\n return memo[(s1, s2)]\\n\\n return solve(s1, s2, {})\",\n \"runtime\": \"176\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n dp = []\\n for i in range(len(s1)):\\n dp.append([0]*len(s1))\\n for j in range(len(s1)):\\n dp[i][j] = [False]*len(s1)\\n\\n\\n def validate(start, start2, m):\\n for i in range(m):\\n if dp[start][start + i][start2] and dp[start + i + 1][start + m][start2 + i + 1]:\\n return True\\n \\n if dp[start][start + i][start2 + m - i] and dp[start + i + 1][start + m][start2]:\\n return True\\n \\n return False\\n\\n for m in range(len(s1)):\\n for start1 in range(len(s1) - m):\\n for start2 in range(len(s2) - m):\\n if m == 0:\\n if s1[start1] == s2[start2]:\\n dp[start1][start1 + m][start2] = True\\n \\n if validate(start1, start2, m):\\n dp[start1][start1 + m][start2] = True\\n return dp[0][len(s1) - 1][0]\\n \\n\\n\\n\\n\",\n \"runtime\": \"180\"\n },\n {\n \"code\": \"class Solution(object):\\n def isScramble(self, s1, s2):\\n n = len(s1)\\n if len(s2) != n: return False\\n if s1 == s2: return True\\n if n == 1: return False\\n key = s1 + \\\" \\\" + s2\\n if key in self.mp: return self.mp[key]\\n for i in range(1, n):\\n WOS = (self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]))\\n if WOS: return True\\n WS = (self.isScramble(s1[:i], s2[n-i:]) and self.isScramble(s1[i:], s2[:n-i]))\\n if WS: return True\\n self.mp[key] = False\\n return False\\n mp = {}\",\n \"runtime\": \"180\"\n },\n {\n \"code\": \"class Solution:\\n def f(self, s1, s2):\\n \\n if s1 == s2:\\n self.cache[(s1, s2)] = True\\n return True\\n\\n if len(s1) == 1 and len(s2) == 1:\\n self.cache[(s1, s2)] = (s1 == s2)\\n return s1 == s2\\n\\n if (s1, s2) in self.cache:\\n return self.cache[(s1, s2)]\\n\\n N = len(s1)\\n \\n for i in range(1, N):\\n p1 = s1[:i]\\n p2 = s1[i:]\\n q1 = s2[:i]\\n q2 = s2[i:]\\n if self.f(p1, q1) and self.f(p2, q2):\\n self.cache[(s1, s2)] = True\\n print(s1, s2)\\n return True\\n \\n q1 = s2[:N - i]\\n q2 = s2[N - i:]\\n if self.f(p1, q2) and self.f(p2, q1):\\n self.cache[(s1, s2)] = True\\n return True\\n \\n\\n \\n self.cache[(s1, s2)] = False\\n\\n return self.cache[(s1, s2)]\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n self.cache = {}\\n return self.f(s1, s2)\\n \",\n \"runtime\": \"184\"\n },\n {\n \"code\": \"class Solution:\\n def rec(self, s1, s2, memo):\\n # I didn't even optimize the solution and it passes\\n if s1 == s2:\\n return True\\n if len(s1) <= 1 and len(s2) <= 1 and s1 != s2:\\n return False\\n key = (\\\"\\\".join(s1), \\\"\\\".join(s2))\\n if key in memo:\\n return memo[key]\\n \\n isPassed = False\\n\\n for i in range(len(s1)-1):\\n if isPassed:\\n break\\n sub11 = s1[:i+1]\\n sub12 = s1[i+1:]\\n for j in range(len(s2)-1):\\n sub21 = s2[:j+1]\\n sub22 = s2[j+1:]\\n \\n if (sorted(sub11) == sorted(sub21) and sorted(sub12) == sorted(sub22)):\\n ans1 = self.rec(sub11, sub21, memo)\\n ans2 = self.rec(sub12, sub22, memo)\\n if ans1 and ans2:\\n isPassed = True\\n break\\n if (sorted(sub11) == sorted(sub22) and sorted(sub12) == sorted(sub21)):\\n ans1 = self.rec(sub11, sub22, memo)\\n ans2 = self.rec(sub12, sub21, memo)\\n if ans1 and ans2:\\n isPassed = True\\n break\\n memo[key] = isPassed\\n\\n return isPassed\\n \\n def isScramble(self, s1: str, s2: str) -> bool:\\n memo = dict()\\n return self.rec(s1, s2, memo)\",\n \"runtime\": \"184\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n\\n visitedDict = {}\\n def check(src,tar):\\n # print(src, tar)\\n if(src == tar):\\n return 1\\n if(len(src) == 1):\\n return 0\\n\\n if((src, tar) in visitedDict):\\n return visitedDict[(src, tar)]\\n\\n for i in range(1,len(src)):\\n # if(len(src) == len(s1)):\\n # print(src[:i], tar[:i], src[i:], tar[i:])\\n if(src[i:] + src[:i] == tar):\\n visitedDict[(src, tar)] = 1\\n return 1\\n leftSrcLeftTar = check(src[:i], tar[:i])\\n if(not leftSrcLeftTar):\\n leftSrcRightTar = check(src[:i], tar[len(src)-i:])\\n if(not leftSrcRightTar):\\n continue\\n rightSrcLeftTar = check(src[i:], tar[:len(src)-i:])\\n if(leftSrcRightTar & rightSrcLeftTar):\\n visitedDict[(src, tar)] = 1\\n return 1\\n continue\\n rightSrcRightTar = check(src[i:], tar[i:])\\n if(not rightSrcRightTar):\\n continue\\n if(leftSrcLeftTar & rightSrcRightTar):\\n visitedDict[(src, tar)] = 1\\n return 1\\n visitedDict[(src, tar)] = 0\\n return 0\\n\\n ans = check(s1,s2)\\n return ans\\n\\n \",\n \"runtime\": \"188\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1)!=len(s2):\\n return False\\n if len(s1)==0 and len(s2)==0:\\n return True\\n d={}\\n def helper(s1,s2):\\n if s1==s2:\\n return True\\n if len(s1)<=1:\\n return False\\n if (s1,s2) in d:\\n return d[(s1,s2)]\\n flag=False\\n for i in range(1,len(s1)):\\n case1 = (helper(s1[0:i], s2[0:i]) and helper(s1[i:], s2[i:]))\\n case2 = (helper(s1[0:i], s2[-i:]) and helper(s1[i:], s2[0:-i]))\\n if (case1 or case2):\\n flag=True\\n break\\n d[(s1,s2)]=flag\\n return d[(s1,s2)]\\n return helper(s1,s2)\\n\\n \",\n \"runtime\": \"188\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n\\n n = len(s1)\\n dp = [[[False] * n for _ in range(n)] for _ in range(n)]\\n\\n for i in range(n):\\n for j in range(n):\\n dp[0][i][j] = s1[i] == s2[j]\\n\\n for length in range(2, n + 1):\\n for i in range(n - length + 1):\\n for j in range(n - length + 1):\\n for k in range(1, length):\\n if (dp[k - 1][i][j] and dp[length - k - 1][i + k][j + k]) or \\\\\\n (dp[k - 1][i][j + length - k] and dp[length - k - 1][i + k][j]):\\n dp[length - 1][i][j] = True\\n\\n return dp[n - 1][0][0]\\n\",\n \"runtime\": \"192\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n if len(s1) == 1:\\n return False\\n\\n cache = {}\\n def helper(s1, s2):\\n if s1 == s2:\\n return True\\n if len(s1) == 1:\\n return False\\n if s1+s2 in cache:\\n return cache[s1+s2]\\n\\n for i in range(1, len(s1)):\\n if (helper(s1[:i], s2[:i]) and helper(s1[i:], s2[i:])) or (helper(s1[len(s1) - i:], s2[:i]) and helper(s1[:len(s1) - i], s2[i:])):\\n cache[s1+s2] = True\\n return True\\n cache[s1+s2] = False\\n return False\\n return helper(s1, s2)\\n\\n \",\n \"runtime\": \"196\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2) or sorted(s1) != sorted(s2):\\n return False\\n if len(s1) == 1:\\n return s1 == s2\\n \\n n = len(s1)\\n dp = [[[False] * (n + 1) for _ in range(n)] for __ in range(n)]\\n for i in range(n):\\n for j in range(n):\\n if s1[i] == s2[j]:\\n dp[i][j][1] = True\\n \\n for l in range(2, n + 1):\\n for i in range(n - l + 1):\\n for j in range(n - l + 1):\\n for k in range(1, l):\\n if (dp[i][j][k] and dp[i + k][j + k][l - k]) or (dp[i][j + l - k][k] and dp[i + k][j][l - k]):\\n dp[i][j][l] = True\\n break\\n return dp[0][0][n]\",\n \"runtime\": \"200\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.sk = SolutionK()\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n return self.sk.isScramble(s1, s2)\\n \\n\\n\\nclass SolutionK:\\n # Approach:\\n # Once we cut the string in two parts and swap (or not swap) them,\\n # the characters in those two parts do not cross the boundary therefore,\\n # We can use divide and conquer method here.\\n # \\n # Let's say we cut s1 into x1, y1.\\n # Now also cut s2 into same sized parts x2 and y2.\\n # s1 = x1 + y1 (or y1 + x1)\\n # s2 = x2 + y2 (or y2 + x2)\\n # If s2 is indeed a scrambled version of s1 then the following must hold:\\n # y2 is scrambled version of y1 and x2 is scrambled version of x1.\\n def isScramble(self, s1: str, s2: str) -> bool:\\n ans = {}\\n return self._isScramble(s1, s2, ans)\\n\\n def _isScramble(self, s1, s2, ans):\\n N = len(s1)\\n if N == 1:\\n return s1 == s2\\n\\n key = (s1, s2)\\n if key in ans:\\n return ans[key]\\n\\n result = False\\n\\n def split(s, i):\\n return s[:i], s[i:]\\n\\n for i in range(1, N):\\n x1, y1 = split(s1, i)\\n x2, y2 = split(s2, i)\\n y3, x3 = split(s2, N - i)\\n\\n if self._isScramble(x1, x2, ans) and self._isScramble(y1, y2, ans):\\n result = True\\n break\\n\\n if self._isScramble(x1, x3, ans) and self._isScramble(y1, y3, ans):\\n result = True\\n break\\n\\n ans[key] = result\\n\\n # print(f\\\"{s1} ~ {s2} => {result}\\\")\\n return result\\n \",\n \"runtime\": \"200\"\n },\n {\n \"code\": \"class Solution:\\n table = dict()\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n if s1 == s2:\\n return True\\n if len(s1) <= 1:\\n return False \\n temp = \\\"{}-{}\\\".format(s1,s2)\\n if temp in self.table:\\n return self.table[temp]\\n n = len(s1)\\n for i in range(1,n):\\n cond1 = self.isScramble(s1[0:i],s2[(n-i):n]) and self.isScramble(s1[i:n],s2[0:(n-i)])\\n cond2 = self.isScramble(s1[0:i],s2[0:i]) and self.isScramble(s1[i:n],s2[i:n])\\n if cond1 or cond2:\\n self.table[temp] = True\\n return True\\n self.table[temp] = False\\n return False\\n \",\n \"runtime\": \"204\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n\\n dp = [\\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\\n ]\\n\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n \\n for length in range(2, n + 1):\\n for i in range(n - length + 1):\\n for j in range(n - length + 1):\\n for new_length in range(1, length):\\n dp[length][i][j] = dp[length][i][j] or (dp[new_length][i][j] and dp[length - new_length][i + new_length][j + new_length]) or (dp[new_length][i][j + length - new_length] and dp[length - new_length][i + new_length][j])\\n \\n return dp[n][0][0]\\n\",\n \"runtime\": \"208\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1==s2:\\n return True\\n s1len=len(s1)\\n s2len=len(s2)\\n if not s1len==s2len:\\n return False\\n if not sorted(s1)==sorted(s2):\\n return False\\n dpt=[]\\n for loop1 in range(s1len+1):\\n block=[]\\n for loop2 in range(s1len):\\n block.append([False]*s1len)\\n dpt.append(block)\\n for splptr in range(1,s1len+1):\\n for s1ptr in range(s1len-splptr+1):\\n for s2ptr in range(s2len-splptr+1):\\n if splptr==1:\\n if s1[s1ptr]==s2[s2ptr]:\\n dpt[splptr][s1ptr][s2ptr]=True\\n else:\\n for aftersplptr in range(1,splptr):\\n leftmatchleft=dpt[aftersplptr][s1ptr][s2ptr] and dpt[splptr-aftersplptr][s1ptr+aftersplptr][s2ptr+aftersplptr]\\n leftmatchright=dpt[aftersplptr][s1ptr][s2ptr+(splptr-aftersplptr)] and dpt[splptr-aftersplptr][s1ptr+aftersplptr][s2ptr]\\n dpt[splptr][s1ptr][s2ptr]=leftmatchleft or leftmatchright\\n if leftmatchleft or leftmatchright:\\n break\\n return dpt[s1len][0][0]\",\n \"runtime\": \"212\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s: str, t: str) -> bool:\\n N = len(s)\\n dp = [set(), set()] # index is length, contains (s_index, t_index) => subproblem is scramble\\n for i in range(N):\\n for j in range(N):\\n if s[i] == t[j]:\\n dp[1].add((i,j))\\n\\n for l in range(2, N+1):#2\\n dp.append(set())\\n for i in range(N-l+1):\\n for j in range(N-l+1):\\n for prefix_len in range(1, l):\\n suffix_len = l - prefix_len\\n if (i,j) in dp[prefix_len] and (i+prefix_len,j+prefix_len) in dp[suffix_len] or (i,j+suffix_len) in dp[prefix_len] and (i+prefix_len,j) in dp[suffix_len]: \\n dp[l].add((i,j))\\n\\n \\n return len(dp[N]) > 0\",\n \"runtime\": \"216\"\n },\n {\n \"code\": \"checked = {}\\n\\nclass Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if (s1, s2) in checked:\\n return checked[(s1, s2)]\\n if len(s1) == 1:\\n return s1 == s2\\n\\n for i in range(1, len(s1)):\\n ss1 = s1[:i]\\n ss2 = s1[i:]\\n # print(ss1, ss2, s2)\\n if self.isScramble(ss2, s2[:len(s2) - i]) and self.isScramble(ss1, s2[len(s2) - i:]):\\n checked[(s1, s2)] = True\\n return True\\n if self.isScramble(ss1, s2[:i]) and self.isScramble(ss2, s2[i:]):\\n checked[(s1, s2)] = True\\n return True\\n checked[(s1, s2)] = False\\n return False\",\n \"runtime\": \"220\"\n },\n {\n \"code\": \"class Solution:\\n table = dict()\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n if s1 == s2:\\n return True\\n if len(s1) <= 1:\\n return False \\n temp = \\\"{}-{}\\\".format(s1,s2)\\n if temp in self.table:\\n return self.table[temp]\\n n = len(s1)\\n for i in range(1,n):\\n cond1 = self.isScramble(s1[0:i],s2[(n-i):n]) and self.isScramble(s1[i:n],s2[0:(n-i)])\\n cond2 = self.isScramble(s1[0:i],s2[0:i]) and self.isScramble(s1[i:n],s2[i:n])\\n if cond1 or cond2:\\n self.table[temp] = True\\n return True\\n self.table[temp] = False\\n return False\\n \",\n \"runtime\": \"224\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n debugging: bool = True\\n '''True iff I want print messages'''\\n\\n def four_dimensional_initialization(self, scramble: np.ndarray,\\n s1: str, s2: str):\\n '''pg 63: We can scramble pairs of chars iff they're equal'''\\n for i in range(len(s1)):\\n for j in range(len(s2)):\\n scramble[i, i+1, j, j+1] = int(s1[i] == s2[j])\\n\\n def four_dimensional_dp(self, s1: str, s2: str) -> bool:\\n '''scramble[i, j, k, l] == 1 iff s1[i:j] can be scrambled to s2[k:l]'''\\n if self.debugging:\\n print(f'{np.__version__=}')\\n scramble = np.zeros((len(s1)+1, len(s1)+1, len(s2)+1, len(s2)+1), dtype=int)\\n self.four_dimensional_initialization(scramble, s1, s2)\\n if self.debugging:\\n print(f'{scramble.sum()=} after initialization')\\n\\n for substring_lengths in range(2, len(s1)+1):\\n if self.debugging:\\n print(f'{substring_lengths=}')\\n for s1_start in range(0, len(s1)-substring_lengths+1):\\n for s2_start in range(0, len(s2)-substring_lengths+1):\\n can_scramble = 0\\n for k in range(1, substring_lengths):\\n no_swap_scramble = bool(\\n scramble[s1_start, s1_start+k, s2_start, s2_start+k] and\\n scramble[s1_start+k, s1_start+substring_lengths,\\n s2_start+k, s2_start+substring_lengths]\\n )\\n swap_scramble = bool(\\n scramble[s1_start, s1_start+k, \\n s2_start+substring_lengths-k, s2_start+substring_lengths] and\\n scramble[s1_start+k, s1_start+substring_lengths,\\n s2_start, s2_start+(substring_lengths-k)]\\n )\\n can_scramble = int(no_swap_scramble or swap_scramble)\\n if can_scramble:\\n if self.debugging:\\n print(f'\\\\t\\\\tCan scramble s1{s1_start, s1_start+substring_lengths} and '\\n f's2{s2_start, s2_start+substring_lengths} by cutting at {k=}')\\n print(f'\\\\t\\\\t{no_swap_scramble=}, {swap_scramble=}')\\n break\\n scramble[s1_start, s1_start+substring_lengths,\\n s2_start, s2_start+substring_lengths] = can_scramble\\n \\n return bool(scramble[0, len(s1), 0, len(s2)])\\n\\n def recursion_with_memoization(self, s1: str, s2: str) -> bool:\\n '''Above DP solution works, but it's faster to just do a top-down recursion\\n Cache intermediate results using tuple of strings (function args) as a key'''\\n scramble: dict[tuple[str, str], bool] = {}\\n\\n def try_scrambling_substrings(s_1: str, s_2: str) -> bool:\\n '''Return True iff we can scramble s_1 into s_2'''\\n if (s_1, s_2) in scramble: \\n return scramble[(s_1, s_2)]\\n if not sorted(s_1) == sorted(s_2):\\n # Don't have the same chars -> no way to scramble\\n scramble[(s_1, s_2)] = False\\n return False\\n if len(s_1) == 1:\\n # One char base case\\n one_char_equal = (s_1 == s_2)\\n scramble[(s_1, s_2)] = one_char_equal\\n return one_char_equal\\n\\n can_scramble = False\\n for k in range(1, len(s_1)):\\n no_swap_scramble = (try_scrambling_substrings(s_1[:k], s_2[:k]) and\\n try_scrambling_substrings(s_1[k:], s_2[k:]))\\n if no_swap_scramble:\\n scramble[(s_1, s_2)] = True\\n return True\\n swap_scramble = (try_scrambling_substrings(s_1[:k], s_2[len(s_2)-k:]) and\\n try_scrambling_substrings(s_1[k:], s_2[:len(s_2)-k]))\\n if swap_scramble:\\n scramble[(s_1, s_2)] = True\\n return True\\n\\n scramble[(s_1, s_2)] = False\\n return False\\n \\n overall_scramble = try_scrambling_substrings(s1, s2)\\n if self.debugging:\\n print(f'{scramble=}')\\n return overall_scramble\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n self.debugging = False\\n # return self.four_dimensional_dp(s1, s2)\\n return self.recursion_with_memoization(s1, s2)\\n \",\n \"runtime\": \"224\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n len_s1 = len(s1)\\n F = [[[False for _ in range(len_s1 + 1)] for _ in range(len_s1)] for _ in range(len_s1)]\\n\\n for k in range(1, len_s1 + 1):\\n for i in range(len_s1 - k + 1):\\n for j in range(len_s1 - k + 1):\\n if k == 1:\\n F[i][j][k] = s1[i] == s2[j]\\n else:\\n for q in range(1, k):\\n F[i][j][k] = (F[i][j][q] and F[i + q][j + q][k - q]) or (F[i][j + k - q][q] and F[i + q][j][k - q])\\n if F[i][j][k]:\\n break\\n return F[0][0][len_s1]\",\n \"runtime\": \"228\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n @cache\\n \\n def dfs(s1, s2): \\n \\n if s1 == s2: return True\\n \\n for i in range(1, len(s1)): \\n if dfs(s1[i:], s2[i:]) and dfs(s1[:i], s2[:i]):\\n return True\\n if dfs(s1[i:], s2[:-i]) and dfs(s1[:i], s2[-i:]):\\n return True\\n \\n return False\\n \\n return dfs(s1, s2)\",\n \"runtime\": \"232\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # let f[a][b][c][d] = True / False to check whether s2[c:d] can be scambled to s1[a:b]\\n # if c - d != b - a: f[a][b][c][d] = False\\n # if s1[a:b] == s2[c:d]: f[a][b][c][d] = True\\n # if find t, where 0 < t < d - c:\\n # f[a][b][c][d] = True if exist t:\\n # f[a][a+t][c][c+t] and f[a+t][b][c+t][d] or\\n # f[a][a+n-t][c][c+n-t] and f[a+n-t+1][b][c+n-t+1][d]\\n\\n f = {}\\n\\n def dp(a, b, c, d):\\n if (a, b, c, d) in f:\\n return f[(a, b, c, d)]\\n \\n # print(a, b, c, d)\\n\\n if b - a != d - c:\\n return False\\n\\n if s1[a:b] == s2[c:d]:\\n return True\\n\\n n = b - a\\n for t in range(1, n):\\n if (dp(a, a+t, c, c+t) and dp(a+t, b, c+t, d)) or (dp(a, a+n-t, d-n+t, d) and dp(a+n-t, b, c, d-n+t)):\\n f[(a, b, c, d)] = True\\n return True\\n \\n f[(a, b, c, d)] = False\\n return False\\n\\n\\n return dp(0, len(s1), 0, len(s2))\",\n \"runtime\": \"232\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dp(s1, s2):\\n if s1 == s2: return True\\n for i in range(1, len(s1)):\\n if dp(s1[i:], s2[i:]) and dp(s1[:i], s2[:i]):\\n return True\\n if dp(s1[i:], s2[:-i]) and dp(s1[:i], s2[-i:]):\\n return True\\n return False\\n return dp(s1, s2)\\n\\n \\n \",\n \"runtime\": \"236\"\n },\n {\n \"code\": \"class Solution:\\n def scrambleHelp(self, s1, s2):\\n if s1 == s2:\\n return True\\n if len(s1) == 1:\\n return False\\n n = len(s1)\\n for j in range(1, n):\\n #swap option\\n if (sorted(s1[:j]) == sorted(s2[n-j:])\\n and sorted(s1[j:]) == sorted(s2[:n-j])\\n and self.scrambleHelp(s1[:j], s2[n - j:]) \\n and self.scrambleHelp(s1[j:], s2[:n - j])):\\n return True\\n if (sorted(s1[:j]) == sorted(s2[:j])\\n and sorted(s1[j:]) == sorted(s2[j:])\\n and self.scrambleHelp(s1[:j], s2[:j]) \\n and self.scrambleHelp(s1[j:], s2[j:])):\\n return True\\n return False\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2) or sorted(s1) != sorted(s2):\\n return False\\n n = len(s1)\\n memo = [[[False] * (n + 1) for _ in range(n + 1)] for _ in range(n + 1)]\\n for l in range(1, n + 1):\\n for i in range(n):\\n for j in range(n):\\n if i + l > n or j + l > n:\\n memo[i][j][l] = False\\n elif l == 1:\\n memo[i][j][l] = (s1[i] == s2[j])\\n else:\\n for p in range(i + 1, i + l):\\n l1 = p - i\\n l2 = (i + l) - p\\n if memo[i][j][l1] and memo[p][j + l1][l2]:\\n memo[i][j][l] = True\\n break\\n elif memo[p][j][l2] and memo[i][j + l2][l1]:\\n memo[i][j][l] = True\\n break\\n return memo[0][0][n]\",\n \"runtime\": \"236\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n @cache\\n \\n def dfs(s1, s2): \\n \\n if s1 == s2: return True\\n \\n for i in range(1, len(s1)): \\n if dfs(s1[i:], s2[i:]) and dfs(s1[:i], s2[:i]):\\n return True\\n if dfs(s1[i:], s2[:-i]) and dfs(s1[:i], s2[-i:]):\\n return True\\n \\n return False\\n \\n return dfs(s1, s2)\",\n \"runtime\": \"240\"\n },\n {\n \"code\": \"checked = {}\\n\\nclass Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if (s1, s2) in checked:\\n return checked[(s1, s2)]\\n if len(s1) == 1:\\n return s1 == s2\\n\\n for i in range(1, len(s1)):\\n ss1 = s1[:i]\\n ss2 = s1[i:]\\n # print(ss1, ss2, s2)\\n if self.isScramble(ss2, s2[:len(s2) - i]) and self.isScramble(ss1, s2[len(s2) - i:]):\\n checked[(s1, s2)] = True\\n return True\\n if self.isScramble(ss1, s2[:i]) and self.isScramble(ss2, s2[i:]):\\n checked[(s1, s2)] = True\\n return True\\n checked[(s1, s2)] = False\\n return False\",\n \"runtime\": \"240\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str, dctx = {}) -> bool:\\n if (s1,s2) in dctx:\\n return dctx[(s1,s2)]\\n if len(s1) != len(s2):\\n return False\\n elif s1 == s2:\\n return True\\n elif set(s1) != set(s2):\\n return False\\n \\n for i in range(1,len(s1)):\\n # No Swap\\n a = self.isScramble(s1[:i], s2[:i], dctx)\\n b = self.isScramble(s1[i:], s2[i:], dctx)\\n if a and b:\\n dctx[(s1,s2)] = True\\n return True\\n\\n # With Swap\\n # print(s1[i:] + \\\" \\\" + s1[:i])\\n # print(s2[:len(s1)-i] + \\\" \\\" + s2[len(s1)-i:])\\n a = self.isScramble(s1[i:], s2[:len(s1)-i], dctx)\\n b = self.isScramble(s1[:i], s2[len(s1)-i:], dctx)\\n if a and b:\\n dctx[(s1,s2)] = True\\n return True\\n dctx[(s1,s2)] = False\\n return False\\n \\n \",\n \"runtime\": \"244\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n\\n @cache\\n def dp(s1, s2):\\n if s1 == s2: return True\\n\\n for i in range(1, len(s1)):\\n if dp(s1[i:], s2[i:]) and dp(s1[:i], s2[:i]):\\n return True\\n if dp(s1[i:], s2[:-i]) and dp(s1[:i], s2[-i:]):\\n return True\\n \\n return False\\n \\n return dp(s1, s2)\\n\\n\\n \",\n \"runtime\": \"244\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dp(s1,s2):\\n if s1==s2:\\n return True\\n for i in range(1,len(s1)):\\n if dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i]):\\n return True\\n if dp(s1[i:],s2[:-i]) and dp(s1[:i],s2[-i:]):\\n return True\\n return False\\n return dp(s1,s2)\\n \\n \",\n \"runtime\": \"248\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dp(s1,s2):\\n if(s1==s2):\\n return True\\n for i in range(1,len(s1)):\\n if dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i]):\\n return True\\n if dp(s1[i:],s2[:-i]) and dp(s1[:i],s2[-i:]):\\n return True\\n return False\\n return dp(s1,s2)\\n\\n\",\n \"runtime\": \"248\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n debugging: bool = True\\n '''True iff I want print messages'''\\n\\n def four_dimensional_initialization(self, scramble: np.ndarray,\\n s1: str, s2: str):\\n '''pg 63: We can scramble pairs of chars iff they're equal'''\\n for i in range(len(s1)):\\n for j in range(len(s2)):\\n scramble[i, i+1, j, j+1] = int(s1[i] == s2[j])\\n\\n def four_dimensional_dp(self, s1: str, s2: str) -> bool:\\n '''scramble[i, j, k, l] == 1 iff s1[i:j] can be scrambled to s2[k:l]'''\\n if self.debugging:\\n print(f'{np.__version__=}')\\n scramble = np.zeros((len(s1)+1, len(s1)+1, len(s2)+1, len(s2)+1), dtype=int)\\n self.four_dimensional_initialization(scramble, s1, s2)\\n if self.debugging:\\n print(f'{scramble.sum()=} after initialization')\\n\\n for substring_lengths in range(2, len(s1)+1):\\n if self.debugging:\\n print(f'{substring_lengths=}')\\n for s1_start in range(0, len(s1)-substring_lengths+1):\\n for s2_start in range(0, len(s2)-substring_lengths+1):\\n can_scramble = 0\\n for k in range(1, substring_lengths):\\n no_swap_scramble = bool(\\n scramble[s1_start, s1_start+k, s2_start, s2_start+k] and\\n scramble[s1_start+k, s1_start+substring_lengths,\\n s2_start+k, s2_start+substring_lengths]\\n )\\n swap_scramble = bool(\\n scramble[s1_start, s1_start+k, \\n s2_start+substring_lengths-k, s2_start+substring_lengths] and\\n scramble[s1_start+k, s1_start+substring_lengths,\\n s2_start, s2_start+(substring_lengths-k)]\\n )\\n can_scramble = int(no_swap_scramble or swap_scramble)\\n if can_scramble:\\n if self.debugging:\\n print(f'\\\\t\\\\tCan scramble s1{s1_start, s1_start+substring_lengths} and '\\n f's2{s2_start, s2_start+substring_lengths} by cutting at {k=}')\\n print(f'\\\\t\\\\t{no_swap_scramble=}, {swap_scramble=}')\\n break\\n scramble[s1_start, s1_start+substring_lengths,\\n s2_start, s2_start+substring_lengths] = can_scramble\\n \\n return bool(scramble[0, len(s1), 0, len(s2)])\\n\\n def recursion_with_memoization(self, s1: str, s2: str) -> bool:\\n '''Above DP solution works, but it's faster to just do a top-down recursion\\n Cache intermediate results using tuple of strings (function args) as a key'''\\n scramble: dict[tuple[str, str], bool] = {}\\n\\n def try_scrambling_substrings(s_1: str, s_2: str) -> bool:\\n '''Return True iff we can scramble s_1 into s_2'''\\n if (s_1, s_2) in scramble: \\n return scramble[(s_1, s_2)]\\n if not sorted(s_1) == sorted(s_2):\\n # Don't have the same chars -> no way to scramble\\n # scramble[(s_1, s_2)] = False...no need to cache this. Saves space and time\\n return False\\n if len(s_1) == 1:\\n # One char base case\\n # one_char_equal = (s_1 == s_2)...not needed, since we just checked\\n # \\\"sorted(s_1) == sorted(s_2)\\\". If we're here, s_1 == s_2\\n # scramble[(s_1, s_2)] = one_char_equal...no need to cache. Saves space and time\\n return True\\n\\n can_scramble = False\\n for k in range(1, len(s_1)):\\n no_swap_scramble = (try_scrambling_substrings(s_1[:k], s_2[:k]) and\\n try_scrambling_substrings(s_1[k:], s_2[k:]))\\n if no_swap_scramble:\\n scramble[(s_1, s_2)] = True\\n return True\\n swap_scramble = (try_scrambling_substrings(s_1[:k], s_2[len(s_2)-k:]) and\\n try_scrambling_substrings(s_1[k:], s_2[:len(s_2)-k]))\\n if swap_scramble:\\n scramble[(s_1, s_2)] = True\\n return True\\n\\n scramble[(s_1, s_2)] = False\\n return False\\n \\n overall_scramble = try_scrambling_substrings(s1, s2)\\n if self.debugging:\\n print(f'{scramble=}')\\n return overall_scramble\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n self.debugging = False\\n # return self.four_dimensional_dp(s1, s2)\\n return self.recursion_with_memoization(s1, s2)\\n \",\n \"runtime\": \"252\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n if n != len(s2):\\n return False\\n \\n # Initialize the dp table\\n dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]\\n \\n # Base case: single characters\\n for i in range(n):\\n for j in range(n):\\n dp[i][j][1] = s1[i] == s2[j]\\n \\n # Fill the dp table for lengths greater than 1\\n for length in range(2, n + 1):\\n for i in range(n - length + 1):\\n for j in range(n - length + 1):\\n for new_length in range(1, length):\\n dp1 = dp[i][j][new_length]\\n dp2 = dp[i + new_length][j + new_length][length - new_length]\\n \\n dp3 = dp[i][j + length - new_length][new_length]\\n dp4 = dp[i + new_length][j][length - new_length]\\n \\n if (dp1 and dp2) or (dp3 and dp4):\\n dp[i][j][length] = True\\n break\\n \\n return dp[0][0][n]\\n\\n# Example usage:\\nsolution = Solution()\\ns1 = \\\"great\\\"\\ns2 = \\\"rgeat\\\"\\nprint(solution.isScramble(s1, s2)) # Output: True\",\n \"runtime\": \"256\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n=len(s1)\\n dp=[[[False for j in range(n)]for i in range(n)]for l in \\n range(n+1)];\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j]=s1[i]==s2[j]\\n for length in range(2,n+1):\\n for i in range(n+1-length):\\n for j in range(n+1-length):\\n for new in range(1,length):\\n dp1=dp[new][i]\\n dp2=dp[length-new][i+new]\\n dp[length][i][j]|=(\\n dp1[j] and dp2[j+new]\\n )\\n dp[length][i][j]|=(\\n dp2[j] and dp1[j+length-new]\\n )\\n return dp[n][0][0]\",\n \"runtime\": \"260\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n # dp[length][i][j]\\n # recurring eq\\n # dp[length][i][j] = dp[sublength1][i][j] and dp[length - sublength1][i+sublength1][j+sublength1]\\n # or\\n # dp[length][i][j] = dp[sublength1][i+length - sublength1][j] and dp[length - sublength1][i][j+sublength1]\\n dp = [[[False] * n for _ in range(n)] for _ in range(n+1)]\\n # base case\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = True if s1[i] == s2[j] else False\\n for l in range(2,n+1):\\n for i in range(n-l+1):\\n for j in range(n-l+1):\\n for subl in range(1,l):\\n dp[l][i][j] |= dp[subl][i][j] and dp[l - subl][i+subl][j+subl]\\n dp[l][i][j] |= dp[subl][i+l - subl][j] and dp[l - subl][i][j+subl]\\n return dp[n][0][0]\\n\\n\",\n \"runtime\": \"264\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n dp = [[[False for _ in range(n)] for _ in range(n)] for _ in range(n + 1)]\\n l = 1\\n for idx1 in range(n):\\n for idx2 in range(n):\\n dp[l][idx1][idx2] = s1[idx1] == s2[idx2]\\n\\n for l in range(2, n + 1):\\n for idx1 in range(n - l + 1):\\n for idx2 in range(n - l + 1):\\n for split_len in range(1, l):\\n dp[l][idx1][idx2] |= dp[split_len][idx1][idx2] and dp[l - split_len][idx1 + split_len][idx2 + split_len]\\n dp[l][idx1][idx2] |= dp[split_len][idx1][idx2 + (l - split_len)] and dp[l - split_len][idx1 + split_len][idx2]\\n return dp[n][0][0]\",\n \"runtime\": \"268\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n \\n # DP table to store results of subproblems\\n # dp[i][j][k] will be true if s2[j:j+k] is a scrambled string of s1[i:i+k]\\n dp = [[[False for _ in range(n + 1)] for _ in range(n)] for _ in range(n)]\\n \\n # Initialize the base case when length of substring is 1\\n for i in range(n):\\n for j in range(n):\\n dp[i][j][1] = (s1[i] == s2[j])\\n \\n # Fill the DP table for lengths greater than 1\\n for length in range(2, n + 1):\\n for i in range(n - length + 1):\\n for j in range(n - length + 1):\\n for new_length in range(1, length):\\n # Check if there is any split position that makes s2 a scrambled string of s1\\n dp[i][j][length] |= (dp[i][j][new_length] and dp[i + new_length][j + new_length][length - new_length]) or \\\\\\n (dp[i][j + length - new_length][new_length] and dp[i + new_length][j][length - new_length])\\n \\n # If the current substring is a scrambled string, no need to check further splits\\n if dp[i][j][length]:\\n break\\n \\n # The result will be stored in dp[0][0][n]\\n return dp[0][0][n]\\n\\n# Example usage:\\nsolution = Solution()\\ns1 = \\\"great\\\"\\ns2 = \\\"rgeat\\\"\\nprint(solution.isScramble(s1, s2)) # Output: True\",\n \"runtime\": \"272\"\n },\n {\n \"code\": \"class Solution:\\n def is_valid(self, s: str, t: str) -> bool:\\n mask1 = mask2 = 0\\n for ch in s:\\n mask1 = (mask1 | (1<<(ord(ch)-ord(\\\"a\\\"))))\\n for ch in t:\\n mask2 = (mask2 | (1<<(ord(ch)-ord(\\\"a\\\"))))\\n return mask1 == mask2\\n \\n def compare(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n elif len(s) == 1:\\n return s==t\\n elif (s,t) in self.cache:\\n return self.cache[(s,t)]\\n else:\\n res = False\\n for i in range(1, len(s)):\\n # 1. not swap\\n s_l, s_r = s[:i], s[i:]\\n t_l, t_r = t[:i], t[i:]\\n if self.is_valid(s_l, t_l):\\n tmp = self.compare(s_l, t_l) and self.compare(s_r, t_r)\\n res = res or tmp\\n # 2. swap\\n s_l, s_r = s[:i], s[i:]\\n t_l, t_r = t[:len(t)-i], t[len(t)-i:]\\n if self.is_valid(s_l, t_r):\\n tmp = self.compare(s_l, t_r) and self.compare(s_r, t_l)\\n res = res or tmp\\n self.cache[(s, t)] = res\\n return res\\n \\n def isScramble(self, s1: str, s2: str) -> bool:\\n self.cache = {}\\n \\n res = self.compare(s1, s2)\\n \\n return res\",\n \"runtime\": \"276\"\n },\n {\n \"code\": \"class Solution:\\n def getCounts(self, s):\\n counts = [0 for _ in range(26)]\\n for c in s:\\n counts[ord(c) - ord(\\\"a\\\")] += 1\\n return counts\\n def isScramble(self, s1: str, s2: str) -> bool:\\n return self.helper(s1, s2)\\n\\n def helper(self, s1, s2, memo={}):\\n combo1 = (s1, s2)\\n combo2 = (s2, s1)\\n if combo1 in memo:\\n return memo[combo1]\\n if len(s1) == len(s2) == 1:\\n rval = s1 == s2\\n memo[combo1] = rval\\n memo[combo2] = rval\\n return rval\\n n = len(s1)\\n counts1 = [0 for _ in range(26)]\\n counts2 = [0 for _ in range(26)]\\n abs_diff = 0\\n for split_idx, (c1, c2) in enumerate(zip(s1, s2[::-1])):\\n if 1 <= split_idx and abs_diff == 0:\\n if self.helper(s1[:split_idx], s2[:split_idx], memo) and self.helper(s1[split_idx:], s2[split_idx:], memo):\\n rval = True\\n memo[combo1] = rval\\n memo[combo2] = rval\\n return rval\\n if self.helper(s1[:split_idx], s2[n - split_idx:], memo) and self.helper(s1[split_idx:], s2[:n - split_idx], memo):\\n rval = True\\n memo[combo1] = rval\\n memo[combo2] = rval\\n return rval\\n ic1 = ord(c1) - ord(\\\"a\\\")\\n ic2 = ord(c2) - ord(\\\"a\\\")\\n p_abs_diff = abs(counts1[ic1] - counts2[ic2]) + abs(counts1[ic1] - counts2[ic2])\\n counts1[ic1] += 1\\n counts2[ic2] += 1\\n n_abs_diff = abs(counts1[ic1] - counts2[ic2]) + abs(counts1[ic1] - counts2[ic2])\\n abs_diff += n_abs_diff - p_abs_diff\\n rval = False\\n memo[combo1] = rval\\n memo[combo2] = rval\\n return rval\\n \",\n \"runtime\": \"280\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n dp = [\\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\\n ]\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n for length in range(2, n + 1):\\n for i in range(n + 1 - length):\\n for j in range(n + 1 - length):\\n for new_length in range(1, length):\\n dp1 = dp[new_length][i]\\n dp2 = dp[length - new_length][i + new_length]\\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\\n dp[length][i][j] |= (\\n dp1[j + length - new_length] and dp2[j]\\n )\\n return dp[n][0][0]\",\n \"runtime\": \"284\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n \\n # If both strings are equal, they are scrambled strings of each other\\n if s1 == s2:\\n return True\\n \\n # If the sorted strings are not equal, they cannot be scrambled strings of each other\\n if sorted(s1) != sorted(s2):\\n return False\\n \\n # Initialize a 3D DP table to store intermediate results\\n dp = [[[False for _ in range(n + 1)] for _ in range(n)] for _ in range(n)]\\n \\n # Base case: If the length of the substring is 1, check if the characters are equal\\n for i in range(n):\\n for j in range(n):\\n dp[i][j][1] = s1[i] == s2[j]\\n \\n # Fill the DP table for substrings of length 2 to n\\n for length in range(2, n + 1):\\n for i in range(n - length + 1):\\n for j in range(n - length + 1):\\n for new_length in range(1, length):\\n dp1 = dp[i][j][new_length]\\n dp2 = dp[i + new_length][j + new_length][length - new_length]\\n dp3 = dp[i][j + length - new_length][new_length]\\n dp4 = dp[i + new_length][j][length - new_length]\\n \\n if (dp1 and dp2) or (dp3 and dp4):\\n dp[i][j][length] = True\\n break\\n \\n return dp[0][0][n]\\n\\n# Example usage:\\nsolution = Solution()\\ns1 = \\\"great\\\"\\ns2 = \\\"rgeat\\\"\\nprint(solution.isScramble(s1, s2)) # Output: True\",\n \"runtime\": \"284\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n # Initialize a 3D table to store the results of all possible substrings of the two strings\\n dp = [[[False for _ in range(n)] for _ in range(n)] for _ in range(n+1)]\\n\\n # Initialize the table for substrings of length 1\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n\\n # Fill the table for substrings of length 2 to n\\n for length in range(2, n+1):\\n for i in range(n+1-length):\\n for j in range(n+1-length):\\n # Iterate over all possible lengths of the first substring\\n for newLength in range(1, length):\\n # Check if the two possible splits of the substrings are scrambled versions of each other\\n dp1 = dp[newLength][i]\\n dp2 = dp[length-newLength][i+newLength]\\n dp[length][i][j] |= dp1[j] and dp2[j+newLength]\\n dp[length][i][j] |= dp1[j+length-newLength] and dp2[j]\\n\\n # Return whether the entire strings s1 and s2 are scrambled versions of each other\\n return dp[n][0][0]\",\n \"runtime\": \"288\"\n },\n {\n \"code\": \"class Solution:\\n def is_valid(self, s: str, t: str) -> bool:\\n mask1 = mask2 = 0\\n for ch in s:\\n mask1 = (mask1 | (1<<(ord(ch)-ord(\\\"a\\\"))))\\n for ch in t:\\n mask2 = (mask2 | (1<<(ord(ch)-ord(\\\"a\\\"))))\\n return mask1 == mask2\\n \\n def compare(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n elif len(s) == 1:\\n return s==t\\n elif (s,t) in self.cache:\\n return self.cache[(s,t)]\\n else:\\n res = False\\n for i in range(1, len(s)):\\n # 1. not swap\\n s_l, s_r = s[:i], s[i:]\\n t_l, t_r = t[:i], t[i:]\\n if self.is_valid(s_l, t_l):\\n tmp = self.compare(s_l, t_l) and self.compare(s_r, t_r)\\n res = res or tmp\\n # 2. swap\\n s_l, s_r = s[:i], s[i:]\\n t_l, t_r = t[:len(t)-i], t[len(t)-i:]\\n if self.is_valid(s_l, t_r):\\n tmp = self.compare(s_l, t_r) and self.compare(s_r, t_l)\\n res = res or tmp\\n self.cache[(s, t)] = res\\n return res\\n \\n def isScramble(self, s1: str, s2: str) -> bool:\\n self.cache = {}\\n \\n res = self.compare(s1, s2)\\n \\n return res\",\n \"runtime\": \"292\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # Solution: in editorial\\n # Real solution: Give up\\n n = len(s1)\\n dp = [\\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\\n ]\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n for length in range(2, n + 1):\\n for i in range(n + 1 - length):\\n for j in range(n + 1 - length):\\n for new_length in range(1, length):\\n dp1 = dp[new_length][i]\\n dp2 = dp[length - new_length][i + new_length]\\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\\n dp[length][i][j] |= (\\n dp1[j + length - new_length] and dp2[j]\\n )\\n return dp[n][0][0]\",\n \"runtime\": \"292\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n\\n n = len(s1)\\n\\n dp = [\\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\\n ] \\n\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n \\n for length in range(2, n + 1):\\n for i in range(n + 1 - length):\\n for j in range(n + 1 - length):\\n for new_length in range(1, length):\\n dp1 = dp[new_length][i]\\n dp2 = dp[length - new_length][i + new_length]\\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\\n dp[length][i][j] |= (\\n dp1[j + length - new_length] and dp2[j]\\n )\\n \\n return dp[n][0][0]\",\n \"runtime\": \"296\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n \\n # If lengths are different, they cannot be scrambled strings\\n if len(s2) != n:\\n return False\\n \\n # Initialize the DP table\\n dp = [[[False for _ in range(n + 1)] for _ in range(n)] for _ in range(n)]\\n \\n # Base case: single characters\\n for i in range(n):\\n for j in range(n):\\n dp[i][j][1] = (s1[i] == s2[j])\\n \\n # Fill the DP table for lengths greater than 1\\n for length in range(2, n + 1):\\n for i in range(n - length + 1):\\n for j in range(n - length + 1):\\n for new_length in range(1, length):\\n dp1 = dp[i][j][new_length]\\n dp2 = dp[i + new_length][j + new_length][length - new_length]\\n dp3 = dp[i][j + length - new_length][new_length]\\n dp4 = dp[i + new_length][j][length - new_length]\\n \\n if (dp1 and dp2) or (dp3 and dp4):\\n dp[i][j][length] = True\\n break\\n \\n return dp[0][0][n]\\n\\n# Example usage:\\nsolution = Solution()\\ns1 = \\\"great\\\"\\ns2 = \\\"rgeat\\\"\\nprint(solution.isScramble(s1, s2)) # Output: True\",\n \"runtime\": \"296\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n\\n dp = [[[False] * (n+1) for _ in range(n)] for _ in range(n)]\\n for i in range(n):\\n for j in range(n):\\n if s1[i] == s2[j]:\\n dp[i][j][1] = True\\n \\n for l in range(2, n+1):\\n # i = 0, ..., n-1\\n for l1 in range(n-l+1):\\n for l2 in range(n-l+1):\\n for i in range(1, l):\\n dp[l1][l2][l] |= (dp[l1][l2][i] and dp[l1+i][l2+i][l-i])\\n for i in range(1, l):\\n dp[l1][l2][l] |= (dp[l1][l2+l-i][i] and dp[l1+i][l2][l-i])\\n return dp[0][0][n]\",\n \"runtime\": \"300\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n dp = [\\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\\n ]\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n for length in range(2, n + 1):\\n for i in range(n + 1 - length):\\n for j in range(n + 1 - length):\\n for new_length in range(1, length):\\n dp1 = dp[new_length][i]\\n dp2 = dp[length - new_length][i + new_length]\\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\\n dp[length][i][j] |= (\\n dp1[j + length - new_length] and dp2[j]\\n )\\n return dp[n][0][0]\",\n \"runtime\": \"300\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n dp = [\\n [[False for j in range(n)] for i in range(n)] for l in range(n + 1)\\n ]\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n for length in range(2, n + 1):\\n for i in range(n + 1 - length):\\n for j in range(n + 1 - length):\\n for new_length in range(1, length):\\n dp1 = dp[new_length][i]\\n dp2 = dp[length - new_length][i + new_length]\\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\\n dp[length][i][j] |= (\\n dp1[j + length - new_length] and dp2[j]\\n )\\n return dp[n][0][0]\",\n \"runtime\": \"304\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n n = len(s1)\\n\\n dp = []\\n # Length of section\\n for l in range(n + 1):\\n is_ = []\\n # Start of section for s1\\n for i in range(n):\\n js = []\\n # Start of section for s2\\n for j in range(n):\\n js.append(False)\\n is_.append(js)\\n dp.append(is_)\\n \\n # Base case: 1 characters and both are the same character\\n # s1 index\\n for i in range(n):\\n # s2 index\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n\\n # 2 because length 1 checked in base case\\n for length in range(2, n + 1):\\n # One part for s1\\n for i in range(n + 1 - length):\\n # One part for s2\\n for j in range(n + 1 - length):\\n # The other part\\n for new_length in range(1, length):\\n\\n # Left\\n dp1 = dp[new_length][i]\\n # Right\\n dp2 = dp[length - new_length][i + new_length]\\n\\n dp[length][i][j] |= dp1[j] and dp2[j + new_length]\\n\\n # Swap\\n dp[length][i][j] |= dp1[j + length - new_length] and dp2[j]\\n\\n # print(dp)\\n\\n return dp[n][0][0]\",\n \"runtime\": \"312\"\n },\n {\n \"code\": \"from functools import cache\\n\\n\\nclass Solution:\\n @cache\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s2 < s1:\\n return self.isScramble(s2, s1)\\n\\n if s1 == s2:\\n return True\\n \\n if len(s1) == 1:\\n return False\\n \\n for i in range(len(s1) - 1):\\n split_index = i + 1\\n if self.isScramble(s1[:split_index], s2[:split_index]) and self.isScramble(s1[split_index:], s2[split_index:]):\\n return True\\n if self.isScramble(s1[:split_index], s2[len(s1) - split_index:]) and self.isScramble(s1[split_index:], s2[:len(s1) - split_index]):\\n return True\\n \\n return False\",\n \"runtime\": \"312\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n\\n dp = [[[False for j in range(n)] for i in range(n)] for l in range(n+1)]\\n\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n \\n for length in range(2, n+1):\\n for i in range(n+1 - length):\\n for j in range(n+1 - length):\\n for new_length in range(1, length):\\n dp1 = dp[new_length][i]\\n dp2 = dp[length - new_length][i+new_length]\\n dp[length][i][j] |= dp1[j] and dp2[j+new_length]\\n dp[length][i][j] |= (dp1[j + length - new_length] and dp2[j])\\n\\n return dp[n][0][0]\\n # memo = {}\\n # def dfs(s1, s2):\\n # if s1 == s2:\\n # return True\\n # if (s1, s2) in memo:\\n # return memo[(s1, s2)]\\n \\n # if Counter(s1) != Counter(s2):\\n # memo[(s1, s2)] = False\\n # return False\\n\\n # n = len(s1)\\n # memo[(s1, s2)] = False\\n # for k in range(1, n):\\n # if dfs(s1[:k], s2[:k]) and dfs(s1[k:], s2[k:]) or dfs(s1[:k], s2[n-k:]) and dfs(s1[k:], s2[:n-k]):\\n # memo[(s1, s2)] = True\\n # return memo[(s1, s2)]\\n\\n # return dfs(s1, s2)\",\n \"runtime\": \"316\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n dp = [[[False for j in range(n)] for i in range(n)] for l in range(n + 1)]\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n for length in range(2, n + 1):\\n for i in range(n + 1 - length):\\n for j in range(n + 1 - length):\\n for n_length in range(1, length):\\n dp1 = dp[n_length][i]\\n dp2 = dp[length - n_length][i + n_length]\\n dp[length][i][j] |= dp1[j] and dp2[j + n_length]\\n dp[length][i][j] |= (dp1[j + length - n_length] and dp2[j])\\n return dp[n][0][0]\",\n \"runtime\": \"316\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n from functools import cache\\n\\n @cache\\n def scramble(x: str, y: str):\\n if (n := len(x)) == 1:\\n return x == y\\n\\n check = False\\n for i in range(n-1):\\n x1 = x[:i+1]\\n x2 = x[i+1:]\\n y1 = y[:i+1]\\n y2 = y[i+1:]\\n y3 = y[:n-i-1]\\n y4 = y[n-i-1:]\\n check1 = scramble(x1, y1) and scramble(x2, y2)\\n check2 = scramble(x2, y3) and scramble(x1, y4)\\n check = check or check1 or check2\\n \\n return check\\n\\n return scramble(s1, s2)\",\n \"runtime\": \"320\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n @lru_cache(None)\\n def compute(a,b):\\n # abcd bcda\\n n = len(a)\\n if n != len(b):\\n return False\\n if a == b:\\n return True\\n # if sorted(a) != sorted(b): \\n # return False\\n res = False\\n for k in range(1,n):\\n # case0\\n res|=(compute(a[0:k],b[0:k]) and compute(a[k:],b[k:]))\\n #case1\\n res|=(compute(a[0 : k],b[n-k: ]) and compute(a[k : ],b[0 : n-k]))\\n \\n return res\\n res = compute(s1,s2)\\n compute.cache_clear()\\n return res\",\n \"runtime\": \"320\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n dp = [[[False] * n for _ in range(n)] for _ in range(n+1)]\\n if not sorted(s1) == sorted(s2):\\n return False\\n\\n for i in range(n):\\n for j in range(n):\\n dp[1][i][j] = s1[i] == s2[j]\\n \\n for length in range(2, n+1):\\n for i in range(n+1-length):\\n for j in range(n+1-length):\\n for new_length in range(1, length):\\n dp1 = dp[new_length][i]\\n dp2 = dp[length - new_length][i+new_length]\\n dp[length][i][j] |= dp1[j] and dp2[j+new_length]\\n dp[length][i][j] |= (dp1[j+length-new_length] and dp2[j])\\n if dp[length][i][j]:\\n break\\n \\n return dp[n][0][0]\",\n \"runtime\": \"324\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n def dp(s1, s2, memo):\\n if s1+\\\",\\\"+s2 in memo:\\n return memo[s1+\\\",\\\"+s2]\\n if s1 == s2:\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n\\n for i in range(1, len(s1)):\\n if dp(s1[i:], s2[i:], memo) and dp(s1[:i], s2[:i], memo):\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n if dp(s1[i:], s2[:-i], memo) and dp(s1[:i], s2[-i:], memo):\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n memo[s1+\\\",\\\"+s2] = False\\n return False\\n return dp(s1, s2, {})\",\n \"runtime\": \"324\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # # Memomiazation \\n # # O(n^4) time, O(n^3) space\\n # if len(s1) != len(s2):\\n # return False\\n \\n # n = len(s1)\\n\\n # # (ls1, ls2, sslen). ls1 is starting index in s1. ls2 is starting index in s2, sslen is substring length we are testing.\\n # # where memo[(ls1, ls2, sslen)] = isScramble(s1[ls1..ls1+sslen-1], s2[ls2..ls2+sslen-1])\\n # memo = {}\\n\\n # def recurse_is_scramble(ls1, ls2, sslen):\\n # if (ls1, ls2, sslen) in memo:\\n # return memo[(ls1, ls2, sslen)]\\n # if sslen == 1:\\n # memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\\n # return memo[(ls1, ls2, sslen)]\\n \\n # for xlen in range(1, sslen):\\n # ylen = sslen - xlen\\n # # x + y\\n # res = recurse_is_scramble(ls1, ls2, xlen) and recurse_is_scramble(ls1 + xlen, ls2 + xlen, ylen)\\n # if not res:\\n # # y + x\\n # res = res or (recurse_is_scramble(ls1 + xlen, ls2, ylen) and recurse_is_scramble(ls1, ls2 + ylen, xlen))\\n # if res:\\n # memo[(ls1, ls2, sslen)] = True\\n # return True\\n\\n # memo[(ls1, ls2, sslen)] = False\\n # return False\\n \\n # return recurse_is_scramble(0, 0, n)\\n\\n # Iterative solution\\n memo = {}\\n n = len(s1)\\n\\n for sslen in range(1, n + 1):\\n for ls1 in range(n):\\n if ls1 + sslen > n:\\n continue\\n for ls2 in range(n):\\n if ls2 + sslen > n:\\n continue\\n # print(\\\"ls1, ls2, sslen\\\", ls1, ls2, sslen)\\n if sslen == 1:\\n memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\\n continue\\n\\n res = False\\n for xlen in range(1, sslen):\\n ylen = sslen - xlen\\n # x + y\\n res = memo[(ls1, ls2, xlen)] and memo[(ls1 + xlen, ls2 + xlen, ylen)]\\n if not res:\\n # y + x\\n res = res or (memo[(ls1 + xlen, ls2, ylen)] and memo[(ls1, ls2 + ylen, xlen)])\\n if res:\\n memo[(ls1, ls2, sslen)] = True\\n break\\n if not res:\\n memo[(ls1, ls2, sslen)] = False\\n\\n return memo[(0, 0, n)]\",\n \"runtime\": \"328\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def scramble(p1, p2):\\n print(p1)\\n print(p2)\\n if len(p1) == 1:\\n return p1 == p2\\n \\n for k in range(1, len(p1)):\\n rev = len(p1) - k\\n unscrambled = scramble(p1[:k], p2[:k]) and scramble(p1[k:], p2[k:])\\n scrambled = scramble(p1[:rev], p2[k:]) and scramble(p1[rev:], p2[:k])\\n if unscrambled or scrambled:\\n return True\\n\\n return False\\n\\n return scramble(s1, s2)\",\n \"runtime\": \"332\"\n },\n {\n \"code\": \"class Solution:\\n @cache\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) == 1:\\n return s1 == s2\\n \\n for k in range(1, len(s1)):\\n unscrambled = self.isScramble(s1[:k], s2[:k]) and self.isScramble(s1[k:], s2[k:])\\n scrambled = self.isScramble(s1[:-k], s2[k:]) and self.isScramble(s1[-k:], s2[:k])\\n if unscrambled or scrambled:\\n return True\\n\\n return False\",\n \"runtime\": \"332\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # # Memomiazation \\n # # O(n^4) time, O(n^3) space\\n # if len(s1) != len(s2):\\n # return False\\n \\n # n = len(s1)\\n\\n # # (ls1, ls2, sslen). ls1 is starting index in s1. ls2 is starting index in s2, sslen is substring length we are testing.\\n # # where memo[(ls1, ls2, sslen)] = isScramble(s1[ls1..ls1+sslen-1], s2[ls2..ls2+sslen-1])\\n # memo = {}\\n\\n # def recurse_is_scramble(ls1, ls2, sslen):\\n # if (ls1, ls2, sslen) in memo:\\n # return memo[(ls1, ls2, sslen)]\\n # if sslen == 1:\\n # memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\\n # return memo[(ls1, ls2, sslen)]\\n \\n # for xlen in range(1, sslen):\\n # ylen = sslen - xlen\\n # # x + y\\n # res = recurse_is_scramble(ls1, ls2, xlen) and recurse_is_scramble(ls1 + xlen, ls2 + xlen, ylen)\\n # if not res:\\n # # y + x\\n # res = res or (recurse_is_scramble(ls1 + xlen, ls2, ylen) and recurse_is_scramble(ls1, ls2 + ylen, xlen))\\n # if res:\\n # memo[(ls1, ls2, sslen)] = True\\n # return True\\n\\n # memo[(ls1, ls2, sslen)] = False\\n # return False\\n \\n # return recurse_is_scramble(0, 0, n)\\n\\n # Iterative solution\\n memo = {}\\n n = len(s1)\\n\\n for sslen in range(1, n + 1):\\n for ls1 in range(n - sslen + 1):\\n for ls2 in range(n - sslen + 1):\\n # print(\\\"ls1, ls2, sslen\\\", ls1, ls2, sslen)\\n if sslen == 1:\\n memo[(ls1, ls2, sslen)] = s1[ls1] == s2[ls2]\\n continue\\n\\n res = False\\n for xlen in range(1, sslen):\\n ylen = sslen - xlen\\n # x + y\\n res = memo[(ls1, ls2, xlen)] and memo[(ls1 + xlen, ls2 + xlen, ylen)]\\n if not res:\\n # y + x\\n res = res or (memo[(ls1 + xlen, ls2, ylen)] and memo[(ls1, ls2 + ylen, xlen)])\\n if res:\\n memo[(ls1, ls2, sslen)] = True\\n break\\n if not res:\\n memo[(ls1, ls2, sslen)] = False\\n\\n return memo[(0, 0, n)]\",\n \"runtime\": \"336\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n def dp(s1, s2, memo):\\n if s1+\\\",\\\"+s2 in memo:\\n return memo[s1+\\\",\\\"+s2]\\n if s1 == s2:\\n return True\\n for i in range(1, len(s1)):\\n if dp(s1[i:], s2[i:], memo) and dp(s1[:i], s2[:i], memo):\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n if dp(s1[i:], s2[:-i], memo) and dp(s1[:i], s2[-i:], memo):\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n memo[s1+\\\",\\\"+s2] = False\\n return False\\n return dp(s1, s2, {})\",\n \"runtime\": \"336\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":132,"string":"132"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def __init__(self):\n self.memo = {}\n\n def isScramble(self, s1: str, s2: str) -> bool:\n # Early pruning by checking character frequencies\n if sorted(s1) != sorted(s2):\n return False\n \n # If the strings are already the same, they are scrambled versions of each other\n if s1 == s2:\n return True\n \n # Check memoization dictionary to avoid recomputation\n if (s1, s2) in self.memo:\n return self.memo[(s1, s2)]\n \n n = len(s1)\n for i in range(1, n):\n # Check both the direct and swapped conditions in the same loop\n if (self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:])) or \\\n (self.isScramble(s1[:i], s2[n-i:]) and self.isScramble(s1[i:], s2[:n-i])):\n self.memo[(s1, s2)] = True\n return True\n \n # If no valid scramble found, store the result as False\n self.memo[(s1, s2)] = False\n return False\n\n ","memory":"16400"},{"code":"from collections import defaultdict\n\ndef letterset(s:str):\n ret=defaultdict(int)\n for c in s:\n ret[c]+=1\n return ret\n\ndef find_split_points(s1:str, s2:str)->List[int]:\n ls=defaultdict(int)\n ret=[]\n for i,(c1,c2) in enumerate(zip(s1,s2)):\n ls[c1]+=1\n ls[c2]-=1\n if all(v==0 for v in ls.values()):\n ret.append(i+1)\n return ret[:-1] # cut the tail\n\ndef find_swap_points(s1:str, s2:str)->List[int]:\n ls=defaultdict(int)\n ret=[]\n for i in range(len(s1)-1):\n c1=s1[i]\n c2=s2[-1-i]\n ls[c1]+=1\n ls[c2]-=1\n if all(v==0 for v in ls.values()):\n ret.append(i+1)\n return ret\n\ndef solve_swap(s1:str, s2:str)->bool:\n if s1==s2: return True\n swaps = find_swap_points(s1, s2)\n #print(\"swap\", s1, s2, swaps)\n for sw in swaps:\n if solve(s1[:sw],s2[-sw:]) and solve(s1[sw:], s2[:-sw]):\n return True\n return False\n\ndef solve_split(s1:str, s2:str)->bool:\n if s1==s2: return True\n splits = find_split_points(s1, s2)\n #print(\"split\", s1, s2, splits)\n for sp in splits:\n if solve_swap(s1[:sp], s2[:sp]) and solve(s1[sp:], s2[sp:]):\n return True\n return False\n\ndef solve(s1:str, s2:str)->bool:\n if s1==s2: return True\n return solve_swap(s1,s2) or solve_split(s1,s2)\n\nclass Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2): return False\n if letterset(s1) != letterset(s2): return False\n return solve(s1, s2)","memory":"16500"},{"code":"class Solution:\n map = {}\n\n def isScramble(self, s1: str, s2: str) -> bool:\n n = len(s1)\n if s1 == s2:\n return True\n a, b, c = [0] * 26, [0] * 26, [0] * 26\n if (s1 + s2) in self.map:\n return self.map[s1 + s2]\n for i in range(1, n):\n j = n - i\n a[ord(s1[i - 1]) - ord('a')] += 1\n b[ord(s2[i - 1]) - ord('a')] += 1\n c[ord(s2[j]) - ord('a')] += 1\n if a == b and self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n self.map[s1 + s2] = True\n return True\n if a == c and self.isScramble(s1[:i], s2[j:]) and self.isScramble(s1[i:], s2[:j]):\n self.map[s1 + s2] = True\n return True\n self.map[s1 + s2] = False\n return False","memory":"16600"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \n dp = {}\n def helper(s, t):\n if (s, t) in dp:\n return dp[(s, t)]\n if sorted(s) != sorted(t):\n return False\n if len(s) == 1:\n return True\n \n for i in range(1, len(s)):\n if (helper(s[:i], t[-i:]) and helper(s[i:], t[:-i])) or (helper(s[i:], t[i:]) and helper(s[:i], t[:i])):\n dp[(s, t)] = True\n return True\n dp[(s, t)] = False\n return False\n \n return helper(s1, s2)","memory":"16700"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1==s2:\n return True\n s1len=len(s1)\n s2len=len(s2)\n if not s1len==s2len:\n return False\n if not sorted(s1)==sorted(s2):\n return False\n dpt=[]\n for loop1 in range(s1len+1):\n block=[]\n for loop2 in range(s1len):\n block.append([False]*s1len)\n dpt.append(block)\n for splptr in range(1,s1len+1):\n for s1ptr in range(s1len-splptr+1):\n for s2ptr in range(s2len-splptr+1):\n if splptr==1:\n if s1[s1ptr]==s2[s2ptr]:\n dpt[splptr][s1ptr][s2ptr]=True\n else:\n for aftersplptr in range(1,splptr):\n leftmatchleft=dpt[aftersplptr][s1ptr][s2ptr] and dpt[splptr-aftersplptr][s1ptr+aftersplptr][s2ptr+aftersplptr]\n leftmatchright=dpt[aftersplptr][s1ptr][s2ptr+(splptr-aftersplptr)] and dpt[splptr-aftersplptr][s1ptr+aftersplptr][s2ptr]\n dpt[splptr][s1ptr][s2ptr]=leftmatchleft or leftmatchright\n if leftmatchleft or leftmatchright:\n break\n return dpt[s1len][0][0]","memory":"16700"},{"code":"from collections import Counter\n\nfrom functools import cache\n\nclass Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n def _is_candidate(val, target):\n return Counter(val) == Counter(target)\n @cache\n def _fn(a, b):\n assert len(a) == len(b)\n\n l = len(a)\n if l == 1:\n return a == b\n\n for i in range(1, l):\n p2, p1 = a[:i], a[i:]\n t1, t2 = b[:-i], b[-i:]\n #print(f\"swap p1 : {p1} / t1 : {t1} / p2 : {p2} / t2 : {t2} \")\n if _is_candidate(p1, t1) and _is_candidate(p2, t2):\n \n out = _fn(p1, t1) and _fn(p2, t2)\n if out:\n return True\n\n p1, p2 = a[:i], a[i:]\n t1, t2 = b[:i], b[i:]\n #print(f\"no swap p1 : {p1} / t1 : {t1} / p2 : {p2} / t2 : {t2} \")\n\n if _is_candidate(p1, t1) and _is_candidate(p2, t2):\n out = _fn(p1, t1) and _fn(p2, t2)\n if out:\n return True\n\n return False\n return _fn(s1, s2)\n\n","memory":"16800"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \n dp = {}\n def helper(s, t):\n if (s, t) in dp:\n return dp[(s, t)]\n if sorted(s) != sorted(t):\n return False\n if len(s) == 1:\n return True\n \n for i in range(1, len(s)):\n if (helper(s[:i], t[-i:]) and helper(s[i:], t[:-i])) or (helper(s[i:], t[i:]) and helper(s[:i], t[:i])):\n dp[(s, t)] = True\n return True\n dp[(s, t)] = False\n return False\n \n return helper(s1, s2)","memory":"16800"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \n dp = {}\n def helper(s, t):\n if (s, t) in dp:\n return dp[(s, t)]\n if Counter(s) != Counter(t):\n return False\n if len(s) == 1:\n return True\n \n for i in range(1, len(s)):\n if (helper(s[:i], t[-i:]) and helper(s[i:], t[:-i])) or (helper(s[i:], t[i:]) and helper(s[:i], t[:i])):\n dp[(s, t)] = True\n return True\n dp[(s, t)] = False\n return False\n \n return helper(s1, s2)","memory":"16900"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n def mm(dct1,dct2):\n mmCnt=0\n for l,cnt in dct1.items():\n try:\n cnt2=dct2[l]\n except KeyError:\n cnt2=0\n if cnt>cnt2: \n mmCnt+=cnt-cnt2\n return mmCnt \n\n def count(s):\n dct={}\n for l in s:\n try:\n dct[l]+=1\n except KeyError:\n dct[l]=1\n return dct \n\n def upd(s,i,dcts):\n l=s[i]\n cnt=dcts[1].pop(l)\n if cnt >1:\n dcts[1][l]=cnt-1\n try:\n dcts[0][l]+=1\n except KeyError:\n dcts[0][l]=1\n def upd2(s,i,dcts):\n #print(dcts)\n l=s[-1-i]\n cnt=dcts[0].pop(l)\n if cnt >1:\n dcts[0][l]=cnt-1\n try:\n dcts[1][l]+=1\n except KeyError:\n dcts[1][l]=1 \n\n cache={}\n def check(s1,s2,dct1=None,dct2=None,n=0):\n try:\n r= cache[(s1,s2)]\n #print(' '*n,s1,s2, 'HIT!')\n return r\n except KeyError:\n pass \n \n\n #print(' '*n,s1,s2)\n if s1==s2:\n return True\n if dct1 is None:\n dcts1={},count(s1)\n dcts2={},count(s2)\n dcts2x=dcts2[1].copy(),{}\n\n if dcts1[1]!=dcts2[1]:\n return False\n else:\n if len(s1)<=3:\n return True\n dcts1={},dct1.copy()\n dcts2={},dct2.copy()\n dcts2x=dct2.copy(),{} \n\n for i in range(0,len(s1)-1):\n upd(s1,i,dcts1)\n upd(s2,i,dcts2)\n upd2(s2,i,dcts2x)\n if dcts1==dcts2:\n if check(s1[:i+1],s2[:i+1],dcts1[0],dcts2[0] , n+1 ) and check(s1[i+1:],s2[i+1:],dcts1[1],dcts2[1],n+1):\n cache[s1,s2]=True\n return True \n if dcts1==dcts2x[::-1]:\n if check( s1[:i+1],s2[-1-i:], dcts1[0],dcts2x[1] , n+1) and check(s1[i+1:],s2[:-1-i],dcts1[1],dcts2x[0],n+1):\n cache[s1,s2]=True\n return True\n cache[s1,s2]=False \n return False \n\n\n return check(s1,s2)\n\n","memory":"16900"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n def dp(s1, s2, memo):\n if s1+\",\"+s2 in memo:\n return memo[s1+\",\"+s2]\n if s1 == s2:\n memo[s1+\",\"+s2] = True\n return True\n\n for i in range(1, len(s1)):\n if dp(s1[i:], s2[i:], memo) and dp(s1[:i], s2[:i], memo):\n memo[s1+\",\"+s2] = True\n return True\n if dp(s1[i:], s2[:-i], memo) and dp(s1[:i], s2[-i:], memo):\n memo[s1+\",\"+s2] = True\n return True\n \n memo[s1+\",\"+s2] = False\n return False\n return dp(s1, s2, {})","memory":"17000"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str, memo=None) -> bool:\n if memo is None:\n memo = {}\n if (s1, s2) in memo:\n return memo[(s1, s2)]\n if len(s1) != len(s2):\n return False\n if s1 == s2:\n return True\n if sorted(s1) != sorted(s2):\n memo[(s1, s2)] = False\n return False\n n = len(s1)\n for i in range(1, n):\n if (self.isScramble(s1[:i], s2[:i], memo) and self.isScramble(s1[i:], s2[i:], memo)) or (self.isScramble(s1[:i], s2[-i:], memo) and self.isScramble(s1[i:], s2[:-i], memo)):\n memo[(s1, s2)] = True\n return True\n memo[(s1, s2)] = False\n return False\n\n","memory":"17000"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n def dp(s1, s2, memo):\n if s1+\",\"+s2 in memo:\n return memo[s1+\",\"+s2]\n if s1 == s2:\n return True\n for i in range(1, len(s1)):\n if dp(s1[i:], s2[i:], memo) and dp(s1[:i], s2[:i], memo):\n memo[s1+\",\"+s2] = True\n return True\n if dp(s1[i:], s2[:-i], memo) and dp(s1[:i], s2[-i:], memo):\n memo[s1+\",\"+s2] = True\n return True\n memo[s1+\",\"+s2] = False\n return False\n return dp(s1, s2, {})","memory":"17100"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n def dp(s1, s2, memo):\n if s1+\",\"+s2 in memo:\n return memo[s1+\",\"+s2]\n if s1 == s2:\n return True\n for i in range(1, len(s1)):\n if dp(s1[i:], s2[i:], memo) and dp(s1[:i], s2[:i], memo):\n memo[s1+\",\"+s2] = True\n return True\n if dp(s1[i:], s2[:-i], memo) and dp(s1[:i], s2[-i:], memo):\n memo[s1+\",\"+s2] = True\n return True\n memo[s1+\",\"+s2] = False\n return False\n return dp(s1, s2, {})","memory":"17100"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # A memoization dictionary to store already computed subproblems\n memo = {}\n \n # Recursive function to check if s1 is a scrambled string of s2\n def rec(s1, s2):\n if (s1, s2) in memo:\n return memo[(s1, s2)]\n if s1 == s2:\n memo[(s1, s2)] = True\n return memo[(s1, s2)]\n if sorted(s1) != sorted(s2):\n memo[(s1, s2)] = False\n return memo[(s1, s2)]\n \n n = len(s1)\n for i in range(1, n):\n if rec(s1[:i], s2[:i]) and rec(s1[i:], s2[i:]):\n memo[(s1, s2)] = True\n return memo[(s1, s2)]\n if rec(s1[:i], s2[-i:]) and rec(s1[i:], s2[:n-i]):\n memo[(s1, s2)] = True\n return memo[(s1, s2)]\n memo[(s1, s2)] = False\n return memo[(s1, s2)]\n return rec(s1, s2)\n\n \n","memory":"17200"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # Memoization dictionary to store results of subproblems\n memo = {}\n \n def is_scramble_recursive(s1, s2):\n # If the result is already computed, return it\n if (s1, s2) in memo:\n return memo[(s1, s2)]\n \n # If the strings are equal, they are trivially scrambled versions\n if s1 == s2:\n memo[(s1, s2)] = True\n return True\n \n # If the sorted characters of both strings do not match, they cannot be scrambled versions\n if sorted(s1) != sorted(s2):\n memo[(s1, s2)] = False\n return False\n \n n = len(s1)\n for i in range(1, n):\n # Check if there is a valid split where the substrings are scrambled versions\n if (is_scramble_recursive(s1[:i], s2[:i]) and is_scramble_recursive(s1[i:], s2[i:])) or \\\n (is_scramble_recursive(s1[:i], s2[-i:]) and is_scramble_recursive(s1[i:], s2[:-i])):\n memo[(s1, s2)] = True\n return True\n \n # If no valid split is found, the strings are not scrambled versions\n memo[(s1, s2)] = False\n return False\n \n return is_scramble_recursive(s1, s2)","memory":"17300"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # A memoization dictionary to store already computed subproblems\n memo = {}\n \n # Recursive function to check if s1 is a scrambled string of s2\n def rec(s1, s2):\n # If we have computed this already, return the stored result\n if (s1, s2) in memo:\n return memo[(s1, s2)]\n \n # Base case: If the strings are identical, they are scrambled versions\n if s1 == s2:\n memo[(s1, s2)] = True\n return True\n \n # If the sorted characters don't match, then s1 cannot be scrambled to s2\n if sorted(s1) != sorted(s2):\n memo[(s1, s2)] = False\n return False\n \n n = len(s1)\n \n # Try splitting the strings at different positions and check both scrambled and non-scrambled cases\n for i in range(1, n):\n # Case 1: No swap, check if s1[:i] matches s2[:i] and s1[i:] matches s2[i:]\n if rec(s1[:i], s2[:i]) and rec(s1[i:], s2[i:]):\n memo[(s1, s2)] = True\n return True\n # Case 2: Swap, check if s1[:i] matches s2[n-i:] and s1[i:] matches s2[:n-i]\n if rec(s1[:i], s2[-i:]) and rec(s1[i:], s2[:n-i]):\n memo[(s1, s2)] = True\n return True\n \n # If no solution is found, return False\n memo[(s1, s2)] = False\n return False\n \n # Start the recursion with the full strings\n return rec(s1, s2)\n\n \n","memory":"17300"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # base case: if s1 == s2 or if some split in s1 and swap == s2: return True\n \n def solve(s1, s2, memo):\n if (s1, s2) in memo:\n return memo[(s1, s2)]\n \n elif s1 == s2:\n memo[(s1, s2)] = True\n return True\n \n memo[(s1, s2)] = False\n n = len(s1)\n # case 1: split at 2, s1 = gr / eat, s2 = rg / eat\n for i in range(1, n):\n\n memo[(s1, s2)] = memo[(s1, s2)] or solve(s1[:i], s2[:i], memo) and solve(s1[i:], s2[i:], memo) or solve(s1[:i], s2[n-i:], memo) and solve(s1[i:], s2[:n-i], memo)\n \n return memo[(s1, s2)]\n\n return solve(s1, s2, {})","memory":"17400"},{"code":"class Solution:\n def isScramble(self,s1, s2):\n from functools import lru_cache\n\n n = len(s1)\n if n != len(s2):\n return False\n\n @lru_cache(None)\n def isScrambleRec(s1, s2):\n # Base cases\n if s1 == s2:\n return True\n if sorted(s1) != sorted(s2):\n return False\n\n n = len(s1)\n for i in range(1, n):\n # Without Swap\n if (isScrambleRec(s1[:i], s2[:i]) and isScrambleRec(s1[i:], s2[i:])):\n return True\n # With Swap\n if (isScrambleRec(s1[:i], s2[-i:]) and isScrambleRec(s1[i:], s2[:-i])):\n return True\n return False\n\n return isScrambleRec(s1, s2)\n","memory":"17400"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n memo = {}\n\n def dfs(s1, s2):\n if (s1, s2) in memo:\n return memo[(s1, s2)]\n\n if s1 == s2:\n memo[(s1, s2)] = True\n return True\n \n if sorted(s1) != sorted(s2):\n memo[(s1, s2)] = False\n return False\n \n n = len(s1)\n for i in range(1, n):\n if dfs(s1[:i], s2[:i]) and dfs(s1[i:], s2[i:]):\n memo[(s1, s2)] = True\n return True\n if dfs(s1[:i], s2[-i:]) and dfs(s1[i:], s2[:-i]):\n memo[(s1, s2)] = True\n return True\n \n memo[(s1, s2)] = False\n return False\n\n ret = dfs(s1, s2)\n print(memo)\n return ret","memory":"17500"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(i: int, j: int, k: int) -> bool:\n if k == 1:\n return s1[i] == s2[j]\n for h in range(1, k):\n if dfs(i, j, h) and dfs(i + h, j + h, k - h):\n return True\n if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):\n return True\n return False\n\n return dfs(0, 0, len(s1))","memory":"17600"},{"code":"from functools import lru_cache\r\nimport time\r\nclass Solution:\r\n cache = {}\r\n def isScramble2(self, s1: str, s2: str) -> bool: \r\n def hashmatch(s1map, s2):\r\n s2map = {}\r\n for s in s2:\r\n if s not in s2map:\r\n s2map[s] = 1\r\n else:\r\n s2map[s] += 1\r\n for key in s1map.keys():\r\n if key not in s2map or s2map[key] != s1map[key]:\r\n return False\r\n return True \r\n if len(s1) == 1:\r\n return s1 == s2\r\n key = f'{s1}-{s2}'\r\n if key in self.cache:\r\n return self.cache[key]\r\n n = len(s1)\r\n for i in range(n):\r\n if i+1<n-i-1:\r\n s1_l = s1[:i+1]\r\n s2_l = s2[:i+1]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[i+1:]\r\n s1map = {}\r\n for s in s1_l:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n s1rmap = {}\r\n for s in s1_r:\r\n if s not in s1rmap:\r\n s1rmap[s] = 1\r\n else:\r\n s1rmap[s] += 1\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n s1_l = s1[:i+1]\r\n s2_l = s2[-i-1:]\r\n s1_r = s1[i+1:]\r\n s2_r = s2[:-i-1]\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True\r\n else:\r\n s1_l = s1[i+1:]\r\n s2_l = s2[i+1:]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[:i+1]\r\n s1map = {}\r\n for s in s1_l:\r\n if s not in s1map:\r\n s1map[s] = 1\r\n else:\r\n s1map[s] += 1\r\n s1rmap = {}\r\n for s in s1_r:\r\n if s not in s1rmap:\r\n s1rmap[s] = 1\r\n else:\r\n s1rmap[s] += 1 \r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n s1_l = s1[i+1:]\r\n s2_l = s2[:-i-1]\r\n s1_r = s1[:i+1]\r\n s2_r = s2[-i-1:]\r\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\r\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\r\n self.cache[key] = True\r\n return True \r\n self.cache[key] = False\r\n return False\r\n\r\n def isScramble(self, s1: str, s2: str) -> bool:\r\n from functools import lru_cache\r\n\r\n @lru_cache(None)\r\n def dfs(s1, s2):\r\n if s1 == s2:\r\n return True\r\n if sorted(s1) != sorted(s2):\r\n return False\r\n n = len(s1)\r\n for i in range(1, n):\r\n # Check without swap\r\n if dfs(s1[:i], s2[:i]) and dfs(s1[i:], s2[i:]):\r\n return True\r\n # Check with swap\r\n if dfs(s1[:i], s2[-i:]) and dfs(s1[i:], s2[:-i]):\r\n return True\r\n return False\r\n\r\n return dfs(s1, s2) ","memory":"17700"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(l0, l1, _len):\n if _len == 1 and s1[l0] != s2[l1]:\n return False\n if s1[l0 : l0 + _len] == s2[l1 : l1 + _len]:\n return True\n ##\n for k in range(1, _len):\n if dfs(l0, l1, k) and dfs(l0 + k, l1 + k, _len - k):\n return True\n if dfs(l0, l1 + _len - k, k) and dfs(l0 + k, l1, _len - k):\n return True\n ##\n return False\n\n ##\n return dfs(0, 0, len(s2))\n","memory":"17800"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n\n @lru_cache(None)\n def loop(i, j, x, y):\n if x + 1 == y:\n return s1[i] == s2[x]\n\n size = j - i\n for k in range(1, size):\n k_ = size - k\n if (\n loop(i, i + k, x, x + k)\n and loop(i + k, j, x + k, y)\n or loop(i + k, j, x, x + k_)\n and loop(i, i + k, x + k_, y)\n ):\n return True\n return False\n\n n = len(s1)\n\n return loop(0, n, 0, n)\n","memory":"17900"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n\n cache = {} # ()\n\n def dfs(cur_s, cur_e, tar_s, tar_e):\n if (cur_s, cur_e, tar_s, tar_e) in cache:\n return cache[(cur_s, cur_e, tar_s, tar_e)]\n\n lenn = cur_e - cur_s \n \n is_scramble = False\n if s1[cur_s:cur_e] == s2[tar_s:tar_e]:\n is_scramble = True\n elif lenn == 1 and s1[cur_s:cur_e] != s2[tar_s:tar_e]:\n is_scramble = False\n else:\n # We need to split\n for i in range(1, lenn):\n #no-swap\n if dfs(cur_s, cur_s + i, tar_s, tar_s + i) and dfs(cur_s + i, cur_e, tar_s + i, tar_e):\n is_scramble = True\n break\n #swap\n if dfs(cur_s, cur_s + i, tar_e - i, tar_e) and dfs(cur_s + i, cur_e, tar_s, tar_e - i):\n is_scramble = True\n break\n\n cache[(cur_s, cur_e, tar_s, tar_e)] = is_scramble\n return cache[(cur_s, cur_e, tar_s, tar_e)]\n\n return dfs(0, len(s1), 0, len(s2))","memory":"18000"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n\n cache = {} # ()\n\n def dfs(cur_s, cur_e, tar_s, tar_e):\n if (cur_s, cur_e, tar_s, tar_e) in cache:\n return cache[(cur_s, cur_e, tar_s, tar_e)]\n\n lenn = cur_e - cur_s \n \n is_scramble = False\n if s1[cur_s:cur_e] == s2[tar_s:tar_e]:\n is_scramble = True\n elif lenn == 1 and s1[cur_s:cur_e] != s2[tar_s:tar_e]:\n is_scramble = False\n else:\n # We need to split\n for i in range(1, lenn):\n #no-swap\n if dfs(cur_s, cur_s + i, tar_s, tar_s + i) and dfs(cur_s + i, cur_e, tar_s + i, tar_e):\n is_scramble = True\n break\n #swap\n if dfs(cur_s, cur_s + i, tar_e - i, tar_e) and dfs(cur_s + i, cur_e, tar_s, tar_e - i):\n is_scramble = True\n break\n\n cache[(cur_s, cur_e, tar_s, tar_e)] = is_scramble\n return cache[(cur_s, cur_e, tar_s, tar_e)]\n\n return dfs(0, len(s1), 0, len(s2))","memory":"18000"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(l0, r0, l1, r1):\n if not (0 <= l0 < len(s1) and 0 <= l1 < len(s2)):\n return False\n if not (0 <= r0 < len(s1) and 0 <= r1 < len(s2)):\n return False\n if r0 - l0 != r1 - l1:\n return False\n if s1[l0 : 1 + r0] == s2[l1 : 1 + r1]:\n return True\n if r0 == l0 and s1[l0] != s2[l1]:\n return False\n \n ##\n for k in range(0, r0 - l0):\n if dfs(l0, l0 + k, l1, l1 + k) and dfs(l0 + k + 1, r0, l1 + k + 1, r1):\n return True\n if dfs(l0, l0 + k, r1 - k, r1) and dfs(l0 + k + 1, r0, l1, r1 - k - 1):\n return True\n ##\n return False\n\n ##\n return dfs(0, len(s1) - 1, 0, len(s2) - 1)\n","memory":"18100"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dfs(l0, r0, l1, r1):\n if s1[l0 : 1 + r0] == s2[l1 : 1 + r1]:\n return True\n if r0 == l0 and s1[l0] != s2[l1]:\n return False\n \n ##\n for k in range(0, r0 - l0):\n if dfs(l0, l0 + k, l1, l1 + k) and dfs(l0 + k + 1, r0, l1 + k + 1, r1):\n return True\n if dfs(l0, l0 + k, r1 - k, r1) and dfs(l0 + k + 1, r0, l1, r1 - k - 1):\n return True\n ##\n return False\n\n ##\n return dfs(0, len(s1) - 1, 0, len(s2) - 1)\n","memory":"18100"},{"code":"class Solution:\n @functools.lru_cache(None)\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n if collections.Counter(s1) != collections.Counter(s2):\n return False\n\n for i in range(1, len(s1)):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n return True\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\n self.isScramble(s1[i:], s2[: len(s2) - i])):\n return True\n\n return False","memory":"18200"},{"code":"class Solution:\n @lru_cache(None)\n def isScramble(self, s1: str, s2: str) -> bool:\n m =len(s1)\n n=len(s2)\n if m!=n or sorted(s1)!=sorted(s2): return False\n if m<=3 or s1==s2: return True\n f = self.isScramble\n for i in range(1,len(s1)):\n if f(s1[:i],s2[:i]) and f(s1[i:],s2[i:]) or f(s1[:i],s2[-i:]) and f(s1[i:],s2[:-i]):\n return True\n return False\n","memory":"18300"},{"code":"class Solution:\n @functools.lru_cache(None)\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n if collections.Counter(s1) != collections.Counter(s2):\n return False\n\n for i in range(1, len(s1)):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\n return True\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\n self.isScramble(s1[i:], s2[: len(s2) - i])):\n return True\n\n return False","memory":"18400"},{"code":"def substr(s, k, n):\n return s[k:k+n]\n \n\nclass Solution:\n def isScramble(self, s1: str, s2: str, memo=None) -> bool:\n if memo is None: memo = {}\n key1 = f'{s1}_{s2}'\n key2 = f'{s2}_{s1}'\n\n if key1 in memo: return memo[key1]\n if key2 in memo: return memo[key2]\n\n if s1 == s2:\n memo[key1] = True\n memo[key2] = True\n return True\n if len(s1) != len(s2):\n memo[key1] = False\n memo[key2] = False\n return False\n n = len(s1)\n if n <= 1:\n memo[key1] = False\n memo[key2] = False\n return False\n \n ans = False\n for k in range(1, n):\n l, r = substr(s1, 0, k), substr(s2, n-k, k)\n cross_left = self.isScramble(l, r, memo)\n tkey = f'{l}_{r}'\n memo[tkey] = cross_left\n tkey = f'{r}_{l}'\n memo[tkey] = cross_left\n\n l, r = substr(s1, k, n-k), substr(s2, 0, n-k)\n cross_right = self.isScramble(l, r, memo)\n tkey = f'{l}_{r}'\n memo[tkey] = cross_right\n tkey = f'{r}_{l}'\n memo[tkey] = cross_right\n\n l, r = substr(s1, 0, k), substr(s2, 0, k)\n same_left = self.isScramble(l, r, memo)\n tkey = f'{l}_{r}'\n memo[tkey] = same_left\n tkey = f'{r}_{l}'\n memo[tkey] = same_left\n\n l, r = substr(s1, k, n-k), substr(s2, k, n-k)\n same_right = self.isScramble(l, r, memo)\n tkey = f'{l}_{r}'\n memo[tkey] = same_right\n tkey = f'{r}_{l}'\n memo[tkey] = same_right\n \n cond1 = cross_left and cross_right\n cond2 = same_left and same_right\n if cond1 or cond2:\n ans = True\n break\n\n memo[key1] = ans\n memo[key2] = ans\n return ans","memory":"18500"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n save={}\n def dfs(s1: str, s2: str) -> bool:\n nonlocal save\n if s1==s2:\n return True\n if (s1,s2) in save:\n return save[(s1,s2)]\n p1,p2={},{}\n for i in range(len(s1)):\n if s1[i] not in p1:\n p1[s1[i]]=1\n else:\n p1[s1[i]]+=1\n if s2[i] not in p2:\n p2[s2[i]]=1\n else:\n p2[s2[i]]+=1\n if p1!=p2:\n save[(s1,s2)]=False\n return False\n for i in range(1,len(s1)):\n if dfs(s1[:i],s2[:i])&dfs(s1[i:],s2[i:]):\n save[(s1,s2)]=True\n return True\n if dfs(s1[:i],s2[-1:-i-1:-1])&dfs(s1[i:],s2[:-i]):\n save[(s1,s2)]=True\n return True\n save[(s1,s2)]=False\n return False\n return dfs(s1,s2)","memory":"18500"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n memoized = {}\n return self.isScrambleInternal(s1, s2, memoized)\n\n def isScrambleInternal(self, s1, s2, memoized):\n if len(s1) == 0 and len(s2) == 0:\n return True\n if len(s1) == 1 and len(s2) == 1:\n return s1[0] == s2[0]\n if s1 == s2:\n return True\n if (s1, s2) in memoized:\n return memoized[(s1, s2)]\n\n result = False\n for i in range(1, len(s1)):\n left1 = s1[:i]\n left2 = s2[:i]\n scrambledLeft = self.isScrambleInternal(left1, left2, memoized)\n\n right1 = s1[i:]\n right2 = s2[i:]\n scrambledRight = self.isScrambleInternal(right1, right2, memoized)\n\n if scrambledLeft and scrambledRight:\n result = True\n break\n\n revLeft2 = s2[len(s2) - i:]\n revRight2 = s2[:len(s2) - i]\n scrambledRevLeft = self.isScrambleInternal(left1, revLeft2, memoized)\n scrambledRevRight = self.isScrambleInternal(right1, revRight2, memoized)\n if scrambledRevLeft and scrambledRevRight:\n result = True\n break\n\n memoized[(s1, s2)] = result\n return result","memory":"18600"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n memo = defaultdict(bool)\n def helper(a, b):\n nonlocal memo\n if (a, b) in memo:\n return memo[(a, b)]\n if len(a) != len(b):\n memo[(a, b)] = False\n return False\n if a == b:\n memo[(a, b)] = True\n return True\n if len(a) <= 1:\n memo[(a, b)] = False\n return False\n n = len(a)\n for i in range(1, n):\n c1 = (helper(a[0:i], b[n-i:n]) and helper(a[i:n], b[0:n-i]))\n c2 = (helper(a[0:i], b[0:i]) and helper(a[i:n], b[i:n]))\n if (c1 or c2):\n memo[(a, b)] = True\n return True\n memo[(a, b)] = False\n return False\n return helper(s1, s2)\n","memory":"18700"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1)!=len(s2):\n return False\n if len(s1)==0 and len(s2)==0:\n return True\n d={}\n def helper(s1,s2):\n if s1==s2:\n return True\n if len(s1)<=1:\n return False\n if (s1,s2) in d:\n return d[(s1,s2)]\n flag=False\n for i in range(1,len(s1)):\n case1 = (helper(s1[0:i], s2[0:i]) and helper(s1[i:], s2[i:]))\n case2 = (helper(s1[0:i], s2[-i:]) and helper(s1[i:], s2[0:-i]))\n if (case1 or case2):\n flag=True\n break\n d[(s1,s2)]=flag\n return d[(s1,s2)]\n return helper(s1,s2)\n\n ","memory":"18800"},{"code":"# intuition is that s2 can be scrabled by s1 as long as they have the same letters.\n\n# for example \n\n# 12345 -> 54321\n# 12 / 345\n# 12 -> 2 / 1\n# 345 -> 5 / 34\n# 34 -> 4/3\n\n# oh here is a counter example \n\n# abcde -> caebd\n\n# abcde -> bcde / a to move c before a\n\n# but now we have no way to move b/d/e after a \n\n# every scrable moves a substring s1 permanently after s2\n\n# cadbe won't work either, because when you move c before a, you must be moving de before a and no way back\n\n# so the first split must happen between the first letters of s1 and s2, the scramble is promising only when \n# all letter after s2's first letter is always in front of s1's letter\n\n# brute force is to enumerate all scrambled s2, for a string of length n, each split is O(n), and there are n-1 positions to split\n\n# so O(n) = n(n-1)*T(n-1) = O(n^2n)\n# theta(n) = n(n-1)*T(n/2) = O(n^(2*log_2^n))\n\n\n# so basically we can divide and conqure the problem: \n\n# for s1 = abcde and s2 = cdeba, we have 4 split\n\n# a/bcde, ab/cde, abc/de, abcd/e\n\n# now for s2 to be a scramble string, it must be any of the following split match the those for s1's split\n\n# c/deba, cd/eba, cde/ba, cdeb/a\n\n# by match we means the two part of at least one s2 spllits can be scramble, individualy by the two part of at least one s1 splits\n# we know that when letters doesn't match, or length doesn't match, it won't be scramble. This help eliminate many cases. \n\n# Effectively, we only need to check: \n# a/bcde v.s. c/deba and cdeb/a => i=1, s1[:1] v.s. s2[:i] && s1[1:5] v.s. s2[1:5] | s1[:1] v.s. s2[5-1:5] && s1[1:5] v.s. s2[:5-1]\n# ab/cde v.s. cd/eba and cde/ba\n# abc/de v.s. cd/eba and cde/ba\n# abcd/e v.s. c/deba and cdeb/a\n\n# and we can also expect many substrings comparison will be repeated and we can memorize for quicker solution.\n\nclass Solution:\n @functools.lru_cache(maxsize=1024*1024, typed=False)\n def isScramble(self, s1: str, s2: str) -> bool:\n # print(s1, s2)\n if s1 == s2:\n return True\n if sorted(s1) != sorted(s2):\n return False;\n n = len(s1)\n for i in range(1,n):\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:n], s2[i:n]):\n return True\n if self.isScramble(s1[:i], s2[n-i:n]) and self.isScramble(s1[i:n], s2[:n-i]):\n return True\n return False\n","memory":"18900"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def is_scramble(a, b):\n if a == b:\n return True\n\n if len(a) == 1:\n return False\n \n for i in range(1, len(a)):\n a1, a2 = a[:i], a[i:]\n b1, b2 = b[:i], b[i:]\n if is_scramble(a1, b1) and is_scramble(a2, b2):\n return True\n \n b1, b2 = b[:len(a2)], b[len(a2):]\n if is_scramble(a2, b1) and is_scramble(a1, b2):\n return True\n\n return False\n \n return is_scramble(s1, s2)\n","memory":"19000"},{"code":"class Solution(object):\n def isScramble(self, s1, s2):\n \"\"\"\n Determines if s2 is a scrambled string of s1.\n\n Args:\n s1 (str): The original string.\n s2 (str): The string to compare against the scrambled version of s1.\n\n Returns:\n bool: True if s2 is a scrambled string of s1, False otherwise.\n \"\"\"\n from functools import lru_cache\n\n # Early termination if lengths differ or sorted characters don't match\n if len(s1) != len(s2):\n return False\n if sorted(s1) != sorted(s2):\n return False\n\n @lru_cache(maxsize=None)\n def dfs(s1_sub, s2_sub):\n \"\"\"\n Recursively checks if s2_sub is a scrambled string of s1_sub.\n\n Args:\n s1_sub (str): Substring of s1.\n s2_sub (str): Substring of s2.\n\n Returns:\n bool: True if s2_sub is a scrambled string of s1_sub, False otherwise.\n \"\"\"\n # If the substrings are equal, they are scrambles\n if s1_sub == s2_sub:\n return True\n\n n = len(s1_sub)\n # Try all possible split positions\n for i in range(1, n):\n # Without swapping\n if dfs(s1_sub[:i], s2_sub[:i]) and dfs(s1_sub[i:], s2_sub[i:]):\n return True\n # With swapping\n if dfs(s1_sub[:i], s2_sub[-i:]) and dfs(s1_sub[i:], s2_sub[:-i]):\n return True\n # If no valid split found\n return False\n\n return dfs(s1, s2)","memory":"19100"},{"code":"vis = {}\nclass Solution:\n\n def isScramble(self, s1: str, s2: str) -> bool:\n global vis\n if (len(s1) == 1 and len(s2) == 1):\n return s1 == s2\n if ((s1, s2) in vis):\n return vis[(s1, s2)]\n \n vis[(s1, s2)] = False\n if (sorted(s1) != sorted(s2)):\n return False\n \n for i in range(1, len(s1)):\n left = s1[:i]\n right = s1[i:]\n bool1a = self.isScramble(left, s2[:i])\n bool1b = self.isScramble(right, s2[i:])\n\n bool2a = self.isScramble(left, s2[-i:])\n bool2b = self.isScramble(right, s2[:-i])\n if ((bool1a and bool1b) or (bool2a and bool2b)):\n vis[(s1, s2)] = True\n return True\n return False","memory":"19200"},{"code":"class Solution(object):\n def isScramble(self, s1, s2):\n \"\"\"\n :type s1: str\n :type s2: str\n :rtype: bool\n \"\"\"\n # Base cases\n\n n = len(s1)\n\n # If both strings are not equal in size\n if len(s2) != n:\n return False\n\n # If both strings are equal\n if s1 == s2:\n return True\n\n # If code is reached to this condition then following this are sure:\n # 1. size of both string is equal\n # 2. string are not equal\n # so size is equal (where size==1) and they are not equal then obviously false\n # example 'a' and 'b' size is equal, string are not equal\n if n == 1:\n return False\n\n key = s1 + \" \" + s2\n\n # Check if this problem has already been solved\n if key in self.mp:\n return self.mp[key]\n\n # For every iteration it can two condition\n # 1. We should proceed without swapping\n # 2. We should swap before looking next\n for i in range(1, n):\n # ex of without swap: gr|eat and rg|eat\n without_swap = (\n # Left part of first and second string\n self.isScramble(s1[:i], s2[:i])\n and\n # Right part of first and second string;\n self.isScramble(s1[i:], s2[i:])\n )\n\n # If without swap gives us the right answer then we do not need\n # to call the recursion with swap\n if without_swap:\n return True\n\n # ex of with swap: gr|eat rge|at\n # here we compare \"gr\" with \"at\" and \"eat\" with \"rge\"\n with_swap = (\n # Left part of first and right part of second\n self.isScramble(s1[:i], s2[n-i:])\n and\n # Right part of first and left part of second\n self.isScramble(s1[i:], s2[:n-i])\n )\n\n # If with swap gives us the right answer then we return True\n # otherwise, the for loop does its work\n if with_swap:\n return True\n\n self.mp[key] = False\n return False\n\n # for storing already solved problems\n mp = {}","memory":"19300"},{"code":"class Solution(object):\n def isScramble(self, s1, s2):\n \"\"\"\n :type s1: str\n :type s2: str\n :rtype: bool\n \"\"\"\n # Base cases\n\n n = len(s1)\n\n # If both strings are not equal in size\n if len(s2) != n:\n return False\n\n # If both strings are equal\n if s1 == s2:\n return True\n\n # If code is reached to this condition then following this are sure:\n # 1. size of both string is equal\n # 2. string are not equal\n # so size is equal (where size==1) and they are not equal then obviously false\n # example 'a' and 'b' size is equal, string are not equal\n if n == 1:\n return False\n\n key = s1 + \" \" + s2\n\n # Check if this problem has already been solved\n if key in self.mp:\n return self.mp[key]\n\n # For every iteration it can two condition\n # 1. We should proceed without swapping\n # 2. We should swap before looking next\n for i in range(1, n):\n # ex of without swap: gr|eat and rg|eat\n without_swap = (\n # Left part of first and second string\n self.isScramble(s1[:i], s2[:i])\n and\n # Right part of first and second string;\n self.isScramble(s1[i:], s2[i:])\n )\n\n # If without swap gives us the right answer then we do not need\n # to call the recursion with swap\n if without_swap:\n return True\n\n # ex of with swap: gr|eat rge|at\n # here we compare \"gr\" with \"at\" and \"eat\" with \"rge\"\n with_swap = (\n # Left part of first and right part of second\n self.isScramble(s1[:i], s2[n-i:])\n and\n # Right part of first and left part of second\n self.isScramble(s1[i:], s2[:n-i])\n )\n\n # If with swap gives us the right answer then we return True\n # otherwise, the for loop does its work\n if with_swap:\n return True\n\n self.mp[key] = False\n return False\n\n # for storing already solved problems\n mp = {}","memory":"19300"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # n = len(s1)\n\n # dp = [[[False for j in range(n)] for i in range(n)] for l in range(n+1)]\n\n # for i in range(n):\n # for j in range(n):\n # dp[1][i][j] = s1[i] == s2[j]\n \n # for length in range(2, n+1):\n # for i in range(n+1 - length):\n # for j in range(n+1 - length):\n # for new_length in range(1, length):\n # dp1 = dp[new_length][i]\n # dp2 = dp[length - new_length][i+new_length]\n # dp[length][i][j] |= dp1[j] and dp2[j+new_length]\n # dp[length][i][j] |= (dp1[j + length - new_length] and dp2[j])\n\n # return dp[n][0][0]\n memo = {}\n def dfs(s1, s2):\n if s1 == s2:\n return True\n if (s1, s2) in memo:\n return memo[(s1, s2)]\n \n if Counter(s1) != Counter(s2):\n memo[(s1, s2)] = False\n return False\n\n n = len(s1)\n memo[(s1, s2)] = False\n for k in range(1, n):\n if dfs(s1[:k], s2[:k]) and dfs(s1[k:], s2[k:]) or dfs(s1[:k], s2[n-k:]) and dfs(s1[k:], s2[:n-k]):\n memo[(s1, s2)] = True\n return memo[(s1, s2)]\n\n return dfs(s1, s2)","memory":"19400"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n mp = {}\n\n def solve(s1, s2):\n if s1 == s2:\n return True\n if len(s1) <= 1:\n return False\n\n temp = s1 + s2\n if temp in mp:\n return mp[temp]\n\n n = len(s1)\n \n for i in range(1, n):\n # swap\n if (solve(s1[:i], s2[n-i:]) and solve(s1[i:], s2[:n-i])):\n mp[temp] = True\n return True\n # noswap\n if (solve(s1[:i], s2[:i]) and solve(s1[i:], s2[i:])):\n mp[temp] = True\n return True\n \n mp[temp] = False\n return False\n \n if len(s1) != len(s2):\n return False\n if len(s1) == 0 and len(s2) == 0:\n return True\n \n return solve(s1, s2)\n","memory":"19400"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n d=dict()\n def helper(x,y):\n if len(x)!=len(y):\n return False\n if x==y:\n return True\n key=x+\" \"+y\n if key in d:\n return d[key]\n n=len(x)\n for i in range(1,n):\n if helper(x[:i],y[:i]) and helper(x[i:],y[i:]):\n d[key] = True\n return True\n if helper(x[:i],y[-i:]) and helper(x[i:],y[:-i]):\n d[key]=True\n return True\n d[key]=False\n return False\n return helper(s1,s2)","memory":"19500"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1) != len(s2):\n return False\n\n cache = {} # ()\n\n def dfs(current, target):\n if (current, target) in cache:\n return cache[(current, target)]\n\n is_scramble = False\n # print(current, target)\n if current == target:\n is_scramble = True\n elif len(current) == 1 and current != target:\n is_scramble = False\n else:\n # We need to split\n for i in range(1, len(current)):\n front = current[0: i]\n back = current[i:]\n\n #no-swap\n if dfs(front, target[0: i]) and dfs(back, target[i:]):\n is_scramble = True\n break\n end = len(current) - i\n if dfs(front, target[end:]) and dfs(back, target[0: end]):\n is_scramble = True\n break\n\n cache[(current, target)] = is_scramble\n return cache[(current, target)]\n\n return dfs(s1, s2)","memory":"19500"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if(len(s1) != len(s2)):\n return False\n \n if(s1 == s2):\n return True\n\n dp = {}\n def solve(s1, s2):\n if(s1 == s2):\n return True\n \n key = s1 + \"#\" + s2\n\n if key in dp:\n return dp[key]\n \n n = len(s1)\n for i in range(1, n):\n s1Left = s1[:i]\n s1Right = s1[n - i:]\n s2Left = s2[:i]\n s2Right = s2[n - i:]\n\n isSwap = solve(s1[:i],s2[:i]) and solve(s1[i:], s2[i:])\n noSwap = solve(s1[:i], s2[n - i:]) and solve(s1[i:], s2[:n - i])\n\n\n if isSwap or noSwap:\n dp[key] = True\n return True\n \n dp[key] = False\n return False\n \n return solve(s1, s2)\n \n\n ","memory":"19600"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str, dctx = {}) -> bool:\n if (s1,s2) in dctx:\n return dctx[(s1,s2)]\n if len(s1) != len(s2):\n return False\n elif s1 == s2:\n return True\n elif set(s1) != set(s2):\n return False\n \n for i in range(1,len(s1)):\n # No Swap\n a = self.isScramble(s1[:i], s2[:i], dctx)\n b = self.isScramble(s1[i:], s2[i:], dctx)\n if a and b:\n dctx[(s1,s2)] = True\n return True\n\n # With Swap\n # print(s1[i:] + \" \" + s1[:i])\n # print(s2[:len(s1)-i] + \" \" + s2[len(s1)-i:])\n a = self.isScramble(s1[i:], s2[:len(s1)-i], dctx)\n b = self.isScramble(s1[:i], s2[len(s1)-i:], dctx)\n if a and b:\n dctx[(s1,s2)] = True\n return True\n dctx[(s1,s2)] = False\n return False\n \n ","memory":"19700"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if(len(s1) != len(s2)):\n return False\n \n if(s1 == s2):\n return True\n\n dp = {}\n def solve(s1, s2, swap):\n # print(s1, s2, swap)\n if(s1 == s2):\n return True\n \n key = s1 + \"#\" + s2\n\n if key in dp:\n return dp[key]\n \n n = len(s1)\n for i in range(1, n):\n s1Left = s1[:i]\n s1Right = s1[n - i:]\n s2Left = s2[:i]\n s2Right = s2[n - i:]\n\n isSwap = solve(s1[:i],s2[:i], True) and solve(s1[i:], s2[i:], True)\n noSwap = solve(s1[:i], s2[n - i:], False) and solve(s1[i:], s2[:n - i], False)\n\n print(key, s1Left, s1Right, s2Left, s2Right)\n print(key, isSwap, noSwap)\n\n if isSwap or noSwap:\n dp[key] = True\n return True\n \n dp[key] = False\n return False\n \n return solve(s1, s2, False)\n \n\n ","memory":"19900"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n # let f[a][b][c][d] = True / False to check whether s2[c:d] can be scambled to s1[a:b]\n # if c - d != b - a: f[a][b][c][d] = False\n # if s1[a:b] == s2[c:d]: f[a][b][c][d] = True\n # if find t, where 0 < t < d - c:\n # f[a][b][c][d] = True if exist t:\n # f[a][a+t][c][c+t] and f[a+t][b][c+t][d] or\n # f[a][a+n-t][c][c+n-t] and f[a+n-t+1][b][c+n-t+1][d]\n\n f = {}\n\n def dp(a, b, c, d):\n if (a, b, c, d) in f:\n return f[(a, b, c, d)]\n \n # print(a, b, c, d)\n\n if b - a != d - c:\n return False\n\n if s1[a:b] == s2[c:d]:\n return True\n\n n = b - a\n for t in range(1, n):\n if (dp(a, a+t, c, c+t) and dp(a+t, b, c+t, d)) or (dp(a, a+n-t, d-n+t, d) and dp(a+n-t, b, c, d-n+t)):\n f[(a, b, c, d)] = True\n return True\n \n f[(a, b, c, d)] = False\n return False\n\n\n return dp(0, len(s1), 0, len(s2))","memory":"20000"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if s1 == s2:\n return True\n if len(s1) == 1:\n return False\n\n cache = {}\n def helper(s1, s2):\n if s1 == s2:\n return True\n if len(s1) == 1:\n return False\n if s1+s2 in cache:\n return cache[s1+s2]\n\n for i in range(1, len(s1)):\n if (helper(s1[:i], s2[:i]) and helper(s1[i:], s2[i:])) or (helper(s1[len(s1) - i:], s2[:i]) and helper(s1[:len(s1) - i], s2[i:])):\n cache[s1+s2] = True\n return True\n cache[s1+s2] = False\n return False\n return helper(s1, s2)\n\n ","memory":"20100"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n \n dp = {}\n \n def dfs(s1, s2): \n \n if s1 == s2: return True\n \n if (s1, s2) in dp: \n return dp[(s1, s2)]\n \n for i in range(1, len(s1)): \n if dfs(s1[i:], s2[i:]) and dfs(s1[:i], s2[:i]):\n dp[(s1, s2)] = True\n return True\n if dfs(s1[i:], s2[:-i]) and dfs(s1[:i], s2[-i:]):\n dp[(s1, s2)] = True\n return True\n \n dp[(s1, s2)] = False\n return False\n \n return dfs(s1, s2)","memory":"20500"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def scrammed(start1, end1, start2, end2):\n assert end1-start1 == end2-start2\n l = end1 - start1\n assert l > 0\n if l == 1:\n return s1[start1] == s2[start2]\n splits1 = [ ( (start1, start1+split), (start1+split, end1) ) \n for split in range(1, l) ]\n splits2a = [ ( (start2, start2+split), (start2+split, end2) )\n for split in range(1, l) ]\n splits2b = [ ( s2, s1) for s1, s2 in reversed(splits2a) ]\n print\n straight_scram = any( scrammed(*se11, *se21) and scrammed(*se12, *se22) \n for (se11, se12), (se21, se22) in zip(splits1, splits2a)\n )\n flipped_scram = any( scrammed(*se11, *se21) and scrammed(*se12, *se22) \n for (se11, se12), (se21, se22) in zip(splits1, splits2b)\n )\n return straight_scram or flipped_scram\n \n return scrammed(0, len(s1), 0, len(s1))","memory":"20600"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dp(s1, s2):\n if s1 == s2:\n return True\n for i in range(1, len(s1)):\n if dp(s1[i:], s2[i:]) and dp(s1[:i], s2[:i]):\n return True\n if dp(s1[i:], s2[:-i]) and dp(s1[:i], s2[-i:]):\n return True\n return False\n return dp(s1, s2)","memory":"20800"},{"code":"class Solution:\n\n def isScramble(self, s1: str, s2: str) -> bool:\n \n @cache\n def dp(s1,s2):\n if s1 == s2:\n return True\n for i in range(1,len(s1)):\n if dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i]):\n return True\n if dp(s1[i:],s2[:-i]) and dp(s1[:i],s2[-i:]):\n return True\n return False\n return dp(s1,s2)","memory":"20900"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dp(s1,s2):\n if s1 == s2:\n return True\n for i in range(1,len(s1)):\n if dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i]) or dp(s1[i:],s2[:-i]) and dp(s1[:i],s2[-i:]):\n return True\n return False\n return dp(s1,s2)","memory":"20900"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dp(s1,s2):\n if s1 == s2: return True\n for i in range(1,len(s1)):\n if dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i]):\n return True\n if dp(s1[i:],s2[:-i]) and dp(s1[:i],s2[-i:]):\n return True\n return False\n return dp(s1,s2)","memory":"21000"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def dp(s1,s2):\n if(s1==s2):\n return True\n for i in range(1,len(s1)):\n if(dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i])):\n return True\n if(dp(s1[:i],s2[-i:]) and dp(s1[i:],s2[:-i])):\n return True\n return False\n return dp(s1,s2)","memory":"22600"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def scramble(p1, p2):\n if len(p1) == 1:\n return p1 == p2\n \n for k in range(1, len(p1)):\n unscrambled = scramble(p1[:k], p2[:k]) and scramble(p1[k:], p2[k:])\n scrambled = scramble(p1[:-k], p2[k:]) and scramble(p1[-k:], p2[:k])\n if unscrambled or scrambled:\n return True\n\n return False\n\n return scramble(s1, s2)","memory":"23000"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n cache = {}\n def dfs(curr, target):\n if curr == target:\n return True\n \n if len(curr) != len(target):\n return False\n\n if (curr, target) in cache:\n return cache[(curr, target)]\n \n ret = False\n for i in range(1, len(curr)):\n p1, p2 = curr[:i], curr[i:]\n t1, t2 = target[:i], target[i:]\n ret |= dfs(p1, t1) and dfs(p2, t2) or dfs(p1, target[-i:]) and dfs(p2, target[:-i])\n\n cache[(curr, target)] = ret\n return ret\n \n return dfs(s1, s2)","memory":"23100"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def scramble(p1, p2):\n print(p1)\n print(p2)\n if len(p1) == 1:\n return p1 == p2\n \n for k in range(1, len(p1)):\n rev = len(p1) - k\n unscrambled = scramble(p1[:k], p2[:k]) and scramble(p1[k:], p2[k:])\n scrambled = scramble(p1[:rev], p2[k:]) and scramble(p1[rev:], p2[:k])\n if unscrambled or scrambled:\n return True\n\n return False\n\n return scramble(s1, s2)","memory":"23200"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n @cache\n def scramble(p1, p2):\n if len(p1) == 1:\n return p1 == p2\n \n for k in range(1, len(p1)):\n rev = len(p1) - k\n unscrambled = scramble(p1[:k], p2[:k]) and scramble(p1[k:], p2[k:])\n scrambled = scramble(p1[:rev], p2[k:]) and scramble(p1[rev:], p2[:k])\n if unscrambled or scrambled:\n return True\n\n return False\n\n return scramble(s1, s2)","memory":"23200"},{"code":"class Solution:\n def isScramble(self, s1: str, s2: str) -> bool:\n if len(s1)!=len(s2):\n return False\n memo={} \n def scrambled(a,b):\n n=len(a)\n if a==b:\n return True\n if len(a)<=1:\n return False\n if (a,b) in memo:\n return memo[(a,b)]\n flag=False\n for i in range(1,n):\n swap=scrambled(a[:i],b[n-i:]) and scrambled(a[i:],b[:n-i])\n noswap=scrambled(a[:i],b[:i]) and scrambled(a[i:],b[i:])\n if swap or noswap:\n flag=True\n memo[(a,b)]=flag\n return memo[(a,b)]\n return scrambled(s1,s2)","memory":"23600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.memo = {}\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # Early pruning by checking character frequencies\\n if sorted(s1) != sorted(s2):\\n return False\\n \\n # If the strings are already the same, they are scrambled versions of each other\\n if s1 == s2:\\n return True\\n \\n # Check memoization dictionary to avoid recomputation\\n if (s1, s2) in self.memo:\\n return self.memo[(s1, s2)]\\n \\n n = len(s1)\\n for i in range(1, n):\\n # Check both the direct and swapped conditions in the same loop\\n if (self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:])) or \\\\\\n (self.isScramble(s1[:i], s2[n-i:]) and self.isScramble(s1[i:], s2[:n-i])):\\n self.memo[(s1, s2)] = True\\n return True\\n \\n # If no valid scramble found, store the result as False\\n self.memo[(s1, s2)] = False\\n return False\\n\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\ndef letterset(s:str):\\n ret=defaultdict(int)\\n for c in s:\\n ret[c]+=1\\n return ret\\n\\ndef find_split_points(s1:str, s2:str)->List[int]:\\n ls=defaultdict(int)\\n ret=[]\\n for i,(c1,c2) in enumerate(zip(s1,s2)):\\n ls[c1]+=1\\n ls[c2]-=1\\n if all(v==0 for v in ls.values()):\\n ret.append(i+1)\\n return ret[:-1] # cut the tail\\n\\ndef find_swap_points(s1:str, s2:str)->List[int]:\\n ls=defaultdict(int)\\n ret=[]\\n for i in range(len(s1)-1):\\n c1=s1[i]\\n c2=s2[-1-i]\\n ls[c1]+=1\\n ls[c2]-=1\\n if all(v==0 for v in ls.values()):\\n ret.append(i+1)\\n return ret\\n\\ndef solve_swap(s1:str, s2:str)->bool:\\n if s1==s2: return True\\n swaps = find_swap_points(s1, s2)\\n #print(\\\"swap\\\", s1, s2, swaps)\\n for sw in swaps:\\n if solve(s1[:sw],s2[-sw:]) and solve(s1[sw:], s2[:-sw]):\\n return True\\n return False\\n\\ndef solve_split(s1:str, s2:str)->bool:\\n if s1==s2: return True\\n splits = find_split_points(s1, s2)\\n #print(\\\"split\\\", s1, s2, splits)\\n for sp in splits:\\n if solve_swap(s1[:sp], s2[:sp]) and solve(s1[sp:], s2[sp:]):\\n return True\\n return False\\n\\ndef solve(s1:str, s2:str)->bool:\\n if s1==s2: return True\\n return solve_swap(s1,s2) or solve_split(s1,s2)\\n\\nclass Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2): return False\\n if letterset(s1) != letterset(s2): return False\\n return solve(s1, s2)\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n map = {}\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n n = len(s1)\\n if s1 == s2:\\n return True\\n a, b, c = [0] * 26, [0] * 26, [0] * 26\\n if (s1 + s2) in self.map:\\n return self.map[s1 + s2]\\n for i in range(1, n):\\n j = n - i\\n a[ord(s1[i - 1]) - ord('a')] += 1\\n b[ord(s2[i - 1]) - ord('a')] += 1\\n c[ord(s2[j]) - ord('a')] += 1\\n if a == b and self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n self.map[s1 + s2] = True\\n return True\\n if a == c and self.isScramble(s1[:i], s2[j:]) and self.isScramble(s1[i:], s2[:j]):\\n self.map[s1 + s2] = True\\n return True\\n self.map[s1 + s2] = False\\n return False\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n dp = {}\\n def helper(s, t):\\n if (s, t) in dp:\\n return dp[(s, t)]\\n if sorted(s) != sorted(t):\\n return False\\n if len(s) == 1:\\n return True\\n \\n for i in range(1, len(s)):\\n if (helper(s[:i], t[-i:]) and helper(s[i:], t[:-i])) or (helper(s[i:], t[i:]) and helper(s[:i], t[:i])):\\n dp[(s, t)] = True\\n return True\\n dp[(s, t)] = False\\n return False\\n \\n return helper(s1, s2)\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1==s2:\\n return True\\n s1len=len(s1)\\n s2len=len(s2)\\n if not s1len==s2len:\\n return False\\n if not sorted(s1)==sorted(s2):\\n return False\\n dpt=[]\\n for loop1 in range(s1len+1):\\n block=[]\\n for loop2 in range(s1len):\\n block.append([False]*s1len)\\n dpt.append(block)\\n for splptr in range(1,s1len+1):\\n for s1ptr in range(s1len-splptr+1):\\n for s2ptr in range(s2len-splptr+1):\\n if splptr==1:\\n if s1[s1ptr]==s2[s2ptr]:\\n dpt[splptr][s1ptr][s2ptr]=True\\n else:\\n for aftersplptr in range(1,splptr):\\n leftmatchleft=dpt[aftersplptr][s1ptr][s2ptr] and dpt[splptr-aftersplptr][s1ptr+aftersplptr][s2ptr+aftersplptr]\\n leftmatchright=dpt[aftersplptr][s1ptr][s2ptr+(splptr-aftersplptr)] and dpt[splptr-aftersplptr][s1ptr+aftersplptr][s2ptr]\\n dpt[splptr][s1ptr][s2ptr]=leftmatchleft or leftmatchright\\n if leftmatchleft or leftmatchright:\\n break\\n return dpt[s1len][0][0]\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nfrom functools import cache\\n\\nclass Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n def _is_candidate(val, target):\\n return Counter(val) == Counter(target)\\n @cache\\n def _fn(a, b):\\n assert len(a) == len(b)\\n\\n l = len(a)\\n if l == 1:\\n return a == b\\n\\n for i in range(1, l):\\n p2, p1 = a[:i], a[i:]\\n t1, t2 = b[:-i], b[-i:]\\n #print(f\\\"swap p1 : {p1} / t1 : {t1} / p2 : {p2} / t2 : {t2} \\\")\\n if _is_candidate(p1, t1) and _is_candidate(p2, t2):\\n \\n out = _fn(p1, t1) and _fn(p2, t2)\\n if out:\\n return True\\n\\n p1, p2 = a[:i], a[i:]\\n t1, t2 = b[:i], b[i:]\\n #print(f\\\"no swap p1 : {p1} / t1 : {t1} / p2 : {p2} / t2 : {t2} \\\")\\n\\n if _is_candidate(p1, t1) and _is_candidate(p2, t2):\\n out = _fn(p1, t1) and _fn(p2, t2)\\n if out:\\n return True\\n\\n return False\\n return _fn(s1, s2)\\n\\n\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n dp = {}\\n def helper(s, t):\\n if (s, t) in dp:\\n return dp[(s, t)]\\n if sorted(s) != sorted(t):\\n return False\\n if len(s) == 1:\\n return True\\n \\n for i in range(1, len(s)):\\n if (helper(s[:i], t[-i:]) and helper(s[i:], t[:-i])) or (helper(s[i:], t[i:]) and helper(s[:i], t[:i])):\\n dp[(s, t)] = True\\n return True\\n dp[(s, t)] = False\\n return False\\n \\n return helper(s1, s2)\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n dp = {}\\n def helper(s, t):\\n if (s, t) in dp:\\n return dp[(s, t)]\\n if Counter(s) != Counter(t):\\n return False\\n if len(s) == 1:\\n return True\\n \\n for i in range(1, len(s)):\\n if (helper(s[:i], t[-i:]) and helper(s[i:], t[:-i])) or (helper(s[i:], t[i:]) and helper(s[:i], t[:i])):\\n dp[(s, t)] = True\\n return True\\n dp[(s, t)] = False\\n return False\\n \\n return helper(s1, s2)\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n def mm(dct1,dct2):\\n mmCnt=0\\n for l,cnt in dct1.items():\\n try:\\n cnt2=dct2[l]\\n except KeyError:\\n cnt2=0\\n if cnt>cnt2: \\n mmCnt+=cnt-cnt2\\n return mmCnt \\n\\n def count(s):\\n dct={}\\n for l in s:\\n try:\\n dct[l]+=1\\n except KeyError:\\n dct[l]=1\\n return dct \\n\\n def upd(s,i,dcts):\\n l=s[i]\\n cnt=dcts[1].pop(l)\\n if cnt >1:\\n dcts[1][l]=cnt-1\\n try:\\n dcts[0][l]+=1\\n except KeyError:\\n dcts[0][l]=1\\n def upd2(s,i,dcts):\\n #print(dcts)\\n l=s[-1-i]\\n cnt=dcts[0].pop(l)\\n if cnt >1:\\n dcts[0][l]=cnt-1\\n try:\\n dcts[1][l]+=1\\n except KeyError:\\n dcts[1][l]=1 \\n\\n cache={}\\n def check(s1,s2,dct1=None,dct2=None,n=0):\\n try:\\n r= cache[(s1,s2)]\\n #print(' '*n,s1,s2, 'HIT!')\\n return r\\n except KeyError:\\n pass \\n \\n\\n #print(' '*n,s1,s2)\\n if s1==s2:\\n return True\\n if dct1 is None:\\n dcts1={},count(s1)\\n dcts2={},count(s2)\\n dcts2x=dcts2[1].copy(),{}\\n\\n if dcts1[1]!=dcts2[1]:\\n return False\\n else:\\n if len(s1)<=3:\\n return True\\n dcts1={},dct1.copy()\\n dcts2={},dct2.copy()\\n dcts2x=dct2.copy(),{} \\n\\n for i in range(0,len(s1)-1):\\n upd(s1,i,dcts1)\\n upd(s2,i,dcts2)\\n upd2(s2,i,dcts2x)\\n if dcts1==dcts2:\\n if check(s1[:i+1],s2[:i+1],dcts1[0],dcts2[0] , n+1 ) and check(s1[i+1:],s2[i+1:],dcts1[1],dcts2[1],n+1):\\n cache[s1,s2]=True\\n return True \\n if dcts1==dcts2x[::-1]:\\n if check( s1[:i+1],s2[-1-i:], dcts1[0],dcts2x[1] , n+1) and check(s1[i+1:],s2[:-1-i],dcts1[1],dcts2x[0],n+1):\\n cache[s1,s2]=True\\n return True\\n cache[s1,s2]=False \\n return False \\n\\n\\n return check(s1,s2)\\n\\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n def dp(s1, s2, memo):\\n if s1+\\\",\\\"+s2 in memo:\\n return memo[s1+\\\",\\\"+s2]\\n if s1 == s2:\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n\\n for i in range(1, len(s1)):\\n if dp(s1[i:], s2[i:], memo) and dp(s1[:i], s2[:i], memo):\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n if dp(s1[i:], s2[:-i], memo) and dp(s1[:i], s2[-i:], memo):\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n \\n memo[s1+\\\",\\\"+s2] = False\\n return False\\n return dp(s1, s2, {})\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str, memo=None) -> bool:\\n if memo is None:\\n memo = {}\\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n if len(s1) != len(s2):\\n return False\\n if s1 == s2:\\n return True\\n if sorted(s1) != sorted(s2):\\n memo[(s1, s2)] = False\\n return False\\n n = len(s1)\\n for i in range(1, n):\\n if (self.isScramble(s1[:i], s2[:i], memo) and self.isScramble(s1[i:], s2[i:], memo)) or (self.isScramble(s1[:i], s2[-i:], memo) and self.isScramble(s1[i:], s2[:-i], memo)):\\n memo[(s1, s2)] = True\\n return True\\n memo[(s1, s2)] = False\\n return False\\n\\n\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n def dp(s1, s2, memo):\\n if s1+\\\",\\\"+s2 in memo:\\n return memo[s1+\\\",\\\"+s2]\\n if s1 == s2:\\n return True\\n for i in range(1, len(s1)):\\n if dp(s1[i:], s2[i:], memo) and dp(s1[:i], s2[:i], memo):\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n if dp(s1[i:], s2[:-i], memo) and dp(s1[:i], s2[-i:], memo):\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n memo[s1+\\\",\\\"+s2] = False\\n return False\\n return dp(s1, s2, {})\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n def dp(s1, s2, memo):\\n if s1+\\\",\\\"+s2 in memo:\\n return memo[s1+\\\",\\\"+s2]\\n if s1 == s2:\\n return True\\n for i in range(1, len(s1)):\\n if dp(s1[i:], s2[i:], memo) and dp(s1[:i], s2[:i], memo):\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n if dp(s1[i:], s2[:-i], memo) and dp(s1[:i], s2[-i:], memo):\\n memo[s1+\\\",\\\"+s2] = True\\n return True\\n memo[s1+\\\",\\\"+s2] = False\\n return False\\n return dp(s1, s2, {})\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # A memoization dictionary to store already computed subproblems\\n memo = {}\\n \\n # Recursive function to check if s1 is a scrambled string of s2\\n def rec(s1, s2):\\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n if s1 == s2:\\n memo[(s1, s2)] = True\\n return memo[(s1, s2)]\\n if sorted(s1) != sorted(s2):\\n memo[(s1, s2)] = False\\n return memo[(s1, s2)]\\n \\n n = len(s1)\\n for i in range(1, n):\\n if rec(s1[:i], s2[:i]) and rec(s1[i:], s2[i:]):\\n memo[(s1, s2)] = True\\n return memo[(s1, s2)]\\n if rec(s1[:i], s2[-i:]) and rec(s1[i:], s2[:n-i]):\\n memo[(s1, s2)] = True\\n return memo[(s1, s2)]\\n memo[(s1, s2)] = False\\n return memo[(s1, s2)]\\n return rec(s1, s2)\\n\\n \\n\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # Memoization dictionary to store results of subproblems\\n memo = {}\\n \\n def is_scramble_recursive(s1, s2):\\n # If the result is already computed, return it\\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n \\n # If the strings are equal, they are trivially scrambled versions\\n if s1 == s2:\\n memo[(s1, s2)] = True\\n return True\\n \\n # If the sorted characters of both strings do not match, they cannot be scrambled versions\\n if sorted(s1) != sorted(s2):\\n memo[(s1, s2)] = False\\n return False\\n \\n n = len(s1)\\n for i in range(1, n):\\n # Check if there is a valid split where the substrings are scrambled versions\\n if (is_scramble_recursive(s1[:i], s2[:i]) and is_scramble_recursive(s1[i:], s2[i:])) or \\\\\\n (is_scramble_recursive(s1[:i], s2[-i:]) and is_scramble_recursive(s1[i:], s2[:-i])):\\n memo[(s1, s2)] = True\\n return True\\n \\n # If no valid split is found, the strings are not scrambled versions\\n memo[(s1, s2)] = False\\n return False\\n \\n return is_scramble_recursive(s1, s2)\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # A memoization dictionary to store already computed subproblems\\n memo = {}\\n \\n # Recursive function to check if s1 is a scrambled string of s2\\n def rec(s1, s2):\\n # If we have computed this already, return the stored result\\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n \\n # Base case: If the strings are identical, they are scrambled versions\\n if s1 == s2:\\n memo[(s1, s2)] = True\\n return True\\n \\n # If the sorted characters don't match, then s1 cannot be scrambled to s2\\n if sorted(s1) != sorted(s2):\\n memo[(s1, s2)] = False\\n return False\\n \\n n = len(s1)\\n \\n # Try splitting the strings at different positions and check both scrambled and non-scrambled cases\\n for i in range(1, n):\\n # Case 1: No swap, check if s1[:i] matches s2[:i] and s1[i:] matches s2[i:]\\n if rec(s1[:i], s2[:i]) and rec(s1[i:], s2[i:]):\\n memo[(s1, s2)] = True\\n return True\\n # Case 2: Swap, check if s1[:i] matches s2[n-i:] and s1[i:] matches s2[:n-i]\\n if rec(s1[:i], s2[-i:]) and rec(s1[i:], s2[:n-i]):\\n memo[(s1, s2)] = True\\n return True\\n \\n # If no solution is found, return False\\n memo[(s1, s2)] = False\\n return False\\n \\n # Start the recursion with the full strings\\n return rec(s1, s2)\\n\\n \\n\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # base case: if s1 == s2 or if some split in s1 and swap == s2: return True\\n \\n def solve(s1, s2, memo):\\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n \\n elif s1 == s2:\\n memo[(s1, s2)] = True\\n return True\\n \\n memo[(s1, s2)] = False\\n n = len(s1)\\n # case 1: split at 2, s1 = gr / eat, s2 = rg / eat\\n for i in range(1, n):\\n\\n memo[(s1, s2)] = memo[(s1, s2)] or solve(s1[:i], s2[:i], memo) and solve(s1[i:], s2[i:], memo) or solve(s1[:i], s2[n-i:], memo) and solve(s1[i:], s2[:n-i], memo)\\n \\n return memo[(s1, s2)]\\n\\n return solve(s1, s2, {})\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self,s1, s2):\\n from functools import lru_cache\\n\\n n = len(s1)\\n if n != len(s2):\\n return False\\n\\n @lru_cache(None)\\n def isScrambleRec(s1, s2):\\n # Base cases\\n if s1 == s2:\\n return True\\n if sorted(s1) != sorted(s2):\\n return False\\n\\n n = len(s1)\\n for i in range(1, n):\\n # Without Swap\\n if (isScrambleRec(s1[:i], s2[:i]) and isScrambleRec(s1[i:], s2[i:])):\\n return True\\n # With Swap\\n if (isScrambleRec(s1[:i], s2[-i:]) and isScrambleRec(s1[i:], s2[:-i])):\\n return True\\n return False\\n\\n return isScrambleRec(s1, s2)\\n\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n memo = {}\\n\\n def dfs(s1, s2):\\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n\\n if s1 == s2:\\n memo[(s1, s2)] = True\\n return True\\n \\n if sorted(s1) != sorted(s2):\\n memo[(s1, s2)] = False\\n return False\\n \\n n = len(s1)\\n for i in range(1, n):\\n if dfs(s1[:i], s2[:i]) and dfs(s1[i:], s2[i:]):\\n memo[(s1, s2)] = True\\n return True\\n if dfs(s1[:i], s2[-i:]) and dfs(s1[i:], s2[:-i]):\\n memo[(s1, s2)] = True\\n return True\\n \\n memo[(s1, s2)] = False\\n return False\\n\\n ret = dfs(s1, s2)\\n print(memo)\\n return ret\",\n \"memory\": \"17500\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(i: int, j: int, k: int) -> bool:\\n if k == 1:\\n return s1[i] == s2[j]\\n for h in range(1, k):\\n if dfs(i, j, h) and dfs(i + h, j + h, k - h):\\n return True\\n if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):\\n return True\\n return False\\n\\n return dfs(0, 0, len(s1))\",\n \"memory\": \"17600\"\n },\n {\n \"code\": \"from functools import lru_cache\\r\\nimport time\\r\\nclass Solution:\\r\\n cache = {}\\r\\n def isScramble2(self, s1: str, s2: str) -> bool: \\r\\n def hashmatch(s1map, s2):\\r\\n s2map = {}\\r\\n for s in s2:\\r\\n if s not in s2map:\\r\\n s2map[s] = 1\\r\\n else:\\r\\n s2map[s] += 1\\r\\n for key in s1map.keys():\\r\\n if key not in s2map or s2map[key] != s1map[key]:\\r\\n return False\\r\\n return True \\r\\n if len(s1) == 1:\\r\\n return s1 == s2\\r\\n key = f'{s1}-{s2}'\\r\\n if key in self.cache:\\r\\n return self.cache[key]\\r\\n n = len(s1)\\r\\n for i in range(n):\\r\\n if i+1<n-i-1:\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[:i+1]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[i+1:]\\r\\n s1map = {}\\r\\n for s in s1_l:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n s1rmap = {}\\r\\n for s in s1_r:\\r\\n if s not in s1rmap:\\r\\n s1rmap[s] = 1\\r\\n else:\\r\\n s1rmap[s] += 1\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n s1_l = s1[:i+1]\\r\\n s2_l = s2[-i-1:]\\r\\n s1_r = s1[i+1:]\\r\\n s2_r = s2[:-i-1]\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True\\r\\n else:\\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[i+1:]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[:i+1]\\r\\n s1map = {}\\r\\n for s in s1_l:\\r\\n if s not in s1map:\\r\\n s1map[s] = 1\\r\\n else:\\r\\n s1map[s] += 1\\r\\n s1rmap = {}\\r\\n for s in s1_r:\\r\\n if s not in s1rmap:\\r\\n s1rmap[s] = 1\\r\\n else:\\r\\n s1rmap[s] += 1 \\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n s1_l = s1[i+1:]\\r\\n s2_l = s2[:-i-1]\\r\\n s1_r = s1[:i+1]\\r\\n s2_r = s2[-i-1:]\\r\\n if hashmatch(s1map, s2_l) and hashmatch(s1rmap, s2_r):\\r\\n if self.isScramble(s1_l, s2_l) and self.isScramble(s1_r, s2_r):\\r\\n self.cache[key] = True\\r\\n return True \\r\\n self.cache[key] = False\\r\\n return False\\r\\n\\r\\n def isScramble(self, s1: str, s2: str) -> bool:\\r\\n from functools import lru_cache\\r\\n\\r\\n @lru_cache(None)\\r\\n def dfs(s1, s2):\\r\\n if s1 == s2:\\r\\n return True\\r\\n if sorted(s1) != sorted(s2):\\r\\n return False\\r\\n n = len(s1)\\r\\n for i in range(1, n):\\r\\n # Check without swap\\r\\n if dfs(s1[:i], s2[:i]) and dfs(s1[i:], s2[i:]):\\r\\n return True\\r\\n # Check with swap\\r\\n if dfs(s1[:i], s2[-i:]) and dfs(s1[i:], s2[:-i]):\\r\\n return True\\r\\n return False\\r\\n\\r\\n return dfs(s1, s2) \",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(l0, l1, _len):\\n if _len == 1 and s1[l0] != s2[l1]:\\n return False\\n if s1[l0 : l0 + _len] == s2[l1 : l1 + _len]:\\n return True\\n ##\\n for k in range(1, _len):\\n if dfs(l0, l1, k) and dfs(l0 + k, l1 + k, _len - k):\\n return True\\n if dfs(l0, l1 + _len - k, k) and dfs(l0 + k, l1, _len - k):\\n return True\\n ##\\n return False\\n\\n ##\\n return dfs(0, 0, len(s2))\\n\",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n\\n @lru_cache(None)\\n def loop(i, j, x, y):\\n if x + 1 == y:\\n return s1[i] == s2[x]\\n\\n size = j - i\\n for k in range(1, size):\\n k_ = size - k\\n if (\\n loop(i, i + k, x, x + k)\\n and loop(i + k, j, x + k, y)\\n or loop(i + k, j, x, x + k_)\\n and loop(i, i + k, x + k_, y)\\n ):\\n return True\\n return False\\n\\n n = len(s1)\\n\\n return loop(0, n, 0, n)\\n\",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n\\n cache = {} # ()\\n\\n def dfs(cur_s, cur_e, tar_s, tar_e):\\n if (cur_s, cur_e, tar_s, tar_e) in cache:\\n return cache[(cur_s, cur_e, tar_s, tar_e)]\\n\\n lenn = cur_e - cur_s \\n \\n is_scramble = False\\n if s1[cur_s:cur_e] == s2[tar_s:tar_e]:\\n is_scramble = True\\n elif lenn == 1 and s1[cur_s:cur_e] != s2[tar_s:tar_e]:\\n is_scramble = False\\n else:\\n # We need to split\\n for i in range(1, lenn):\\n #no-swap\\n if dfs(cur_s, cur_s + i, tar_s, tar_s + i) and dfs(cur_s + i, cur_e, tar_s + i, tar_e):\\n is_scramble = True\\n break\\n #swap\\n if dfs(cur_s, cur_s + i, tar_e - i, tar_e) and dfs(cur_s + i, cur_e, tar_s, tar_e - i):\\n is_scramble = True\\n break\\n\\n cache[(cur_s, cur_e, tar_s, tar_e)] = is_scramble\\n return cache[(cur_s, cur_e, tar_s, tar_e)]\\n\\n return dfs(0, len(s1), 0, len(s2))\",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n\\n cache = {} # ()\\n\\n def dfs(cur_s, cur_e, tar_s, tar_e):\\n if (cur_s, cur_e, tar_s, tar_e) in cache:\\n return cache[(cur_s, cur_e, tar_s, tar_e)]\\n\\n lenn = cur_e - cur_s \\n \\n is_scramble = False\\n if s1[cur_s:cur_e] == s2[tar_s:tar_e]:\\n is_scramble = True\\n elif lenn == 1 and s1[cur_s:cur_e] != s2[tar_s:tar_e]:\\n is_scramble = False\\n else:\\n # We need to split\\n for i in range(1, lenn):\\n #no-swap\\n if dfs(cur_s, cur_s + i, tar_s, tar_s + i) and dfs(cur_s + i, cur_e, tar_s + i, tar_e):\\n is_scramble = True\\n break\\n #swap\\n if dfs(cur_s, cur_s + i, tar_e - i, tar_e) and dfs(cur_s + i, cur_e, tar_s, tar_e - i):\\n is_scramble = True\\n break\\n\\n cache[(cur_s, cur_e, tar_s, tar_e)] = is_scramble\\n return cache[(cur_s, cur_e, tar_s, tar_e)]\\n\\n return dfs(0, len(s1), 0, len(s2))\",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(l0, r0, l1, r1):\\n if not (0 <= l0 < len(s1) and 0 <= l1 < len(s2)):\\n return False\\n if not (0 <= r0 < len(s1) and 0 <= r1 < len(s2)):\\n return False\\n if r0 - l0 != r1 - l1:\\n return False\\n if s1[l0 : 1 + r0] == s2[l1 : 1 + r1]:\\n return True\\n if r0 == l0 and s1[l0] != s2[l1]:\\n return False\\n \\n ##\\n for k in range(0, r0 - l0):\\n if dfs(l0, l0 + k, l1, l1 + k) and dfs(l0 + k + 1, r0, l1 + k + 1, r1):\\n return True\\n if dfs(l0, l0 + k, r1 - k, r1) and dfs(l0 + k + 1, r0, l1, r1 - k - 1):\\n return True\\n ##\\n return False\\n\\n ##\\n return dfs(0, len(s1) - 1, 0, len(s2) - 1)\\n\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dfs(l0, r0, l1, r1):\\n if s1[l0 : 1 + r0] == s2[l1 : 1 + r1]:\\n return True\\n if r0 == l0 and s1[l0] != s2[l1]:\\n return False\\n \\n ##\\n for k in range(0, r0 - l0):\\n if dfs(l0, l0 + k, l1, l1 + k) and dfs(l0 + k + 1, r0, l1 + k + 1, r1):\\n return True\\n if dfs(l0, l0 + k, r1 - k, r1) and dfs(l0 + k + 1, r0, l1, r1 - k - 1):\\n return True\\n ##\\n return False\\n\\n ##\\n return dfs(0, len(s1) - 1, 0, len(s2) - 1)\\n\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n @functools.lru_cache(None)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n if collections.Counter(s1) != collections.Counter(s2):\\n return False\\n\\n for i in range(1, len(s1)):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n return True\\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\\n self.isScramble(s1[i:], s2[: len(s2) - i])):\\n return True\\n\\n return False\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"class Solution:\\n @lru_cache(None)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n m =len(s1)\\n n=len(s2)\\n if m!=n or sorted(s1)!=sorted(s2): return False\\n if m<=3 or s1==s2: return True\\n f = self.isScramble\\n for i in range(1,len(s1)):\\n if f(s1[:i],s2[:i]) and f(s1[i:],s2[i:]) or f(s1[:i],s2[-i:]) and f(s1[i:],s2[:-i]):\\n return True\\n return False\\n\",\n \"memory\": \"18300\"\n },\n {\n \"code\": \"class Solution:\\n @functools.lru_cache(None)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n if collections.Counter(s1) != collections.Counter(s2):\\n return False\\n\\n for i in range(1, len(s1)):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):\\n return True\\n if (self.isScramble(s1[:i], s2[len(s2) - i:]) and\\n self.isScramble(s1[i:], s2[: len(s2) - i])):\\n return True\\n\\n return False\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"def substr(s, k, n):\\n return s[k:k+n]\\n \\n\\nclass Solution:\\n def isScramble(self, s1: str, s2: str, memo=None) -> bool:\\n if memo is None: memo = {}\\n key1 = f'{s1}_{s2}'\\n key2 = f'{s2}_{s1}'\\n\\n if key1 in memo: return memo[key1]\\n if key2 in memo: return memo[key2]\\n\\n if s1 == s2:\\n memo[key1] = True\\n memo[key2] = True\\n return True\\n if len(s1) != len(s2):\\n memo[key1] = False\\n memo[key2] = False\\n return False\\n n = len(s1)\\n if n <= 1:\\n memo[key1] = False\\n memo[key2] = False\\n return False\\n \\n ans = False\\n for k in range(1, n):\\n l, r = substr(s1, 0, k), substr(s2, n-k, k)\\n cross_left = self.isScramble(l, r, memo)\\n tkey = f'{l}_{r}'\\n memo[tkey] = cross_left\\n tkey = f'{r}_{l}'\\n memo[tkey] = cross_left\\n\\n l, r = substr(s1, k, n-k), substr(s2, 0, n-k)\\n cross_right = self.isScramble(l, r, memo)\\n tkey = f'{l}_{r}'\\n memo[tkey] = cross_right\\n tkey = f'{r}_{l}'\\n memo[tkey] = cross_right\\n\\n l, r = substr(s1, 0, k), substr(s2, 0, k)\\n same_left = self.isScramble(l, r, memo)\\n tkey = f'{l}_{r}'\\n memo[tkey] = same_left\\n tkey = f'{r}_{l}'\\n memo[tkey] = same_left\\n\\n l, r = substr(s1, k, n-k), substr(s2, k, n-k)\\n same_right = self.isScramble(l, r, memo)\\n tkey = f'{l}_{r}'\\n memo[tkey] = same_right\\n tkey = f'{r}_{l}'\\n memo[tkey] = same_right\\n \\n cond1 = cross_left and cross_right\\n cond2 = same_left and same_right\\n if cond1 or cond2:\\n ans = True\\n break\\n\\n memo[key1] = ans\\n memo[key2] = ans\\n return ans\",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n save={}\\n def dfs(s1: str, s2: str) -> bool:\\n nonlocal save\\n if s1==s2:\\n return True\\n if (s1,s2) in save:\\n return save[(s1,s2)]\\n p1,p2={},{}\\n for i in range(len(s1)):\\n if s1[i] not in p1:\\n p1[s1[i]]=1\\n else:\\n p1[s1[i]]+=1\\n if s2[i] not in p2:\\n p2[s2[i]]=1\\n else:\\n p2[s2[i]]+=1\\n if p1!=p2:\\n save[(s1,s2)]=False\\n return False\\n for i in range(1,len(s1)):\\n if dfs(s1[:i],s2[:i])&dfs(s1[i:],s2[i:]):\\n save[(s1,s2)]=True\\n return True\\n if dfs(s1[:i],s2[-1:-i-1:-1])&dfs(s1[i:],s2[:-i]):\\n save[(s1,s2)]=True\\n return True\\n save[(s1,s2)]=False\\n return False\\n return dfs(s1,s2)\",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n memoized = {}\\n return self.isScrambleInternal(s1, s2, memoized)\\n\\n def isScrambleInternal(self, s1, s2, memoized):\\n if len(s1) == 0 and len(s2) == 0:\\n return True\\n if len(s1) == 1 and len(s2) == 1:\\n return s1[0] == s2[0]\\n if s1 == s2:\\n return True\\n if (s1, s2) in memoized:\\n return memoized[(s1, s2)]\\n\\n result = False\\n for i in range(1, len(s1)):\\n left1 = s1[:i]\\n left2 = s2[:i]\\n scrambledLeft = self.isScrambleInternal(left1, left2, memoized)\\n\\n right1 = s1[i:]\\n right2 = s2[i:]\\n scrambledRight = self.isScrambleInternal(right1, right2, memoized)\\n\\n if scrambledLeft and scrambledRight:\\n result = True\\n break\\n\\n revLeft2 = s2[len(s2) - i:]\\n revRight2 = s2[:len(s2) - i]\\n scrambledRevLeft = self.isScrambleInternal(left1, revLeft2, memoized)\\n scrambledRevRight = self.isScrambleInternal(right1, revRight2, memoized)\\n if scrambledRevLeft and scrambledRevRight:\\n result = True\\n break\\n\\n memoized[(s1, s2)] = result\\n return result\",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n memo = defaultdict(bool)\\n def helper(a, b):\\n nonlocal memo\\n if (a, b) in memo:\\n return memo[(a, b)]\\n if len(a) != len(b):\\n memo[(a, b)] = False\\n return False\\n if a == b:\\n memo[(a, b)] = True\\n return True\\n if len(a) <= 1:\\n memo[(a, b)] = False\\n return False\\n n = len(a)\\n for i in range(1, n):\\n c1 = (helper(a[0:i], b[n-i:n]) and helper(a[i:n], b[0:n-i]))\\n c2 = (helper(a[0:i], b[0:i]) and helper(a[i:n], b[i:n]))\\n if (c1 or c2):\\n memo[(a, b)] = True\\n return True\\n memo[(a, b)] = False\\n return False\\n return helper(s1, s2)\\n\",\n \"memory\": \"18700\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1)!=len(s2):\\n return False\\n if len(s1)==0 and len(s2)==0:\\n return True\\n d={}\\n def helper(s1,s2):\\n if s1==s2:\\n return True\\n if len(s1)<=1:\\n return False\\n if (s1,s2) in d:\\n return d[(s1,s2)]\\n flag=False\\n for i in range(1,len(s1)):\\n case1 = (helper(s1[0:i], s2[0:i]) and helper(s1[i:], s2[i:]))\\n case2 = (helper(s1[0:i], s2[-i:]) and helper(s1[i:], s2[0:-i]))\\n if (case1 or case2):\\n flag=True\\n break\\n d[(s1,s2)]=flag\\n return d[(s1,s2)]\\n return helper(s1,s2)\\n\\n \",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"# intuition is that s2 can be scrabled by s1 as long as they have the same letters.\\n\\n# for example \\n\\n# 12345 -> 54321\\n# 12 / 345\\n# 12 -> 2 / 1\\n# 345 -> 5 / 34\\n# 34 -> 4/3\\n\\n# oh here is a counter example \\n\\n# abcde -> caebd\\n\\n# abcde -> bcde / a to move c before a\\n\\n# but now we have no way to move b/d/e after a \\n\\n# every scrable moves a substring s1 permanently after s2\\n\\n# cadbe won't work either, because when you move c before a, you must be moving de before a and no way back\\n\\n# so the first split must happen between the first letters of s1 and s2, the scramble is promising only when \\n# all letter after s2's first letter is always in front of s1's letter\\n\\n# brute force is to enumerate all scrambled s2, for a string of length n, each split is O(n), and there are n-1 positions to split\\n\\n# so O(n) = n(n-1)*T(n-1) = O(n^2n)\\n# theta(n) = n(n-1)*T(n/2) = O(n^(2*log_2^n))\\n\\n\\n# so basically we can divide and conqure the problem: \\n\\n# for s1 = abcde and s2 = cdeba, we have 4 split\\n\\n# a/bcde, ab/cde, abc/de, abcd/e\\n\\n# now for s2 to be a scramble string, it must be any of the following split match the those for s1's split\\n\\n# c/deba, cd/eba, cde/ba, cdeb/a\\n\\n# by match we means the two part of at least one s2 spllits can be scramble, individualy by the two part of at least one s1 splits\\n# we know that when letters doesn't match, or length doesn't match, it won't be scramble. This help eliminate many cases. \\n\\n# Effectively, we only need to check: \\n# a/bcde v.s. c/deba and cdeb/a => i=1, s1[:1] v.s. s2[:i] && s1[1:5] v.s. s2[1:5] | s1[:1] v.s. s2[5-1:5] && s1[1:5] v.s. s2[:5-1]\\n# ab/cde v.s. cd/eba and cde/ba\\n# abc/de v.s. cd/eba and cde/ba\\n# abcd/e v.s. c/deba and cdeb/a\\n\\n# and we can also expect many substrings comparison will be repeated and we can memorize for quicker solution.\\n\\nclass Solution:\\n @functools.lru_cache(maxsize=1024*1024, typed=False)\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # print(s1, s2)\\n if s1 == s2:\\n return True\\n if sorted(s1) != sorted(s2):\\n return False;\\n n = len(s1)\\n for i in range(1,n):\\n if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:n], s2[i:n]):\\n return True\\n if self.isScramble(s1[:i], s2[n-i:n]) and self.isScramble(s1[i:n], s2[:n-i]):\\n return True\\n return False\\n\",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def is_scramble(a, b):\\n if a == b:\\n return True\\n\\n if len(a) == 1:\\n return False\\n \\n for i in range(1, len(a)):\\n a1, a2 = a[:i], a[i:]\\n b1, b2 = b[:i], b[i:]\\n if is_scramble(a1, b1) and is_scramble(a2, b2):\\n return True\\n \\n b1, b2 = b[:len(a2)], b[len(a2):]\\n if is_scramble(a2, b1) and is_scramble(a1, b2):\\n return True\\n\\n return False\\n \\n return is_scramble(s1, s2)\\n\",\n \"memory\": \"19000\"\n },\n {\n \"code\": \"class Solution(object):\\n def isScramble(self, s1, s2):\\n \\\"\\\"\\\"\\n Determines if s2 is a scrambled string of s1.\\n\\n Args:\\n s1 (str): The original string.\\n s2 (str): The string to compare against the scrambled version of s1.\\n\\n Returns:\\n bool: True if s2 is a scrambled string of s1, False otherwise.\\n \\\"\\\"\\\"\\n from functools import lru_cache\\n\\n # Early termination if lengths differ or sorted characters don't match\\n if len(s1) != len(s2):\\n return False\\n if sorted(s1) != sorted(s2):\\n return False\\n\\n @lru_cache(maxsize=None)\\n def dfs(s1_sub, s2_sub):\\n \\\"\\\"\\\"\\n Recursively checks if s2_sub is a scrambled string of s1_sub.\\n\\n Args:\\n s1_sub (str): Substring of s1.\\n s2_sub (str): Substring of s2.\\n\\n Returns:\\n bool: True if s2_sub is a scrambled string of s1_sub, False otherwise.\\n \\\"\\\"\\\"\\n # If the substrings are equal, they are scrambles\\n if s1_sub == s2_sub:\\n return True\\n\\n n = len(s1_sub)\\n # Try all possible split positions\\n for i in range(1, n):\\n # Without swapping\\n if dfs(s1_sub[:i], s2_sub[:i]) and dfs(s1_sub[i:], s2_sub[i:]):\\n return True\\n # With swapping\\n if dfs(s1_sub[:i], s2_sub[-i:]) and dfs(s1_sub[i:], s2_sub[:-i]):\\n return True\\n # If no valid split found\\n return False\\n\\n return dfs(s1, s2)\",\n \"memory\": \"19100\"\n },\n {\n \"code\": \"vis = {}\\nclass Solution:\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n global vis\\n if (len(s1) == 1 and len(s2) == 1):\\n return s1 == s2\\n if ((s1, s2) in vis):\\n return vis[(s1, s2)]\\n \\n vis[(s1, s2)] = False\\n if (sorted(s1) != sorted(s2)):\\n return False\\n \\n for i in range(1, len(s1)):\\n left = s1[:i]\\n right = s1[i:]\\n bool1a = self.isScramble(left, s2[:i])\\n bool1b = self.isScramble(right, s2[i:])\\n\\n bool2a = self.isScramble(left, s2[-i:])\\n bool2b = self.isScramble(right, s2[:-i])\\n if ((bool1a and bool1b) or (bool2a and bool2b)):\\n vis[(s1, s2)] = True\\n return True\\n return False\",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"class Solution(object):\\n def isScramble(self, s1, s2):\\n \\\"\\\"\\\"\\n :type s1: str\\n :type s2: str\\n :rtype: bool\\n \\\"\\\"\\\"\\n # Base cases\\n\\n n = len(s1)\\n\\n # If both strings are not equal in size\\n if len(s2) != n:\\n return False\\n\\n # If both strings are equal\\n if s1 == s2:\\n return True\\n\\n # If code is reached to this condition then following this are sure:\\n # 1. size of both string is equal\\n # 2. string are not equal\\n # so size is equal (where size==1) and they are not equal then obviously false\\n # example 'a' and 'b' size is equal, string are not equal\\n if n == 1:\\n return False\\n\\n key = s1 + \\\" \\\" + s2\\n\\n # Check if this problem has already been solved\\n if key in self.mp:\\n return self.mp[key]\\n\\n # For every iteration it can two condition\\n # 1. We should proceed without swapping\\n # 2. We should swap before looking next\\n for i in range(1, n):\\n # ex of without swap: gr|eat and rg|eat\\n without_swap = (\\n # Left part of first and second string\\n self.isScramble(s1[:i], s2[:i])\\n and\\n # Right part of first and second string;\\n self.isScramble(s1[i:], s2[i:])\\n )\\n\\n # If without swap gives us the right answer then we do not need\\n # to call the recursion with swap\\n if without_swap:\\n return True\\n\\n # ex of with swap: gr|eat rge|at\\n # here we compare \\\"gr\\\" with \\\"at\\\" and \\\"eat\\\" with \\\"rge\\\"\\n with_swap = (\\n # Left part of first and right part of second\\n self.isScramble(s1[:i], s2[n-i:])\\n and\\n # Right part of first and left part of second\\n self.isScramble(s1[i:], s2[:n-i])\\n )\\n\\n # If with swap gives us the right answer then we return True\\n # otherwise, the for loop does its work\\n if with_swap:\\n return True\\n\\n self.mp[key] = False\\n return False\\n\\n # for storing already solved problems\\n mp = {}\",\n \"memory\": \"19300\"\n },\n {\n \"code\": \"class Solution(object):\\n def isScramble(self, s1, s2):\\n \\\"\\\"\\\"\\n :type s1: str\\n :type s2: str\\n :rtype: bool\\n \\\"\\\"\\\"\\n # Base cases\\n\\n n = len(s1)\\n\\n # If both strings are not equal in size\\n if len(s2) != n:\\n return False\\n\\n # If both strings are equal\\n if s1 == s2:\\n return True\\n\\n # If code is reached to this condition then following this are sure:\\n # 1. size of both string is equal\\n # 2. string are not equal\\n # so size is equal (where size==1) and they are not equal then obviously false\\n # example 'a' and 'b' size is equal, string are not equal\\n if n == 1:\\n return False\\n\\n key = s1 + \\\" \\\" + s2\\n\\n # Check if this problem has already been solved\\n if key in self.mp:\\n return self.mp[key]\\n\\n # For every iteration it can two condition\\n # 1. We should proceed without swapping\\n # 2. We should swap before looking next\\n for i in range(1, n):\\n # ex of without swap: gr|eat and rg|eat\\n without_swap = (\\n # Left part of first and second string\\n self.isScramble(s1[:i], s2[:i])\\n and\\n # Right part of first and second string;\\n self.isScramble(s1[i:], s2[i:])\\n )\\n\\n # If without swap gives us the right answer then we do not need\\n # to call the recursion with swap\\n if without_swap:\\n return True\\n\\n # ex of with swap: gr|eat rge|at\\n # here we compare \\\"gr\\\" with \\\"at\\\" and \\\"eat\\\" with \\\"rge\\\"\\n with_swap = (\\n # Left part of first and right part of second\\n self.isScramble(s1[:i], s2[n-i:])\\n and\\n # Right part of first and left part of second\\n self.isScramble(s1[i:], s2[:n-i])\\n )\\n\\n # If with swap gives us the right answer then we return True\\n # otherwise, the for loop does its work\\n if with_swap:\\n return True\\n\\n self.mp[key] = False\\n return False\\n\\n # for storing already solved problems\\n mp = {}\",\n \"memory\": \"19300\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # n = len(s1)\\n\\n # dp = [[[False for j in range(n)] for i in range(n)] for l in range(n+1)]\\n\\n # for i in range(n):\\n # for j in range(n):\\n # dp[1][i][j] = s1[i] == s2[j]\\n \\n # for length in range(2, n+1):\\n # for i in range(n+1 - length):\\n # for j in range(n+1 - length):\\n # for new_length in range(1, length):\\n # dp1 = dp[new_length][i]\\n # dp2 = dp[length - new_length][i+new_length]\\n # dp[length][i][j] |= dp1[j] and dp2[j+new_length]\\n # dp[length][i][j] |= (dp1[j + length - new_length] and dp2[j])\\n\\n # return dp[n][0][0]\\n memo = {}\\n def dfs(s1, s2):\\n if s1 == s2:\\n return True\\n if (s1, s2) in memo:\\n return memo[(s1, s2)]\\n \\n if Counter(s1) != Counter(s2):\\n memo[(s1, s2)] = False\\n return False\\n\\n n = len(s1)\\n memo[(s1, s2)] = False\\n for k in range(1, n):\\n if dfs(s1[:k], s2[:k]) and dfs(s1[k:], s2[k:]) or dfs(s1[:k], s2[n-k:]) and dfs(s1[k:], s2[:n-k]):\\n memo[(s1, s2)] = True\\n return memo[(s1, s2)]\\n\\n return dfs(s1, s2)\",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n mp = {}\\n\\n def solve(s1, s2):\\n if s1 == s2:\\n return True\\n if len(s1) <= 1:\\n return False\\n\\n temp = s1 + s2\\n if temp in mp:\\n return mp[temp]\\n\\n n = len(s1)\\n \\n for i in range(1, n):\\n # swap\\n if (solve(s1[:i], s2[n-i:]) and solve(s1[i:], s2[:n-i])):\\n mp[temp] = True\\n return True\\n # noswap\\n if (solve(s1[:i], s2[:i]) and solve(s1[i:], s2[i:])):\\n mp[temp] = True\\n return True\\n \\n mp[temp] = False\\n return False\\n \\n if len(s1) != len(s2):\\n return False\\n if len(s1) == 0 and len(s2) == 0:\\n return True\\n \\n return solve(s1, s2)\\n\",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n d=dict()\\n def helper(x,y):\\n if len(x)!=len(y):\\n return False\\n if x==y:\\n return True\\n key=x+\\\" \\\"+y\\n if key in d:\\n return d[key]\\n n=len(x)\\n for i in range(1,n):\\n if helper(x[:i],y[:i]) and helper(x[i:],y[i:]):\\n d[key] = True\\n return True\\n if helper(x[:i],y[-i:]) and helper(x[i:],y[:-i]):\\n d[key]=True\\n return True\\n d[key]=False\\n return False\\n return helper(s1,s2)\",\n \"memory\": \"19500\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1) != len(s2):\\n return False\\n\\n cache = {} # ()\\n\\n def dfs(current, target):\\n if (current, target) in cache:\\n return cache[(current, target)]\\n\\n is_scramble = False\\n # print(current, target)\\n if current == target:\\n is_scramble = True\\n elif len(current) == 1 and current != target:\\n is_scramble = False\\n else:\\n # We need to split\\n for i in range(1, len(current)):\\n front = current[0: i]\\n back = current[i:]\\n\\n #no-swap\\n if dfs(front, target[0: i]) and dfs(back, target[i:]):\\n is_scramble = True\\n break\\n end = len(current) - i\\n if dfs(front, target[end:]) and dfs(back, target[0: end]):\\n is_scramble = True\\n break\\n\\n cache[(current, target)] = is_scramble\\n return cache[(current, target)]\\n\\n return dfs(s1, s2)\",\n \"memory\": \"19500\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if(len(s1) != len(s2)):\\n return False\\n \\n if(s1 == s2):\\n return True\\n\\n dp = {}\\n def solve(s1, s2):\\n if(s1 == s2):\\n return True\\n \\n key = s1 + \\\"#\\\" + s2\\n\\n if key in dp:\\n return dp[key]\\n \\n n = len(s1)\\n for i in range(1, n):\\n s1Left = s1[:i]\\n s1Right = s1[n - i:]\\n s2Left = s2[:i]\\n s2Right = s2[n - i:]\\n\\n isSwap = solve(s1[:i],s2[:i]) and solve(s1[i:], s2[i:])\\n noSwap = solve(s1[:i], s2[n - i:]) and solve(s1[i:], s2[:n - i])\\n\\n\\n if isSwap or noSwap:\\n dp[key] = True\\n return True\\n \\n dp[key] = False\\n return False\\n \\n return solve(s1, s2)\\n \\n\\n \",\n \"memory\": \"19600\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str, dctx = {}) -> bool:\\n if (s1,s2) in dctx:\\n return dctx[(s1,s2)]\\n if len(s1) != len(s2):\\n return False\\n elif s1 == s2:\\n return True\\n elif set(s1) != set(s2):\\n return False\\n \\n for i in range(1,len(s1)):\\n # No Swap\\n a = self.isScramble(s1[:i], s2[:i], dctx)\\n b = self.isScramble(s1[i:], s2[i:], dctx)\\n if a and b:\\n dctx[(s1,s2)] = True\\n return True\\n\\n # With Swap\\n # print(s1[i:] + \\\" \\\" + s1[:i])\\n # print(s2[:len(s1)-i] + \\\" \\\" + s2[len(s1)-i:])\\n a = self.isScramble(s1[i:], s2[:len(s1)-i], dctx)\\n b = self.isScramble(s1[:i], s2[len(s1)-i:], dctx)\\n if a and b:\\n dctx[(s1,s2)] = True\\n return True\\n dctx[(s1,s2)] = False\\n return False\\n \\n \",\n \"memory\": \"19700\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if(len(s1) != len(s2)):\\n return False\\n \\n if(s1 == s2):\\n return True\\n\\n dp = {}\\n def solve(s1, s2, swap):\\n # print(s1, s2, swap)\\n if(s1 == s2):\\n return True\\n \\n key = s1 + \\\"#\\\" + s2\\n\\n if key in dp:\\n return dp[key]\\n \\n n = len(s1)\\n for i in range(1, n):\\n s1Left = s1[:i]\\n s1Right = s1[n - i:]\\n s2Left = s2[:i]\\n s2Right = s2[n - i:]\\n\\n isSwap = solve(s1[:i],s2[:i], True) and solve(s1[i:], s2[i:], True)\\n noSwap = solve(s1[:i], s2[n - i:], False) and solve(s1[i:], s2[:n - i], False)\\n\\n print(key, s1Left, s1Right, s2Left, s2Right)\\n print(key, isSwap, noSwap)\\n\\n if isSwap or noSwap:\\n dp[key] = True\\n return True\\n \\n dp[key] = False\\n return False\\n \\n return solve(s1, s2, False)\\n \\n\\n \",\n \"memory\": \"19900\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n # let f[a][b][c][d] = True / False to check whether s2[c:d] can be scambled to s1[a:b]\\n # if c - d != b - a: f[a][b][c][d] = False\\n # if s1[a:b] == s2[c:d]: f[a][b][c][d] = True\\n # if find t, where 0 < t < d - c:\\n # f[a][b][c][d] = True if exist t:\\n # f[a][a+t][c][c+t] and f[a+t][b][c+t][d] or\\n # f[a][a+n-t][c][c+n-t] and f[a+n-t+1][b][c+n-t+1][d]\\n\\n f = {}\\n\\n def dp(a, b, c, d):\\n if (a, b, c, d) in f:\\n return f[(a, b, c, d)]\\n \\n # print(a, b, c, d)\\n\\n if b - a != d - c:\\n return False\\n\\n if s1[a:b] == s2[c:d]:\\n return True\\n\\n n = b - a\\n for t in range(1, n):\\n if (dp(a, a+t, c, c+t) and dp(a+t, b, c+t, d)) or (dp(a, a+n-t, d-n+t, d) and dp(a+n-t, b, c, d-n+t)):\\n f[(a, b, c, d)] = True\\n return True\\n \\n f[(a, b, c, d)] = False\\n return False\\n\\n\\n return dp(0, len(s1), 0, len(s2))\",\n \"memory\": \"20000\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if s1 == s2:\\n return True\\n if len(s1) == 1:\\n return False\\n\\n cache = {}\\n def helper(s1, s2):\\n if s1 == s2:\\n return True\\n if len(s1) == 1:\\n return False\\n if s1+s2 in cache:\\n return cache[s1+s2]\\n\\n for i in range(1, len(s1)):\\n if (helper(s1[:i], s2[:i]) and helper(s1[i:], s2[i:])) or (helper(s1[len(s1) - i:], s2[:i]) and helper(s1[:len(s1) - i], s2[i:])):\\n cache[s1+s2] = True\\n return True\\n cache[s1+s2] = False\\n return False\\n return helper(s1, s2)\\n\\n \",\n \"memory\": \"20100\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n dp = {}\\n \\n def dfs(s1, s2): \\n \\n if s1 == s2: return True\\n \\n if (s1, s2) in dp: \\n return dp[(s1, s2)]\\n \\n for i in range(1, len(s1)): \\n if dfs(s1[i:], s2[i:]) and dfs(s1[:i], s2[:i]):\\n dp[(s1, s2)] = True\\n return True\\n if dfs(s1[i:], s2[:-i]) and dfs(s1[:i], s2[-i:]):\\n dp[(s1, s2)] = True\\n return True\\n \\n dp[(s1, s2)] = False\\n return False\\n \\n return dfs(s1, s2)\",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def scrammed(start1, end1, start2, end2):\\n assert end1-start1 == end2-start2\\n l = end1 - start1\\n assert l > 0\\n if l == 1:\\n return s1[start1] == s2[start2]\\n splits1 = [ ( (start1, start1+split), (start1+split, end1) ) \\n for split in range(1, l) ]\\n splits2a = [ ( (start2, start2+split), (start2+split, end2) )\\n for split in range(1, l) ]\\n splits2b = [ ( s2, s1) for s1, s2 in reversed(splits2a) ]\\n print\\n straight_scram = any( scrammed(*se11, *se21) and scrammed(*se12, *se22) \\n for (se11, se12), (se21, se22) in zip(splits1, splits2a)\\n )\\n flipped_scram = any( scrammed(*se11, *se21) and scrammed(*se12, *se22) \\n for (se11, se12), (se21, se22) in zip(splits1, splits2b)\\n )\\n return straight_scram or flipped_scram\\n \\n return scrammed(0, len(s1), 0, len(s1))\",\n \"memory\": \"20600\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dp(s1, s2):\\n if s1 == s2:\\n return True\\n for i in range(1, len(s1)):\\n if dp(s1[i:], s2[i:]) and dp(s1[:i], s2[:i]):\\n return True\\n if dp(s1[i:], s2[:-i]) and dp(s1[:i], s2[-i:]):\\n return True\\n return False\\n return dp(s1, s2)\",\n \"memory\": \"20800\"\n },\n {\n \"code\": \"class Solution:\\n\\n def isScramble(self, s1: str, s2: str) -> bool:\\n \\n @cache\\n def dp(s1,s2):\\n if s1 == s2:\\n return True\\n for i in range(1,len(s1)):\\n if dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i]):\\n return True\\n if dp(s1[i:],s2[:-i]) and dp(s1[:i],s2[-i:]):\\n return True\\n return False\\n return dp(s1,s2)\",\n \"memory\": \"20900\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dp(s1,s2):\\n if s1 == s2:\\n return True\\n for i in range(1,len(s1)):\\n if dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i]) or dp(s1[i:],s2[:-i]) and dp(s1[:i],s2[-i:]):\\n return True\\n return False\\n return dp(s1,s2)\",\n \"memory\": \"20900\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dp(s1,s2):\\n if s1 == s2: return True\\n for i in range(1,len(s1)):\\n if dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i]):\\n return True\\n if dp(s1[i:],s2[:-i]) and dp(s1[:i],s2[-i:]):\\n return True\\n return False\\n return dp(s1,s2)\",\n \"memory\": \"21000\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def dp(s1,s2):\\n if(s1==s2):\\n return True\\n for i in range(1,len(s1)):\\n if(dp(s1[i:],s2[i:]) and dp(s1[:i],s2[:i])):\\n return True\\n if(dp(s1[:i],s2[-i:]) and dp(s1[i:],s2[:-i])):\\n return True\\n return False\\n return dp(s1,s2)\",\n \"memory\": \"22600\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def scramble(p1, p2):\\n if len(p1) == 1:\\n return p1 == p2\\n \\n for k in range(1, len(p1)):\\n unscrambled = scramble(p1[:k], p2[:k]) and scramble(p1[k:], p2[k:])\\n scrambled = scramble(p1[:-k], p2[k:]) and scramble(p1[-k:], p2[:k])\\n if unscrambled or scrambled:\\n return True\\n\\n return False\\n\\n return scramble(s1, s2)\",\n \"memory\": \"23000\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n cache = {}\\n def dfs(curr, target):\\n if curr == target:\\n return True\\n \\n if len(curr) != len(target):\\n return False\\n\\n if (curr, target) in cache:\\n return cache[(curr, target)]\\n \\n ret = False\\n for i in range(1, len(curr)):\\n p1, p2 = curr[:i], curr[i:]\\n t1, t2 = target[:i], target[i:]\\n ret |= dfs(p1, t1) and dfs(p2, t2) or dfs(p1, target[-i:]) and dfs(p2, target[:-i])\\n\\n cache[(curr, target)] = ret\\n return ret\\n \\n return dfs(s1, s2)\",\n \"memory\": \"23100\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def scramble(p1, p2):\\n print(p1)\\n print(p2)\\n if len(p1) == 1:\\n return p1 == p2\\n \\n for k in range(1, len(p1)):\\n rev = len(p1) - k\\n unscrambled = scramble(p1[:k], p2[:k]) and scramble(p1[k:], p2[k:])\\n scrambled = scramble(p1[:rev], p2[k:]) and scramble(p1[rev:], p2[:k])\\n if unscrambled or scrambled:\\n return True\\n\\n return False\\n\\n return scramble(s1, s2)\",\n \"memory\": \"23200\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n @cache\\n def scramble(p1, p2):\\n if len(p1) == 1:\\n return p1 == p2\\n \\n for k in range(1, len(p1)):\\n rev = len(p1) - k\\n unscrambled = scramble(p1[:k], p2[:k]) and scramble(p1[k:], p2[k:])\\n scrambled = scramble(p1[:rev], p2[k:]) and scramble(p1[rev:], p2[:k])\\n if unscrambled or scrambled:\\n return True\\n\\n return False\\n\\n return scramble(s1, s2)\",\n \"memory\": \"23200\"\n },\n {\n \"code\": \"class Solution:\\n def isScramble(self, s1: str, s2: str) -> bool:\\n if len(s1)!=len(s2):\\n return False\\n memo={} \\n def scrambled(a,b):\\n n=len(a)\\n if a==b:\\n return True\\n if len(a)<=1:\\n return False\\n if (a,b) in memo:\\n return memo[(a,b)]\\n flag=False\\n for i in range(1,n):\\n swap=scrambled(a[:i],b[n-i:]) and scrambled(a[i:],b[:n-i])\\n noswap=scrambled(a[:i],b[:i]) and scrambled(a[i:],b[i:])\\n if swap or noswap:\\n flag=True\\n memo[(a,b)]=flag\\n return memo[(a,b)]\\n return scrambled(s1,s2)\",\n \"memory\": \"23600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":62,"string":"62"}}},{"rowIdx":42,"cells":{"question_id":{"kind":"number","value":88,"string":"88"},"name":{"kind":"string","value":"merge-sorted-array"},"content":{"kind":"string","value":"<p>You are given two integer arrays <code>nums1</code> and <code>nums2</code>, sorted in <strong>non-decreasing order</strong>, and two integers <code>m</code> and <code>n</code>, representing the number of elements in <code>nums1</code> and <code>nums2</code> respectively.</p>\n\n<p><strong>Merge</strong> <code>nums1</code> and <code>nums2</code> into a single array sorted in <strong>non-decreasing order</strong>.</p>\n\n<p>The final sorted array should not be returned by the function, but instead be <em>stored inside the array </em><code>nums1</code>. To accommodate this, <code>nums1</code> has a length of <code>m + n</code>, where the first <code>m</code> elements denote the elements that should be merged, and the last <code>n</code> elements are set to <code>0</code> and should be ignored. <code>nums2</code> has a length of <code>n</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3\n<strong>Output:</strong> [1,2,2,3,5,6]\n<strong>Explanation:</strong> The arrays we are merging are [1,2,3] and [2,5,6].\nThe result of the merge is [<u>1</u>,<u>2</u>,2,<u>3</u>,5,6] with the underlined elements coming from nums1.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums1 = [1], m = 1, nums2 = [], n = 0\n<strong>Output:</strong> [1]\n<strong>Explanation:</strong> The arrays we are merging are [1] and [].\nThe result of the merge is [1].\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums1 = [0], m = 0, nums2 = [1], n = 1\n<strong>Output:</strong> [1]\n<strong>Explanation:</strong> The arrays we are merging are [] and [1].\nThe result of the merge is [1].\nNote that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>nums1.length == m + n</code></li>\n\t<li><code>nums2.length == n</code></li>\n\t<li><code>0 <= m, n <= 200</code></li>\n\t<li><code>1 <= m + n <= 200</code></li>\n\t<li><code>-10<sup>9</sup> <= nums1[i], nums2[j] <= 10<sup>9</sup></code></li>\n</ul>\n\n<p> </p>\n<p><strong>Follow up: </strong>Can you come up with an algorithm that runs in <code>O(m + n)</code> time?</p>\n"},"acRate":{"kind":"number","value":51.0066023923003,"string":"51.006602"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["array","two-pointers","sorting"],"string":"[\n \"array\",\n \"two-pointers\",\n \"sorting\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"11\", 0.0016], [\"14\", 0.0016], [\"15\", 0.0016], [\"17\", 0.0049], [\"18\", 0.0065], [\"19\", 0.0277], [\"20\", 0.0212], [\"21\", 0.0245], [\"22\", 0.1094], [\"23\", 0.1518], [\"24\", 0.129], [\"25\", 0.1828], [\"26\", 0.5517], [\"27\", 0.5925], [\"28\", 0.5485], [\"29\", 0.8423], [\"30\", 2.1514], [\"31\", 1.9751], [\"32\", 1.647], [\"33\", 2.819], [\"34\", 5.5712], [\"35\", 4.5003], [\"36\", 3.583], [\"37\", 5.7148], [\"38\", 9.2668], [\"39\", 7.0256], [\"40\", 5.2643], [\"41\", 7.2361], [\"42\", 8.7444], [\"43\", 6.7138], [\"44\", 4.6897], [\"45\", 4.8382], [\"46\", 4.4824], [\"47\", 3.2255], [\"48\", 2.1449]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15800\", 0.0016], [\"15900\", 0.0016], [\"16000\", 0.0033], [\"16100\", 0.018], [\"16200\", 0.0441], [\"16300\", 0.7035], [\"16400\", 10.602], [\"16500\", 36.7063], [\"16600\", 43.2323]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n n1, n2, i = m-1, n-1, m+n-1\n while n2 >= 0:\n if n1 >=0 and nums1[n1] > nums2[n2]:\n nums1[i] = nums1[n1]\n n1 -= 1\n else:\n nums1[i] = nums2[n2]\n n2 -= 1\n i -= 1\n \n ","runtime":"11"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n # Start merging from the end of the arrays\n i, j, k = m - 1, n - 1, m + n - 1\n \n # Merge the arrays by comparing elements from the end\n while i >= 0 and j >= 0:\n if nums1[i] > nums2[j]:\n nums1[k] = nums1[i]\n i -= 1\n else:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1\n \n # If there are remaining elements in nums2, copy them into nums1\n while j >= 0:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1","runtime":"14"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n k,l = m-1,n-1\n i = m+n-1\n while k>=0 and l>=0:\n if nums1[k]>nums2[l]:\n nums1[i] = nums1[k]\n k-=1\n else: \n nums1[i] = nums2[l]\n l-=1\n i-=1\n\n if k<0:\n nums1[:i+1] = nums2[:l+1]\n\n\n ","runtime":"15"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n # Here m and n are last index of each array\n k=len(nums1)-1\n i,j=m-1,n-1\n while i>=0 and j>=0:\n if nums1[i]<nums2[j]:\n nums1[k]=nums2[j]\n k-=1\n j-=1\n else:\n nums1[k]=nums1[i]\n k-=1\n i-=1\n # if j>=0\n while j>=0:\n nums1[k]=nums2[j]\n k-=1\n j-=1\n \n\n\n\n ","runtime":"17"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n \n p1 = m - 1\n p2 = n - 1\n p = m + n - 1\n \n while p >= 0:\n if p1 >= 0 and p2 >= 0:\n if nums1[p1] > nums2[p2]:\n nums1[p] = nums1[p1]\n p1 -= 1\n else:\n nums1[p] = nums2[p2]\n p2 -= 1\n elif p2 >= 0: \n nums1[p] = nums2[p2] \n p2 -=1\n p -= 1\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n ","runtime":"18"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n last=m+n-1\n while m>0 and n>0:\n if nums1[m-1]>nums2[n-1]:\n nums1[last]=nums1[m-1]\n m-=1\n else:\n nums1[last]=nums2[n-1]\n n-=1\n last-=1\n while n>0:\n nums1[last]=nums2[n-1]\n last-=1\n n-=1\n ","runtime":"19"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n\n left=0\n right=0\n while right<n:\n if nums1[left]==0:\n nums1[left]=nums2[right]\n right+=1\n left+=1\n else:\n left+=1\n nums1.sort()\n","runtime":"20"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n i, j, k = m - 1, n - 1, len(nums1) - 1\n while i >= 0 and j >= 0:\n if nums1[i] > nums2[j]:\n nums1[k] = nums1[i]\n k -= 1\n i -= 1\n else:\n nums1[k] = nums2[j]\n k -= 1\n j -= 1\n \n while j >= 0:\n nums1[k] = nums2[j]\n k -= 1\n j -= 1","runtime":"20"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n i = m - 1\n j = n - 1\n p = m + n - 1\n\n while i>=0 and j>=0:\n if nums1[i] >= nums2[j]:\n nums1[p] = nums1[i]\n i -= 1\n else:\n nums1[p] = nums2[j]\n j -= 1\n p -= 1\n\n while j >= 0:\n nums1[j] = nums2[j]\n j -= 1","runtime":"21"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n \n i = 0\n j = 0\n\n while j < n:\n nums1[m+j] = nums2[j]\n j += 1\n\n nums1.sort()","runtime":"22"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n nums1[m:] = nums2\n nums1.sort()","runtime":"22"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n midx = m - 1\n nidx = n - 1 \n right = m + n - 1\n\n while nidx >= 0:\n if midx >= 0 and nums1[midx] > nums2[nidx]:\n nums1[right] = nums1[midx]\n midx -= 1\n else:\n nums1[right] = nums2[nidx]\n nidx -= 1\n\n right -= 1","runtime":"23"},{"code":"'''\nRead the problem statement in own words and read samples:\n- Given two sorted arrays in increasing order, merge both into the first array.\n- Use array sizes m and n to determine how much to populate in first array.\n\nIdentify key words and phrases (definitions, what is/isn't possible):\n- m + n determines the length of the first array.\n- m = 0 and n > 0 means copying second array into first array.\n- must copy in place.\n\nIdentify directions of processing (what seems natural? simplest? optimal?):\n- zip through both in parallel <--\n- parse one array at a time\n -> requires maybe a min heap to track order\n\nDecisions:\n- Nothing in mth but something nth, copy nth\n- Something in mth but nothing in nth, copy mth\n- Something in both mth and nth\n --> Preprocess - In first array, move m elements to starting at (m + n) - m.\n --> Copy smallest element\n\n'''\nclass Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n\n if m > 0 and n == 0:\n return nums1\n elif m == 0 and n > 0:\n # Copy nums2 to nums1\n for idx in range(n):\n nums1[idx] = nums2[idx]\n else:\n # Shift elements in first array to preprocess for merging.\n for idx in reversed(range(m)):\n offset_index = idx + n\n nums1[idx], nums1[offset_index] = nums1[offset_index], nums1[idx]\n\n cur = 0\n nums1_cur = (m + n) - m\n nums2_cur = 0\n\n while nums1_cur < m + n and nums2_cur < n:\n if nums1[nums1_cur] < nums2[nums2_cur]:\n nums1[cur] = nums1[nums1_cur]\n nums1_cur += 1\n else:\n nums1[cur] = nums2[nums2_cur]\n nums2_cur += 1\n cur += 1\n\n if nums1_cur < m:\n while cur < m + n:\n nums1[cur] = nums1[nums1_cur]\n nums1_cur += 1\n cur += 1\n\n if nums2_cur < n:\n while cur < m + n:\n nums1[cur] = nums2[nums2_cur]\n nums2_cur += 1\n cur += 1\n\n\n","runtime":"23"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n p1, p2 = m - 1, n - 1\n\n for i in range(m + n - 1, -1, -1):\n if p2 < 0:\n break\n if p1 >= 0 and nums1[p1] > nums2[p2]:\n nums1[i] = nums1[p1]\n p1 -= 1\n else:\n nums1[i] = nums2[p2]\n p2 -= 1\n ","runtime":"24"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n pt = 0\n while n > 0:\n if pt >= m:\n nums1[pt:] = nums2\n break\n if nums2[0] < nums1[pt]:\n nums1.insert(pt,nums2.pop(0))\n nums1.pop()\n pt+=1\n n-=1\n m+=1\n else:\n pt+=1\n ","runtime":"25"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \n nums1_pointer = m-1\n nums2_pointer = n-1\n \n for i in range(len(nums1)-1,-1,-1):\n if nums2_pointer < 0:\n break\n if nums1_pointer < 0:\n nums1[i] = nums2[nums2_pointer] \n nums2_pointer-=1\n continue\n\n \n \n \n if nums1[nums1_pointer] > nums2[nums2_pointer]:\n nums1[i] = nums1[nums1_pointer] \n nums1_pointer-=1\n else:\n nums1[i] = nums2[nums2_pointer] \n nums2_pointer-=1\n\n return nums1\n\n\n\n \n \n\n\n\n ","runtime":"25"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Merges two sorted arrays nums1 and nums2 into nums1 in-place.\n \"\"\"\n # Start from the last index of nums1 and nums2\n i = m - 1 # Last element in the valid portion of nums1\n j = n - 1 # Last element in nums2\n k = m + n - 1 # Last position in nums1\n\n # Merge nums2 into nums1, starting from the back\n while j >= 0:\n if i >= 0 and nums1[i] > nums2[j]:\n nums1[k] = nums1[i]\n i -= 1\n else:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1\n","runtime":"26"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n i = m+n-1 \n m = m-1 \n n = n-1 \n\n while n>=0: \n if m>=0 and nums1[m] > nums2[n]:\n nums1[i] = nums1[m]\n m-=1\n else:\n nums1[i] = nums2[n]\n n-=1\n i -=1\n \n ","runtime":"26"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n\n \"\"\"\n last = m+n-1\n while m>0 and n>0:\n if nums1[m-1] <= nums2[n-1]:\n nums1[last]=nums2[n-1]\n #last-=1\n n-=1\n else:\n nums1[last]=nums1[m-1]\n #last-=1\n m-=1\n last-=1\n\n #fill num1 with leftover num2 elements:\n while n>0:\n nums1[last]=nums2[n-1]\n n-=1\n last-=1\n","runtime":"27"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n idx = m + n - 1\n while m > 0 and n > 0:\n if nums1[m - 1] < nums2[n - 1]:\n nums1[idx] = nums2[n - 1]\n n -= 1\n else:\n nums1[idx] = nums1[m - 1]\n m -= 1\n idx -= 1\n while n > 0:\n nums1[idx] = nums2[n - 1]\n n -= 1\n idx -= 1\n ","runtime":"27"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n i=0\n j=0\n for _ in range(len(nums1)-m):\n nums1.pop()\n while i<m and j<n:\n if nums1[i]<=nums2[j]:\n i+=1\n else :\n nums1.insert(i,nums2[j])\n j+=1\n m+=1\n \n i+=m\n while j<n:\n nums1.append(nums2[j])\n j+=1","runtime":"28"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n nums1[m:] = nums2\n nums1.sort()\n \n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n ","runtime":"28"},{"code":"# class Solution:\n# def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n# \"\"\"\n# Do not return anything, modify nums1 in-place instead.\n# \"\"\"\n# # Start from the end of nums1\n# i = m - 1 # Last index of the valid part in nums1\n# j = n - 1 # Last index of nums2\n# k = m + n - 1 # Last index of the entire nums1 array\n\n# # Merge in reverse order\n# while i >= 0 and j >= 0:\n# if nums1[i] > nums2[j]:\n# nums1[k] = nums1[i]\n# i -= 1\n# else:\n# nums1[k] = nums2[j]\n# j -= 1\n# k -= 1\n \n# # If nums2 is still left\n# while j >= 0:\n# nums1[k] = nums2[j]\n# j -= 1\n# k -= 1\n\nclass Solution(object):\n def merge(self, nums1, m, nums2, n):\n for j in range(n):\n nums1[m+j] = nums2[j]\n nums1.sort()\n\n ","runtime":"29"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\" \n i = m - 1\n j = n - 1\n \n # Where to start inserting elements in nums1\n for p in range(len(nums1) - 1, -1, -1):\n if i >= 0 and j >= 0:\n if nums1[i] > nums2[j]:\n nums1[p] = nums1[i]\n i -= 1\n else:\n nums1[p] = nums2[j]\n j -= 1\n elif i >= 0:\n nums1[p] = nums1[i]\n i -= 1\n else:\n nums1[p] = nums2[j]\n j -= 1\n \n \n \n ","runtime":"29"},{"code":"class Solution:\n def merge(self, nums1: list[int], m: int, nums2: list[int], n: int) -> None:\n # Start from the end of both arrays\n i, j, k = m - 1, n - 1, m + n - 1\n \n # Merge nums1 and nums2 from the end\n while i >= 0 and j >= 0:\n if nums1[i] > nums2[j]:\n nums1[k] = nums1[i]\n i -= 1\n else:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1\n \n # If there are remaining elements in nums2\n while j >= 0:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1\n","runtime":"30"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n temp_nums1 = nums1[:] \n nums1_idx = 0\n nums2_idx = 0\n for i in range(m+n):\n nums1_item = temp_nums1[nums1_idx] if nums1_idx < m else float('inf') \n nums2_item = nums2[nums2_idx] if nums2_idx < n else float('inf')\n if nums1_item < nums2_item:\n item = temp_nums1[nums1_idx]\n nums1_idx = nums1_idx + 1 if nums1_idx < m else m\n else:\n item = nums2[nums2_idx]\n nums2_idx = nums2_idx + 1 if nums2_idx < n else n\n nums1[i] = item","runtime":"30"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n p1 = m - 1 # Pointer for nums1\n p2 = n - 1 # Pointer for nums2\n p = m + n - 1 # Pointer for placing elements\n\n # While there are elements to compare in both arrays\n while p1 >= 0 and p2 >= 0:\n if nums1[p1] > nums2[p2]:\n nums1[p] = nums1[p1]\n p1 -= 1\n else:\n nums1[p] = nums2[p2]\n p2 -= 1\n p -= 1\n\n # If there are remaining elements in nums2, copy them\n nums1[:p2 + 1] = nums2[:p2 + 1]","runtime":"31"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n # if m == 0:\n # for i in range(n):\n # nums1[i] = nums2[i]\n i = m - 1\n j = n - 1\n k = m + n - 1\n while j >= 0:\n if i >= 0 and nums1[i] > nums2[j]:\n nums1[k] = nums1[i]\n i -= 1\n else:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1\n ","runtime":"31"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n last = m+n-1\n while m > 0 and n > 0:\n if nums1[m-1] > nums2[n-1]:\n nums1[last] = nums1[m-1]\n m-=1\n else:\n nums1[last] = nums2[n-1]\n n-=1\n last-=1\n while n > 0:\n nums1[last] = nums2[n-1]\n n-=1\n last-=1","runtime":"32"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n l = (m + n) -1\n while(m>0 and n>0):\n if nums1[m-1] > nums2[n-1]:\n nums1[l] = nums1[m-1]\n m = m-1\n else:\n nums1[l] = nums2[n-1]\n n = n-1\n l = l-1\n while n > 0:\n nums1[l] = nums2[n-1]\n n = n-1\n l = l-1\n ","runtime":"32"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n i = m - 1\n j = n - 1\n k = m + n - 1\n while i >= 0 and j >= 0:\n if nums1[i] > nums2[j]:\n nums1[k] = nums1[i]\n i -= 1\n else:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1\n while j >= 0:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1\n\n ","runtime":"33"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n m_idx = m - 1\n n_idx = n - 1\n right = m + n - 1\n\n while n_idx >= 0:\n if m_idx >= 0 and nums1[m_idx] > nums2[n_idx]:\n nums1[right] = nums1[m_idx]\n m_idx -= 1\n else:\n nums1[right] = nums2[n_idx]\n n_idx -= 1\n\n right -= 1\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n ","runtime":"33"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n nums1.extend( nums2) \n while(m+n < len(nums1)):\n nums1.remove(0)\n nums1.sort()","runtime":"34"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n ns =nums1[:m]\n i,j =0,0\n while i<m or j<n:\n if j==n:\n nums1[i+j]= ns[i]\n i+=1 \n elif i==m:\n nums1[i+j]= nums2[j]\n j+=1\n elif ns[i]<nums2[j]:\n nums1[i+j]= ns[i]\n i+=1\n else:\n nums1[i+j]= nums2[j]\n j+=1\n return nums1\n\n","runtime":"34"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n i,j,k = m-1,n-1,(m+n)-1\n while (i >=0 and j>=0):\n if (nums1[i]> nums2[j]):\n nums1[k] = nums1[i]\n i -=1\n else:\n nums1[k] = nums2[j]\n j -=1\n k -=1\n while j >=0:\n nums1[k] = nums2[j]\n j -=1\n k -=1","runtime":"35"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n nums1[m:]=nums2\n nums1.sort()\n\n\n\n\n ","runtime":"35"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n\n nums1[m:] = nums2 \n nums1.sort()\n \n \n\n ","runtime":"36"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n i = m - 1\n j = n - 1\n k = m + n - 1\n while i >= 0 and j >=0:\n if nums1[i] > nums2[j]:\n nums1[k] = nums1[i]\n i -= 1\n else:\n nums1[k] = nums2[j]\n j -= 1\n\n k -= 1\n while j >= 0:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1\n","runtime":"36"},{"code":"class Solution:\n\n\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n i = m-1\n j = n-1\n nums1_blank_space = m+n-1\n\n while i>=0 and j>=0:\n if nums1[i] > nums2[j]:\n nums1[nums1_blank_space] = nums1[i]\n i-=1\n else:\n nums1[nums1_blank_space] = nums2[j]\n j-=1\n nums1_blank_space-=1\n \n while j>=0:\n nums1[nums1_blank_space] = nums2[j]\n j-=1\n nums1_blank_space-=1\n\n\n\n ","runtime":"37"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n i,j,k=m-1,n-1,m+n-1\n\n while i>=0 and j>=0:\n if nums1[i]>nums2[j]:\n nums1[k]=nums1[i]\n i-=1\n else:\n nums1[k]=nums2[j]\n j-=1\n k-=1\n while j>=0:\n nums1[k]=nums2[j]\n j-=1\n k-=1\n\n \n \n \n ","runtime":"37"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n p1 = m - 1 # Pointer for nums1\n p2 = n - 1 # Pointer for nums2\n p = m + n - 1 # Pointer for the merged array\n\n while p2 >= 0:\n if p1 >= 0 and nums1[p1] > nums2[p2]:\n nums1[p] = nums1[p1]\n p1 -= 1\n else:\n nums1[p] = nums2[p2]\n p2 -= 1\n p -= 1\n ","runtime":"38"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n if n == 0:\n return\n if m == 0:\n nums1[:] = nums2[:]\n return\n\n while m > 0 and n > 0:\n if nums1[m - 1] > nums2[n - 1]:\n nums1[n + m - 1] = nums1[m - 1]\n m -= 1\n else:\n nums1[n + m - 1] = nums2[n - 1]\n n -= 1\n \n while n > 0:\n nums1[n - 1] = nums2[n - 1]\n n -= 1\n\n ","runtime":"38"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n if m == 0:\n for i in range(n):\n nums1[i] = nums2[i]\n return\n if n == 0:\n nums1[:m]\n return\n\n j = 0 \n\n for i in range(m, m+n):\n nums1[i] = nums2[j]\n j += 1\n\n nums1.sort()","runtime":"39"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n if m == 0:\n for i in range(n):\n nums1[i] = nums2[i] \n return\n if n == 0:\n nums1[:m]\n return\n\n j = 0 \n \n for i in range(m, m+n):\n nums1[i] = nums2[j]\n j += 1\n\n nums1.sort()\n ","runtime":"39"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n p1 = m-1\n p2 = n-1\n p = m+n-1\n while p2 >= 0:\n if p1 >= 0 and nums1[p1] > nums2[p2]:\n nums1[p] = nums1[p1]\n p1 -= 1\n else:\n nums1[p] = nums2[p2]\n p2 -= 1\n p -= 1\n ","runtime":"41"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n\n #O((m+n)log(m+n))\n #nums1[m:]=nums2\n #nums1.sort()\n\n #with loops, O(m+n)\n #if n == 0: return\n\n len1 = len(nums1)\n end_index = len1-1\n while n > 0 and m > 0:\n if nums2[n-1] >= nums1[m-1]:\n nums1[end_index] = nums2[n-1]\n n-=1\n else:\n nums1[end_index] = nums1[m-1]\n m-=1\n end_index-=1 \n while n > 0:\n nums1[end_index]=nums2[n-1]\n n-=1\n end_index-=1 ","runtime":"41"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n # nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3\n # [1,2,2,3,5,6]\n # nums1 = [1], m = 1, nums2 = [], n = 0 -> [1]\n # nums1 = [0], m = 0, nums2 = [1], n = 1 -> [1]\n # nums1 = [2, 0] m = 1, nums2 = [], n =0 -> [1,2]\n# [4,0,0,0,0,0]\n# 1\n# [1,2,3,5,6]\n# 5\n\n # [1, 2, 0]\n# i = 0 # 0 \n# j = 0 # 0 \n \n# while i <= m or j <= n:\n# if i == m:\n# del nums1[i + j:]\n# nums1.extend(nums2[j:])\n# return\n# elif j == n:\n# return\n# if nums1[i] < nums2[j]:\n# i += 1\n# continue\n# else:\n# nums1.insert(i,nums2[j])\n# j += 1\n# i += 1\n# continue\n# nums1 = [1,2,2,3,5,6]\n# m = 3 2 2 1 0\n# nums2 = [2,5,6] [5,6] [5,6] [5,6] [5,6]\n# n = 3 3 2 2 2\n# [2,0] [1,2,0] [2,0]\n# 1 1\n# [1] []\n# 1 0\n # if m == 0:\n # nums1 = nums2\n # return\n # if n == 0:\n # del nums1[m:]\n # return\n # if nums1[0] < nums2[0]:\n # self.merge(nums1[1:], m - 1, nums2, n)\n # print(nums1)\n # else:\n # nums1.insert(0, nums2.pop(0))\n # nums1.pop()\n # self.merge(nums1[1:], m, nums2, n - 1)\n # print(nums1)\n p1 = m - 1\n p2 = n - 1\n for p in range(n + m -1 , -1, -1):\n if p2 < 0:\n break\n if p1 >= 0 and nums1[p1] > nums2[p2]:\n nums1[p] = nums1[p1]\n p1 -= 1\n else:\n nums1[p] = nums2[p2]\n p2 -= 1","runtime":"42"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n p1 = m - 1\n p2 = n - 1\n\n for p in reversed(range(n+m)):\n if p2 < 0:\n break\n if p1 >= 0 and nums1[p1] > nums2[p2]:\n nums1[p] = nums1[p1]\n p1 -= 1\n else:\n nums1[p] = nums2[p2]\n p2 -= 1","runtime":"42"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n if m == 0:\n nums1[:n] = nums2\n elif n == 0:\n pass\n else:\n nums = nums1[:m].copy()\n for i in range(0, m + n):\n if len(nums2) == 0:\n nums1[i] = nums.pop(0)\n elif len(nums) == 0:\n nums1[i] = nums2.pop(0)\n else:\n nums1[i] = min(nums[0], nums2[0])\n if nums[0] <= nums2[0]:\n nums.pop(0)\n else: nums2.pop(0)\n\n\n\n\n\n\n\n ","runtime":"43"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n i, j = m-1, n-1\n k = n + m - 1\n while k >= 0:\n if i < 0:\n nums1[k] = nums2[j]\n j -= 1\n elif j < 0:\n nums1[k] = nums1[i]\n i -= 1\n elif nums1[i] > nums2[j]:\n nums1[k] = nums1[i]\n i -= 1\n else:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1","runtime":"43"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n # Start merging from the back of nums1\n i, j, k = m - 1, n - 1, m + n - 1\n \n # Compare elements from the end and merge them into nums1\n while j >= 0:\n if i >= 0 and nums1[i] > nums2[j]:\n nums1[k] = nums1[i]\n i -= 1\n else:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1","runtime":"44"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n n2len = len(nums2)\n n1len = len(nums1)\n totlen = n1len - n2len\n for n in nums2:\n nums1.pop(totlen)\n nums1.insert(totlen,n)\n totlen += 1\n \n nums1.sort()","runtime":"44"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n ptr1 = m - 1\n ptr2 = n - 1\n writing_ptr = m + n - 1\n while ptr1 != -1 and ptr2 != -1:\n if nums1[ptr1] <= nums2[ptr2]:\n nums1[writing_ptr] = nums2[ptr2]\n ptr2 -= 1\n else:\n nums1[writing_ptr] = nums1[ptr1]\n ptr1 -= 1\n writing_ptr -= 1\n if ptr1 == -1:\n while ptr2 != -1:\n nums1[writing_ptr] = nums2[ptr2]\n ptr2 -= 1\n writing_ptr -= 1\n else:\n # ptr2 == -1\n while ptr1 != -1:\n nums1[writing_ptr] = nums1[ptr1]\n ptr1 -= 1\n writing_ptr -= 1","runtime":"45"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n r1, r2 = m - 1, n - 1\n for i in range(len(nums1) - 1, -1, -1):\n if r2 < 0:\n break\n if r1 >= 0 and nums1[r1] >= nums2[r2]:\n nums1[i] = nums1[r1]\n r1 -= 1\n else:\n nums1[i] = nums2[r2]\n r2 -= 1\n return nums1\n \n ","runtime":"45"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n n1, n2, i = m-1, n-1, m+n-1\n while n2 >= 0:\n if n1 >=0 and nums1[n1] > nums2[n2]:\n nums1[i] = nums1[n1]\n n1 -= 1\n else:\n nums1[i] = nums2[n2]\n n2 -= 1\n i -= 1\n \n ","runtime":"46"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n # for j in range(n):\n # nums1[m+j] = nums2[j]\n # nums1.sort()\n \n i = m - 1\n j = n - 1\n k = m+n-1\n\n while j >= 0:\n if(i >= 0 and nums1[i] > nums2[j]):\n nums1[k] = nums1[i]\n i -= 1\n else:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1\n","runtime":"46"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n x = m\n len_arr = m+n\n for j in range(0,n):\n nums1[x] = nums2[j]\n x+=1\n \n arr = nums1\n \n for i in range(len(arr)):\n temp =0\n for j in range(i+1,len(arr)):\n if arr[i] > arr[j]:\n temp = arr[i]\n arr[i] = arr[j]\n arr[j] = temp\n print(arr)\n\n \n \n\n ","runtime":"47"},{"code":"\nclass Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n i = m -1\n j = n -1\n\n zero_index = (m+n)-1\n while i>=0 and j>=0:\n if nums1[i] <= nums2[j]:\n nums1[zero_index] = nums2[j]\n j-=1\n zero_index-=1\n else:\n nums1[zero_index] = nums1[i]\n zero_index-=1\n i-=1\n \n while i>=0:\n nums1[zero_index] = nums1[i]\n i-=1\n zero_index-=1\n \n while j>=0:\n nums1[zero_index] = nums2[j]\n j-=1\n zero_index-=1\n \n \n ","runtime":"47"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n p = m-1\n q = n-1\n index = len(nums1) - 1\n \n while(index >= 0):\n if (q < 0):\n break\n if(p>=0 and nums1[p] >= nums2[q]):\n nums1[index] = nums1[p]\n index -= 1\n p -= 1\n else:\n nums1[index] = nums2[q]\n index -= 1\n q -= 1","runtime":"48"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n nums1[:] = nums1[:m] + nums2[:n]\n nums1.sort()\n ","runtime":"48"}],"string":"[\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n n1, n2, i = m-1, n-1, m+n-1\\n while n2 >= 0:\\n if n1 >=0 and nums1[n1] > nums2[n2]:\\n nums1[i] = nums1[n1]\\n n1 -= 1\\n else:\\n nums1[i] = nums2[n2]\\n n2 -= 1\\n i -= 1\\n \\n \",\n \"runtime\": \"11\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n # Start merging from the end of the arrays\\n i, j, k = m - 1, n - 1, m + n - 1\\n \\n # Merge the arrays by comparing elements from the end\\n while i >= 0 and j >= 0:\\n if nums1[i] > nums2[j]:\\n nums1[k] = nums1[i]\\n i -= 1\\n else:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\\n \\n # If there are remaining elements in nums2, copy them into nums1\\n while j >= 0:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\",\n \"runtime\": \"14\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n k,l = m-1,n-1\\n i = m+n-1\\n while k>=0 and l>=0:\\n if nums1[k]>nums2[l]:\\n nums1[i] = nums1[k]\\n k-=1\\n else: \\n nums1[i] = nums2[l]\\n l-=1\\n i-=1\\n\\n if k<0:\\n nums1[:i+1] = nums2[:l+1]\\n\\n\\n \",\n \"runtime\": \"15\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n # Here m and n are last index of each array\\n k=len(nums1)-1\\n i,j=m-1,n-1\\n while i>=0 and j>=0:\\n if nums1[i]<nums2[j]:\\n nums1[k]=nums2[j]\\n k-=1\\n j-=1\\n else:\\n nums1[k]=nums1[i]\\n k-=1\\n i-=1\\n # if j>=0\\n while j>=0:\\n nums1[k]=nums2[j]\\n k-=1\\n j-=1\\n \\n\\n\\n\\n \",\n \"runtime\": \"17\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n \\n p1 = m - 1\\n p2 = n - 1\\n p = m + n - 1\\n \\n while p >= 0:\\n if p1 >= 0 and p2 >= 0:\\n if nums1[p1] > nums2[p2]:\\n nums1[p] = nums1[p1]\\n p1 -= 1\\n else:\\n nums1[p] = nums2[p2]\\n p2 -= 1\\n elif p2 >= 0: \\n nums1[p] = nums2[p2] \\n p2 -=1\\n p -= 1\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n last=m+n-1\\n while m>0 and n>0:\\n if nums1[m-1]>nums2[n-1]:\\n nums1[last]=nums1[m-1]\\n m-=1\\n else:\\n nums1[last]=nums2[n-1]\\n n-=1\\n last-=1\\n while n>0:\\n nums1[last]=nums2[n-1]\\n last-=1\\n n-=1\\n \",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n\\n left=0\\n right=0\\n while right<n:\\n if nums1[left]==0:\\n nums1[left]=nums2[right]\\n right+=1\\n left+=1\\n else:\\n left+=1\\n nums1.sort()\\n\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n i, j, k = m - 1, n - 1, len(nums1) - 1\\n while i >= 0 and j >= 0:\\n if nums1[i] > nums2[j]:\\n nums1[k] = nums1[i]\\n k -= 1\\n i -= 1\\n else:\\n nums1[k] = nums2[j]\\n k -= 1\\n j -= 1\\n \\n while j >= 0:\\n nums1[k] = nums2[j]\\n k -= 1\\n j -= 1\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n i = m - 1\\n j = n - 1\\n p = m + n - 1\\n\\n while i>=0 and j>=0:\\n if nums1[i] >= nums2[j]:\\n nums1[p] = nums1[i]\\n i -= 1\\n else:\\n nums1[p] = nums2[j]\\n j -= 1\\n p -= 1\\n\\n while j >= 0:\\n nums1[j] = nums2[j]\\n j -= 1\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n \\n i = 0\\n j = 0\\n\\n while j < n:\\n nums1[m+j] = nums2[j]\\n j += 1\\n\\n nums1.sort()\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n nums1[m:] = nums2\\n nums1.sort()\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n midx = m - 1\\n nidx = n - 1 \\n right = m + n - 1\\n\\n while nidx >= 0:\\n if midx >= 0 and nums1[midx] > nums2[nidx]:\\n nums1[right] = nums1[midx]\\n midx -= 1\\n else:\\n nums1[right] = nums2[nidx]\\n nidx -= 1\\n\\n right -= 1\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"'''\\nRead the problem statement in own words and read samples:\\n- Given two sorted arrays in increasing order, merge both into the first array.\\n- Use array sizes m and n to determine how much to populate in first array.\\n\\nIdentify key words and phrases (definitions, what is/isn't possible):\\n- m + n determines the length of the first array.\\n- m = 0 and n > 0 means copying second array into first array.\\n- must copy in place.\\n\\nIdentify directions of processing (what seems natural? simplest? optimal?):\\n- zip through both in parallel <--\\n- parse one array at a time\\n -> requires maybe a min heap to track order\\n\\nDecisions:\\n- Nothing in mth but something nth, copy nth\\n- Something in mth but nothing in nth, copy mth\\n- Something in both mth and nth\\n --> Preprocess - In first array, move m elements to starting at (m + n) - m.\\n --> Copy smallest element\\n\\n'''\\nclass Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n\\n if m > 0 and n == 0:\\n return nums1\\n elif m == 0 and n > 0:\\n # Copy nums2 to nums1\\n for idx in range(n):\\n nums1[idx] = nums2[idx]\\n else:\\n # Shift elements in first array to preprocess for merging.\\n for idx in reversed(range(m)):\\n offset_index = idx + n\\n nums1[idx], nums1[offset_index] = nums1[offset_index], nums1[idx]\\n\\n cur = 0\\n nums1_cur = (m + n) - m\\n nums2_cur = 0\\n\\n while nums1_cur < m + n and nums2_cur < n:\\n if nums1[nums1_cur] < nums2[nums2_cur]:\\n nums1[cur] = nums1[nums1_cur]\\n nums1_cur += 1\\n else:\\n nums1[cur] = nums2[nums2_cur]\\n nums2_cur += 1\\n cur += 1\\n\\n if nums1_cur < m:\\n while cur < m + n:\\n nums1[cur] = nums1[nums1_cur]\\n nums1_cur += 1\\n cur += 1\\n\\n if nums2_cur < n:\\n while cur < m + n:\\n nums1[cur] = nums2[nums2_cur]\\n nums2_cur += 1\\n cur += 1\\n\\n\\n\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n p1, p2 = m - 1, n - 1\\n\\n for i in range(m + n - 1, -1, -1):\\n if p2 < 0:\\n break\\n if p1 >= 0 and nums1[p1] > nums2[p2]:\\n nums1[i] = nums1[p1]\\n p1 -= 1\\n else:\\n nums1[i] = nums2[p2]\\n p2 -= 1\\n \",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n pt = 0\\n while n > 0:\\n if pt >= m:\\n nums1[pt:] = nums2\\n break\\n if nums2[0] < nums1[pt]:\\n nums1.insert(pt,nums2.pop(0))\\n nums1.pop()\\n pt+=1\\n n-=1\\n m+=1\\n else:\\n pt+=1\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\n nums1_pointer = m-1\\n nums2_pointer = n-1\\n \\n for i in range(len(nums1)-1,-1,-1):\\n if nums2_pointer < 0:\\n break\\n if nums1_pointer < 0:\\n nums1[i] = nums2[nums2_pointer] \\n nums2_pointer-=1\\n continue\\n\\n \\n \\n \\n if nums1[nums1_pointer] > nums2[nums2_pointer]:\\n nums1[i] = nums1[nums1_pointer] \\n nums1_pointer-=1\\n else:\\n nums1[i] = nums2[nums2_pointer] \\n nums2_pointer-=1\\n\\n return nums1\\n\\n\\n\\n \\n \\n\\n\\n\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Merges two sorted arrays nums1 and nums2 into nums1 in-place.\\n \\\"\\\"\\\"\\n # Start from the last index of nums1 and nums2\\n i = m - 1 # Last element in the valid portion of nums1\\n j = n - 1 # Last element in nums2\\n k = m + n - 1 # Last position in nums1\\n\\n # Merge nums2 into nums1, starting from the back\\n while j >= 0:\\n if i >= 0 and nums1[i] > nums2[j]:\\n nums1[k] = nums1[i]\\n i -= 1\\n else:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\\n\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n i = m+n-1 \\n m = m-1 \\n n = n-1 \\n\\n while n>=0: \\n if m>=0 and nums1[m] > nums2[n]:\\n nums1[i] = nums1[m]\\n m-=1\\n else:\\n nums1[i] = nums2[n]\\n n-=1\\n i -=1\\n \\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n\\n \\\"\\\"\\\"\\n last = m+n-1\\n while m>0 and n>0:\\n if nums1[m-1] <= nums2[n-1]:\\n nums1[last]=nums2[n-1]\\n #last-=1\\n n-=1\\n else:\\n nums1[last]=nums1[m-1]\\n #last-=1\\n m-=1\\n last-=1\\n\\n #fill num1 with leftover num2 elements:\\n while n>0:\\n nums1[last]=nums2[n-1]\\n n-=1\\n last-=1\\n\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n idx = m + n - 1\\n while m > 0 and n > 0:\\n if nums1[m - 1] < nums2[n - 1]:\\n nums1[idx] = nums2[n - 1]\\n n -= 1\\n else:\\n nums1[idx] = nums1[m - 1]\\n m -= 1\\n idx -= 1\\n while n > 0:\\n nums1[idx] = nums2[n - 1]\\n n -= 1\\n idx -= 1\\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n i=0\\n j=0\\n for _ in range(len(nums1)-m):\\n nums1.pop()\\n while i<m and j<n:\\n if nums1[i]<=nums2[j]:\\n i+=1\\n else :\\n nums1.insert(i,nums2[j])\\n j+=1\\n m+=1\\n \\n i+=m\\n while j<n:\\n nums1.append(nums2[j])\\n j+=1\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n nums1[m:] = nums2\\n nums1.sort()\\n \\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# class Solution:\\n# def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n# \\\"\\\"\\\"\\n# Do not return anything, modify nums1 in-place instead.\\n# \\\"\\\"\\\"\\n# # Start from the end of nums1\\n# i = m - 1 # Last index of the valid part in nums1\\n# j = n - 1 # Last index of nums2\\n# k = m + n - 1 # Last index of the entire nums1 array\\n\\n# # Merge in reverse order\\n# while i >= 0 and j >= 0:\\n# if nums1[i] > nums2[j]:\\n# nums1[k] = nums1[i]\\n# i -= 1\\n# else:\\n# nums1[k] = nums2[j]\\n# j -= 1\\n# k -= 1\\n \\n# # If nums2 is still left\\n# while j >= 0:\\n# nums1[k] = nums2[j]\\n# j -= 1\\n# k -= 1\\n\\nclass Solution(object):\\n def merge(self, nums1, m, nums2, n):\\n for j in range(n):\\n nums1[m+j] = nums2[j]\\n nums1.sort()\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\" \\n i = m - 1\\n j = n - 1\\n \\n # Where to start inserting elements in nums1\\n for p in range(len(nums1) - 1, -1, -1):\\n if i >= 0 and j >= 0:\\n if nums1[i] > nums2[j]:\\n nums1[p] = nums1[i]\\n i -= 1\\n else:\\n nums1[p] = nums2[j]\\n j -= 1\\n elif i >= 0:\\n nums1[p] = nums1[i]\\n i -= 1\\n else:\\n nums1[p] = nums2[j]\\n j -= 1\\n \\n \\n \\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: list[int], m: int, nums2: list[int], n: int) -> None:\\n # Start from the end of both arrays\\n i, j, k = m - 1, n - 1, m + n - 1\\n \\n # Merge nums1 and nums2 from the end\\n while i >= 0 and j >= 0:\\n if nums1[i] > nums2[j]:\\n nums1[k] = nums1[i]\\n i -= 1\\n else:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\\n \\n # If there are remaining elements in nums2\\n while j >= 0:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\\n\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n temp_nums1 = nums1[:] \\n nums1_idx = 0\\n nums2_idx = 0\\n for i in range(m+n):\\n nums1_item = temp_nums1[nums1_idx] if nums1_idx < m else float('inf') \\n nums2_item = nums2[nums2_idx] if nums2_idx < n else float('inf')\\n if nums1_item < nums2_item:\\n item = temp_nums1[nums1_idx]\\n nums1_idx = nums1_idx + 1 if nums1_idx < m else m\\n else:\\n item = nums2[nums2_idx]\\n nums2_idx = nums2_idx + 1 if nums2_idx < n else n\\n nums1[i] = item\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n p1 = m - 1 # Pointer for nums1\\n p2 = n - 1 # Pointer for nums2\\n p = m + n - 1 # Pointer for placing elements\\n\\n # While there are elements to compare in both arrays\\n while p1 >= 0 and p2 >= 0:\\n if nums1[p1] > nums2[p2]:\\n nums1[p] = nums1[p1]\\n p1 -= 1\\n else:\\n nums1[p] = nums2[p2]\\n p2 -= 1\\n p -= 1\\n\\n # If there are remaining elements in nums2, copy them\\n nums1[:p2 + 1] = nums2[:p2 + 1]\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n # if m == 0:\\n # for i in range(n):\\n # nums1[i] = nums2[i]\\n i = m - 1\\n j = n - 1\\n k = m + n - 1\\n while j >= 0:\\n if i >= 0 and nums1[i] > nums2[j]:\\n nums1[k] = nums1[i]\\n i -= 1\\n else:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n last = m+n-1\\n while m > 0 and n > 0:\\n if nums1[m-1] > nums2[n-1]:\\n nums1[last] = nums1[m-1]\\n m-=1\\n else:\\n nums1[last] = nums2[n-1]\\n n-=1\\n last-=1\\n while n > 0:\\n nums1[last] = nums2[n-1]\\n n-=1\\n last-=1\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n l = (m + n) -1\\n while(m>0 and n>0):\\n if nums1[m-1] > nums2[n-1]:\\n nums1[l] = nums1[m-1]\\n m = m-1\\n else:\\n nums1[l] = nums2[n-1]\\n n = n-1\\n l = l-1\\n while n > 0:\\n nums1[l] = nums2[n-1]\\n n = n-1\\n l = l-1\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n i = m - 1\\n j = n - 1\\n k = m + n - 1\\n while i >= 0 and j >= 0:\\n if nums1[i] > nums2[j]:\\n nums1[k] = nums1[i]\\n i -= 1\\n else:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\\n while j >= 0:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\\n\\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n m_idx = m - 1\\n n_idx = n - 1\\n right = m + n - 1\\n\\n while n_idx >= 0:\\n if m_idx >= 0 and nums1[m_idx] > nums2[n_idx]:\\n nums1[right] = nums1[m_idx]\\n m_idx -= 1\\n else:\\n nums1[right] = nums2[n_idx]\\n n_idx -= 1\\n\\n right -= 1\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n nums1.extend( nums2) \\n while(m+n < len(nums1)):\\n nums1.remove(0)\\n nums1.sort()\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n ns =nums1[:m]\\n i,j =0,0\\n while i<m or j<n:\\n if j==n:\\n nums1[i+j]= ns[i]\\n i+=1 \\n elif i==m:\\n nums1[i+j]= nums2[j]\\n j+=1\\n elif ns[i]<nums2[j]:\\n nums1[i+j]= ns[i]\\n i+=1\\n else:\\n nums1[i+j]= nums2[j]\\n j+=1\\n return nums1\\n\\n\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n i,j,k = m-1,n-1,(m+n)-1\\n while (i >=0 and j>=0):\\n if (nums1[i]> nums2[j]):\\n nums1[k] = nums1[i]\\n i -=1\\n else:\\n nums1[k] = nums2[j]\\n j -=1\\n k -=1\\n while j >=0:\\n nums1[k] = nums2[j]\\n j -=1\\n k -=1\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n nums1[m:]=nums2\\n nums1.sort()\\n\\n\\n\\n\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n\\n nums1[m:] = nums2 \\n nums1.sort()\\n \\n \\n\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n i = m - 1\\n j = n - 1\\n k = m + n - 1\\n while i >= 0 and j >=0:\\n if nums1[i] > nums2[j]:\\n nums1[k] = nums1[i]\\n i -= 1\\n else:\\n nums1[k] = nums2[j]\\n j -= 1\\n\\n k -= 1\\n while j >= 0:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n\\n\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n i = m-1\\n j = n-1\\n nums1_blank_space = m+n-1\\n\\n while i>=0 and j>=0:\\n if nums1[i] > nums2[j]:\\n nums1[nums1_blank_space] = nums1[i]\\n i-=1\\n else:\\n nums1[nums1_blank_space] = nums2[j]\\n j-=1\\n nums1_blank_space-=1\\n \\n while j>=0:\\n nums1[nums1_blank_space] = nums2[j]\\n j-=1\\n nums1_blank_space-=1\\n\\n\\n\\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n i,j,k=m-1,n-1,m+n-1\\n\\n while i>=0 and j>=0:\\n if nums1[i]>nums2[j]:\\n nums1[k]=nums1[i]\\n i-=1\\n else:\\n nums1[k]=nums2[j]\\n j-=1\\n k-=1\\n while j>=0:\\n nums1[k]=nums2[j]\\n j-=1\\n k-=1\\n\\n \\n \\n \\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n p1 = m - 1 # Pointer for nums1\\n p2 = n - 1 # Pointer for nums2\\n p = m + n - 1 # Pointer for the merged array\\n\\n while p2 >= 0:\\n if p1 >= 0 and nums1[p1] > nums2[p2]:\\n nums1[p] = nums1[p1]\\n p1 -= 1\\n else:\\n nums1[p] = nums2[p2]\\n p2 -= 1\\n p -= 1\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n if n == 0:\\n return\\n if m == 0:\\n nums1[:] = nums2[:]\\n return\\n\\n while m > 0 and n > 0:\\n if nums1[m - 1] > nums2[n - 1]:\\n nums1[n + m - 1] = nums1[m - 1]\\n m -= 1\\n else:\\n nums1[n + m - 1] = nums2[n - 1]\\n n -= 1\\n \\n while n > 0:\\n nums1[n - 1] = nums2[n - 1]\\n n -= 1\\n\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n if m == 0:\\n for i in range(n):\\n nums1[i] = nums2[i]\\n return\\n if n == 0:\\n nums1[:m]\\n return\\n\\n j = 0 \\n\\n for i in range(m, m+n):\\n nums1[i] = nums2[j]\\n j += 1\\n\\n nums1.sort()\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n if m == 0:\\n for i in range(n):\\n nums1[i] = nums2[i] \\n return\\n if n == 0:\\n nums1[:m]\\n return\\n\\n j = 0 \\n \\n for i in range(m, m+n):\\n nums1[i] = nums2[j]\\n j += 1\\n\\n nums1.sort()\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n p1 = m-1\\n p2 = n-1\\n p = m+n-1\\n while p2 >= 0:\\n if p1 >= 0 and nums1[p1] > nums2[p2]:\\n nums1[p] = nums1[p1]\\n p1 -= 1\\n else:\\n nums1[p] = nums2[p2]\\n p2 -= 1\\n p -= 1\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n\\n #O((m+n)log(m+n))\\n #nums1[m:]=nums2\\n #nums1.sort()\\n\\n #with loops, O(m+n)\\n #if n == 0: return\\n\\n len1 = len(nums1)\\n end_index = len1-1\\n while n > 0 and m > 0:\\n if nums2[n-1] >= nums1[m-1]:\\n nums1[end_index] = nums2[n-1]\\n n-=1\\n else:\\n nums1[end_index] = nums1[m-1]\\n m-=1\\n end_index-=1 \\n while n > 0:\\n nums1[end_index]=nums2[n-1]\\n n-=1\\n end_index-=1 \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n # nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3\\n # [1,2,2,3,5,6]\\n # nums1 = [1], m = 1, nums2 = [], n = 0 -> [1]\\n # nums1 = [0], m = 0, nums2 = [1], n = 1 -> [1]\\n # nums1 = [2, 0] m = 1, nums2 = [], n =0 -> [1,2]\\n# [4,0,0,0,0,0]\\n# 1\\n# [1,2,3,5,6]\\n# 5\\n\\n # [1, 2, 0]\\n# i = 0 # 0 \\n# j = 0 # 0 \\n \\n# while i <= m or j <= n:\\n# if i == m:\\n# del nums1[i + j:]\\n# nums1.extend(nums2[j:])\\n# return\\n# elif j == n:\\n# return\\n# if nums1[i] < nums2[j]:\\n# i += 1\\n# continue\\n# else:\\n# nums1.insert(i,nums2[j])\\n# j += 1\\n# i += 1\\n# continue\\n# nums1 = [1,2,2,3,5,6]\\n# m = 3 2 2 1 0\\n# nums2 = [2,5,6] [5,6] [5,6] [5,6] [5,6]\\n# n = 3 3 2 2 2\\n# [2,0] [1,2,0] [2,0]\\n# 1 1\\n# [1] []\\n# 1 0\\n # if m == 0:\\n # nums1 = nums2\\n # return\\n # if n == 0:\\n # del nums1[m:]\\n # return\\n # if nums1[0] < nums2[0]:\\n # self.merge(nums1[1:], m - 1, nums2, n)\\n # print(nums1)\\n # else:\\n # nums1.insert(0, nums2.pop(0))\\n # nums1.pop()\\n # self.merge(nums1[1:], m, nums2, n - 1)\\n # print(nums1)\\n p1 = m - 1\\n p2 = n - 1\\n for p in range(n + m -1 , -1, -1):\\n if p2 < 0:\\n break\\n if p1 >= 0 and nums1[p1] > nums2[p2]:\\n nums1[p] = nums1[p1]\\n p1 -= 1\\n else:\\n nums1[p] = nums2[p2]\\n p2 -= 1\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n p1 = m - 1\\n p2 = n - 1\\n\\n for p in reversed(range(n+m)):\\n if p2 < 0:\\n break\\n if p1 >= 0 and nums1[p1] > nums2[p2]:\\n nums1[p] = nums1[p1]\\n p1 -= 1\\n else:\\n nums1[p] = nums2[p2]\\n p2 -= 1\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n if m == 0:\\n nums1[:n] = nums2\\n elif n == 0:\\n pass\\n else:\\n nums = nums1[:m].copy()\\n for i in range(0, m + n):\\n if len(nums2) == 0:\\n nums1[i] = nums.pop(0)\\n elif len(nums) == 0:\\n nums1[i] = nums2.pop(0)\\n else:\\n nums1[i] = min(nums[0], nums2[0])\\n if nums[0] <= nums2[0]:\\n nums.pop(0)\\n else: nums2.pop(0)\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n i, j = m-1, n-1\\n k = n + m - 1\\n while k >= 0:\\n if i < 0:\\n nums1[k] = nums2[j]\\n j -= 1\\n elif j < 0:\\n nums1[k] = nums1[i]\\n i -= 1\\n elif nums1[i] > nums2[j]:\\n nums1[k] = nums1[i]\\n i -= 1\\n else:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n # Start merging from the back of nums1\\n i, j, k = m - 1, n - 1, m + n - 1\\n \\n # Compare elements from the end and merge them into nums1\\n while j >= 0:\\n if i >= 0 and nums1[i] > nums2[j]:\\n nums1[k] = nums1[i]\\n i -= 1\\n else:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n n2len = len(nums2)\\n n1len = len(nums1)\\n totlen = n1len - n2len\\n for n in nums2:\\n nums1.pop(totlen)\\n nums1.insert(totlen,n)\\n totlen += 1\\n \\n nums1.sort()\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n ptr1 = m - 1\\n ptr2 = n - 1\\n writing_ptr = m + n - 1\\n while ptr1 != -1 and ptr2 != -1:\\n if nums1[ptr1] <= nums2[ptr2]:\\n nums1[writing_ptr] = nums2[ptr2]\\n ptr2 -= 1\\n else:\\n nums1[writing_ptr] = nums1[ptr1]\\n ptr1 -= 1\\n writing_ptr -= 1\\n if ptr1 == -1:\\n while ptr2 != -1:\\n nums1[writing_ptr] = nums2[ptr2]\\n ptr2 -= 1\\n writing_ptr -= 1\\n else:\\n # ptr2 == -1\\n while ptr1 != -1:\\n nums1[writing_ptr] = nums1[ptr1]\\n ptr1 -= 1\\n writing_ptr -= 1\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n r1, r2 = m - 1, n - 1\\n for i in range(len(nums1) - 1, -1, -1):\\n if r2 < 0:\\n break\\n if r1 >= 0 and nums1[r1] >= nums2[r2]:\\n nums1[i] = nums1[r1]\\n r1 -= 1\\n else:\\n nums1[i] = nums2[r2]\\n r2 -= 1\\n return nums1\\n \\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n n1, n2, i = m-1, n-1, m+n-1\\n while n2 >= 0:\\n if n1 >=0 and nums1[n1] > nums2[n2]:\\n nums1[i] = nums1[n1]\\n n1 -= 1\\n else:\\n nums1[i] = nums2[n2]\\n n2 -= 1\\n i -= 1\\n \\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n # for j in range(n):\\n # nums1[m+j] = nums2[j]\\n # nums1.sort()\\n \\n i = m - 1\\n j = n - 1\\n k = m+n-1\\n\\n while j >= 0:\\n if(i >= 0 and nums1[i] > nums2[j]):\\n nums1[k] = nums1[i]\\n i -= 1\\n else:\\n nums1[k] = nums2[j]\\n j -= 1\\n k -= 1\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n x = m\\n len_arr = m+n\\n for j in range(0,n):\\n nums1[x] = nums2[j]\\n x+=1\\n \\n arr = nums1\\n \\n for i in range(len(arr)):\\n temp =0\\n for j in range(i+1,len(arr)):\\n if arr[i] > arr[j]:\\n temp = arr[i]\\n arr[i] = arr[j]\\n arr[j] = temp\\n print(arr)\\n\\n \\n \\n\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n i = m -1\\n j = n -1\\n\\n zero_index = (m+n)-1\\n while i>=0 and j>=0:\\n if nums1[i] <= nums2[j]:\\n nums1[zero_index] = nums2[j]\\n j-=1\\n zero_index-=1\\n else:\\n nums1[zero_index] = nums1[i]\\n zero_index-=1\\n i-=1\\n \\n while i>=0:\\n nums1[zero_index] = nums1[i]\\n i-=1\\n zero_index-=1\\n \\n while j>=0:\\n nums1[zero_index] = nums2[j]\\n j-=1\\n zero_index-=1\\n \\n \\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n p = m-1\\n q = n-1\\n index = len(nums1) - 1\\n \\n while(index >= 0):\\n if (q < 0):\\n break\\n if(p>=0 and nums1[p] >= nums2[q]):\\n nums1[index] = nums1[p]\\n index -= 1\\n p -= 1\\n else:\\n nums1[index] = nums2[q]\\n index -= 1\\n q -= 1\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n nums1[:] = nums1[:m] + nums2[:n]\\n nums1.sort()\\n \",\n \"runtime\": \"48\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":60,"string":"60"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n ptr1 = m - 1\n ptr2 = n - 1\n\n for moving_ptr in range(m + n - 1, -1, -1):\n if ptr2 < 0:\n break\n \n if ptr1 >= 0 and nums1[ptr1] > nums2[ptr2]:\n nums1[moving_ptr] = nums1[ptr1]\n ptr1 -= 1\n else:\n nums1[moving_ptr] = nums2[ptr2]\n ptr2 -= 1\n\n # # set two pointers to the end of each array\n # ptr1 = m - 1\n # ptr2 = n - 1\n # for moving_ptr in range(n + m - 1, -1, -1):\n # if ptr2 < 0:\n # break\n \n # if ptr1 >= 0 and nums1[ptr1] > nums2[ptr2]:\n # nums1[moving_ptr] = nums1[ptr1]\n # ptr1 -= 1\n # else:\n # nums1[moving_ptr] = nums2[ptr2]\n # ptr2 -= 1","memory":"15800"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n p1 = m-1\n p2 = n-1\n p = m+n-1\n \n while p >= 0:\n if p2 < 0:\n break\n \n if p1 >= 0 and nums1[p1] > nums2[p2]:\n nums1[p] = nums1[p1]\n p1 -= 1\n else:\n nums1[p] = nums2[p2]\n p2 -= 1\n \n p -= 1","memory":"15900"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n j = 0\n for i in range(m, m + n):\n nums1[i] = nums2[j]\n j += 1\n nums1.sort()\n","memory":"16000"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n for i in range(m, len(nums1)):\n nums1[i] = nums2[i-m]\n nums1.sort()\n ","memory":"16100"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n\n # working backwards\n\n p1 = m - 1\n p2 = n - 1\n\n i = len(nums1) - 1\n\n if m == 0:\n for j in range(len(nums2)):\n nums1[j] = nums2[j]\n else:\n while i >= 0:\n if p2 < 0:\n break\n elif p1 < 0:\n nums1[i] = nums2[p2]\n i -= 1\n p2 -= 1\n elif nums1[p1] < nums2[p2]:\n nums1[i] = nums2[p2]\n i -= 1\n p2 -= 1\n else:\n nums1[i] = nums1[p1]\n i -= 1\n p1 -= 1\n \n\n\n ","memory":"16200"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n curm = m - 1\n curn = n - 1\n array_len = m + n - 1 \n while curn > -1 and curm > -1:\n if nums1[curm] >= nums2[curn]:\n nums1[array_len] = nums1[curm]\n curm -= 1\n else:\n nums1[array_len] = nums2[curn]\n curn -= 1\n array_len -= 1\n while curn > -1:\n nums1[array_len] = nums2[curn]\n curn -= 1\n array_len -= 1\n ","memory":"16300"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n midx = m - 1\n nidx = n - 1 \n right = m + n - 1\n\n while nidx >= 0:\n if midx >= 0 and nums1[midx] > nums2[nidx]:\n nums1[right] = nums1[midx]\n midx -= 1\n else:\n nums1[right] = nums2[nidx]\n nidx -= 1\n\n right -= 1","memory":"16300"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n\n last = m+n-1\n while m>0 and n>0 :\n if nums1[m-1] > nums2[n-1] :\n nums1[last] = nums1[m-1]\n m -= 1\n else :\n nums1[last] = nums2[n-1]\n n -= 1\n last -= 1\n\n while n>0 :\n nums1[last] = nums2[n-1]\n n -= 1\n last -= 1\n\n\n ","memory":"16400"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n\n #Create new list\n nums3 = nums1[:m]\n if n > 0:\n for i in range(n):\n nums3.append(nums2[i])\n nums3 = sorted(nums3)\n\n #assign new list values into main list\n for i in range(m + n):\n nums1[i] = nums3[i]\n nums1 = sorted(nums1)\n\n\n","memory":"16400"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n \n ptr1 = m - 1\n ptr2 = n - 1\n \n for ptr_new in range(m+n-1, -1, -1):\n if (ptr1 < 0):\n nums1[ptr_new] = nums2[ptr2]\n ptr2 -= 1\n elif (ptr2 < 0):\n nums1[ptr_new] = nums1[ptr1]\n ptr1 -= 1\n elif (nums1[ptr1] > nums2[ptr2]):\n nums1[ptr_new] = nums1[ptr1]\n ptr1 -= 1\n else:\n nums1[ptr_new] = nums2[ptr2]\n ptr2 -= 1\n \n ","memory":"16500"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n track_m = m - 1\n track_n = n - 1\n write_index = m + n -1 \n\n while track_n >= 0 :\n if track_m >= 0 and nums1[track_m] > nums2[track_n] :\n nums1[write_index] = nums1[track_m]\n track_m -= 1\n else :\n nums1[write_index] = nums2[track_n]\n track_n -= 1\n \n write_index -= 1","memory":"16500"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n p = m + n - 1\n m -= 1\n n -= 1\n while m >= 0 or n >= 0:\n x = nums1[m] if m >= 0 else -inf\n y = nums2[n] if n >= 0 else -inf\n if x > y:\n nums1[p] = x\n m -= 1\n else:\n nums1[p] = y\n n -= 1\n p -= 1\n ","memory":"16600"},{"code":"class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\"\n for i in range(n):\n nums1[m + i] = nums2[i]\n nums1.sort()\n \n\n ","memory":"16600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n ptr1 = m - 1\\n ptr2 = n - 1\\n\\n for moving_ptr in range(m + n - 1, -1, -1):\\n if ptr2 < 0:\\n break\\n \\n if ptr1 >= 0 and nums1[ptr1] > nums2[ptr2]:\\n nums1[moving_ptr] = nums1[ptr1]\\n ptr1 -= 1\\n else:\\n nums1[moving_ptr] = nums2[ptr2]\\n ptr2 -= 1\\n\\n # # set two pointers to the end of each array\\n # ptr1 = m - 1\\n # ptr2 = n - 1\\n # for moving_ptr in range(n + m - 1, -1, -1):\\n # if ptr2 < 0:\\n # break\\n \\n # if ptr1 >= 0 and nums1[ptr1] > nums2[ptr2]:\\n # nums1[moving_ptr] = nums1[ptr1]\\n # ptr1 -= 1\\n # else:\\n # nums1[moving_ptr] = nums2[ptr2]\\n # ptr2 -= 1\",\n \"memory\": \"15800\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n p1 = m-1\\n p2 = n-1\\n p = m+n-1\\n \\n while p >= 0:\\n if p2 < 0:\\n break\\n \\n if p1 >= 0 and nums1[p1] > nums2[p2]:\\n nums1[p] = nums1[p1]\\n p1 -= 1\\n else:\\n nums1[p] = nums2[p2]\\n p2 -= 1\\n \\n p -= 1\",\n \"memory\": \"15900\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n j = 0\\n for i in range(m, m + n):\\n nums1[i] = nums2[j]\\n j += 1\\n nums1.sort()\\n\",\n \"memory\": \"16000\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n for i in range(m, len(nums1)):\\n nums1[i] = nums2[i-m]\\n nums1.sort()\\n \",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n\\n # working backwards\\n\\n p1 = m - 1\\n p2 = n - 1\\n\\n i = len(nums1) - 1\\n\\n if m == 0:\\n for j in range(len(nums2)):\\n nums1[j] = nums2[j]\\n else:\\n while i >= 0:\\n if p2 < 0:\\n break\\n elif p1 < 0:\\n nums1[i] = nums2[p2]\\n i -= 1\\n p2 -= 1\\n elif nums1[p1] < nums2[p2]:\\n nums1[i] = nums2[p2]\\n i -= 1\\n p2 -= 1\\n else:\\n nums1[i] = nums1[p1]\\n i -= 1\\n p1 -= 1\\n \\n\\n\\n \",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n curm = m - 1\\n curn = n - 1\\n array_len = m + n - 1 \\n while curn > -1 and curm > -1:\\n if nums1[curm] >= nums2[curn]:\\n nums1[array_len] = nums1[curm]\\n curm -= 1\\n else:\\n nums1[array_len] = nums2[curn]\\n curn -= 1\\n array_len -= 1\\n while curn > -1:\\n nums1[array_len] = nums2[curn]\\n curn -= 1\\n array_len -= 1\\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n midx = m - 1\\n nidx = n - 1 \\n right = m + n - 1\\n\\n while nidx >= 0:\\n if midx >= 0 and nums1[midx] > nums2[nidx]:\\n nums1[right] = nums1[midx]\\n midx -= 1\\n else:\\n nums1[right] = nums2[nidx]\\n nidx -= 1\\n\\n right -= 1\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n\\n last = m+n-1\\n while m>0 and n>0 :\\n if nums1[m-1] > nums2[n-1] :\\n nums1[last] = nums1[m-1]\\n m -= 1\\n else :\\n nums1[last] = nums2[n-1]\\n n -= 1\\n last -= 1\\n\\n while n>0 :\\n nums1[last] = nums2[n-1]\\n n -= 1\\n last -= 1\\n\\n\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n\\n #Create new list\\n nums3 = nums1[:m]\\n if n > 0:\\n for i in range(n):\\n nums3.append(nums2[i])\\n nums3 = sorted(nums3)\\n\\n #assign new list values into main list\\n for i in range(m + n):\\n nums1[i] = nums3[i]\\n nums1 = sorted(nums1)\\n\\n\\n\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n \\n ptr1 = m - 1\\n ptr2 = n - 1\\n \\n for ptr_new in range(m+n-1, -1, -1):\\n if (ptr1 < 0):\\n nums1[ptr_new] = nums2[ptr2]\\n ptr2 -= 1\\n elif (ptr2 < 0):\\n nums1[ptr_new] = nums1[ptr1]\\n ptr1 -= 1\\n elif (nums1[ptr1] > nums2[ptr2]):\\n nums1[ptr_new] = nums1[ptr1]\\n ptr1 -= 1\\n else:\\n nums1[ptr_new] = nums2[ptr2]\\n ptr2 -= 1\\n \\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n track_m = m - 1\\n track_n = n - 1\\n write_index = m + n -1 \\n\\n while track_n >= 0 :\\n if track_m >= 0 and nums1[track_m] > nums2[track_n] :\\n nums1[write_index] = nums1[track_m]\\n track_m -= 1\\n else :\\n nums1[write_index] = nums2[track_n]\\n track_n -= 1\\n \\n write_index -= 1\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n p = m + n - 1\\n m -= 1\\n n -= 1\\n while m >= 0 or n >= 0:\\n x = nums1[m] if m >= 0 else -inf\\n y = nums2[n] if n >= 0 else -inf\\n if x > y:\\n nums1[p] = x\\n m -= 1\\n else:\\n nums1[p] = y\\n n -= 1\\n p -= 1\\n \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums1 in-place instead.\\n \\\"\\\"\\\"\\n for i in range(n):\\n nums1[m + i] = nums2[i]\\n nums1.sort()\\n \\n\\n \",\n \"memory\": \"16600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":13,"string":"13"}}},{"rowIdx":43,"cells":{"question_id":{"kind":"number","value":89,"string":"89"},"name":{"kind":"string","value":"gray-code"},"content":{"kind":"string","value":"<p>An <strong>n-bit gray code sequence</strong> is a sequence of <code>2<sup>n</sup></code> integers where:</p>\n\n<ul>\n\t<li>Every integer is in the <strong>inclusive</strong> range <code>[0, 2<sup>n</sup> - 1]</code>,</li>\n\t<li>The first integer is <code>0</code>,</li>\n\t<li>An integer appears <strong>no more than once</strong> in the sequence,</li>\n\t<li>The binary representation of every pair of <strong>adjacent</strong> integers differs by <strong>exactly one bit</strong>, and</li>\n\t<li>The binary representation of the <strong>first</strong> and <strong>last</strong> integers differs by <strong>exactly one bit</strong>.</li>\n</ul>\n\n<p>Given an integer <code>n</code>, return <em>any valid <strong>n-bit gray code sequence</strong></em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> n = 2\n<strong>Output:</strong> [0,1,3,2]\n<strong>Explanation:</strong>\nThe binary representation of [0,1,3,2] is [00,01,11,10].\n- 0<u>0</u> and 0<u>1</u> differ by one bit\n- <u>0</u>1 and <u>1</u>1 differ by one bit\n- 1<u>1</u> and 1<u>0</u> differ by one bit\n- <u>1</u>0 and <u>0</u>0 differ by one bit\n[0,2,3,1] is also a valid gray code sequence, whose binary representation is [00,10,11,01].\n- <u>0</u>0 and <u>1</u>0 differ by one bit\n- 1<u>0</u> and 1<u>1</u> differ by one bit\n- <u>1</u>1 and <u>0</u>1 differ by one bit\n- 0<u>1</u> and 0<u>0</u> differ by one bit\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> n = 1\n<strong>Output:</strong> [0,1]\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n <= 16</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":60.071494288123894,"string":"60.071494"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["math","backtracking","bit-manipulation"],"string":"[\n \"math\",\n \"backtracking\",\n \"bit-manipulation\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"48\", 0.11], [\"50\", 0.32989999999999997], [\"53\", 0.3849], [\"56\", 1.3195000000000001], [\"58\", 3.5183999999999997], [\"61\", 3.2436], [\"64\", 5.7175], [\"66\", 10.8301], [\"69\", 8.6861], [\"72\", 11.9296], [\"74\", 11.819700000000001], [\"77\", 5.0577], [\"80\", 6.5969999999999995], [\"82\", 3.5183999999999997], [\"85\", 1.0995], [\"88\", 1.8142], [\"90\", 1.6493], [\"93\", 0.8247], [\"96\", 1.2645], [\"98\", 1.4844], [\"101\", 1.2094], [\"104\", 1.4295], [\"106\", 1.9241], [\"109\", 1.0445], [\"112\", 1.8692], [\"114\", 1.1545], [\"117\", 0.4948], [\"120\", 0.7147], [\"122\", 0.32989999999999997], [\"125\", 0.21989999999999998], [\"128\", 0.32989999999999997], [\"130\", 0.2199], [\"133\", 0.055], [\"136\", 0.165], [\"138\", 0.11], [\"141\", 0.055], [\"144\", 0.055], [\"146\", 0.11], [\"149\", 0.055], [\"152\", 0.11], [\"154\", 0.055], [\"157\", 0.055], [\"160\", 0.055], [\"162\", 0.055], [\"165\", 0.055], [\"168\", 0.055], [\"170\", 0.055], [\"173\", 0.055], [\"176\", 0.055], [\"178\", 0.055], [\"181\", 0.11], [\"184\", 0.11], [\"186\", 0.11], [\"189\", 0.055], [\"192\", 0.055], [\"194\", 0.055], [\"197\", 0.055], [\"200\", 0.055], [\"202\", 0.055], [\"205\", 0.055], [\"208\", 0.055], [\"210\", 0.055], [\"213\", 0.055], [\"216\", 0.055], [\"218\", 0.055], [\"221\", 0.055], [\"224\", 0.055], [\"226\", 0.055], [\"229\", 0.055], [\"232\", 0.055], [\"234\", 0.055], [\"237\", 0.055], [\"240\", 0.055], [\"242\", 0.055], [\"245\", 0.055]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"22400\", 0.055], [\"23400\", 0.055], [\"23500\", 0.2199], [\"23600\", 1.4294], [\"23700\", 6.2672], [\"23800\", 8.5212], [\"23900\", 12.8092], [\"24000\", 25.1787], [\"24100\", 19.0764], [\"24200\", 1.9241], [\"24300\", 0.6597], [\"24400\", 0.6047], [\"24500\", 0.9346], [\"24600\", 0.11], [\"24700\", 0.4398], [\"24800\", 0.9896], [\"24900\", 1.5393], [\"25000\", 0.055], [\"25100\", 0.3848], [\"25200\", 1.5393], [\"25300\", 0.7697], [\"25400\", 0.2749], [\"25500\", 0.1649], [\"25600\", 0.055], [\"25800\", 0.2199], [\"25900\", 0.11], [\"26000\", 0.11], [\"26100\", 0.11], [\"26500\", 0.055], [\"26600\", 0.055], [\"26800\", 0.11], [\"26900\", 0.1649], [\"27600\", 0.055], [\"27800\", 0.055], [\"28000\", 0.1649], [\"28100\", 0.055], [\"28600\", 0.055], [\"28900\", 0.055], [\"29200\", 0.055], [\"29600\", 0.055], [\"29800\", 0.055], [\"30000\", 0.055], [\"30200\", 0.11], [\"30500\", 0.055], [\"31100\", 0.055], [\"31900\", 0.1649], [\"32600\", 0.055], [\"32900\", 0.055], [\"33000\", 0.1649], [\"33400\", 0.055], [\"33900\", 0.055], [\"34100\", 0.11], [\"34400\", 0.2199], [\"34500\", 0.2199], [\"34700\", 0.055], [\"34800\", 0.11], [\"34900\", 0.2749], [\"35000\", 1.8692], [\"35100\", 3.4085], [\"35200\", 0.3299], [\"35300\", 0.11], [\"35400\", 0.4948]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res = []\n for i in range(2**n):\n res.append(i ^ i >> 1)\n return res","runtime":"48"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n ans = [0, 1]\n for i in range(1, n):\n j = len(ans) - 1\n offset = 1 << i\n for k in range(j, -1, -1):\n ans.append(ans[k] + offset)\n\n return ans","runtime":"48"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n return [i^i>>1 for i in range(2**n)]\n \n \n\n \n\n ","runtime":"50"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def grayCodeRecursive(n):\n if n == 0:\n return [0]\n prev_gray_code = grayCodeRecursive(n-1)\n leading_bit_one = 1 << (n-1)\n return prev_gray_code + [leading_bit_one + i for i in reversed(prev_gray_code)]\n return grayCodeRecursive(n)","runtime":"50"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n if n == 1:\n return [0, 1]\n left = self.grayCode(n-1)\n right = left.copy()\n right.reverse()\n shift = 1 << (n-1)\n right = [r+shift for r in right]\n return left + right\n\n ","runtime":"53"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res = []\n L = 1 << n\n for i in range(L):\n num = i ^ (i >> 1) #each gray code num = i xor (i/2)\n res.append(num)\n return res","runtime":"53"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n rv = [0, 1]\n p = 1\n for _ in range(n - 1):\n p <<= 1\n rv += [p | x for x in rv[::-1]]\n return rv\n \n ","runtime":"56"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def generate_gray_code(n: int) -> List[int]:\n if n == 0:\n return [0]\n if n == 1:\n return [0, 1]\n \n previous_gray_code = generate_gray_code(n - 1)\n mask = 1 << (n - 1)\n result = previous_gray_code + [mask | num for num in reversed(previous_gray_code)]\n return result\n return generate_gray_code(n)\n","runtime":"56"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def grayCodeHelper(n):\n if n == 0:\n return [0]\n else:\n prev_gray_codes = grayCodeHelper(n-1)\n leading_bit_one = 1 << (n-1)\n return prev_gray_codes + [leading_bit_one | code for code in reversed(prev_gray_codes)]\n return grayCodeHelper(n)","runtime":"58"},{"code":"class Solution:\n# def grayCode(self, n: int) -> List[int]:\n \n \n# res = [0]\n \n \n# visited = set([0])\n# while len(res) < 2**n:\n# shift = 0\n# val = res[-1]\n# while val in visited:\n# val ^= 1 << shift \n# if val in visited:\n# val ^= 1 << shift\n# shift += 1\n \n# res.append(val)\n# visited.add(val)\n \n \n# return res\n\n def grayCode(self, n: int) -> List[int]:\n return [i ^ (i >> 1) for i in range(2 ** n)]","runtime":"58"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n results = [0]\n for i in range(n): \n results += [x + pow(2, i) for x in reversed(results)]\n return results\n ","runtime":"61"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n ans = [0]\n\n for i in range(n):\n for j in reversed(range(len(ans))):\n ans.append(ans[j] | 1 << i)\n\n return ans\n ","runtime":"61"},{"code":"import time\r\nfrom typing import List\r\nclass Solution:\r\n def grayCode(self, n: int) -> List[int]:\r\n res = []\r\n start = 1\r\n start_res = [0,1]\r\n def genNext(current, last):\r\n nonlocal res\r\n if current == n:\r\n res = last\r\n return\r\n cur = [0]\r\n for i in range(1, len(last)):\r\n cur.append(last[i])\r\n for i in range(len(last)-1, -1, -1):\r\n cur.append(2**current+last[i])\r\n genNext(current+1, cur)\r\n genNext(start, start_res)\r\n return res","runtime":"64"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res=[0]\n for i in range(n):\n for j in range(len(res)-1,-1,-1):\n res.append(res[j] | (1<<i))\n return res\n ","runtime":"64"},{"code":"import time\r\nfrom typing import List\r\nclass Solution:\r\n def grayCode(self, n: int) -> List[int]:\r\n res = []\r\n start = 1\r\n start_res = [0,1]\r\n def genNext(current, last):\r\n nonlocal res\r\n if current == n:\r\n res = last\r\n return\r\n cur = [0]\r\n for i in range(1, len(last)):\r\n cur.append(last[i])\r\n for i in range(len(last)-1, -1, -1):\r\n cur.append(2**current+last[i])\r\n genNext(current+1, cur)\r\n genNext(start, start_res)\r\n return res","runtime":"66"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n # Start with the base case for 1-bit Gray code\n result = [0, 1]\n \n # Generate Gray code sequence for n bits\n for i in range(1, n):\n # The current size of the result list\n size = len(result)\n # Add 1 to the prefix of the reversed result list\n # This operation mirrors the sequence and prefixes it with 1\n for j in range(size - 1, -1, -1):\n result.append(result[j] | (1 << i))\n \n return result\n","runtime":"66"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n if n == 0:\n return [0]\n \n previous = self.grayCode(n-1)\n result = []\n\n for code in previous:\n result.append(code)\n\n add_bit = 1 << (n - 1)\n for code in reversed(previous):\n result.append(add_bit | code)\n\n return result\n \n \n\n ","runtime":"69"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n if not n: return []\n\n res = [0, 1]\n n-=1\n count = 1\n\n while n > 0:\n newres = [2**n + r for r in res[::-1]]\n res += newres\n count += 1\n n -= 1\n\n return res\n\n\n\n ","runtime":"69"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n start = [0, 1]\n res = [0]\n for i in range(n):\n x = 2 ** i\n for num in reversed(res):\n res.append(x ^ num)\n \n return res","runtime":"72"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n if n == 0:\n return [0]\n \n # Base case for n = 1\n if n == 1:\n return [0, 1]\n \n # Generate Gray code for n-1 bits\n previous_gray_code = self.grayCode(n - 1)\n \n # Reflect and prepend 1 to each of the previous gray code\n # Example: previous_gray_code = [0, 1] => reflected = [1, 0] => prepended = [3, 2]\n reflected_gray_code = [(1 << (n - 1)) | x for x in reversed(previous_gray_code)]\n \n # Combine the original and reflected Gray codes\n return previous_gray_code + reflected_gray_code\n ","runtime":"72"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = []\n for i in range(1 << n): # 1 << n is 2^n, the total number of gray codes\n result.append(i ^ (i >> 1)) # Append the gray code for number i\n return result\n ","runtime":"74"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = []\n for i in range(1 << n):\n result.append(i ^ (i >> 1))\n return result\n","runtime":"74"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = []\n\n for i in range(2**n):\n \n result.append(i ^ i >> 1)\n\n return result","runtime":"77"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res = []\n for i in range(0,2**n):\n res.append(i^(i>>1))\n return res","runtime":"77"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res = [0]\n for bit in range(n):\n size = len(res)\n for i in reversed(range(size)):\n res.append(res[i] | 1 << bit)\n return res","runtime":"80"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n def dfs(n):\n if n==0:\n return [0]\n \n previous = dfs(n-1)\n appending_0 = [(i << 1) for i in previous]\n appending_1 = [((i << 1) | 1) for i in reversed(previous)]\n\n return appending_0+appending_1\n return dfs(n)\n ","runtime":"80"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n if n == 1:\n return [0, 1]\n\n prev_gray = self.grayCode(n - 1)\n size = len(prev_gray)\n\n # Complement each number in prev_gray and add it to the list\n for i in range(size - 1, -1, -1):\n prev_gray.append(prev_gray[i] | (1 << (n - 1)))\n\n return prev_gray","runtime":"82"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n print(f'grayCode({n}):')\n\n if n == 0:\n return (0,)\n \n prior = self.grayCode(n - 1)\n print(f' {prior=}')\n \n REV = lambda x: tuple(reversed(tuple(x)))\n\n priorR = REV(prior)\n print(f' {priorR=}')\n\n increment = 2 ** (n - 1)\n secondHalf = tuple([\n R + increment\n for R in priorR\n ])\n print(f'{secondHalf=}')\n\n return prior + secondHalf\n","runtime":"82"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n print(n*n)\n pre_array = []\n final_array = []\n for i in range(n):\n if i == 0:\n final_array.append(0)\n final_array.append(1)\n else:\n for j in range(len(final_array)):\n final_array.append(pre_array[-j-1] + 2**i)\n \n pre_array[:] = final_array[:]\n\n print(final_array)\n return final_array","runtime":"85"},{"code":"import time\r\nfrom typing import List\r\nclass Solution:\r\n def grayCode(self, n: int) -> List[int]:\r\n res = []\r\n start = 1\r\n start_res = [0,1]\r\n def genNext(current, last):\r\n nonlocal res\r\n if current == n:\r\n res = last\r\n return\r\n cur = [0]\r\n for i in range(1, len(last)):\r\n cur.append(last[i])\r\n for i in range(len(last)-1, -1, -1):\r\n cur.append(2**current+last[i])\r\n genNext(current+1, cur)\r\n genNext(start, start_res)\r\n return res","runtime":"85"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result","runtime":"90"},{"code":"import time\r\nfrom typing import List\r\nclass Solution:\r\n def grayCode(self, n: int) -> List[int]:\r\n res = []\r\n start = 1\r\n start_res = [0,1]\r\n def genNext(current, last):\r\n nonlocal res\r\n if current == n:\r\n res = last\r\n return\r\n cur = [0]\r\n for i in range(len(last)):\r\n cur.append(2**current+last[i])\r\n for i in range(len(last)-1, 0, -1):\r\n cur.append(last[i])\r\n genNext(current+1, cur)\r\n genNext(start, start_res)\r\n return res","runtime":"90"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n\n def gray(n):\n if n==1: return [\"0\", \"1\"]\n\n old = gray(n-1)\n ref = [\"1\" + x for x in old[::-1]]\n\n old = [\"0\" + x for x in old]\n\n return old+ ref\n return list(map(lambda x: int(x, 2), gray(n)))\n\n\n","runtime":"93"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n self.codes = []\n self.c = 0\n self._gray_code(n)\n return self.codes\n\n def _gray_code(self, n, rev=False):\n if n == 0:\n self.codes.append(self.c)\n return\n\n origc = self.c\n\n self.c = (origc << 1)\n if rev:\n self.c |= 1\n self._gray_code(n-1, rev=False)\n\n self.c = (origc << 1)\n if not rev:\n self.c |= 1\n self._gray_code(n-1, rev=True)\n\n self.c = origc\n\n","runtime":"93"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = [0]\n visited = {0}\n self.generate(result, n, visited)\n return result\n\n def generate(self, result, n, visited):\n if len(result) == (1 << n):\n return True\n current = result[-1]\n for i in range(n):\n nextNum = current ^ (1 << i)\n if nextNum not in visited:\n visited.add(nextNum)\n result.append(nextNum)\n if self.generate(result, n, visited):\n return True\n # visited.remove(nextNum)\n # result.pop()","runtime":"96"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n def backtracking(track, curr):\n if len(self.res) != 0:\n return True\n if used[curr]:\n return False\n if len(track) == (1 << n) - 1:\n self.res = track + [curr]\n return True\n track.append(curr)\n used[curr] = True\n # flip one bit for each pos\n for pos in range(n):\n nxt = curr ^ (1 << pos) #xor one bit\n if backtracking(track, nxt):\n return True\n track.pop()\n used[curr] = False\n return False\n \n self.res = []\n used = [False] * (1<<n)\n backtracking([], 0)\n return self.res","runtime":"96"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n length = 1 << n # same as 2**n\n visited = [False] * length\n\n def dfs(start_index, code):\n if start_index == length:\n return True\n for i in range(n):\n new_code = code ^ (1 << i)\n if not visited[new_code]:\n path.append(new_code)\n visited[new_code] = True\n if dfs(start_index+1, new_code): \n return True\n visited[new_code] = False\n path.pop()\n return False\n \n path = [0]\n visited[0] = True\n dfs(1, 0)\n return path","runtime":"98"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n nums = [0 for i in range(0,2**n)]\n seen = set([0])\n for i in range(1,2**n):\n for j in range(0,n):\n if nums[i-1] ^ (1 << j) in seen:\n continue\n nums[i] = nums[i-1] ^ (1 << j)\n seen.add(nums[i])\n break\n return nums","runtime":"98"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n length = 1 << n # same as 2**n\n visited = [False] * length\n\n def dfs(start_index, code):\n if start_index == length:\n return True\n for i in range(n):\n new_code = code ^ (1 << i)\n\n if not visited[new_code]:\n path.append(new_code)\n visited[new_code] = True\n if dfs(start_index+1, new_code):\n return True\n visited[new_code] = False\n path.pop()\n\n return False\n\n path = [0]\n visited[0] = True\n dfs(1, 0)\n return path","runtime":"101"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res, vis = [0], set([0])\n def helper(res, n, vis):\n if len(res) == (1 << n):\n return True\n curr = res[-1]\n for i in range(n):\n nextnum = curr ^ (1<<i)\n if nextnum not in vis:\n vis.add(nextnum)\n res.append(nextnum)\n if helper(res, n, vis):\n return True\n vis.remove(nextnum)\n res.pop()\n helper(res, n, vis)\n return res","runtime":"101"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n result = [0]\n visited = set([0])\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n if generateGrayCode(next_num):\n return True\n result.pop()\n visited.remove(next_num)\n return False\n generateGrayCode(0)\n return result","runtime":"104"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result ","runtime":"104"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result ","runtime":"106"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = [0]\n visited=set([0])\n\n\n def generateGrayCode(num):\n if len(result)==2**n:\n return True\n for i in range(n):\n next_num=num^(1<<i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return Fasle\n generateGrayCode(0)\n return result\n ","runtime":"106"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result","runtime":"109"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def dfs(path):\n if len(path) == n:\n return [path]\n a = dfs(path + \"0\")\n b = dfs(path + \"1\")\n b = b[::-1]\n return a + b\n\n if n == 0:\n return [0]\n res = dfs(\"\")\n return list(map(lambda x: int(x, 2), res))\n","runtime":"109"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n # 0부터 시작\n # - 아래부터 검사: 0이면 1로 변환하고, 다음 (vst 체크)\n # - 아래부터 검사: 1이면 0으로 변환하고, 다음\n vst = [False] * (1 << 17)\n result = []\n \n def check(x):\n result.append(x)\n i = 0\n while i < n:\n if x & (1 << i) == 0:\n if not vst[x | (1 << i)]:\n vst[x | (1 << i)] = True\n check(x | (1 << i))\n return\n else:\n if not vst[x - (1 << i)]:\n vst[x - (1 << i)] = True\n check(x - (1 << i))\n return\n i += 1\n\n vst[0] = True\n check(0)\n return result\n","runtime":"112"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result","runtime":"112"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result","runtime":"114"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result\n\n ","runtime":"114"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n # formula:\n # result = []\n # for i in range(1<<n):\n # result.append(i^(i>>1))\n # return result\n\n result = [0]\n visited = set([0])\n\n def bt():\n if len(result) == (1<< n):\n return True\n \n current = result[-1]\n for i in range(n):\n next_code = current ^ (1 << i)\n if next_code not in visited:\n result.append(next_code)\n visited.add(next_code)\n if bt():\n return True\n result.pop()\n visited.remove(next_code)\n return False\n bt()\n return result","runtime":"117"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result","runtime":"117"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n \n if generateGrayCode(next_num):\n return True\n \n result.pop()\n visited.remove(next_num)\n \n return False\n\n generateGrayCode(0)\n return result","runtime":"120"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result","runtime":"120"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n col = set( [i for i in range(2**n)] )\n last_digit = set( [2**i for i in range(n)] )\n N, f = [], [False] \n def DFS(i):\n col.remove(i)\n N.append(i) \n if not col: \n if i in last_digit: f[0] = True \n return \n for j in range(n):\n v = i^(2**j) \n if v in col:\n DFS( v ) \n if f[0]: return \n N.pop()\n col.add(i)\n return \n DFS(0)\n return N ","runtime":"122"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def dfs(path):\n if len(path) ==n:\n return [path]\n\n a = dfs(path+'0')\n\n b = dfs(path+'1')\n\n b = b[::-1]\n\n return a+b\n \n if n==0:\n return [0]\n res = dfs('')\n\n return list(map(lambda x: int(x,2),res))\n ","runtime":"122"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def dfs(path):\n # action\n if len(path) == n:\n return [path]\n\n # continue path with 0 first\n a = dfs(path + '0')\n\n # then continue path with 1\n b = dfs(path + '1')\n\n # reverse the order of possibilities for 1 case\n b = b[::-1]\n\n # append 0 and 1 lists\n return a + b\n\n # base\n if n == 0:\n return [0]\n\n res = dfs('')\n \n # map path string to integers\n return list(map(lambda x: int(x, 2), res))\n ","runtime":"125"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def dfs(path):\n if len(path) == n:\n return [path]\n a = dfs(path + \"0\")\n b = dfs(path + \"1\")\n b = b[::-1]\n return a + b\n\n if n == 0:\n return [0]\n res = dfs(\"\")\n return list(map(lambda x: int(x, 2), res))\n","runtime":"125"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n col = set( [i for i in range(2**n)] )\n last_digit = set( [2**i for i in range(n)] )\n N, f = [], [False] \n def DFS(i):\n col.remove(i)\n N.append(i) \n if not col: \n if i in last_digit: f[0] = True \n return \n for j in range(n):\n v = i^(2**j) \n if v in col: DFS( v ) \n if f[0]: return \n N.pop()\n col.add(i)\n return \n DFS(0)\n return N ","runtime":"128"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = []\n for i in range(2 ** n):\n print(i, i >> 1)\n gray = i ^ (i >> 1)\n result.append(gray)\n return result","runtime":"128"},{"code":"class Solution:\n def backtrack(self, result, visited):\n if len(result) == 1 << self.n:\n # self.results.append(deepcopy(result))\n return deepcopy(result)\n\n current = result[-1]\n for bit in range(self.n):\n new = current ^ (1 << bit)\n if new not in visited:\n result.append(new)\n visited.add(new)\n # print(f'Trying {result} neighbors{arr[:ix] + arr[ix+1:]}')\n res = self.backtrack(result, visited) \n if res is not None:\n return res\n visited.remove(new)\n result.pop()\n return\n \n def grayCode(self, n: int) -> List[int]:\n self.n = n\n self.results = []\n visited = set([0])\n result = self.backtrack([0], visited)\n\n return result\n ","runtime":"130"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n seq, visited = [0], set([0])\n\n def dfs():\n # initially added the other check, but it works even without it..\n # is this the case because only 1 possuble sequence exist?\n if len(seq) == 2**n: # and self._differ_by_exactly_one_bit(seq[-1], 0)\n return True\n \n for i in range(n):\n if seq[-1] & 1 << i:\n # bit already set, try removing it\n mask = 1 << i\n inverted_mask = ~mask\n next_num = seq[-1] & inverted_mask\n else:\n # but not set, try adding it\n next_num = seq[-1] | 1 << i\n \n if next_num not in visited:\n seq.append(next_num)\n visited.add(next_num)\n if dfs():\n # sequence found\n return True\n visited.remove(next_num)\n seq.pop()\n\n return False\n\n dfs()\n return seq","runtime":"133"},{"code":"class Solution:\n @cache\n def grayCode(self, n: int) -> List[int]:\n if n < 1:\n return []\n if n < 2:\n return [0, 1]\n f = self.grayCode\n prev = f(n - 1)\n ret1, ret2 = [], []\n for e in prev:\n ret1.append(bin(e)[2:] + '0')\n ret2.append(bin(e)[2:] + '1')\n return list(map(lambda x: int(x, 2), ret1 + ret2[::-1]))","runtime":"136"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n power = int(2**n)\n numbers = [0 for _ in range(power)]\n\n series = power\n curr_pow = 1\n\n for _ in range(n):\n reverse = False\n half_series = series // 2\n\n i = 0\n for _ in range(curr_pow):\n if reverse:\n for _ in range(half_series):\n numbers[i] += curr_pow\n i += 1\n i = i + half_series\n else:\n i = i + half_series\n for _ in range(half_series):\n numbers[i] += curr_pow\n i += 1\n reverse = not reverse\n series = series // 2\n curr_pow *= 2\n\n return numbers\n\n\n # n == 1: [0, 1]\n # n == 2: [00, 01, 11, 10]\n # n == 3: [000, 001, 011, 010, 110, 111, 101, 100]\n # [0 0 0 0 1 1 1 1]\n # [ 0 0 1 1 1 1 0 0]\n # [ 0 1 1 0 0 1 1 0]\n\n # 0 ones: 1\n # 1 ones: n\n # 2 ones: n\n # n == 4: [0000, 0001, 0011, 0010, 0110, 0100]\n # [0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 ] # series = 16\n # [ 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 ] # series = 8\n # [ 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 ] # series = 4\n # [ 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 ] # series = 2\n","runtime":"136"},{"code":"class Solution:\n def backtrack(self, result, visited):\n if len(result) == 1 << self.n:\n # self.results.append(deepcopy(result))\n return deepcopy(result)\n\n current = result[-1]\n for bit in range(self.n):\n new = current ^ (1 << bit)\n if new not in visited:\n result.append(new)\n visited.add(new)\n # print(f'Trying {result} neighbors{arr[:ix] + arr[ix+1:]}')\n res = self.backtrack(result, visited) \n if res is not None:\n return res\n visited.remove(new)\n result.pop()\n return\n \n def grayCode(self, n: int) -> List[int]:\n self.n = n\n self.results = []\n visited = set([0])\n result = self.backtrack([0], visited)\n\n return result\n ","runtime":"138"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def rec(n: int) -> List[int]:\n if n == 0:\n return []\n # 0 <-> 1\n # 10 <-> 11 <-> 01 <-> 00\n if n == 1:\n return [0, 1]\n if n == 2:\n return [0, 1, 3, 2]\n res = []\n # Prior step\n # 1000 -> ... -> 1100\n for el in rec(n - 1):\n res.append(el | (1 << (n-1)))\n # Major step \n # 1100 -> 0100\n for el in rec(n - 1)[::-1]:\n res.append(el)\n return list(reversed(res))\n return rec(n)\n","runtime":"138"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res = [0]\n def dfs(visited):\n if len(res) == 2 ** n and bin((res[0] ^ res[-1])).count('1') == 1:\n return res\n else:\n for i in range(n):\n num = res[-1] ^ (1 << i)\n if num not in visited and bin((num ^ res[-1])).count('1') == 1:\n res.append(num)\n visited.add(num)\n if dfs(visited):\n return res\n res.pop()\n visited.remove(num)\n return False\n\n return dfs({0})\n","runtime":"141"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n seen = [False] * (2 ** n)\n\n res = [0]\n last = '0' * n\n\n seen[0] = True\n\n for i in range(2 ** n - 1):\n for j in range(n):\n changed = last[:j] + ('0' if last[j] == '1' else '1') + last[j+1:]\n\n next_i = int(changed,2)\n if not seen[next_i]:\n res.append(next_i)\n last = changed\n seen[next_i] = True\n break\n\n return res","runtime":"144"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n powers: set[int] = set([2 ** i for i in range(16)])\n def is_power_of_two(n: int) -> bool:\n return n in powers\n\n available_nums: set[int] = set([i for i in range(1, 2 ** n)])\n list_so_far: list[int] = [0]\n ans: list = []\n def backtrack() -> bool:\n \n if len(list_so_far) == 2 ** n:\n nonlocal ans\n ans = list_so_far.copy()\n return True\n elif len(list_so_far) == 2 ** n - 1:\n final_num: int = list(available_nums)[0]\n if is_power_of_two(final_num ^ list_so_far[0]) and is_power_of_two(final_num ^ list_so_far[-1]):\n list_so_far.append(final_num)\n retval: bool = backtrack()\n list_so_far.pop()\n return retval\n return False\n \n # Try out each candidate number\n for i in range(n):\n # i is the digit number\n last_num: int = list_so_far[-1]\n if last_num & (2 ** i) != 0:\n candidate: int = last_num - (2 ** i)\n else:\n candidate: int = last_num + (2 ** i)\n \n if candidate in available_nums:\n list_so_far.append(candidate)\n available_nums.remove(candidate)\n if backtrack():\n list_so_far.pop()\n available_nums.add(candidate)\n return True\n available_nums.add(candidate)\n list_so_far.pop()\n return False\n\n backtrack()\n \n return ans\n \n \n\n\n","runtime":"146"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n # differs by exactly one bit ---> xor\n res = [0]\n\n for i in range(n):\n for j in range(len(res) - 1, - 1, -1):\n res.append(res[j] | (1 << i))\n print(res[j], 1 << i, res[j] | (1 << i))\n \n return res","runtime":"146"},{"code":"class Solution:\n def genNext(self, cur, n, used):\n for i in range(n):\n bit = 1 << i\n if (cur >> i) % 2 == 1:\n bit *= -1\n adj = cur + bit\n if not used[adj]:\n yield adj\n \n def checkDiff(self, num1, num2):\n xor = num1 ^ num2\n while xor % 2 == 0:\n xor >>= 1\n xor >>= 1\n if xor > 0:\n return False\n return True\n\n def buildCode(self, cur, code, used, n):\n if len(code) == 2**n:\n if self.checkDiff(code[0], code[-1]):\n return True\n return False\n for adj in self.genNext(cur, n, used):\n code.append(adj)\n used[adj] = True\n res = self.buildCode(adj, code, used, n)\n if res:\n return True\n used[adj] = False\n code.pop()\n return False\n \n def grayCode(self, n: int) -> List[int]:\n used = [False]*2**n\n code = [0]\n used[0] = True\n\n self.buildCode(0, code, used, n)\n return code\n\n\n \n\n\n ","runtime":"149"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n visited = set()\n res = []\n length = 2**n \n\n def dfs(prev_str):\n visited.add(prev_str)\n res.append(int(prev_str, 2))\n if len(res)==length:\n return True\n \n for i in range(len(prev_str)):\n new_str = prev_str[:i] + (\"1\" if prev_str[i]==\"0\" else \"0\") + prev_str[i+1:]\n if new_str not in visited:\n if dfs(new_str):\n return True\n return False\n\n dfs(\"0\"*n)\n return res\n ","runtime":"152"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res = [0] + [-1] * (2 ** n - 1)\n used = [True] + [False] * (2 ** n - 1)\n\n def differ_by_one_bit(a, b):\n xor = a ^ b\n return xor != 0 and (xor & (xor - 1)) == 0\n\n def get_next_int(num):\n for i in range(n):\n next_int = num ^ (1 << i)\n if not used[next_int]:\n yield next_int\n\n def backtrack(idx):\n if idx == 2 ** n - 1:\n return differ_by_one_bit(res[0], res[-1])\n\n for next_int in get_next_int(res[idx]):\n res[idx + 1] = next_int\n used[next_int] = True\n if backtrack(idx + 1):\n return True\n res[idx + 1] = -1\n used[next_int] = False\n\n return False\n\n backtrack(0)\n\n return res\n","runtime":"152"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n start=\"0\"*n\n lst_length = 2**n\n d_visited = {}\n lst_visited = []\n d_swap = {\"0\": \"1\", \"1\": \"0\"}\n\n def helper(curr_val, i):\n if curr_val in d_visited:\n return None\n else:\n d_visited[curr_val]=1\n lst_visited.append(int(curr_val,2))\n\n if i == lst_length:\n return lst_visited\n \n for j in range(len(curr_val)-1,-1,-1):\n next_val = curr_val[:j]+d_swap[curr_val[j]]+curr_val[j+1:]\n ans = helper(next_val,i+1)\n if ans:\n return ans\n\n del d[curr_val]\n lst_visited.pop()\n\n return helper(start, 1)\n \n \n\n ","runtime":"154"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n length = 1 << n # same as 2**n\n visited = [False] * length\n\n def dfs(start_index, code):\n if start_index == length:\n return True\n for i in range(n):\n new_code = code ^ (1 << i)\n print(new_code)\n if not visited[new_code]:\n path.append(new_code)\n visited[new_code] = True\n if dfs(start_index+1, new_code): return True\n visited[new_code] = False\n path.pop()\n return False\n \n path = [0]\n visited[0] = True\n dfs(1, 0)\n return path\n ","runtime":"157"},{"code":"class Solution:\n def __init__(self):\n self.codes = [[\"0\", \"1\"]]\n for i in range(2, 17):\n codes = self.codes[i - 2]\n new = list()\n for c in codes:\n new.append(c+\"0\")\n for c in codes[::-1]:\n new.append(c+\"1\")\n self.codes.append(new)\n\n def grayCode(self, n: int) -> List[int]:\n return list(map(lambda x: int(x, 2), self.codes[n - 1]))","runtime":"160"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n nums = [0 for i in range(0,2**n)]\n swap = [i for i in range(n-1,-1,-1)]\n for i in range(1,2**n):\n for j in swap:\n if i%(2**j) == 0:\n nums[i] = nums[i-1] ^ (1 << j)\n break\n return nums","runtime":"162"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n length = 1 << n # same as 2**n\n visited = [False] * length\n\n def dfs(start_index, code):\n if start_index == length:\n return True\n for i in range(n):\n new_code = code ^ (1 << i)\n print(new_code)\n if not visited[new_code]:\n path.append(new_code)\n visited[new_code] = True\n if dfs(start_index+1, new_code): return True\n visited[new_code] = False\n path.pop()\n return False\n \n path = [0]\n visited[0] = True\n dfs(1, 0)\n return path","runtime":"165"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n used = {0}\n code = [0] * 2 ** n\n def codes(i):\n if i == 2 ** n:\n yield code\n\n for shift in range(n):\n num = code[i - 1] ^ (1 << shift)\n if num in used:\n continue\n\n code[i] = num\n used.add(num)\n yield from codes(i + 1)\n used.remove(num)\n \n return next(codes(1))\n","runtime":"168"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n return list(self._gray_code(n))\n\n def _gray_code(self, n):\n if n == 0:\n yield 0\n return\n for x in self._gray_code(n-1):\n yield (x << 1)\n for x in reversed(list(self._gray_code(n-1))):\n yield (x << 1) | 1","runtime":"170"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = []\n if n >= 1:\n result = [0,1]\n\n for i in range (1, n):\n temp = result[::-1]\n while temp:\n result.append(temp.pop(0)+(2**i))\n \n return result\n\n ","runtime":"173"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n digit_length = n\n start=\"0\"*digit_length\n lst_length = 2**n\n d_visited = {}\n lst_visited = []\n d_swap = {\"0\": \"1\", \"1\": \"0\"}\n\n def binary_convert(lst):\n ans = []\n for x in lst:\n ans.append(int(x,2))\n return ans\n\n def helper(curr_val, i):\n if curr_val in d_visited:\n return None\n else:\n d_visited[curr_val]=1\n lst_visited.append(curr_val)\n\n if i == lst_length:\n return binary_convert(lst_visited)\n \n for j in range(len(curr_val)-1,-1,-1):\n next_val = curr_val[:j]+d_swap[curr_val[j]]+curr_val[j+1:]\n ans = helper(next_val,i+1)\n if ans:\n return ans\n\n del d[curr_val]\n lst_visited.pop()\n\n return helper(start, 1)\n \n \n\n ","runtime":"176"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n # code = [\"0\", \"1\"]\n # for i in range(n-1):\n # newCode = [\"0\" + x for x in code] + ['1' + x for x in code[::-1]]\n # code = newCode\n # return [int(x, 2) for x in code]\n\n seen = set()\n totalCnt = 2 ** n\n res = []\n def dfs(num):\n nonlocal seen, totalCnt, res\n if len(res) == totalCnt:\n return\n \n seen.add(num)\n res.append(num)\n\n for i in range(n):\n nextNum = num ^ (1 << i)\n if nextNum not in seen:\n dfs(nextNum)\n pass\n \n dfs(0)\n return res\n\n","runtime":"178"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n visited = set()\n res = []\n length = 2**n \n\n def dfs(prev_str):\n visited.add(prev_str)\n res.append(int(prev_str, 2))\n if len(res)==length:\n return True\n \n for i in range(len(prev_str)):\n new_str = prev_str[:i] + (\"1\" if prev_str[i]==\"0\" else \"0\") + prev_str[i+1:]\n if new_str not in visited:\n if dfs(new_str):\n return True\n # return False\n\n dfs(\"0\"*n)\n return res\n ","runtime":"181"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result=[2**n-1]*2**n\n\n for i in range(n,0,-1):\n mask=2**n-1\n mask2=1<<i-1\n mask^=mask2\n\n for j in range(2**(i-1)):\n result[j] &= mask\n for j in range(2**i+2**(i-1),2**n,2**(i+1)):\n for k in range(2**i):\n if j+k<2**n:\n result[j+k] &= mask\n\n return result","runtime":"184"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = []\n visited = set()\n \n def helper(curr_num, level):\n result.append(curr_num)\n visited.add(curr_num)\n \n for i in range(n):\n next_num = curr_num ^ (1 << i)\n \n if next_num not in visited:\n helper(next_num, i)\n \n helper(0, 0)\n\n return result","runtime":"186"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n start=\"0\"*n\n lst_length = 2**n\n d_visited = {}\n lst_visited = []\n d_swap = {\"0\": \"1\", \"1\": \"0\"}\n\n def helper(curr_val, i):\n if curr_val in d_visited:\n return None\n else:\n d_visited[curr_val]=1\n lst_visited.append(int(curr_val,2))\n\n if i == lst_length:\n return lst_visited\n \n for j in range(len(curr_val)-1,-1,-1):\n next_val = curr_val[:j]+d_swap[curr_val[j]]+curr_val[j+1:]\n ans = helper(next_val,i+1)\n if ans:\n return ans\n\n del d[curr_val]\n lst_visited.pop()\n\n return helper(start, 1)\n \n \n\n ","runtime":"189"},{"code":"import math\n\nlog = math.log\n\n\nclass Solution(object):\n def grayCode(self, n):\n \"\"\"\n :type n: int\n :rtype: List[int]\n \"\"\"\n\n # [[0]]\n # [[1]]\n #\n\n bnums = [[0], [1]]\n\n if n != 1:\n for i in range(n - 1):\n for j in range(len(bnums) - 1, -1, -1):\n bnums.append(bnums[j].copy())\n for j in range(int(len(bnums) / 2)):\n bnums[j].insert(0, 0)\n for j in range(int(len(bnums) / 2), len(bnums)):\n bnums[j].insert(0, 1)\n\n for i in range(len(bnums)):\n dnum = 0\n for b in range(n):\n if bnums[i][b]:\n dnum += pow(2, b)\n bnums[i] = dnum\n\n # print(bnums)\n return bnums\n\n\n# 0,0\n# ^\n# 0,1\n# ^\n# 1,1\n# ^\n# 1,0\n# ^\n#\n","runtime":"192"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res=[]\n def backtrack(num,vis):\n if len(res)==2**n:\n return\n res.append(int(num,2))\n vis.add(num)\n for i in range(n):\n l=list(num)\n l[i]='0' if l[i]=='1' else '1'\n nw=''.join(l)\n if nw not in vis:\n backtrack(nw,vis)\n break\n backtrack('0'*n,set())\n return res\n","runtime":"194"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result=[0]\n isPresent={0}\n self.graycodeHelper(result,n,isPresent)\n return result\n def graycodeHelper(self,result,n,isPresent):\n if len(result)==(1<<n):\n return True\n current=result[-1]\n print(\"C\",current)\n for i in range(n):\n nextNum=current^(1<<i)#toggles the i-th bit of the variable current and assigns the result to nextNum\n print(nextNum)\n if nextNum not in isPresent:\n isPresent.add(nextNum)\n result.append(nextNum)\n if self.graycodeHelper(result,n,isPresent):\n return True\n isPresent.remove(nextNum)\n result.pop()\n return False\n\n\n\n ","runtime":"197"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = []\n if n >= 1:\n result = [0,1]\n\n for i in range (1, n):\n temp = result[::-1]\n while temp:\n result.append(temp.pop(0)+(2**i))\n \n return result\n\n ","runtime":"202"},{"code":"import numpy as np\nclass Solution:\n def grayCode(self, n: int) -> List[int]:\n # return gray code of length n, in binary encoding\n def gc(n):\n if n == 1:\n return np.array([0, 1])\n sub = gc(n - 1)\n return np.concat((sub, 2**(n-1) + sub[::-1]))\n return gc(n)\n\n\n","runtime":"205"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n code_strs = self.gray_code_seq(\"0\" * n)\n return [int(s, 2) for s in code_strs]\n \n def gray_code_seq(self, start_code: str) -> List[str]:\n if len(start_code) == 0:\n return [\"\"]\n else:\n curr, next_code = start_code[0], start_code[1:]\n code = []\n if curr == \"0\":\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"0\" + s for s in next_code_seq])\n next_code = next_code_seq[-1]\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"1\" + s for s in next_code_seq])\n else:\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"1\" + s for s in next_code_seq])\n next_code = next_code_seq[-1]\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"0\" + s for s in next_code_seq])\n\n return code\n \n","runtime":"208"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n ans = []\n def convert(b):\n res = b[0]\n for j in range(1,len(b)):\n if b[j]==b[j-1]:res += '0'\n else:res += '1'\n return int(res, 2)\n\n for i in range(pow(2, n)):\n ans.append(convert(bin(i)[2:]))\n return ans","runtime":"210"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n input = ['0','1']\n for i in range(2, n+1):\n input = input+input[::-1]\n for j in range((2**i)//2):\n input[j]='0'+input[j]\n for j in range((2**i)//2,2**i):\n input[j]='1'+input[j]\n def stringBin(index):\n count = 0\n out =0\n for i in range(n-1, -1, -1):\n if input[index][i] == '1':\n out = out + (2**count)\n count+=1\n input[index]=out\n for i in range(2**n):\n stringBin(i)\n return input\n ","runtime":"213"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def biDec(bi):\n dec = 0\n for i in range(len(bi)):\n dec += bi[i] * pow(2, i)\n return dec\n\n cur = [tuple([0] * n)]\n \n j = 0\n while j < n:\n l = len(cur)\n for i in range(l-1, -1, -1):\n cu = list(cur[i])\n cu[j] = 1\n cur.append(tuple(cu))\n j += 1\n \n ans = []\n for bi in cur:\n ans.append(biDec(bi))\n\n return ans ","runtime":"216"},{"code":"import numpy as np\nclass Solution:\n\n\n\n def grayCode(self, n: int) -> List[int]:\n seq_len = n**2\n g_seq = np.zeros((2**n, n), dtype=np.int32)\n g_seq[1][0] = 1 \n\n powers = np.array([2**idx for idx in range(n)], dtype=np.int32)\n\n for idx in range(1, n):\n half_point = (2**idx)\n g_seq[half_point: 2*half_point] = g_seq[:half_point][::-1]\n g_seq[half_point: 2*half_point, idx] = 1\n\n res = (g_seq * powers[None, : ]).sum(axis=-1).tolist()\n return res\n\n\n ","runtime":"218"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def s2i(s):\n v = 0\n for i in s:\n v = v * 2 + int(i)\n return v\n codes = ['']\n for _ in range(n):\n nxt = []\n for s in codes:\n nxt.append(s+'0')\n for s in reversed(codes):\n nxt.append(s+'1')\n codes = nxt\n return [s2i(code) for code in codes]","runtime":"221"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res = [0] # a pos 0 é sempre 0, mesmo quando n = 0\n\n is_available = [True for _ in range(2**n)] # Usado para nao repetir o mesmo numero. Indexado pelo valor do numero\n candidates = [[] for _ in range(2**n)] # A seq sempre tem 2^n elementos. Indexado pela posicao do numero\n\n candidates[0] = [0]\n is_available[0] = False\n\n for i in range(1, 2**n):\n previous = res[i-1]\n candidates[i] = [previous ^ (0b1 << b) \n for b in range(n) \n if is_available[previous ^ (0b1 << b)] == True] # numeros candidatos a serem o proximo\n\n #print(f\"Total cand.: {candidates}. Cur. cand.: {candidates[i]}. Available: {is_available}\")\n\n current = candidates[i][0]\n\n is_available[current] = False\n candidates[i] = candidates[i][1:]\n\n res.append(current)\n return res\n\n","runtime":"224"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n lst = [0]\n n_1 = 2**(n-1)\n for i in range(1, 2**n):\n s = ''\n x = 0\n if i&n_1:\n s+=\"1\"\n x = 1\n else:\n s+='0'\n x = 0\n i<<=1\n y = 0\n j = 1\n while j<n:\n if i&n_1:\n y = 1\n else:\n y = 0\n if x==y:\n s+='0'\n else:\n s+='1'\n x = y\n i<<=1\n j+=1\n lst.append(int(s, 2))\n return lst","runtime":"226"},{"code":"class Solution:\n def _go(self, binary, l, r, invert):\n\n if l >= r or l < 0 or r >= len(binary):\n # print('early return ', l, r, len(binary))\n return\n\n vals = [\"0\", \"1\"]\n if invert:\n vals.reverse()\n\n ml = (l + r) // 2\n\n # print(l, ml, r)\n\n for i in range(l, ml + 1):\n # print('here1')\n binary[i] += vals[0]\n\n for i in range(ml + 1, r + 1):\n # print('here2')\n binary[i] += vals[1]\n\n # print(binary)\n\n self._go(binary, l, ml, False)\n self._go(binary, ml + 1, r, True)\n\n def grayCode(self, n: int) -> List[int]:\n arr_len = 2**n\n binary = [\"\"] * arr_len\n self._go(binary, 0, arr_len - 1, False)\n \n return [int(x,2) for x in binary if len(x) > 0]\n ","runtime":"229"},{"code":"\"\"\"\n89. Gray Code\n\nAn n-bit gray code sequence is a sequence of 2^n integers where:\n\nEvery integer is in the inclusive range [0, 2^n - 1],\n- The first integer is 0,\n- An integer appears no more than once in the sequence,\n- The binary representation of every pair of adjacent integers differs by\n exactly one bit, and\n- The binary representation of the first and last integers differs by exactly\n one bit.\n\nGiven an integer n, return any valid n-bit gray code sequence.\n\"\"\"\nfrom typing import List\n\n\nclass Solution:\n def grayCode(self, n: int) -> List[int]:\n seq: List[int] = [0] * (2 ** n)\n\n for shift in range(n):\n count = 0\n bit = 0\n for i in range(len(seq)):\n seq[i] = seq[i] | (bit << shift)\n count += 1\n if count == 1 << (shift + 1):\n count = 0\n elif count == 1 << shift:\n bit = bit ^ 1\n\n return seq\n\n","runtime":"232"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n self.track = []\n self.used = [False] * 2**n\n self.ans = []\n self.found = False\n self.backtrack(n)\n return self.ans\n\n def backtrack(self, n):\n if len(self.track) == 2**n:\n self.ans = self.track\n self.found = True\n return\n valids = self.all_valids(n, self.track[-1]) if self.track else list(range(2**n))\n for i in valids:\n if self.used[i]:\n continue\n self.used[i] = True\n self.track.append(i)\n self.backtrack(n)\n if self.found:\n return\n self.track.pop()\n self.used[i] = False\n \n def all_valids(self, n, prev):\n valids = []\n for i in range(n):\n valids.append(prev ^ (1 << i))\n return valids\n","runtime":"234"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n start=\"0\"*n\n lst_length = 2**n\n d_visited = {}\n lst_visited = []\n d_swap = {\"0\": \"1\", \"1\": \"0\"}\n @cache\n def helper(curr_val, i):\n if curr_val in d_visited:\n return None\n else:\n d_visited[curr_val]=1\n lst_visited.append(int(curr_val,2))\n\n if i == lst_length:\n return lst_visited\n \n for j in range(len(curr_val)-1,-1,-1):\n next_val = curr_val[:j]+d_swap[curr_val[j]]+curr_val[j+1:]\n ans = helper(next_val,i+1)\n if ans:\n return ans\n\n del d[curr_val]\n lst_visited.pop()\n\n return helper(start, 1)\n \n \n\n ","runtime":"237"},{"code":"class Solution:\n def getNeighbs(self, num, n, visited):\n neighbs = []\n for i in range(n):\n candidate = num ^ (1 << i)\n if candidate not in visited:\n neighbs.append(candidate)\n return neighbs\n\n def checkLast(self, path):\n num = path[-1]\n while num % 2 == 0:\n num /= 2\n\n return num == 1\n\n def recDfs(self, num, n, path, visited):\n #print(f\"checking {num=}, {path=}, {visited=}\")\n if len(path) == 2 ** n and self.checkLast(path):\n return True\n\n neighbs = self.getNeighbs(num, n, visited)\n for neighb in neighbs:\n path.append(neighb)\n visited.add(neighb)\n found = self.recDfs(neighb, n, path, visited)\n if found:\n return found\n path.pop()\n visited.remove(neighb)\n\n return False\n \n def grayCode(self, n: int) -> List[int]:\n path = [0]\n visited = set([0])\n self.recDfs(0, n, path, visited)\n return path\n","runtime":"240"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \"\"\"\n i did some brainstorming on the ipad \n opposite binary split aka\n 2^n total numbers, correct? \n let's assume n = 3 \n then 8 numbers total\n 1-4 = 0xx\n 5-8 = 1xx\n\n 1-2 = 00x\n 3-4 = 01x\n 5-6 = 11x\n 7-8 = 10x\n\n then do the same flip-flop for the last few numbers \n can start from the smallest denomination and do bit addition to work your way up\n as needed\n and since there are n bits in the number, that works great\n \"\"\"\n totalNums = 2**n\n result = [0] * totalNums\n # run through the numbers, \n\n for i in range(n):\n print(\"i =\", i)\n prev = True\n current = False\n for j in range(totalNums):\n if (j % (2**i) == 0):\n if prev == False and current == False:\n current = True\n elif prev == False and current == True:\n prev = True\n elif prev == True and current == True:\n current = False\n elif prev == True and current == False:\n prev = False\n if current:\n result[j] = result[j] | 1 << i\n j += 1\n i += 1 \n\n return result\n","runtime":"242"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n lst = [[0, 1]]\n\n def maker(n):\n a = []\n for i in range(n//2):\n a.append(0)\n i = n/2\n while i < n:\n a.append(1)\n i+=1\n return a\n\n def join(a, b):\n for i in b:\n a.append(i)\n return a\n\n def reverse(a):\n o = []\n\n i = len(a)-1\n\n while i >=0:\n o.append(a[i])\n i -= 1\n return o\n\n for i in range(n-1):\n for ii in range(len(lst)):\n lst[ii] = join(lst[ii], reverse(lst[ii]))\n a = maker(len(lst[ii]))\n lst.append(a)\n\n out = []\n \n for i in range(len(lst[0])):\n a = 0\n for ii in range(len(lst)):\n if lst[ii][i] == 1:\n a += 2 ** ii\n out.append(a)\n return out\n ","runtime":"245"}],"string":"[\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res = []\\n for i in range(2**n):\\n res.append(i ^ i >> 1)\\n return res\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n ans = [0, 1]\\n for i in range(1, n):\\n j = len(ans) - 1\\n offset = 1 << i\\n for k in range(j, -1, -1):\\n ans.append(ans[k] + offset)\\n\\n return ans\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n return [i^i>>1 for i in range(2**n)]\\n \\n \\n\\n \\n\\n \",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def grayCodeRecursive(n):\\n if n == 0:\\n return [0]\\n prev_gray_code = grayCodeRecursive(n-1)\\n leading_bit_one = 1 << (n-1)\\n return prev_gray_code + [leading_bit_one + i for i in reversed(prev_gray_code)]\\n return grayCodeRecursive(n)\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n if n == 1:\\n return [0, 1]\\n left = self.grayCode(n-1)\\n right = left.copy()\\n right.reverse()\\n shift = 1 << (n-1)\\n right = [r+shift for r in right]\\n return left + right\\n\\n \",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res = []\\n L = 1 << n\\n for i in range(L):\\n num = i ^ (i >> 1) #each gray code num = i xor (i/2)\\n res.append(num)\\n return res\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n rv = [0, 1]\\n p = 1\\n for _ in range(n - 1):\\n p <<= 1\\n rv += [p | x for x in rv[::-1]]\\n return rv\\n \\n \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def generate_gray_code(n: int) -> List[int]:\\n if n == 0:\\n return [0]\\n if n == 1:\\n return [0, 1]\\n \\n previous_gray_code = generate_gray_code(n - 1)\\n mask = 1 << (n - 1)\\n result = previous_gray_code + [mask | num for num in reversed(previous_gray_code)]\\n return result\\n return generate_gray_code(n)\\n\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def grayCodeHelper(n):\\n if n == 0:\\n return [0]\\n else:\\n prev_gray_codes = grayCodeHelper(n-1)\\n leading_bit_one = 1 << (n-1)\\n return prev_gray_codes + [leading_bit_one | code for code in reversed(prev_gray_codes)]\\n return grayCodeHelper(n)\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n# def grayCode(self, n: int) -> List[int]:\\n \\n \\n# res = [0]\\n \\n \\n# visited = set([0])\\n# while len(res) < 2**n:\\n# shift = 0\\n# val = res[-1]\\n# while val in visited:\\n# val ^= 1 << shift \\n# if val in visited:\\n# val ^= 1 << shift\\n# shift += 1\\n \\n# res.append(val)\\n# visited.add(val)\\n \\n \\n# return res\\n\\n def grayCode(self, n: int) -> List[int]:\\n return [i ^ (i >> 1) for i in range(2 ** n)]\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n results = [0]\\n for i in range(n): \\n results += [x + pow(2, i) for x in reversed(results)]\\n return results\\n \",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n ans = [0]\\n\\n for i in range(n):\\n for j in reversed(range(len(ans))):\\n ans.append(ans[j] | 1 << i)\\n\\n return ans\\n \",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"import time\\r\\nfrom typing import List\\r\\nclass Solution:\\r\\n def grayCode(self, n: int) -> List[int]:\\r\\n res = []\\r\\n start = 1\\r\\n start_res = [0,1]\\r\\n def genNext(current, last):\\r\\n nonlocal res\\r\\n if current == n:\\r\\n res = last\\r\\n return\\r\\n cur = [0]\\r\\n for i in range(1, len(last)):\\r\\n cur.append(last[i])\\r\\n for i in range(len(last)-1, -1, -1):\\r\\n cur.append(2**current+last[i])\\r\\n genNext(current+1, cur)\\r\\n genNext(start, start_res)\\r\\n return res\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res=[0]\\n for i in range(n):\\n for j in range(len(res)-1,-1,-1):\\n res.append(res[j] | (1<<i))\\n return res\\n \",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"import time\\r\\nfrom typing import List\\r\\nclass Solution:\\r\\n def grayCode(self, n: int) -> List[int]:\\r\\n res = []\\r\\n start = 1\\r\\n start_res = [0,1]\\r\\n def genNext(current, last):\\r\\n nonlocal res\\r\\n if current == n:\\r\\n res = last\\r\\n return\\r\\n cur = [0]\\r\\n for i in range(1, len(last)):\\r\\n cur.append(last[i])\\r\\n for i in range(len(last)-1, -1, -1):\\r\\n cur.append(2**current+last[i])\\r\\n genNext(current+1, cur)\\r\\n genNext(start, start_res)\\r\\n return res\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n # Start with the base case for 1-bit Gray code\\n result = [0, 1]\\n \\n # Generate Gray code sequence for n bits\\n for i in range(1, n):\\n # The current size of the result list\\n size = len(result)\\n # Add 1 to the prefix of the reversed result list\\n # This operation mirrors the sequence and prefixes it with 1\\n for j in range(size - 1, -1, -1):\\n result.append(result[j] | (1 << i))\\n \\n return result\\n\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n if n == 0:\\n return [0]\\n \\n previous = self.grayCode(n-1)\\n result = []\\n\\n for code in previous:\\n result.append(code)\\n\\n add_bit = 1 << (n - 1)\\n for code in reversed(previous):\\n result.append(add_bit | code)\\n\\n return result\\n \\n \\n\\n \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n if not n: return []\\n\\n res = [0, 1]\\n n-=1\\n count = 1\\n\\n while n > 0:\\n newres = [2**n + r for r in res[::-1]]\\n res += newres\\n count += 1\\n n -= 1\\n\\n return res\\n\\n\\n\\n \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n start = [0, 1]\\n res = [0]\\n for i in range(n):\\n x = 2 ** i\\n for num in reversed(res):\\n res.append(x ^ num)\\n \\n return res\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n if n == 0:\\n return [0]\\n \\n # Base case for n = 1\\n if n == 1:\\n return [0, 1]\\n \\n # Generate Gray code for n-1 bits\\n previous_gray_code = self.grayCode(n - 1)\\n \\n # Reflect and prepend 1 to each of the previous gray code\\n # Example: previous_gray_code = [0, 1] => reflected = [1, 0] => prepended = [3, 2]\\n reflected_gray_code = [(1 << (n - 1)) | x for x in reversed(previous_gray_code)]\\n \\n # Combine the original and reflected Gray codes\\n return previous_gray_code + reflected_gray_code\\n \",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = []\\n for i in range(1 << n): # 1 << n is 2^n, the total number of gray codes\\n result.append(i ^ (i >> 1)) # Append the gray code for number i\\n return result\\n \",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = []\\n for i in range(1 << n):\\n result.append(i ^ (i >> 1))\\n return result\\n\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = []\\n\\n for i in range(2**n):\\n \\n result.append(i ^ i >> 1)\\n\\n return result\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res = []\\n for i in range(0,2**n):\\n res.append(i^(i>>1))\\n return res\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res = [0]\\n for bit in range(n):\\n size = len(res)\\n for i in reversed(range(size)):\\n res.append(res[i] | 1 << bit)\\n return res\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n def dfs(n):\\n if n==0:\\n return [0]\\n \\n previous = dfs(n-1)\\n appending_0 = [(i << 1) for i in previous]\\n appending_1 = [((i << 1) | 1) for i in reversed(previous)]\\n\\n return appending_0+appending_1\\n return dfs(n)\\n \",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n if n == 1:\\n return [0, 1]\\n\\n prev_gray = self.grayCode(n - 1)\\n size = len(prev_gray)\\n\\n # Complement each number in prev_gray and add it to the list\\n for i in range(size - 1, -1, -1):\\n prev_gray.append(prev_gray[i] | (1 << (n - 1)))\\n\\n return prev_gray\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n print(f'grayCode({n}):')\\n\\n if n == 0:\\n return (0,)\\n \\n prior = self.grayCode(n - 1)\\n print(f' {prior=}')\\n \\n REV = lambda x: tuple(reversed(tuple(x)))\\n\\n priorR = REV(prior)\\n print(f' {priorR=}')\\n\\n increment = 2 ** (n - 1)\\n secondHalf = tuple([\\n R + increment\\n for R in priorR\\n ])\\n print(f'{secondHalf=}')\\n\\n return prior + secondHalf\\n\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n print(n*n)\\n pre_array = []\\n final_array = []\\n for i in range(n):\\n if i == 0:\\n final_array.append(0)\\n final_array.append(1)\\n else:\\n for j in range(len(final_array)):\\n final_array.append(pre_array[-j-1] + 2**i)\\n \\n pre_array[:] = final_array[:]\\n\\n print(final_array)\\n return final_array\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"import time\\r\\nfrom typing import List\\r\\nclass Solution:\\r\\n def grayCode(self, n: int) -> List[int]:\\r\\n res = []\\r\\n start = 1\\r\\n start_res = [0,1]\\r\\n def genNext(current, last):\\r\\n nonlocal res\\r\\n if current == n:\\r\\n res = last\\r\\n return\\r\\n cur = [0]\\r\\n for i in range(1, len(last)):\\r\\n cur.append(last[i])\\r\\n for i in range(len(last)-1, -1, -1):\\r\\n cur.append(2**current+last[i])\\r\\n genNext(current+1, cur)\\r\\n genNext(start, start_res)\\r\\n return res\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result\",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"import time\\r\\nfrom typing import List\\r\\nclass Solution:\\r\\n def grayCode(self, n: int) -> List[int]:\\r\\n res = []\\r\\n start = 1\\r\\n start_res = [0,1]\\r\\n def genNext(current, last):\\r\\n nonlocal res\\r\\n if current == n:\\r\\n res = last\\r\\n return\\r\\n cur = [0]\\r\\n for i in range(len(last)):\\r\\n cur.append(2**current+last[i])\\r\\n for i in range(len(last)-1, 0, -1):\\r\\n cur.append(last[i])\\r\\n genNext(current+1, cur)\\r\\n genNext(start, start_res)\\r\\n return res\",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n\\n def gray(n):\\n if n==1: return [\\\"0\\\", \\\"1\\\"]\\n\\n old = gray(n-1)\\n ref = [\\\"1\\\" + x for x in old[::-1]]\\n\\n old = [\\\"0\\\" + x for x in old]\\n\\n return old+ ref\\n return list(map(lambda x: int(x, 2), gray(n)))\\n\\n\\n\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n self.codes = []\\n self.c = 0\\n self._gray_code(n)\\n return self.codes\\n\\n def _gray_code(self, n, rev=False):\\n if n == 0:\\n self.codes.append(self.c)\\n return\\n\\n origc = self.c\\n\\n self.c = (origc << 1)\\n if rev:\\n self.c |= 1\\n self._gray_code(n-1, rev=False)\\n\\n self.c = (origc << 1)\\n if not rev:\\n self.c |= 1\\n self._gray_code(n-1, rev=True)\\n\\n self.c = origc\\n\\n\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = [0]\\n visited = {0}\\n self.generate(result, n, visited)\\n return result\\n\\n def generate(self, result, n, visited):\\n if len(result) == (1 << n):\\n return True\\n current = result[-1]\\n for i in range(n):\\n nextNum = current ^ (1 << i)\\n if nextNum not in visited:\\n visited.add(nextNum)\\n result.append(nextNum)\\n if self.generate(result, n, visited):\\n return True\\n # visited.remove(nextNum)\\n # result.pop()\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n def backtracking(track, curr):\\n if len(self.res) != 0:\\n return True\\n if used[curr]:\\n return False\\n if len(track) == (1 << n) - 1:\\n self.res = track + [curr]\\n return True\\n track.append(curr)\\n used[curr] = True\\n # flip one bit for each pos\\n for pos in range(n):\\n nxt = curr ^ (1 << pos) #xor one bit\\n if backtracking(track, nxt):\\n return True\\n track.pop()\\n used[curr] = False\\n return False\\n \\n self.res = []\\n used = [False] * (1<<n)\\n backtracking([], 0)\\n return self.res\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n length = 1 << n # same as 2**n\\n visited = [False] * length\\n\\n def dfs(start_index, code):\\n if start_index == length:\\n return True\\n for i in range(n):\\n new_code = code ^ (1 << i)\\n if not visited[new_code]:\\n path.append(new_code)\\n visited[new_code] = True\\n if dfs(start_index+1, new_code): \\n return True\\n visited[new_code] = False\\n path.pop()\\n return False\\n \\n path = [0]\\n visited[0] = True\\n dfs(1, 0)\\n return path\",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n nums = [0 for i in range(0,2**n)]\\n seen = set([0])\\n for i in range(1,2**n):\\n for j in range(0,n):\\n if nums[i-1] ^ (1 << j) in seen:\\n continue\\n nums[i] = nums[i-1] ^ (1 << j)\\n seen.add(nums[i])\\n break\\n return nums\",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n length = 1 << n # same as 2**n\\n visited = [False] * length\\n\\n def dfs(start_index, code):\\n if start_index == length:\\n return True\\n for i in range(n):\\n new_code = code ^ (1 << i)\\n\\n if not visited[new_code]:\\n path.append(new_code)\\n visited[new_code] = True\\n if dfs(start_index+1, new_code):\\n return True\\n visited[new_code] = False\\n path.pop()\\n\\n return False\\n\\n path = [0]\\n visited[0] = True\\n dfs(1, 0)\\n return path\",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res, vis = [0], set([0])\\n def helper(res, n, vis):\\n if len(res) == (1 << n):\\n return True\\n curr = res[-1]\\n for i in range(n):\\n nextnum = curr ^ (1<<i)\\n if nextnum not in vis:\\n vis.add(nextnum)\\n res.append(nextnum)\\n if helper(res, n, vis):\\n return True\\n vis.remove(nextnum)\\n res.pop()\\n helper(res, n, vis)\\n return res\",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n result = [0]\\n visited = set([0])\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n if generateGrayCode(next_num):\\n return True\\n result.pop()\\n visited.remove(next_num)\\n return False\\n generateGrayCode(0)\\n return result\",\n \"runtime\": \"104\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result \",\n \"runtime\": \"104\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result \",\n \"runtime\": \"106\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = [0]\\n visited=set([0])\\n\\n\\n def generateGrayCode(num):\\n if len(result)==2**n:\\n return True\\n for i in range(n):\\n next_num=num^(1<<i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return Fasle\\n generateGrayCode(0)\\n return result\\n \",\n \"runtime\": \"106\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result\",\n \"runtime\": \"109\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def dfs(path):\\n if len(path) == n:\\n return [path]\\n a = dfs(path + \\\"0\\\")\\n b = dfs(path + \\\"1\\\")\\n b = b[::-1]\\n return a + b\\n\\n if n == 0:\\n return [0]\\n res = dfs(\\\"\\\")\\n return list(map(lambda x: int(x, 2), res))\\n\",\n \"runtime\": \"109\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n # 0부터 시작\\n # - 아래부터 검사: 0이면 1로 변환하고, 다음 (vst 체크)\\n # - 아래부터 검사: 1이면 0으로 변환하고, 다음\\n vst = [False] * (1 << 17)\\n result = []\\n \\n def check(x):\\n result.append(x)\\n i = 0\\n while i < n:\\n if x & (1 << i) == 0:\\n if not vst[x | (1 << i)]:\\n vst[x | (1 << i)] = True\\n check(x | (1 << i))\\n return\\n else:\\n if not vst[x - (1 << i)]:\\n vst[x - (1 << i)] = True\\n check(x - (1 << i))\\n return\\n i += 1\\n\\n vst[0] = True\\n check(0)\\n return result\\n\",\n \"runtime\": \"112\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result\",\n \"runtime\": \"112\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result\",\n \"runtime\": \"114\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result\\n\\n \",\n \"runtime\": \"114\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n # formula:\\n # result = []\\n # for i in range(1<<n):\\n # result.append(i^(i>>1))\\n # return result\\n\\n result = [0]\\n visited = set([0])\\n\\n def bt():\\n if len(result) == (1<< n):\\n return True\\n \\n current = result[-1]\\n for i in range(n):\\n next_code = current ^ (1 << i)\\n if next_code not in visited:\\n result.append(next_code)\\n visited.add(next_code)\\n if bt():\\n return True\\n result.pop()\\n visited.remove(next_code)\\n return False\\n bt()\\n return result\",\n \"runtime\": \"117\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result\",\n \"runtime\": \"117\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n \\n if generateGrayCode(next_num):\\n return True\\n \\n result.pop()\\n visited.remove(next_num)\\n \\n return False\\n\\n generateGrayCode(0)\\n return result\",\n \"runtime\": \"120\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result\",\n \"runtime\": \"120\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n col = set( [i for i in range(2**n)] )\\n last_digit = set( [2**i for i in range(n)] )\\n N, f = [], [False] \\n def DFS(i):\\n col.remove(i)\\n N.append(i) \\n if not col: \\n if i in last_digit: f[0] = True \\n return \\n for j in range(n):\\n v = i^(2**j) \\n if v in col:\\n DFS( v ) \\n if f[0]: return \\n N.pop()\\n col.add(i)\\n return \\n DFS(0)\\n return N \",\n \"runtime\": \"122\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def dfs(path):\\n if len(path) ==n:\\n return [path]\\n\\n a = dfs(path+'0')\\n\\n b = dfs(path+'1')\\n\\n b = b[::-1]\\n\\n return a+b\\n \\n if n==0:\\n return [0]\\n res = dfs('')\\n\\n return list(map(lambda x: int(x,2),res))\\n \",\n \"runtime\": \"122\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def dfs(path):\\n # action\\n if len(path) == n:\\n return [path]\\n\\n # continue path with 0 first\\n a = dfs(path + '0')\\n\\n # then continue path with 1\\n b = dfs(path + '1')\\n\\n # reverse the order of possibilities for 1 case\\n b = b[::-1]\\n\\n # append 0 and 1 lists\\n return a + b\\n\\n # base\\n if n == 0:\\n return [0]\\n\\n res = dfs('')\\n \\n # map path string to integers\\n return list(map(lambda x: int(x, 2), res))\\n \",\n \"runtime\": \"125\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def dfs(path):\\n if len(path) == n:\\n return [path]\\n a = dfs(path + \\\"0\\\")\\n b = dfs(path + \\\"1\\\")\\n b = b[::-1]\\n return a + b\\n\\n if n == 0:\\n return [0]\\n res = dfs(\\\"\\\")\\n return list(map(lambda x: int(x, 2), res))\\n\",\n \"runtime\": \"125\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n col = set( [i for i in range(2**n)] )\\n last_digit = set( [2**i for i in range(n)] )\\n N, f = [], [False] \\n def DFS(i):\\n col.remove(i)\\n N.append(i) \\n if not col: \\n if i in last_digit: f[0] = True \\n return \\n for j in range(n):\\n v = i^(2**j) \\n if v in col: DFS( v ) \\n if f[0]: return \\n N.pop()\\n col.add(i)\\n return \\n DFS(0)\\n return N \",\n \"runtime\": \"128\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = []\\n for i in range(2 ** n):\\n print(i, i >> 1)\\n gray = i ^ (i >> 1)\\n result.append(gray)\\n return result\",\n \"runtime\": \"128\"\n },\n {\n \"code\": \"class Solution:\\n def backtrack(self, result, visited):\\n if len(result) == 1 << self.n:\\n # self.results.append(deepcopy(result))\\n return deepcopy(result)\\n\\n current = result[-1]\\n for bit in range(self.n):\\n new = current ^ (1 << bit)\\n if new not in visited:\\n result.append(new)\\n visited.add(new)\\n # print(f'Trying {result} neighbors{arr[:ix] + arr[ix+1:]}')\\n res = self.backtrack(result, visited) \\n if res is not None:\\n return res\\n visited.remove(new)\\n result.pop()\\n return\\n \\n def grayCode(self, n: int) -> List[int]:\\n self.n = n\\n self.results = []\\n visited = set([0])\\n result = self.backtrack([0], visited)\\n\\n return result\\n \",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n seq, visited = [0], set([0])\\n\\n def dfs():\\n # initially added the other check, but it works even without it..\\n # is this the case because only 1 possuble sequence exist?\\n if len(seq) == 2**n: # and self._differ_by_exactly_one_bit(seq[-1], 0)\\n return True\\n \\n for i in range(n):\\n if seq[-1] & 1 << i:\\n # bit already set, try removing it\\n mask = 1 << i\\n inverted_mask = ~mask\\n next_num = seq[-1] & inverted_mask\\n else:\\n # but not set, try adding it\\n next_num = seq[-1] | 1 << i\\n \\n if next_num not in visited:\\n seq.append(next_num)\\n visited.add(next_num)\\n if dfs():\\n # sequence found\\n return True\\n visited.remove(next_num)\\n seq.pop()\\n\\n return False\\n\\n dfs()\\n return seq\",\n \"runtime\": \"133\"\n },\n {\n \"code\": \"class Solution:\\n @cache\\n def grayCode(self, n: int) -> List[int]:\\n if n < 1:\\n return []\\n if n < 2:\\n return [0, 1]\\n f = self.grayCode\\n prev = f(n - 1)\\n ret1, ret2 = [], []\\n for e in prev:\\n ret1.append(bin(e)[2:] + '0')\\n ret2.append(bin(e)[2:] + '1')\\n return list(map(lambda x: int(x, 2), ret1 + ret2[::-1]))\",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n power = int(2**n)\\n numbers = [0 for _ in range(power)]\\n\\n series = power\\n curr_pow = 1\\n\\n for _ in range(n):\\n reverse = False\\n half_series = series // 2\\n\\n i = 0\\n for _ in range(curr_pow):\\n if reverse:\\n for _ in range(half_series):\\n numbers[i] += curr_pow\\n i += 1\\n i = i + half_series\\n else:\\n i = i + half_series\\n for _ in range(half_series):\\n numbers[i] += curr_pow\\n i += 1\\n reverse = not reverse\\n series = series // 2\\n curr_pow *= 2\\n\\n return numbers\\n\\n\\n # n == 1: [0, 1]\\n # n == 2: [00, 01, 11, 10]\\n # n == 3: [000, 001, 011, 010, 110, 111, 101, 100]\\n # [0 0 0 0 1 1 1 1]\\n # [ 0 0 1 1 1 1 0 0]\\n # [ 0 1 1 0 0 1 1 0]\\n\\n # 0 ones: 1\\n # 1 ones: n\\n # 2 ones: n\\n # n == 4: [0000, 0001, 0011, 0010, 0110, 0100]\\n # [0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 ] # series = 16\\n # [ 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 ] # series = 8\\n # [ 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 ] # series = 4\\n # [ 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 ] # series = 2\\n\",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"class Solution:\\n def backtrack(self, result, visited):\\n if len(result) == 1 << self.n:\\n # self.results.append(deepcopy(result))\\n return deepcopy(result)\\n\\n current = result[-1]\\n for bit in range(self.n):\\n new = current ^ (1 << bit)\\n if new not in visited:\\n result.append(new)\\n visited.add(new)\\n # print(f'Trying {result} neighbors{arr[:ix] + arr[ix+1:]}')\\n res = self.backtrack(result, visited) \\n if res is not None:\\n return res\\n visited.remove(new)\\n result.pop()\\n return\\n \\n def grayCode(self, n: int) -> List[int]:\\n self.n = n\\n self.results = []\\n visited = set([0])\\n result = self.backtrack([0], visited)\\n\\n return result\\n \",\n \"runtime\": \"138\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def rec(n: int) -> List[int]:\\n if n == 0:\\n return []\\n # 0 <-> 1\\n # 10 <-> 11 <-> 01 <-> 00\\n if n == 1:\\n return [0, 1]\\n if n == 2:\\n return [0, 1, 3, 2]\\n res = []\\n # Prior step\\n # 1000 -> ... -> 1100\\n for el in rec(n - 1):\\n res.append(el | (1 << (n-1)))\\n # Major step \\n # 1100 -> 0100\\n for el in rec(n - 1)[::-1]:\\n res.append(el)\\n return list(reversed(res))\\n return rec(n)\\n\",\n \"runtime\": \"138\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res = [0]\\n def dfs(visited):\\n if len(res) == 2 ** n and bin((res[0] ^ res[-1])).count('1') == 1:\\n return res\\n else:\\n for i in range(n):\\n num = res[-1] ^ (1 << i)\\n if num not in visited and bin((num ^ res[-1])).count('1') == 1:\\n res.append(num)\\n visited.add(num)\\n if dfs(visited):\\n return res\\n res.pop()\\n visited.remove(num)\\n return False\\n\\n return dfs({0})\\n\",\n \"runtime\": \"141\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n seen = [False] * (2 ** n)\\n\\n res = [0]\\n last = '0' * n\\n\\n seen[0] = True\\n\\n for i in range(2 ** n - 1):\\n for j in range(n):\\n changed = last[:j] + ('0' if last[j] == '1' else '1') + last[j+1:]\\n\\n next_i = int(changed,2)\\n if not seen[next_i]:\\n res.append(next_i)\\n last = changed\\n seen[next_i] = True\\n break\\n\\n return res\",\n \"runtime\": \"144\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n powers: set[int] = set([2 ** i for i in range(16)])\\n def is_power_of_two(n: int) -> bool:\\n return n in powers\\n\\n available_nums: set[int] = set([i for i in range(1, 2 ** n)])\\n list_so_far: list[int] = [0]\\n ans: list = []\\n def backtrack() -> bool:\\n \\n if len(list_so_far) == 2 ** n:\\n nonlocal ans\\n ans = list_so_far.copy()\\n return True\\n elif len(list_so_far) == 2 ** n - 1:\\n final_num: int = list(available_nums)[0]\\n if is_power_of_two(final_num ^ list_so_far[0]) and is_power_of_two(final_num ^ list_so_far[-1]):\\n list_so_far.append(final_num)\\n retval: bool = backtrack()\\n list_so_far.pop()\\n return retval\\n return False\\n \\n # Try out each candidate number\\n for i in range(n):\\n # i is the digit number\\n last_num: int = list_so_far[-1]\\n if last_num & (2 ** i) != 0:\\n candidate: int = last_num - (2 ** i)\\n else:\\n candidate: int = last_num + (2 ** i)\\n \\n if candidate in available_nums:\\n list_so_far.append(candidate)\\n available_nums.remove(candidate)\\n if backtrack():\\n list_so_far.pop()\\n available_nums.add(candidate)\\n return True\\n available_nums.add(candidate)\\n list_so_far.pop()\\n return False\\n\\n backtrack()\\n \\n return ans\\n \\n \\n\\n\\n\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n # differs by exactly one bit ---> xor\\n res = [0]\\n\\n for i in range(n):\\n for j in range(len(res) - 1, - 1, -1):\\n res.append(res[j] | (1 << i))\\n print(res[j], 1 << i, res[j] | (1 << i))\\n \\n return res\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class Solution:\\n def genNext(self, cur, n, used):\\n for i in range(n):\\n bit = 1 << i\\n if (cur >> i) % 2 == 1:\\n bit *= -1\\n adj = cur + bit\\n if not used[adj]:\\n yield adj\\n \\n def checkDiff(self, num1, num2):\\n xor = num1 ^ num2\\n while xor % 2 == 0:\\n xor >>= 1\\n xor >>= 1\\n if xor > 0:\\n return False\\n return True\\n\\n def buildCode(self, cur, code, used, n):\\n if len(code) == 2**n:\\n if self.checkDiff(code[0], code[-1]):\\n return True\\n return False\\n for adj in self.genNext(cur, n, used):\\n code.append(adj)\\n used[adj] = True\\n res = self.buildCode(adj, code, used, n)\\n if res:\\n return True\\n used[adj] = False\\n code.pop()\\n return False\\n \\n def grayCode(self, n: int) -> List[int]:\\n used = [False]*2**n\\n code = [0]\\n used[0] = True\\n\\n self.buildCode(0, code, used, n)\\n return code\\n\\n\\n \\n\\n\\n \",\n \"runtime\": \"149\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n visited = set()\\n res = []\\n length = 2**n \\n\\n def dfs(prev_str):\\n visited.add(prev_str)\\n res.append(int(prev_str, 2))\\n if len(res)==length:\\n return True\\n \\n for i in range(len(prev_str)):\\n new_str = prev_str[:i] + (\\\"1\\\" if prev_str[i]==\\\"0\\\" else \\\"0\\\") + prev_str[i+1:]\\n if new_str not in visited:\\n if dfs(new_str):\\n return True\\n return False\\n\\n dfs(\\\"0\\\"*n)\\n return res\\n \",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res = [0] + [-1] * (2 ** n - 1)\\n used = [True] + [False] * (2 ** n - 1)\\n\\n def differ_by_one_bit(a, b):\\n xor = a ^ b\\n return xor != 0 and (xor & (xor - 1)) == 0\\n\\n def get_next_int(num):\\n for i in range(n):\\n next_int = num ^ (1 << i)\\n if not used[next_int]:\\n yield next_int\\n\\n def backtrack(idx):\\n if idx == 2 ** n - 1:\\n return differ_by_one_bit(res[0], res[-1])\\n\\n for next_int in get_next_int(res[idx]):\\n res[idx + 1] = next_int\\n used[next_int] = True\\n if backtrack(idx + 1):\\n return True\\n res[idx + 1] = -1\\n used[next_int] = False\\n\\n return False\\n\\n backtrack(0)\\n\\n return res\\n\",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n start=\\\"0\\\"*n\\n lst_length = 2**n\\n d_visited = {}\\n lst_visited = []\\n d_swap = {\\\"0\\\": \\\"1\\\", \\\"1\\\": \\\"0\\\"}\\n\\n def helper(curr_val, i):\\n if curr_val in d_visited:\\n return None\\n else:\\n d_visited[curr_val]=1\\n lst_visited.append(int(curr_val,2))\\n\\n if i == lst_length:\\n return lst_visited\\n \\n for j in range(len(curr_val)-1,-1,-1):\\n next_val = curr_val[:j]+d_swap[curr_val[j]]+curr_val[j+1:]\\n ans = helper(next_val,i+1)\\n if ans:\\n return ans\\n\\n del d[curr_val]\\n lst_visited.pop()\\n\\n return helper(start, 1)\\n \\n \\n\\n \",\n \"runtime\": \"154\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n length = 1 << n # same as 2**n\\n visited = [False] * length\\n\\n def dfs(start_index, code):\\n if start_index == length:\\n return True\\n for i in range(n):\\n new_code = code ^ (1 << i)\\n print(new_code)\\n if not visited[new_code]:\\n path.append(new_code)\\n visited[new_code] = True\\n if dfs(start_index+1, new_code): return True\\n visited[new_code] = False\\n path.pop()\\n return False\\n \\n path = [0]\\n visited[0] = True\\n dfs(1, 0)\\n return path\\n \",\n \"runtime\": \"157\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.codes = [[\\\"0\\\", \\\"1\\\"]]\\n for i in range(2, 17):\\n codes = self.codes[i - 2]\\n new = list()\\n for c in codes:\\n new.append(c+\\\"0\\\")\\n for c in codes[::-1]:\\n new.append(c+\\\"1\\\")\\n self.codes.append(new)\\n\\n def grayCode(self, n: int) -> List[int]:\\n return list(map(lambda x: int(x, 2), self.codes[n - 1]))\",\n \"runtime\": \"160\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n nums = [0 for i in range(0,2**n)]\\n swap = [i for i in range(n-1,-1,-1)]\\n for i in range(1,2**n):\\n for j in swap:\\n if i%(2**j) == 0:\\n nums[i] = nums[i-1] ^ (1 << j)\\n break\\n return nums\",\n \"runtime\": \"162\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n length = 1 << n # same as 2**n\\n visited = [False] * length\\n\\n def dfs(start_index, code):\\n if start_index == length:\\n return True\\n for i in range(n):\\n new_code = code ^ (1 << i)\\n print(new_code)\\n if not visited[new_code]:\\n path.append(new_code)\\n visited[new_code] = True\\n if dfs(start_index+1, new_code): return True\\n visited[new_code] = False\\n path.pop()\\n return False\\n \\n path = [0]\\n visited[0] = True\\n dfs(1, 0)\\n return path\",\n \"runtime\": \"165\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n used = {0}\\n code = [0] * 2 ** n\\n def codes(i):\\n if i == 2 ** n:\\n yield code\\n\\n for shift in range(n):\\n num = code[i - 1] ^ (1 << shift)\\n if num in used:\\n continue\\n\\n code[i] = num\\n used.add(num)\\n yield from codes(i + 1)\\n used.remove(num)\\n \\n return next(codes(1))\\n\",\n \"runtime\": \"168\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n return list(self._gray_code(n))\\n\\n def _gray_code(self, n):\\n if n == 0:\\n yield 0\\n return\\n for x in self._gray_code(n-1):\\n yield (x << 1)\\n for x in reversed(list(self._gray_code(n-1))):\\n yield (x << 1) | 1\",\n \"runtime\": \"170\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = []\\n if n >= 1:\\n result = [0,1]\\n\\n for i in range (1, n):\\n temp = result[::-1]\\n while temp:\\n result.append(temp.pop(0)+(2**i))\\n \\n return result\\n\\n \",\n \"runtime\": \"173\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n digit_length = n\\n start=\\\"0\\\"*digit_length\\n lst_length = 2**n\\n d_visited = {}\\n lst_visited = []\\n d_swap = {\\\"0\\\": \\\"1\\\", \\\"1\\\": \\\"0\\\"}\\n\\n def binary_convert(lst):\\n ans = []\\n for x in lst:\\n ans.append(int(x,2))\\n return ans\\n\\n def helper(curr_val, i):\\n if curr_val in d_visited:\\n return None\\n else:\\n d_visited[curr_val]=1\\n lst_visited.append(curr_val)\\n\\n if i == lst_length:\\n return binary_convert(lst_visited)\\n \\n for j in range(len(curr_val)-1,-1,-1):\\n next_val = curr_val[:j]+d_swap[curr_val[j]]+curr_val[j+1:]\\n ans = helper(next_val,i+1)\\n if ans:\\n return ans\\n\\n del d[curr_val]\\n lst_visited.pop()\\n\\n return helper(start, 1)\\n \\n \\n\\n \",\n \"runtime\": \"176\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n # code = [\\\"0\\\", \\\"1\\\"]\\n # for i in range(n-1):\\n # newCode = [\\\"0\\\" + x for x in code] + ['1' + x for x in code[::-1]]\\n # code = newCode\\n # return [int(x, 2) for x in code]\\n\\n seen = set()\\n totalCnt = 2 ** n\\n res = []\\n def dfs(num):\\n nonlocal seen, totalCnt, res\\n if len(res) == totalCnt:\\n return\\n \\n seen.add(num)\\n res.append(num)\\n\\n for i in range(n):\\n nextNum = num ^ (1 << i)\\n if nextNum not in seen:\\n dfs(nextNum)\\n pass\\n \\n dfs(0)\\n return res\\n\\n\",\n \"runtime\": \"178\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n visited = set()\\n res = []\\n length = 2**n \\n\\n def dfs(prev_str):\\n visited.add(prev_str)\\n res.append(int(prev_str, 2))\\n if len(res)==length:\\n return True\\n \\n for i in range(len(prev_str)):\\n new_str = prev_str[:i] + (\\\"1\\\" if prev_str[i]==\\\"0\\\" else \\\"0\\\") + prev_str[i+1:]\\n if new_str not in visited:\\n if dfs(new_str):\\n return True\\n # return False\\n\\n dfs(\\\"0\\\"*n)\\n return res\\n \",\n \"runtime\": \"181\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result=[2**n-1]*2**n\\n\\n for i in range(n,0,-1):\\n mask=2**n-1\\n mask2=1<<i-1\\n mask^=mask2\\n\\n for j in range(2**(i-1)):\\n result[j] &= mask\\n for j in range(2**i+2**(i-1),2**n,2**(i+1)):\\n for k in range(2**i):\\n if j+k<2**n:\\n result[j+k] &= mask\\n\\n return result\",\n \"runtime\": \"184\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = []\\n visited = set()\\n \\n def helper(curr_num, level):\\n result.append(curr_num)\\n visited.add(curr_num)\\n \\n for i in range(n):\\n next_num = curr_num ^ (1 << i)\\n \\n if next_num not in visited:\\n helper(next_num, i)\\n \\n helper(0, 0)\\n\\n return result\",\n \"runtime\": \"186\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n start=\\\"0\\\"*n\\n lst_length = 2**n\\n d_visited = {}\\n lst_visited = []\\n d_swap = {\\\"0\\\": \\\"1\\\", \\\"1\\\": \\\"0\\\"}\\n\\n def helper(curr_val, i):\\n if curr_val in d_visited:\\n return None\\n else:\\n d_visited[curr_val]=1\\n lst_visited.append(int(curr_val,2))\\n\\n if i == lst_length:\\n return lst_visited\\n \\n for j in range(len(curr_val)-1,-1,-1):\\n next_val = curr_val[:j]+d_swap[curr_val[j]]+curr_val[j+1:]\\n ans = helper(next_val,i+1)\\n if ans:\\n return ans\\n\\n del d[curr_val]\\n lst_visited.pop()\\n\\n return helper(start, 1)\\n \\n \\n\\n \",\n \"runtime\": \"189\"\n },\n {\n \"code\": \"import math\\n\\nlog = math.log\\n\\n\\nclass Solution(object):\\n def grayCode(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: List[int]\\n \\\"\\\"\\\"\\n\\n # [[0]]\\n # [[1]]\\n #\\n\\n bnums = [[0], [1]]\\n\\n if n != 1:\\n for i in range(n - 1):\\n for j in range(len(bnums) - 1, -1, -1):\\n bnums.append(bnums[j].copy())\\n for j in range(int(len(bnums) / 2)):\\n bnums[j].insert(0, 0)\\n for j in range(int(len(bnums) / 2), len(bnums)):\\n bnums[j].insert(0, 1)\\n\\n for i in range(len(bnums)):\\n dnum = 0\\n for b in range(n):\\n if bnums[i][b]:\\n dnum += pow(2, b)\\n bnums[i] = dnum\\n\\n # print(bnums)\\n return bnums\\n\\n\\n# 0,0\\n# ^\\n# 0,1\\n# ^\\n# 1,1\\n# ^\\n# 1,0\\n# ^\\n#\\n\",\n \"runtime\": \"192\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res=[]\\n def backtrack(num,vis):\\n if len(res)==2**n:\\n return\\n res.append(int(num,2))\\n vis.add(num)\\n for i in range(n):\\n l=list(num)\\n l[i]='0' if l[i]=='1' else '1'\\n nw=''.join(l)\\n if nw not in vis:\\n backtrack(nw,vis)\\n break\\n backtrack('0'*n,set())\\n return res\\n\",\n \"runtime\": \"194\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result=[0]\\n isPresent={0}\\n self.graycodeHelper(result,n,isPresent)\\n return result\\n def graycodeHelper(self,result,n,isPresent):\\n if len(result)==(1<<n):\\n return True\\n current=result[-1]\\n print(\\\"C\\\",current)\\n for i in range(n):\\n nextNum=current^(1<<i)#toggles the i-th bit of the variable current and assigns the result to nextNum\\n print(nextNum)\\n if nextNum not in isPresent:\\n isPresent.add(nextNum)\\n result.append(nextNum)\\n if self.graycodeHelper(result,n,isPresent):\\n return True\\n isPresent.remove(nextNum)\\n result.pop()\\n return False\\n\\n\\n\\n \",\n \"runtime\": \"197\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = []\\n if n >= 1:\\n result = [0,1]\\n\\n for i in range (1, n):\\n temp = result[::-1]\\n while temp:\\n result.append(temp.pop(0)+(2**i))\\n \\n return result\\n\\n \",\n \"runtime\": \"202\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def grayCode(self, n: int) -> List[int]:\\n # return gray code of length n, in binary encoding\\n def gc(n):\\n if n == 1:\\n return np.array([0, 1])\\n sub = gc(n - 1)\\n return np.concat((sub, 2**(n-1) + sub[::-1]))\\n return gc(n)\\n\\n\\n\",\n \"runtime\": \"205\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n code_strs = self.gray_code_seq(\\\"0\\\" * n)\\n return [int(s, 2) for s in code_strs]\\n \\n def gray_code_seq(self, start_code: str) -> List[str]:\\n if len(start_code) == 0:\\n return [\\\"\\\"]\\n else:\\n curr, next_code = start_code[0], start_code[1:]\\n code = []\\n if curr == \\\"0\\\":\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"0\\\" + s for s in next_code_seq])\\n next_code = next_code_seq[-1]\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"1\\\" + s for s in next_code_seq])\\n else:\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"1\\\" + s for s in next_code_seq])\\n next_code = next_code_seq[-1]\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"0\\\" + s for s in next_code_seq])\\n\\n return code\\n \\n\",\n \"runtime\": \"208\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n ans = []\\n def convert(b):\\n res = b[0]\\n for j in range(1,len(b)):\\n if b[j]==b[j-1]:res += '0'\\n else:res += '1'\\n return int(res, 2)\\n\\n for i in range(pow(2, n)):\\n ans.append(convert(bin(i)[2:]))\\n return ans\",\n \"runtime\": \"210\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n input = ['0','1']\\n for i in range(2, n+1):\\n input = input+input[::-1]\\n for j in range((2**i)//2):\\n input[j]='0'+input[j]\\n for j in range((2**i)//2,2**i):\\n input[j]='1'+input[j]\\n def stringBin(index):\\n count = 0\\n out =0\\n for i in range(n-1, -1, -1):\\n if input[index][i] == '1':\\n out = out + (2**count)\\n count+=1\\n input[index]=out\\n for i in range(2**n):\\n stringBin(i)\\n return input\\n \",\n \"runtime\": \"213\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def biDec(bi):\\n dec = 0\\n for i in range(len(bi)):\\n dec += bi[i] * pow(2, i)\\n return dec\\n\\n cur = [tuple([0] * n)]\\n \\n j = 0\\n while j < n:\\n l = len(cur)\\n for i in range(l-1, -1, -1):\\n cu = list(cur[i])\\n cu[j] = 1\\n cur.append(tuple(cu))\\n j += 1\\n \\n ans = []\\n for bi in cur:\\n ans.append(biDec(bi))\\n\\n return ans \",\n \"runtime\": \"216\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n\\n\\n\\n def grayCode(self, n: int) -> List[int]:\\n seq_len = n**2\\n g_seq = np.zeros((2**n, n), dtype=np.int32)\\n g_seq[1][0] = 1 \\n\\n powers = np.array([2**idx for idx in range(n)], dtype=np.int32)\\n\\n for idx in range(1, n):\\n half_point = (2**idx)\\n g_seq[half_point: 2*half_point] = g_seq[:half_point][::-1]\\n g_seq[half_point: 2*half_point, idx] = 1\\n\\n res = (g_seq * powers[None, : ]).sum(axis=-1).tolist()\\n return res\\n\\n\\n \",\n \"runtime\": \"218\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def s2i(s):\\n v = 0\\n for i in s:\\n v = v * 2 + int(i)\\n return v\\n codes = ['']\\n for _ in range(n):\\n nxt = []\\n for s in codes:\\n nxt.append(s+'0')\\n for s in reversed(codes):\\n nxt.append(s+'1')\\n codes = nxt\\n return [s2i(code) for code in codes]\",\n \"runtime\": \"221\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res = [0] # a pos 0 é sempre 0, mesmo quando n = 0\\n\\n is_available = [True for _ in range(2**n)] # Usado para nao repetir o mesmo numero. Indexado pelo valor do numero\\n candidates = [[] for _ in range(2**n)] # A seq sempre tem 2^n elementos. Indexado pela posicao do numero\\n\\n candidates[0] = [0]\\n is_available[0] = False\\n\\n for i in range(1, 2**n):\\n previous = res[i-1]\\n candidates[i] = [previous ^ (0b1 << b) \\n for b in range(n) \\n if is_available[previous ^ (0b1 << b)] == True] # numeros candidatos a serem o proximo\\n\\n #print(f\\\"Total cand.: {candidates}. Cur. cand.: {candidates[i]}. Available: {is_available}\\\")\\n\\n current = candidates[i][0]\\n\\n is_available[current] = False\\n candidates[i] = candidates[i][1:]\\n\\n res.append(current)\\n return res\\n\\n\",\n \"runtime\": \"224\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n lst = [0]\\n n_1 = 2**(n-1)\\n for i in range(1, 2**n):\\n s = ''\\n x = 0\\n if i&n_1:\\n s+=\\\"1\\\"\\n x = 1\\n else:\\n s+='0'\\n x = 0\\n i<<=1\\n y = 0\\n j = 1\\n while j<n:\\n if i&n_1:\\n y = 1\\n else:\\n y = 0\\n if x==y:\\n s+='0'\\n else:\\n s+='1'\\n x = y\\n i<<=1\\n j+=1\\n lst.append(int(s, 2))\\n return lst\",\n \"runtime\": \"226\"\n },\n {\n \"code\": \"class Solution:\\n def _go(self, binary, l, r, invert):\\n\\n if l >= r or l < 0 or r >= len(binary):\\n # print('early return ', l, r, len(binary))\\n return\\n\\n vals = [\\\"0\\\", \\\"1\\\"]\\n if invert:\\n vals.reverse()\\n\\n ml = (l + r) // 2\\n\\n # print(l, ml, r)\\n\\n for i in range(l, ml + 1):\\n # print('here1')\\n binary[i] += vals[0]\\n\\n for i in range(ml + 1, r + 1):\\n # print('here2')\\n binary[i] += vals[1]\\n\\n # print(binary)\\n\\n self._go(binary, l, ml, False)\\n self._go(binary, ml + 1, r, True)\\n\\n def grayCode(self, n: int) -> List[int]:\\n arr_len = 2**n\\n binary = [\\\"\\\"] * arr_len\\n self._go(binary, 0, arr_len - 1, False)\\n \\n return [int(x,2) for x in binary if len(x) > 0]\\n \",\n \"runtime\": \"229\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n89. Gray Code\\n\\nAn n-bit gray code sequence is a sequence of 2^n integers where:\\n\\nEvery integer is in the inclusive range [0, 2^n - 1],\\n- The first integer is 0,\\n- An integer appears no more than once in the sequence,\\n- The binary representation of every pair of adjacent integers differs by\\n exactly one bit, and\\n- The binary representation of the first and last integers differs by exactly\\n one bit.\\n\\nGiven an integer n, return any valid n-bit gray code sequence.\\n\\\"\\\"\\\"\\nfrom typing import List\\n\\n\\nclass Solution:\\n def grayCode(self, n: int) -> List[int]:\\n seq: List[int] = [0] * (2 ** n)\\n\\n for shift in range(n):\\n count = 0\\n bit = 0\\n for i in range(len(seq)):\\n seq[i] = seq[i] | (bit << shift)\\n count += 1\\n if count == 1 << (shift + 1):\\n count = 0\\n elif count == 1 << shift:\\n bit = bit ^ 1\\n\\n return seq\\n\\n\",\n \"runtime\": \"232\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n self.track = []\\n self.used = [False] * 2**n\\n self.ans = []\\n self.found = False\\n self.backtrack(n)\\n return self.ans\\n\\n def backtrack(self, n):\\n if len(self.track) == 2**n:\\n self.ans = self.track\\n self.found = True\\n return\\n valids = self.all_valids(n, self.track[-1]) if self.track else list(range(2**n))\\n for i in valids:\\n if self.used[i]:\\n continue\\n self.used[i] = True\\n self.track.append(i)\\n self.backtrack(n)\\n if self.found:\\n return\\n self.track.pop()\\n self.used[i] = False\\n \\n def all_valids(self, n, prev):\\n valids = []\\n for i in range(n):\\n valids.append(prev ^ (1 << i))\\n return valids\\n\",\n \"runtime\": \"234\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n start=\\\"0\\\"*n\\n lst_length = 2**n\\n d_visited = {}\\n lst_visited = []\\n d_swap = {\\\"0\\\": \\\"1\\\", \\\"1\\\": \\\"0\\\"}\\n @cache\\n def helper(curr_val, i):\\n if curr_val in d_visited:\\n return None\\n else:\\n d_visited[curr_val]=1\\n lst_visited.append(int(curr_val,2))\\n\\n if i == lst_length:\\n return lst_visited\\n \\n for j in range(len(curr_val)-1,-1,-1):\\n next_val = curr_val[:j]+d_swap[curr_val[j]]+curr_val[j+1:]\\n ans = helper(next_val,i+1)\\n if ans:\\n return ans\\n\\n del d[curr_val]\\n lst_visited.pop()\\n\\n return helper(start, 1)\\n \\n \\n\\n \",\n \"runtime\": \"237\"\n },\n {\n \"code\": \"class Solution:\\n def getNeighbs(self, num, n, visited):\\n neighbs = []\\n for i in range(n):\\n candidate = num ^ (1 << i)\\n if candidate not in visited:\\n neighbs.append(candidate)\\n return neighbs\\n\\n def checkLast(self, path):\\n num = path[-1]\\n while num % 2 == 0:\\n num /= 2\\n\\n return num == 1\\n\\n def recDfs(self, num, n, path, visited):\\n #print(f\\\"checking {num=}, {path=}, {visited=}\\\")\\n if len(path) == 2 ** n and self.checkLast(path):\\n return True\\n\\n neighbs = self.getNeighbs(num, n, visited)\\n for neighb in neighbs:\\n path.append(neighb)\\n visited.add(neighb)\\n found = self.recDfs(neighb, n, path, visited)\\n if found:\\n return found\\n path.pop()\\n visited.remove(neighb)\\n\\n return False\\n \\n def grayCode(self, n: int) -> List[int]:\\n path = [0]\\n visited = set([0])\\n self.recDfs(0, n, path, visited)\\n return path\\n\",\n \"runtime\": \"240\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\\"\\\"\\\"\\n i did some brainstorming on the ipad \\n opposite binary split aka\\n 2^n total numbers, correct? \\n let's assume n = 3 \\n then 8 numbers total\\n 1-4 = 0xx\\n 5-8 = 1xx\\n\\n 1-2 = 00x\\n 3-4 = 01x\\n 5-6 = 11x\\n 7-8 = 10x\\n\\n then do the same flip-flop for the last few numbers \\n can start from the smallest denomination and do bit addition to work your way up\\n as needed\\n and since there are n bits in the number, that works great\\n \\\"\\\"\\\"\\n totalNums = 2**n\\n result = [0] * totalNums\\n # run through the numbers, \\n\\n for i in range(n):\\n print(\\\"i =\\\", i)\\n prev = True\\n current = False\\n for j in range(totalNums):\\n if (j % (2**i) == 0):\\n if prev == False and current == False:\\n current = True\\n elif prev == False and current == True:\\n prev = True\\n elif prev == True and current == True:\\n current = False\\n elif prev == True and current == False:\\n prev = False\\n if current:\\n result[j] = result[j] | 1 << i\\n j += 1\\n i += 1 \\n\\n return result\\n\",\n \"runtime\": \"242\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n lst = [[0, 1]]\\n\\n def maker(n):\\n a = []\\n for i in range(n//2):\\n a.append(0)\\n i = n/2\\n while i < n:\\n a.append(1)\\n i+=1\\n return a\\n\\n def join(a, b):\\n for i in b:\\n a.append(i)\\n return a\\n\\n def reverse(a):\\n o = []\\n\\n i = len(a)-1\\n\\n while i >=0:\\n o.append(a[i])\\n i -= 1\\n return o\\n\\n for i in range(n-1):\\n for ii in range(len(lst)):\\n lst[ii] = join(lst[ii], reverse(lst[ii]))\\n a = maker(len(lst[ii]))\\n lst.append(a)\\n\\n out = []\\n \\n for i in range(len(lst[0])):\\n a = 0\\n for ii in range(len(lst)):\\n if lst[ii][i] == 1:\\n a += 2 ** ii\\n out.append(a)\\n return out\\n \",\n \"runtime\": \"245\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":107,"string":"107"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n def gen(k):\n if k == 1:\n yield from [0, 1]\n return\n \n xs = list(gen(k-1))\n yield from xs\n y = 1 << (k-1)\n for x in reversed(xs):\n yield y + x\n \n return gen(n)","memory":"22400"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n nums = []\n for i in range(2**n):\n nums.append(i ^ (i >> 1))\n return nums","memory":"23400"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n gint=[]\n gint.append(int(\"0\",2))\n gint.append(int(\"1\",2))\n if n>1:\n for i in range(2,n+1):\n for item in gint[::-1]:\n gint.append(item|int(\"1\"+\"0\"*(i-1),2))\n return gint","memory":"23500"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def rec(n):\n if n==0:\n return [0]\n if n==1:\n return [0,1]\n prevs=rec(n-1)\n res=[]\n for i in range(len(prevs)):\n res.append(prevs[i])\n for i in range(len(prevs)-1, -1,-1):\n res.append(prevs[i]+(1<<(n-1)))\n return res\n return rec(n)","memory":"23600"},{"code":"class Solution:\n def grayCode(self, n):\n if n == 0: return [0]\n t = self.grayCode(n-1)\n return t + [i+(1<<(n-1)) for i in t][::-1]","memory":"23700"},{"code":"from typing import List\n\nclass Solution:\n def grayCode(self, n: int) -> List[int]:\n result = [0]\n for i in range(n):\n result += [x + (1 << i) for x in reversed(result)]\n return result","memory":"23800"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n start_list = [0, 1]\n for i in range(2, n+1):\n summand = 2**(i-1)\n start_list = start_list+[elem+summand for elem in reversed(start_list)]\n return start_list\n\n ","memory":"23800"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def generate_gray_code(n):\n if n == 0:\n return [0]\n previous_gray_code = generate_gray_code(n - 1)\n # Generate the new Gray code sequence\n prefix_0 = [code << 1 for code in previous_gray_code]\n prefix_1 = [code << 1 | 1 for code in reversed(previous_gray_code)]\n return prefix_0 + prefix_1\n \n return generate_gray_code(n)","memory":"23900"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n if n == 0:\n return [0]\n \n # Base case for n = 1\n if n == 1:\n return [0, 1]\n \n # Generate Gray code for n-1 bits\n previous_gray_code = self.grayCode(n - 1)\n \n # Reflect and prepend 1 to each of the previous gray code\n # Example: previous_gray_code = [0, 1] => reflected = [1, 0] => prepended = [3, 2]\n reflected_gray_code = [(1 << (n - 1)) | x for x in reversed(previous_gray_code)]\n \n # Combine the original and reflected Gray codes\n return previous_gray_code + reflected_gray_code\n ","memory":"23900"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = []\n for i in range(1 << n): # 1 << n is 2^n, the total number of gray codes\n result.append(i ^ (i >> 1)) # Append the gray code for number i\n return result\n ","memory":"24000"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = []\n for i in range(1 << n): # 1 << n is 2^n, the total number of gray codes\n result.append(i ^ (i >> 1)) # Append the gray code for number i\n return result\n ","memory":"24000"},{"code":"from typing import List\n\nclass Solution:\n def grayCode(self, n: int) -> List[int]:\n if n == 0:\n return [0]\n elif n == 1:\n return [0, 1]\n \n smaller_gray_code = self.grayCode(n - 1)\n first_half = [code << 1 for code in smaller_gray_code]\n second_half = [(code << 1) | 1 for code in reversed(smaller_gray_code)]\n \n return first_half + second_half","memory":"24100"},{"code":"# Gray Code Formula:\n# n <= 16\n# Gray_Code(n) = n XOR (n / 2)\n\nclass Solution:\n def grayCode(self, n: int) -> List[int]:\n result = [i ^ (i // 2) for i in range(pow(2, n))]\n return result","memory":"24100"},{"code":"import time\r\nfrom typing import List\r\nclass Solution:\r\n def grayCode(self, n: int) -> List[int]:\r\n start = 1\r\n start_res = [0,1]\r\n def genNext(current, last):\r\n if current == n:\r\n return last\r\n cur = [0]\r\n for i in range(len(last)):\r\n cur.append(2**current+last[i])\r\n for i in range(len(last)-1, 0, -1):\r\n cur.append(last[i])\r\n return genNext(current+1, cur) \r\n return genNext(start, start_res)","memory":"24200"},{"code":"import time\r\nfrom typing import List\r\nclass Solution:\r\n def grayCode(self, n: int) -> List[int]:\r\n res = []\r\n start = 1\r\n start_res = [0,1]\r\n def genNext(current, last):\r\n nonlocal res\r\n if current == n:\r\n res = last\r\n return\r\n cur = [0]\r\n for i in range(1, len(last)):\r\n cur.append(last[i])\r\n for i in range(len(last)-1, -1, -1):\r\n cur.append(2**current+last[i])\r\n genNext(current+1, cur)\r\n genNext(start, start_res)\r\n return res","memory":"24200"},{"code":"import time\r\nfrom typing import List\r\nclass Solution:\r\n def grayCode(self, n: int) -> List[int]:\r\n res = []\r\n start = 1\r\n start_res = [0,1]\r\n def genNext(current, last):\r\n nonlocal res\r\n if current == n:\r\n res = last\r\n return\r\n cur = [0]\r\n for i in range(1, len(last)):\r\n cur.append(last[i])\r\n for i in range(len(last)-1, -1, -1):\r\n cur.append(2**current+last[i])\r\n genNext(current+1, cur)\r\n genNext(start, start_res)\r\n return res","memory":"24300"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res = [0]\n for i in range(n):\n res.extend([r + (1 << i) for r in res[::-1]])\n return res\n\n ","memory":"24400"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n ans = [0]\n for i in range(1, n + 1):\n ans.extend(list(map(lambda x: x + (1 << (i - 1)), ans[::-1])))\n return ans","memory":"24500"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n ans = [0]\n for i in range(1, n + 1):\n ans.extend(list(map(lambda x: x + (1 << (i - 1)), ans[::-1])))\n return ans","memory":"24500"},{"code":"def grayCode(n):\n if n == 1:\n yield 0\n yield 1\n return\n buffer, c = [], 2**(n-1)\n for i in grayCode(n-1):\n buffer.append(i)\n yield i\n while buffer:\n yield c + buffer.pop()\n\nclass Solution:\n def grayCode(self, n: int) -> List[int]:\n return list(grayCode(n))","memory":"24600"},{"code":"def grayCode(n):\n if n == 1:\n yield 0\n yield 1\n return\n buffer, c = [], 2**(n-1)\n for i in grayCode(n-1):\n buffer.append(i)\n yield i\n while buffer:\n yield c + buffer.pop()\n\nclass Solution:\n def grayCode(self, n: int) -> List[int]:\n return list(grayCode(n))","memory":"24600"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def dfs(path):\n # action\n if len(path) == n:\n return [path]\n\n # continue path with 0 first\n a = dfs(path + '0')\n\n # then continue path with 1\n b = dfs(path + '1')\n\n # reverse the order of possibilities for 1 case\n b = b[::-1]\n\n # append 0 and 1 lists\n return a + b\n\n # base\n if n == 0:\n return [0]\n\n res = dfs('')\n \n # map path string to integers\n return list(map(lambda x: int(x, 2), res))","memory":"24700"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def dfs(path):\n if len(path) ==n:\n return [path]\n\n a = dfs(path+'0')\n\n b = dfs(path+'1')\n\n b = b[::-1]\n\n return a+b\n \n if n==0:\n return [0]\n res = dfs('')\n\n return list(map(lambda x: int(x,2),res))\n ","memory":"24800"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def dfs(path):\n if len(path) == n:\n return [path]\n a = dfs(path + \"0\")\n b = dfs(path + \"1\")\n b = b[::-1]\n return a + b\n\n if n == 0:\n return [0]\n res = dfs(\"\")\n return list(map(lambda x: int(x, 2), res))\n","memory":"24900"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def dfs(path):\n if len(path) == n:\n return [path]\n a = dfs(path + \"0\")\n b = dfs(path + \"1\")\n b = b[::-1]\n return a + b\n\n if n == 0:\n return [0]\n res = dfs(\"\")\n return list(map(lambda x: int(x, 2), res))\n","memory":"24900"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n first_zero = '0' * n\n first_one = ('0' * (n-1)) + '1' \n res_str = [first_zero, first_one]\n\n for i in range(n - 2, -1, -1):\n print(res_str)\n for s in res_str[::-1]:\n new_s = s[:i] + '1' + s[i+1:]\n res_str.append(new_s)\n\n res = []\n\n for i in res_str:\n res.append(int(i,2))\n \n return res\n \n\n\n\n \n\n \n\n '''\n reading:\n 2^n integer\n every integer is in inclusive range\n\n first integer is 0\n every pair of adjacent integers differs by exactly one bit\n binary representation of first and last integers differs by one bit\n\n valid n-bit gray code sequence\n\n brute force:\n\n differs by exactly one bit?\n binary representation\n wise\n\n absolutely nothign is coming to mind\n how to make integers differ by one bit reprsentation wise\n\n deal with strings pretty much\n how to make strings off by 1\n to generate all combinations \n at each index can be 0 or 1\n 2^n to generate all combinations\n how to order them together?\n count number of one's\n\n and put counts with each other\n no that wouldn't work\n\n can i solve this with a dynamic programming?\n\n simple backtracking tree?\n n = 3\n 000\n 001\n 010\n 111\n 101\n\n\n 10011\n 00111\n\n 0000\n 1000\n 1100\n 1110\n 1111\n\n 0111\n 0011\n 0001\n\n 0000\n 0001\n 0011\n 0010\n 0110\n 0111\n 0101\n 0100\n 1100\n 1101\n 1111\n 1110\n 1010\n 1011\n 1001\n 1000\n \n\n figured it out after doing some examples\n sort of building up to index\n then reverse and add next digit\n\n\n\n '''\n ","memory":"25000"},{"code":"class Solution:\n @cache\n def grayCode(self, n: int) -> List[int]:\n if n == 1: return [0, 1]\n ans = [0 for _ in range(1 << n)]\n for i, val in enumerate(self.grayCode(n - 1)):\n ans[i] = val\n ans[(1 << n) - i - 1] = val | (1 << (n - 1)) \n \n return ans","memory":"25100"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def dfs(n):\n if n == 1 :\n return [\"0\",\"1\"]\n return_arr = dfs(n-1)\n my_arr = []\n for thing in return_arr :\n gray = \"0\"+thing\n my_arr.append(gray)\n for i in range(len(my_arr)-1,-1,-1):\n gray = \"1\" + return_arr[i]\n my_arr.append(gray)\n return my_arr\n gray_codes = dfs(n)\n integers = []\n for thing in gray_codes :\n integers.append(int(thing,2))\n return integers\n","memory":"25200"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n input = ['0','1']\n for i in range(2, n+1):\n input = input+input[::-1]\n print(\"First input == \", input)\n for j in range((2**i)//2):\n input[j]='0'+input[j]\n print(\"Second input == \", input)\n for j in range((2**i)//2,2**i):\n input[j]='1'+input[j]\n print(\"Third input == \", input)\n def stringBin(index):\n count = 0\n out =0\n for i in range(n-1, -1, -1):\n if input[index][i] == '1':\n out = out + (2**count)\n count+=1\n input[index]=out\n print(input)\n for i in range(2**n):\n stringBin(i)\n print(input)\n return input\n ","memory":"25300"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n grey = {\n 1 : [0, 1],\n 2 : [0, 1, 3, 2]\n }\n\n def generate(n):\n if n in grey: return grey[n]\n prev = generate(n-1)\n rev = list(reversed(prev))\n for i in range(len(prev)):\n rev[i] += 2**(n-1)\n grey[n] = prev + rev\n return grey[n]\n \n return generate(n)\n \n","memory":"25400"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n gr_0 = [\n 0, 1\n ]\n print(help(ge))\n step = 2**0\n for i in range(1, n):\n step*=2\n gr_1 = [g + step for g in gr_0[::-1]]\n gr_0 = gr_0\n gr_0 = gr_0 + gr_1\n return gr_0","memory":"25500"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n grey = {1: [0, 1], \n 2: [0, 1, 3, 2], \n 3: [0, 1, 3, 2, 6, 7, 5, 4], \n 4: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8], \n 5: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8, 24, 25, 27, 26, 30, 31, 29, 28, 20, 21, 23, 22, 18, 19, 17, 16], \n 6: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8, 24, 25, 27, 26, 30, 31, 29, 28, 20, 21, 23, 22, 18, 19, 17, 16, 48, 49, 51, 50, 54, 55, 53, 52, 60, 61, 63, 62, 58, 59, 57, 56, 40, 41, 43, 42, 46, 47, 45, 44, 36, 37, 39, 38, 34, 35, 33, 32],\n 7: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8, 24, 25, 27, 26, 30, 31, 29, 28, 20, 21, 23, 22, 18, 19, 17, 16, 48, 49, 51, 50, 54, 55, 53, 52, 60, 61, 63, 62, 58, 59, 57, 56, 40, 41, 43, 42, 46, 47, 45, 44, 36, 37, 39, 38, 34, 35, 33, 32, 96, 97, 99, 98, 102, 103, 101, 100, 108, 109, 111, 110, 106, 107, 105, 104, 120, 121, 123, 122, 126, 127, 125, 124, 116, 117, 119, 118, 114, 115, 113, 112, 80, 81, 83, 82, 86, 87, 85, 84, 92, 93, 95, 94, 90, 91, 89, 88, 72, 73, 75, 74, 78, 79, 77, 76, 68, 69, 71, 70, 66, 67, 65, 64],\n 8: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8, 24, 25, 27, 26, 30, 31, 29, 28, 20, 21, 23, 22, 18, 19, 17, 16, 48, 49, 51, 50, 54, 55, 53, 52, 60, 61, 63, 62, 58, 59, 57, 56, 40, 41, 43, 42, 46, 47, 45, 44, 36, 37, 39, 38, 34, 35, 33, 32, 96, 97, 99, 98, 102, 103, 101, 100, 108, 109, 111, 110, 106, 107, 105, 104, 120, 121, 123, 122, 126, 127, 125, 124, 116, 117, 119, 118, 114, 115, 113, 112, 80, 81, 83, 82, 86, 87, 85, 84, 92, 93, 95, 94, 90, 91, 89, 88, 72, 73, 75, 74, 78, 79, 77, 76, 68, 69, 71, 70, 66, 67, 65, 64, 192, 193, 195, 194, 198, 199, 197, 196, 204, 205, 207, 206, 202, 203, 201, 200, 216, 217, 219, 218, 222, 223, 221, 220, 212, 213, 215, 214, 210, 211, 209, 208, 240, 241, 243, 242, 246, 247, 245, 244, 252, 253, 255, 254, 250, 251, 249, 248, 232, 233, 235, 234, 238, 239, 237, 236, 228, 229, 231, 230, 226, 227, 225, 224, 160, 161, 163, 162, 166, 167, 165, 164, 172, 173, 175, 174, 170, 171, 169, 168, 184, 185, 187, 186, 190, 191, 189, 188, 180, 181, 183, 182, 178, 179, 177, 176, 144, 145, 147, 146, 150, 151, 149, 148, 156, 157, 159, 158, 154, 155, 153, 152, 136, 137, 139, 138, 142, 143, 141, 140, 132, 133, 135, 134, 130, 131, 129, 128]}\n\n def generate(n):\n if n in grey: return grey[n]\n prev = generate(n-1)\n rev = list(reversed(prev))\n for i in range(len(prev)):\n rev[i] += 2**(n-1)\n grey[n] = prev + rev\n return grey[n]\n \n return generate(n)\n \n","memory":"25600"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n # 2^n numbers, so bit length n \n # 0000 0001 0011.. 1000 \n # 000 100 110 010 011 111 101 001 \n # 0 4 6 2 3 7 5 1\n # 00 10 11 01\n # 0000 1000 1100 0100 0110 1110 \n\n def toBinary(s):\n k = len(s) -1\n ans = 0\n for bit in s:\n ans += int(bit) * (2**k)\n k-=1\n return ans\n \n\n '''\n s = \"000\"\n ret = [0]\n termination = 001\n new_s = 100\n '''\n ret = []\n seen = set()\n s = \"\".join([\"0\" for i in range(n)])\n ret.append(toBinary(s))\n seen.add(s)\n termination = s[:-1] + \"1\"\n while True: \n if s == termination:\n break \n for i in range(len(s)):\n new_s = s[:i] + str(1-int(s[i])) + s[i+1:]\n if new_s in seen:\n continue\n else:\n s = new_s\n seen.add(s)\n ret.append(toBinary(s))\n break\n return ret\n \n\n\n \n\n","memory":"25800"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n # backtracking\n n -= 1\n curr = ['0','1']\n\n while n:\n n -= 1\n res = []\n for i in range(len(curr)):\n res.append('0' + curr[i])\n \n for i in range(len(curr) - 1, -1, -1):\n res.append('1' + curr[i])\n \n curr = res[:]\n \n\n def backtoint(s):\n ans = 0\n s = s[::-1]\n for i in range(len(s)):\n ans += (2**(i)) * int(s[i])\n return ans\n\n final = [backtoint(s) for s in curr]\n return final","memory":"25900"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n def get_bin_rep(input_str) -> int:\n print(input_str)\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\n\n last_val = [\"0\", \"1\"]\n\n for i in range(2, n+1):\n \n options = last_val\n zero_options = [f\"0{i}\" for i in options] \n one_options = [f\"1{i}\" for i in options[::-1]]\n options = zero_options + one_options\n last_val = options\n\n \n return [get_bin_rep(i) for i in last_val]","memory":"26000"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n def get_bin_rep(input_str) -> int:\n print(input_str)\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\n\n last_val = [\"0\", \"1\"]\n\n for i in range(2, n+1):\n \n zero_options = [f\"0{i}\" for i in last_val] \n one_options = [f\"1{i}\" for i in last_val[::-1]]\n last_val = zero_options + one_options\n\n \n return [get_bin_rep(i) for i in last_val]","memory":"26000"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n def get_bin_rep(input_str) -> int:\n print(input_str)\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\n\n last_val = [\"0\", \"1\"]\n\n for i in range(2, n+1):\n \n options = last_val\n zero_options = [f\"0{i}\" for i in options] \n one_options = [f\"1{i}\" for i in options[::-1]]\n options = zero_options + one_options\n last_val = options\n\n \n return [get_bin_rep(i) for i in last_val]","memory":"26100"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n code_strs = self.gray_code_seq(\"0\" * n)\n return [int(s, 2) for s in code_strs]\n \n def gray_code_seq(self, start_code: str) -> List[str]:\n if len(start_code) == 0:\n return [\"\"]\n else:\n curr, next_code = start_code[0], start_code[1:]\n code = []\n if curr == \"0\":\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"0\" + s for s in next_code_seq])\n next_code = next_code_seq[-1]\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"1\" + s for s in next_code_seq])\n else:\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"1\" + s for s in next_code_seq])\n next_code = next_code_seq[-1]\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"0\" + s for s in next_code_seq])\n\n return code\n \n","memory":"26500"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n if n < 1:\n return []\n if n < 2:\n return [0, 1]\n f = self.grayCode\n prev = f(n - 1)\n ret1, ret2 = [], []\n for e in prev:\n ret1.append(bin(e)[2:] + '0')\n ret2.append(bin(e)[2:] + '1')\n return list(map(lambda x: int(x, 2), ret1 + ret2[::-1]))","memory":"26600"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n if n < 1:\n return []\n if n < 2:\n return [0, 1]\n f = self.grayCode\n prev = f(n - 1)\n ret1, ret2 = [], []\n for e in prev:\n ret1.append(bin(e)[2:] + '0')\n ret2.append(bin(e)[2:] + '1')\n return list(map(lambda x: int(x, 2), ret1 + ret2[::-1]))","memory":"26800"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n twobit = [\"00\", \"01\", \"11\", \"10\"]\n\n def gray(n):\n if n==1: return [\"0\", \"1\"]\n if n==2: return twobit\n\n old = gray(n-1)\n ref = [\"1\" + x for x in old[::-1]]\n\n old = [\"0\" + x for x in old]\n\n return old+ ref\n print(gray(n))\n return list(map(lambda x: int(x, 2), gray(n)))\n\n\n","memory":"26900"},{"code":"class Solution:\n \n \n def grayCode(self, n: int) -> List[int]:\n \n def helper(n):\n \n if(n==1):\n return [\"0\",\"1\"]\n \n x=helper(n-1)\n res=[]\n print(n, x)\n for i in range(len(x)):\n s=x[i]\n res.append(\"0\"+s)\n print(n, res) \n for i in range(len(x)-1,-1,-1):\n s=x[i]\n res.append(\"1\"+s)\n print(n, res)\n return res\n \n res=helper(n)\n fres=[]\n for i in res:\n fres.append(int(i,2))\n return fres \n ","memory":"27600"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n grey_codes = self.generate_grey_code(n-1, [\"0\",\"1\"])\n #print(grey_codes)\n return [int(each, 2) for each in grey_codes]\n\n def generate_grey_code(self, n, grey_codes):\n if n == 0:\n return grey_codes\n else:\n l1 = [each+\"0\" for each in grey_codes]\n l2 = [each+\"1\" for each in grey_codes[::-1]]\n return self.generate_grey_code(n-1, l1+l2)","memory":"27800"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n lst = [[0, 1]]\n\n def maker(n):\n a = []\n for i in range(n//2):\n a.append(0)\n i = n/2\n while i < n:\n a.append(1)\n i+=1\n return a\n\n def join(a, b):\n for i in b:\n a.append(i)\n return a\n\n def reverse(a):\n o = []\n\n i = len(a)-1\n\n while i >=0:\n o.append(a[i])\n i -= 1\n return o\n\n for i in range(n-1):\n for ii in range(len(lst)):\n lst[ii] = join(lst[ii], reverse(lst[ii]))\n a = maker(len(lst[ii]))\n lst.append(a)\n\n out = []\n \n for i in range(len(lst[0])):\n a = 0\n for ii in range(len(lst)):\n if lst[ii][i] == 1:\n a += 2 ** ii\n out.append(a)\n return out\n ","memory":"28600"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]: \n dict = {}\n dict[1] = [0,1]\n def dp(n):\n if n in dict:\n return dict[n]\n ans = []\n for num in dp(n-1):\n ans.append(num *2)\n for num in dp(n-1)[::-1]:\n ans.append(num*2 +1)\n dict[n] = ans\n return ans\n return dp(n)\n\n\n ","memory":"28900"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n code_strs = self.gray_code_seq(\"0\" * n)\n print(code_strs)\n return [int(s, 2) for s in code_strs]\n \n def gray_code_seq(self, start_code: str) -> List[str]:\n if len(start_code) == 0:\n return [\"\"]\n else:\n print(start_code)\n curr, next_code = start_code[0], start_code[1:]\n code = []\n if curr == \"0\":\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"0\" + s for s in next_code_seq])\n next_code = next_code_seq[-1]\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"1\" + s for s in next_code_seq])\n else:\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"1\" + s for s in next_code_seq])\n next_code = next_code_seq[-1]\n next_code_seq = self.gray_code_seq(next_code)\n code.extend([\"0\" + s for s in next_code_seq])\n\n return code\n \n","memory":"29200"},{"code":"class Solution:\n @cache\n def grayCode(self, n: int) -> List[int]:\n if n < 1:\n return []\n if n < 2:\n return [0, 1]\n f = self.grayCode\n prev = f(n - 1)\n ret1, ret2 = [], []\n for e in prev:\n ret1.append(bin(e)[2:] + '0')\n ret2.append(bin(e)[2:] + '1')\n return list(map(lambda x: int(x, 2), ret1 + ret2[::-1]))","memory":"29600"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n def get_bin_rep(input_str) -> int:\n print(input_str)\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\n\n return_dict = {1:[\"0\", \"1\"]}\n\n for i in range(2, n+1):\n \n options = return_dict.get(i-1)\n zero_options = [f\"0{i}\" for i in options] \n one_options = [f\"1{i}\" for i in options[::-1]]\n options = zero_options + one_options\n return_dict[i] = options\n\n \n return [get_bin_rep(i) for i in return_dict[n]]","memory":"29800"},{"code":"class Solution:\n def __init__(self):\n self.codes = [[\"0\", \"1\"]]\n for i in range(2, 17):\n codes = self.codes[i - 2]\n new = list()\n for c in codes:\n new.append(c+\"0\")\n for c in codes[::-1]:\n new.append(c+\"1\")\n self.codes.append(new)\n\n def grayCode(self, n: int) -> List[int]:\n return list(map(lambda x: int(x, 2), self.codes[n - 1]))","memory":"30000"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n def get_bin_rep(input_str) -> int:\n print(input_str)\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\n\n return_dict = {1:[\"0\", \"1\"]}\n\n for i in range(2, n+1):\n \n options = return_dict.get(i-1)\n zero_options = [f\"0{i}\" for i in options] \n one_options = [f\"1{i}\" for i in options[::-1]]\n options = zero_options + one_options\n return_dict[i] = options\n\n \n return [get_bin_rep(i) for i in return_dict[n]]","memory":"30200"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n def get_bin_rep(input_str) -> int:\n print(input_str)\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\n\n return_dict = {1:[\"0\", \"1\"]}\n\n for i in range(2, n+1):\n \n options = return_dict.get(i-1)\n zero_options = [f\"0{i}\" for i in options] \n one_options = [f\"1{i}\" for i in options[::-1]]\n options = zero_options + one_options\n return_dict[i] = options\n\n \n return [get_bin_rep(i) for i in return_dict[n]]","memory":"30200"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n ans = [\"0\"]\n for i in range(n):\n next_ans = ans.copy()\n for x in ans[::-1]:\n next_ans.append(\"1\" + x[1:])\n ans = [\"0\" + x for x in next_ans]\n return [int(x, 2) for x in next_ans]","memory":"30500"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def biDec(bi):\n dec = 0\n for i in range(len(bi)):\n dec += bi[i] * pow(2, i)\n return dec\n\n cur = [tuple([0] * n)]\n \n j = 0\n while j < n:\n l = len(cur)\n for i in range(l-1, -1, -1):\n cu = list(cur[i])\n cu[j] = 1\n cur.append(tuple(cu))\n j += 1\n \n ans = []\n for bi in cur:\n ans.append(biDec(bi))\n\n return ans ","memory":"31100"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n r = []\n array = [ False for _ in range(n) ] \n i = 2**n # number of iterations\n offset = i//2 \n\n for x in range(i):\n # val = val if (x+1)%2 else not val\n # val = val if (x+2)%4 else not val\n # val = val if (x+4)%8 else not val \n\n val = i\n for j in range(n):\n array[j] = array[j] if (x+val//2)%val else not array[j]\n val//=2\n\n r.append(array[:])\n \n return [ int('0b' + ''.join([ str(int(x)) for x in item ]),2) for item in r ]\n\n # iter = 1 * 2\n # 0 \n # 1\n\n # iter = 1 * 2 * 2\n # 0 0\n # 0 1\n # 1 1\n # 1 0\n \n # iter = 1 * 2 * 2 * 2\n # 0 0 0 x = 1 \n # 0 0 1 x = 2\n # 0 1 1 x = 3\n # 0 1 0\n # 1 1 0\n # 1 1 1\n # 1 0 1\n # 1 0 0","memory":"31900"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n r = []\n array = [ False for _ in range(n) ] \n i = 2**n \n offset = i//2 \n\n for x in range(i):\n\n val = i\n for j in range(n):\n array[j] = array[j] if (x+val//2)%val else not array[j]\n val//=2\n\n r.append(array[:])\n \n return [ int('0b' + ''.join([ str(int(x)) for x in item ]),2) for item in r ]\n\n","memory":"31900"},{"code":"import math\n\nlog = math.log\n\n\nclass Solution(object):\n def grayCode(self, n):\n \"\"\"\n :type n: int\n :rtype: List[int]\n \"\"\"\n\n # [[0]]\n # [[1]]\n #\n\n bnums = [[0], [1]]\n\n if n != 1:\n for i in range(n - 1):\n for j in range(len(bnums) - 1, -1, -1):\n bnums.append(bnums[j].copy())\n for j in range(int(len(bnums) / 2)):\n bnums[j].insert(0, 0)\n for j in range(int(len(bnums) / 2), len(bnums)):\n bnums[j].insert(0, 1)\n\n for i in range(len(bnums)):\n dnum = 0\n for b in range(n):\n if bnums[i][b]:\n dnum += pow(2, b)\n bnums[i] = dnum\n\n # print(bnums)\n return bnums\n\n\n# 0,0\n# ^\n# 0,1\n# ^\n# 1,1\n# ^\n# 1,0\n# ^\n#\n","memory":"32600"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n self.n = n \n self.result = [0]\n self.visited = set([0])\n self.generate_gray_code(0)\n return self.result\n\n def generate_gray_code(self, num):\n if len(self.result) == 2**self.n:\n return True\n for i in range(self.n):\n next_num = num ^ (1 << i)\n if next_num not in self.visited:\n self.result.append(next_num)\n self.visited.add(next_num)\n \n if self.generate_gray_code(next_num):\n return True\n \n self.result.pop()\n self.visited.remove(next_num)\n return False\n ","memory":"32900"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n def backtracking(track):\n if len(track) == (1 << n):\n self.res = track\n return True\n # flip one bit\n # for each bit/pos in binary representation\n for pos in range(n):\n nxt = track[-1] ^ (1 << pos) #xor one bit\n if not used[nxt]:\n used[nxt] = True\n track.append(nxt)\n if backtracking(track):\n return True\n track.pop()\n used[nxt] = False\n return False\n \n self.res = []\n used = [False] * (1<<n)\n used[0] = True\n backtracking([0])\n return self.res","memory":"33000"},{"code":"from copy import deepcopy\n\nclass Solution:\n debugging = True\n\n def get_num_bits_diff(self, a: int, b: int) -> int:\n '''Return the number of bits that a and b differ by'''\n ab_xor = a ^ b\n if ab_xor == 0:\n return 0\n \n one_count = 0\n while ab_xor > 0:\n if ab_xor % 2 == 1:\n one_count += 1\n ab_xor = ab_xor >> 1\n return one_count\n\n def backtracking_approach(self, n: int) -> List[int]:\n '''Try backtracking until we get a valid sequence\n pg 53: the alternative is trying to inductively notice a pattern from small n'''\n first_gray_code_seen = []\n\n def recur(cur_sequence: List[int], visited: List[bool]) -> bool:\n if self.debugging:\n print(f'{cur_sequence=}')\n if len(cur_sequence) == 2**n:\n first_last_bit_diff = self.get_num_bits_diff(cur_sequence[0], cur_sequence[-1])\n if first_last_bit_diff == 1:\n if self.debugging:\n print(f'\\tis a Gray code')\n first_gray_code_seen.extend(cur_sequence)\n return True\n else:\n if self.debugging:\n print(f'\\tnot a Gray code because {first_last_bit_diff=}')\n \n for i in range(2**n):\n if visited[i]:\n continue\n bit_diff_w_last = self.get_num_bits_diff(i, cur_sequence[-1])\n if bit_diff_w_last != 1:\n continue\n \n visited[i] = True # Try adding i to the sequence\n found_gray_code = recur(cur_sequence + [i], visited)\n if found_gray_code:\n return True\n visited[i] = False # If we get here, then this branch didn't work\n \n if self.debugging:\n print(f'\\tfailed to lead to any Gray codes')\n return False # None of the possibilities worked\n\n recur([0], [True if i == 0 else False for i in range(2**n)])\n return first_gray_code_seen\n\n def check(self, gray_code: List[int]):\n '''For debugging purposes, check bit diffs between the output of the above function\n Don't forget to check bit diff between the first and the last'''\n bit_diffs = []\n for i in range(1, len(gray_code)):\n bit_diffs.append(self.get_num_bits_diff(gray_code[i], gray_code[i-1]))\n bit_diffs.append(self.get_num_bits_diff(gray_code[0], gray_code[-1]))\n print(f'{bit_diffs=}')\n\n def reverse_and_prepend(self, n: int) -> List[List[int]]:\n '''Much faster method to generate an n-bit Gray code:\n Take the n-1 bit Gray code, append a reversed version of it\n Then, prepend 0 to the original half, 1 to the reversed half'''\n cur_gray_code = [[0], [1]]\n for i in range(2, n+1):\n half_to_append = deepcopy(list(reversed(cur_gray_code)))\n for h in half_to_append:\n h.append(1)\n for c in cur_gray_code:\n c.append(0)\n cur_gray_code.extend(half_to_append)\n if self.debugging:\n print(f'{i=}, {cur_gray_code=}')\n return cur_gray_code\n\n \n def reversed_binary_to_int(self, reversed_digits: List[int]) -> int:\n '''Convert binary number (given as least-to-most significant digits) to an int'''\n int_repr = 0\n for i in range(len(reversed_digits)):\n int_repr += reversed_digits[i] * 2**(i)\n return int_repr\n\n\n def grayCode(self, n: int) -> List[int]:\n self.debugging = False\n # return self.backtracking_approach(n)\n reversed_gray_code_bits = self.reverse_and_prepend(n)\n return [self.reversed_binary_to_int(bits) for bits in reversed_gray_code_bits]","memory":"33400"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res = [0]\n\n def helper(visited):\n if len(res) == (1 << n):\n return True\n for i in range(n):\n num = (1 << i) ^ res[-1]\n if num not in visited:\n visited.add(num)\n res.append(num)\n if helper(visited):\n return True\n visited.remove(num)\n res.pop()\n\n helper({0})\n return res\n","memory":"33900"},{"code":"import numpy as np\nclass Solution:\n def grayCode(self, n: int) -> List[int]:\n # return gray code of length n, in binary encoding\n def gc(n):\n if n == 1:\n return np.array([0, 1])\n sub = gc(n - 1)\n return np.concat((sub, 2**(n-1) + sub[::-1]))\n return gc(n)\n\n\n","memory":"34100"},{"code":"class Solution:\n\n def __init__(self):\n self.res = []\n self.path = []\n self.used = set()\n\n def grayCode(self, n: int) -> List[int]:\n if n < 0: return self.res\n self.dfs(n, 0)\n return self.res[0]\n \n def dfs(self, n: int, num:int):\n if self.res: # there is one valid res, return\n return\n \n if len(self.path) == (1 << n): # path has 2^n element, found a res\n self.res.append(self.path[:])\n return\n \n if num in self.used: # num visited\n return\n\n self.path.append(num) # dfs, add node now\n self.used.add(num)\n\n for i in range(n):\n onediff = self.flipbit(num, i)\n self.dfs(n, onediff)\n\n self.path.pop() # dfs, revert node now\n self.used.remove(num)\n\n def flipbit(self, num:int, pos: int) -> int:\n return num ^ (1 << pos) \n","memory":"34400"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n res = [0]\n def dfs(visited):\n if len(res) == 2 ** n and bin((res[0] ^ res[-1])).count('1') == 1:\n return res\n else:\n for i in range(n):\n num = res[-1] ^ (1 << i) # get next number\n if num not in visited:\n res.append(num)\n visited.add(num)\n if dfs(visited):\n return res\n res.pop()\n visited.remove(num)\n return False\n\n return dfs({0})\n","memory":"34500"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n \n def backtracking(track, curr):\n if len(self.res) != 0:\n return True\n if used[curr]:\n return False\n if len(track) == (1 << n) - 1:\n self.res = track + [curr]\n return True\n track.append(curr)\n used[curr] = True\n # flip one bit for each pos\n for pos in range(n):\n nxt = curr ^ (1 << pos) #xor one bit\n if backtracking(track, nxt):\n return True\n track.pop()\n used[curr] = False\n return False\n \n self.res = []\n used = [False] * (1<<n)\n backtracking([], 0)\n return self.res","memory":"34700"},{"code":"\"\"\"\n# The binary representation of the first and last integers differs by exactly one bit.\n# and\n# The first integer is 0\n# so\n# the last integer is a power of 2\n\"\"\"\nclass Solution:\n def grayCode(self, n: int) -> List[int]:\n seq = [0]\n visited = set([0])\n\n def dfs():\n # print(seq)\n if len(seq) == 2**n:\n return True\n \n for i in range(n):\n # wheter the integer differs by exactly one bit (from last inserted num)\n if seq[-1] & 2**i:\n # already set, remove that bit\n next_num = seq[-1] - 2**i # improve this\n else:\n next_num = seq[-1] | 2**i\n if next_num not in visited:\n seq.append(next_num)\n visited.add(next_num)\n if dfs():\n # found\n return True\n visited.remove(next_num)\n seq.pop()\n\n return False\n\n dfs()\n return seq\n \n def _differ_by_exactly_one_bit(self, int1, int2):\n c = 0\n\n for i in range(16):\n if int1 & 2**i != int2 & 2**i:\n c += 1\n \n return c == 1\n # find difference bit(s)\n # check if difference is power of 2\n\n\n\"\"\"\n000000 -> \n\"\"\"\n\n# [0,1,3,2,6,7,5,4,12,13,15,14,10,11,9,8]\n# [0,1,3,2,6,7,5,4,12,13,15,14,10,11,9,8,24,25,27,26,30,31,29,28,20,21,23,22,18,19,17,16,48,49,51,50,54,55,53,52,60,61,63,62,58,59,57,56,40,41,43,42,46,47,45,44,36,37,39,38,34,35,33,32]","memory":"34800"},{"code":"\"\"\"\n# The binary representation of the first and last integers differs by exactly one bit.\n# and\n# The first integer is 0\n# so\n# the last integer is a power of 2\n\"\"\"\nclass Solution:\n def grayCode(self, n: int) -> List[int]:\n seq = [0]\n visited = set([0])\n\n def dfs():\n # print(seq)\n # initially: and self._differ_by_exactly_one_bit(seq[-1], 0)\n # but it work even without it\n # yeah, because only 1 sequence is possible?\n if len(seq) == 2**n:\n return True\n \n for i in range(n):\n # wheter the integer differs by exactly one bit (from last inserted num)\n if seq[-1] & 2**i:\n # already set, remove that bit\n next_num = seq[-1] - 2**i # improve this\n else:\n next_num = seq[-1] | 2**i\n if next_num not in visited:\n seq.append(next_num)\n visited.add(next_num)\n if dfs():\n # found\n return True\n visited.remove(next_num)\n seq.pop()\n\n return False\n\n dfs()\n return seq","memory":"34800"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n def backtrack(current, used):\n if len(result) == 1 << n:\n if (1 << n) - 1 in result:\n return True\n else:\n return False\n \n for i in range(n):\n next_num = current ^ (1 << i)\n if next_num not in used:\n used.add(next_num)\n result.append(next_num)\n if backtrack(next_num, used):\n return True\n result.pop()\n used.remove(next_num)\n return False\n \n result = [0]\n used = set([0])\n backtrack(0, used)\n return result\n\n# Example usage:\nsolution = Solution()\nprint(solution.grayCode(2)) # Output: [0, 1, 3, 2]\nprint(solution.grayCode(1)) # Output: [0, 1]","memory":"34900"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result","memory":"35000"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result","memory":"35100"},{"code":"class Solution:\n def grayCode(self, n: int) -> list[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result ","memory":"35100"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n result = [0]\n visited = set([0])\n\n def generateGrayCode(num):\n if len(result) == 2 ** n:\n return True\n for i in range(n):\n next_num = num ^ (1 << i)\n\n if next_num not in visited:\n result.append(next_num)\n visited.add(next_num)\n\n if generateGrayCode(next_num):\n return True\n\n result.pop()\n visited.remove(next_num)\n return False\n\n generateGrayCode(0)\n return result\n\n ","memory":"35200"},{"code":"class Solution:\n def grayCode(self, n: int) -> List[int]:\n\n def dfs(val: int):\n if val not in visited:\n res.append(val)\n visited.add(val)\n for i in range(n):\n t = val ^ (1 << i)\n if t not in visited:\n res.append(t)\n visited.add(t)\n dfs(t)\n break\n \n\n res, visited = [], set()\n dfs(0)\n return res\n ","memory":"35300"},{"code":"# class Solution:\n# def grayCode(self, n: int) -> List[int]:\n\n# TARGET = 2**n\n\n# result = []\n# def dfs(running_list, running_set, last_int):\n# if len(result):\n# return\n# if len(running_list) == TARGET:\n# if (last_int & (last_int-1) == 0) and last_int != 0:\n# result.append(running_list)\n# return\n# for i in range(n):\n# new_int = (2**i) ^ last_int\n# if new_int in running_set:\n# continue\n# else:\n# running_set.add(new_int)\n# dfs(running_list+[new_int], running_set, new_int)\n# running_set.remove(new_int)\n# dfs([0], set([0]), 0)\n# return result[0]\n\nclass Solution:\n def grayCode(self, n: int):\n result = [0]\n isPresent = {0}\n self.grayCodeHelper(result, n, isPresent)\n return result\n\n def grayCodeHelper(self, result, n, isPresent):\n if len(result) == (1 << n):\n return True\n current = result[-1]\n for i in range(n):\n nextNum = current ^ (1 << i)\n if nextNum not in isPresent:\n isPresent.add(nextNum)\n result.append(nextNum)\n if self.grayCodeHelper(result, n, isPresent):\n return True\n isPresent.remove(nextNum)\n result.pop()\n return False","memory":"35400"}],"string":"[\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n def gen(k):\\n if k == 1:\\n yield from [0, 1]\\n return\\n \\n xs = list(gen(k-1))\\n yield from xs\\n y = 1 << (k-1)\\n for x in reversed(xs):\\n yield y + x\\n \\n return gen(n)\",\n \"memory\": \"22400\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n nums = []\\n for i in range(2**n):\\n nums.append(i ^ (i >> 1))\\n return nums\",\n \"memory\": \"23400\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n gint=[]\\n gint.append(int(\\\"0\\\",2))\\n gint.append(int(\\\"1\\\",2))\\n if n>1:\\n for i in range(2,n+1):\\n for item in gint[::-1]:\\n gint.append(item|int(\\\"1\\\"+\\\"0\\\"*(i-1),2))\\n return gint\",\n \"memory\": \"23500\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def rec(n):\\n if n==0:\\n return [0]\\n if n==1:\\n return [0,1]\\n prevs=rec(n-1)\\n res=[]\\n for i in range(len(prevs)):\\n res.append(prevs[i])\\n for i in range(len(prevs)-1, -1,-1):\\n res.append(prevs[i]+(1<<(n-1)))\\n return res\\n return rec(n)\",\n \"memory\": \"23600\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n):\\n if n == 0: return [0]\\n t = self.grayCode(n-1)\\n return t + [i+(1<<(n-1)) for i in t][::-1]\",\n \"memory\": \"23700\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = [0]\\n for i in range(n):\\n result += [x + (1 << i) for x in reversed(result)]\\n return result\",\n \"memory\": \"23800\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n start_list = [0, 1]\\n for i in range(2, n+1):\\n summand = 2**(i-1)\\n start_list = start_list+[elem+summand for elem in reversed(start_list)]\\n return start_list\\n\\n \",\n \"memory\": \"23800\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def generate_gray_code(n):\\n if n == 0:\\n return [0]\\n previous_gray_code = generate_gray_code(n - 1)\\n # Generate the new Gray code sequence\\n prefix_0 = [code << 1 for code in previous_gray_code]\\n prefix_1 = [code << 1 | 1 for code in reversed(previous_gray_code)]\\n return prefix_0 + prefix_1\\n \\n return generate_gray_code(n)\",\n \"memory\": \"23900\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n if n == 0:\\n return [0]\\n \\n # Base case for n = 1\\n if n == 1:\\n return [0, 1]\\n \\n # Generate Gray code for n-1 bits\\n previous_gray_code = self.grayCode(n - 1)\\n \\n # Reflect and prepend 1 to each of the previous gray code\\n # Example: previous_gray_code = [0, 1] => reflected = [1, 0] => prepended = [3, 2]\\n reflected_gray_code = [(1 << (n - 1)) | x for x in reversed(previous_gray_code)]\\n \\n # Combine the original and reflected Gray codes\\n return previous_gray_code + reflected_gray_code\\n \",\n \"memory\": \"23900\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = []\\n for i in range(1 << n): # 1 << n is 2^n, the total number of gray codes\\n result.append(i ^ (i >> 1)) # Append the gray code for number i\\n return result\\n \",\n \"memory\": \"24000\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = []\\n for i in range(1 << n): # 1 << n is 2^n, the total number of gray codes\\n result.append(i ^ (i >> 1)) # Append the gray code for number i\\n return result\\n \",\n \"memory\": \"24000\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def grayCode(self, n: int) -> List[int]:\\n if n == 0:\\n return [0]\\n elif n == 1:\\n return [0, 1]\\n \\n smaller_gray_code = self.grayCode(n - 1)\\n first_half = [code << 1 for code in smaller_gray_code]\\n second_half = [(code << 1) | 1 for code in reversed(smaller_gray_code)]\\n \\n return first_half + second_half\",\n \"memory\": \"24100\"\n },\n {\n \"code\": \"# Gray Code Formula:\\n# n <= 16\\n# Gray_Code(n) = n XOR (n / 2)\\n\\nclass Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = [i ^ (i // 2) for i in range(pow(2, n))]\\n return result\",\n \"memory\": \"24100\"\n },\n {\n \"code\": \"import time\\r\\nfrom typing import List\\r\\nclass Solution:\\r\\n def grayCode(self, n: int) -> List[int]:\\r\\n start = 1\\r\\n start_res = [0,1]\\r\\n def genNext(current, last):\\r\\n if current == n:\\r\\n return last\\r\\n cur = [0]\\r\\n for i in range(len(last)):\\r\\n cur.append(2**current+last[i])\\r\\n for i in range(len(last)-1, 0, -1):\\r\\n cur.append(last[i])\\r\\n return genNext(current+1, cur) \\r\\n return genNext(start, start_res)\",\n \"memory\": \"24200\"\n },\n {\n \"code\": \"import time\\r\\nfrom typing import List\\r\\nclass Solution:\\r\\n def grayCode(self, n: int) -> List[int]:\\r\\n res = []\\r\\n start = 1\\r\\n start_res = [0,1]\\r\\n def genNext(current, last):\\r\\n nonlocal res\\r\\n if current == n:\\r\\n res = last\\r\\n return\\r\\n cur = [0]\\r\\n for i in range(1, len(last)):\\r\\n cur.append(last[i])\\r\\n for i in range(len(last)-1, -1, -1):\\r\\n cur.append(2**current+last[i])\\r\\n genNext(current+1, cur)\\r\\n genNext(start, start_res)\\r\\n return res\",\n \"memory\": \"24200\"\n },\n {\n \"code\": \"import time\\r\\nfrom typing import List\\r\\nclass Solution:\\r\\n def grayCode(self, n: int) -> List[int]:\\r\\n res = []\\r\\n start = 1\\r\\n start_res = [0,1]\\r\\n def genNext(current, last):\\r\\n nonlocal res\\r\\n if current == n:\\r\\n res = last\\r\\n return\\r\\n cur = [0]\\r\\n for i in range(1, len(last)):\\r\\n cur.append(last[i])\\r\\n for i in range(len(last)-1, -1, -1):\\r\\n cur.append(2**current+last[i])\\r\\n genNext(current+1, cur)\\r\\n genNext(start, start_res)\\r\\n return res\",\n \"memory\": \"24300\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res = [0]\\n for i in range(n):\\n res.extend([r + (1 << i) for r in res[::-1]])\\n return res\\n\\n \",\n \"memory\": \"24400\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n ans = [0]\\n for i in range(1, n + 1):\\n ans.extend(list(map(lambda x: x + (1 << (i - 1)), ans[::-1])))\\n return ans\",\n \"memory\": \"24500\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n ans = [0]\\n for i in range(1, n + 1):\\n ans.extend(list(map(lambda x: x + (1 << (i - 1)), ans[::-1])))\\n return ans\",\n \"memory\": \"24500\"\n },\n {\n \"code\": \"def grayCode(n):\\n if n == 1:\\n yield 0\\n yield 1\\n return\\n buffer, c = [], 2**(n-1)\\n for i in grayCode(n-1):\\n buffer.append(i)\\n yield i\\n while buffer:\\n yield c + buffer.pop()\\n\\nclass Solution:\\n def grayCode(self, n: int) -> List[int]:\\n return list(grayCode(n))\",\n \"memory\": \"24600\"\n },\n {\n \"code\": \"def grayCode(n):\\n if n == 1:\\n yield 0\\n yield 1\\n return\\n buffer, c = [], 2**(n-1)\\n for i in grayCode(n-1):\\n buffer.append(i)\\n yield i\\n while buffer:\\n yield c + buffer.pop()\\n\\nclass Solution:\\n def grayCode(self, n: int) -> List[int]:\\n return list(grayCode(n))\",\n \"memory\": \"24600\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def dfs(path):\\n # action\\n if len(path) == n:\\n return [path]\\n\\n # continue path with 0 first\\n a = dfs(path + '0')\\n\\n # then continue path with 1\\n b = dfs(path + '1')\\n\\n # reverse the order of possibilities for 1 case\\n b = b[::-1]\\n\\n # append 0 and 1 lists\\n return a + b\\n\\n # base\\n if n == 0:\\n return [0]\\n\\n res = dfs('')\\n \\n # map path string to integers\\n return list(map(lambda x: int(x, 2), res))\",\n \"memory\": \"24700\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def dfs(path):\\n if len(path) ==n:\\n return [path]\\n\\n a = dfs(path+'0')\\n\\n b = dfs(path+'1')\\n\\n b = b[::-1]\\n\\n return a+b\\n \\n if n==0:\\n return [0]\\n res = dfs('')\\n\\n return list(map(lambda x: int(x,2),res))\\n \",\n \"memory\": \"24800\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def dfs(path):\\n if len(path) == n:\\n return [path]\\n a = dfs(path + \\\"0\\\")\\n b = dfs(path + \\\"1\\\")\\n b = b[::-1]\\n return a + b\\n\\n if n == 0:\\n return [0]\\n res = dfs(\\\"\\\")\\n return list(map(lambda x: int(x, 2), res))\\n\",\n \"memory\": \"24900\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def dfs(path):\\n if len(path) == n:\\n return [path]\\n a = dfs(path + \\\"0\\\")\\n b = dfs(path + \\\"1\\\")\\n b = b[::-1]\\n return a + b\\n\\n if n == 0:\\n return [0]\\n res = dfs(\\\"\\\")\\n return list(map(lambda x: int(x, 2), res))\\n\",\n \"memory\": \"24900\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n first_zero = '0' * n\\n first_one = ('0' * (n-1)) + '1' \\n res_str = [first_zero, first_one]\\n\\n for i in range(n - 2, -1, -1):\\n print(res_str)\\n for s in res_str[::-1]:\\n new_s = s[:i] + '1' + s[i+1:]\\n res_str.append(new_s)\\n\\n res = []\\n\\n for i in res_str:\\n res.append(int(i,2))\\n \\n return res\\n \\n\\n\\n\\n \\n\\n \\n\\n '''\\n reading:\\n 2^n integer\\n every integer is in inclusive range\\n\\n first integer is 0\\n every pair of adjacent integers differs by exactly one bit\\n binary representation of first and last integers differs by one bit\\n\\n valid n-bit gray code sequence\\n\\n brute force:\\n\\n differs by exactly one bit?\\n binary representation\\n wise\\n\\n absolutely nothign is coming to mind\\n how to make integers differ by one bit reprsentation wise\\n\\n deal with strings pretty much\\n how to make strings off by 1\\n to generate all combinations \\n at each index can be 0 or 1\\n 2^n to generate all combinations\\n how to order them together?\\n count number of one's\\n\\n and put counts with each other\\n no that wouldn't work\\n\\n can i solve this with a dynamic programming?\\n\\n simple backtracking tree?\\n n = 3\\n 000\\n 001\\n 010\\n 111\\n 101\\n\\n\\n 10011\\n 00111\\n\\n 0000\\n 1000\\n 1100\\n 1110\\n 1111\\n\\n 0111\\n 0011\\n 0001\\n\\n 0000\\n 0001\\n 0011\\n 0010\\n 0110\\n 0111\\n 0101\\n 0100\\n 1100\\n 1101\\n 1111\\n 1110\\n 1010\\n 1011\\n 1001\\n 1000\\n \\n\\n figured it out after doing some examples\\n sort of building up to index\\n then reverse and add next digit\\n\\n\\n\\n '''\\n \",\n \"memory\": \"25000\"\n },\n {\n \"code\": \"class Solution:\\n @cache\\n def grayCode(self, n: int) -> List[int]:\\n if n == 1: return [0, 1]\\n ans = [0 for _ in range(1 << n)]\\n for i, val in enumerate(self.grayCode(n - 1)):\\n ans[i] = val\\n ans[(1 << n) - i - 1] = val | (1 << (n - 1)) \\n \\n return ans\",\n \"memory\": \"25100\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def dfs(n):\\n if n == 1 :\\n return [\\\"0\\\",\\\"1\\\"]\\n return_arr = dfs(n-1)\\n my_arr = []\\n for thing in return_arr :\\n gray = \\\"0\\\"+thing\\n my_arr.append(gray)\\n for i in range(len(my_arr)-1,-1,-1):\\n gray = \\\"1\\\" + return_arr[i]\\n my_arr.append(gray)\\n return my_arr\\n gray_codes = dfs(n)\\n integers = []\\n for thing in gray_codes :\\n integers.append(int(thing,2))\\n return integers\\n\",\n \"memory\": \"25200\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n input = ['0','1']\\n for i in range(2, n+1):\\n input = input+input[::-1]\\n print(\\\"First input == \\\", input)\\n for j in range((2**i)//2):\\n input[j]='0'+input[j]\\n print(\\\"Second input == \\\", input)\\n for j in range((2**i)//2,2**i):\\n input[j]='1'+input[j]\\n print(\\\"Third input == \\\", input)\\n def stringBin(index):\\n count = 0\\n out =0\\n for i in range(n-1, -1, -1):\\n if input[index][i] == '1':\\n out = out + (2**count)\\n count+=1\\n input[index]=out\\n print(input)\\n for i in range(2**n):\\n stringBin(i)\\n print(input)\\n return input\\n \",\n \"memory\": \"25300\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n grey = {\\n 1 : [0, 1],\\n 2 : [0, 1, 3, 2]\\n }\\n\\n def generate(n):\\n if n in grey: return grey[n]\\n prev = generate(n-1)\\n rev = list(reversed(prev))\\n for i in range(len(prev)):\\n rev[i] += 2**(n-1)\\n grey[n] = prev + rev\\n return grey[n]\\n \\n return generate(n)\\n \\n\",\n \"memory\": \"25400\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n gr_0 = [\\n 0, 1\\n ]\\n print(help(ge))\\n step = 2**0\\n for i in range(1, n):\\n step*=2\\n gr_1 = [g + step for g in gr_0[::-1]]\\n gr_0 = gr_0\\n gr_0 = gr_0 + gr_1\\n return gr_0\",\n \"memory\": \"25500\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n grey = {1: [0, 1], \\n 2: [0, 1, 3, 2], \\n 3: [0, 1, 3, 2, 6, 7, 5, 4], \\n 4: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8], \\n 5: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8, 24, 25, 27, 26, 30, 31, 29, 28, 20, 21, 23, 22, 18, 19, 17, 16], \\n 6: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8, 24, 25, 27, 26, 30, 31, 29, 28, 20, 21, 23, 22, 18, 19, 17, 16, 48, 49, 51, 50, 54, 55, 53, 52, 60, 61, 63, 62, 58, 59, 57, 56, 40, 41, 43, 42, 46, 47, 45, 44, 36, 37, 39, 38, 34, 35, 33, 32],\\n 7: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8, 24, 25, 27, 26, 30, 31, 29, 28, 20, 21, 23, 22, 18, 19, 17, 16, 48, 49, 51, 50, 54, 55, 53, 52, 60, 61, 63, 62, 58, 59, 57, 56, 40, 41, 43, 42, 46, 47, 45, 44, 36, 37, 39, 38, 34, 35, 33, 32, 96, 97, 99, 98, 102, 103, 101, 100, 108, 109, 111, 110, 106, 107, 105, 104, 120, 121, 123, 122, 126, 127, 125, 124, 116, 117, 119, 118, 114, 115, 113, 112, 80, 81, 83, 82, 86, 87, 85, 84, 92, 93, 95, 94, 90, 91, 89, 88, 72, 73, 75, 74, 78, 79, 77, 76, 68, 69, 71, 70, 66, 67, 65, 64],\\n 8: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8, 24, 25, 27, 26, 30, 31, 29, 28, 20, 21, 23, 22, 18, 19, 17, 16, 48, 49, 51, 50, 54, 55, 53, 52, 60, 61, 63, 62, 58, 59, 57, 56, 40, 41, 43, 42, 46, 47, 45, 44, 36, 37, 39, 38, 34, 35, 33, 32, 96, 97, 99, 98, 102, 103, 101, 100, 108, 109, 111, 110, 106, 107, 105, 104, 120, 121, 123, 122, 126, 127, 125, 124, 116, 117, 119, 118, 114, 115, 113, 112, 80, 81, 83, 82, 86, 87, 85, 84, 92, 93, 95, 94, 90, 91, 89, 88, 72, 73, 75, 74, 78, 79, 77, 76, 68, 69, 71, 70, 66, 67, 65, 64, 192, 193, 195, 194, 198, 199, 197, 196, 204, 205, 207, 206, 202, 203, 201, 200, 216, 217, 219, 218, 222, 223, 221, 220, 212, 213, 215, 214, 210, 211, 209, 208, 240, 241, 243, 242, 246, 247, 245, 244, 252, 253, 255, 254, 250, 251, 249, 248, 232, 233, 235, 234, 238, 239, 237, 236, 228, 229, 231, 230, 226, 227, 225, 224, 160, 161, 163, 162, 166, 167, 165, 164, 172, 173, 175, 174, 170, 171, 169, 168, 184, 185, 187, 186, 190, 191, 189, 188, 180, 181, 183, 182, 178, 179, 177, 176, 144, 145, 147, 146, 150, 151, 149, 148, 156, 157, 159, 158, 154, 155, 153, 152, 136, 137, 139, 138, 142, 143, 141, 140, 132, 133, 135, 134, 130, 131, 129, 128]}\\n\\n def generate(n):\\n if n in grey: return grey[n]\\n prev = generate(n-1)\\n rev = list(reversed(prev))\\n for i in range(len(prev)):\\n rev[i] += 2**(n-1)\\n grey[n] = prev + rev\\n return grey[n]\\n \\n return generate(n)\\n \\n\",\n \"memory\": \"25600\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n # 2^n numbers, so bit length n \\n # 0000 0001 0011.. 1000 \\n # 000 100 110 010 011 111 101 001 \\n # 0 4 6 2 3 7 5 1\\n # 00 10 11 01\\n # 0000 1000 1100 0100 0110 1110 \\n\\n def toBinary(s):\\n k = len(s) -1\\n ans = 0\\n for bit in s:\\n ans += int(bit) * (2**k)\\n k-=1\\n return ans\\n \\n\\n '''\\n s = \\\"000\\\"\\n ret = [0]\\n termination = 001\\n new_s = 100\\n '''\\n ret = []\\n seen = set()\\n s = \\\"\\\".join([\\\"0\\\" for i in range(n)])\\n ret.append(toBinary(s))\\n seen.add(s)\\n termination = s[:-1] + \\\"1\\\"\\n while True: \\n if s == termination:\\n break \\n for i in range(len(s)):\\n new_s = s[:i] + str(1-int(s[i])) + s[i+1:]\\n if new_s in seen:\\n continue\\n else:\\n s = new_s\\n seen.add(s)\\n ret.append(toBinary(s))\\n break\\n return ret\\n \\n\\n\\n \\n\\n\",\n \"memory\": \"25800\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n # backtracking\\n n -= 1\\n curr = ['0','1']\\n\\n while n:\\n n -= 1\\n res = []\\n for i in range(len(curr)):\\n res.append('0' + curr[i])\\n \\n for i in range(len(curr) - 1, -1, -1):\\n res.append('1' + curr[i])\\n \\n curr = res[:]\\n \\n\\n def backtoint(s):\\n ans = 0\\n s = s[::-1]\\n for i in range(len(s)):\\n ans += (2**(i)) * int(s[i])\\n return ans\\n\\n final = [backtoint(s) for s in curr]\\n return final\",\n \"memory\": \"25900\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n def get_bin_rep(input_str) -> int:\\n print(input_str)\\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\\n\\n last_val = [\\\"0\\\", \\\"1\\\"]\\n\\n for i in range(2, n+1):\\n \\n options = last_val\\n zero_options = [f\\\"0{i}\\\" for i in options] \\n one_options = [f\\\"1{i}\\\" for i in options[::-1]]\\n options = zero_options + one_options\\n last_val = options\\n\\n \\n return [get_bin_rep(i) for i in last_val]\",\n \"memory\": \"26000\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n def get_bin_rep(input_str) -> int:\\n print(input_str)\\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\\n\\n last_val = [\\\"0\\\", \\\"1\\\"]\\n\\n for i in range(2, n+1):\\n \\n zero_options = [f\\\"0{i}\\\" for i in last_val] \\n one_options = [f\\\"1{i}\\\" for i in last_val[::-1]]\\n last_val = zero_options + one_options\\n\\n \\n return [get_bin_rep(i) for i in last_val]\",\n \"memory\": \"26000\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n def get_bin_rep(input_str) -> int:\\n print(input_str)\\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\\n\\n last_val = [\\\"0\\\", \\\"1\\\"]\\n\\n for i in range(2, n+1):\\n \\n options = last_val\\n zero_options = [f\\\"0{i}\\\" for i in options] \\n one_options = [f\\\"1{i}\\\" for i in options[::-1]]\\n options = zero_options + one_options\\n last_val = options\\n\\n \\n return [get_bin_rep(i) for i in last_val]\",\n \"memory\": \"26100\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n code_strs = self.gray_code_seq(\\\"0\\\" * n)\\n return [int(s, 2) for s in code_strs]\\n \\n def gray_code_seq(self, start_code: str) -> List[str]:\\n if len(start_code) == 0:\\n return [\\\"\\\"]\\n else:\\n curr, next_code = start_code[0], start_code[1:]\\n code = []\\n if curr == \\\"0\\\":\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"0\\\" + s for s in next_code_seq])\\n next_code = next_code_seq[-1]\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"1\\\" + s for s in next_code_seq])\\n else:\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"1\\\" + s for s in next_code_seq])\\n next_code = next_code_seq[-1]\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"0\\\" + s for s in next_code_seq])\\n\\n return code\\n \\n\",\n \"memory\": \"26500\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n if n < 1:\\n return []\\n if n < 2:\\n return [0, 1]\\n f = self.grayCode\\n prev = f(n - 1)\\n ret1, ret2 = [], []\\n for e in prev:\\n ret1.append(bin(e)[2:] + '0')\\n ret2.append(bin(e)[2:] + '1')\\n return list(map(lambda x: int(x, 2), ret1 + ret2[::-1]))\",\n \"memory\": \"26600\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n if n < 1:\\n return []\\n if n < 2:\\n return [0, 1]\\n f = self.grayCode\\n prev = f(n - 1)\\n ret1, ret2 = [], []\\n for e in prev:\\n ret1.append(bin(e)[2:] + '0')\\n ret2.append(bin(e)[2:] + '1')\\n return list(map(lambda x: int(x, 2), ret1 + ret2[::-1]))\",\n \"memory\": \"26800\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n twobit = [\\\"00\\\", \\\"01\\\", \\\"11\\\", \\\"10\\\"]\\n\\n def gray(n):\\n if n==1: return [\\\"0\\\", \\\"1\\\"]\\n if n==2: return twobit\\n\\n old = gray(n-1)\\n ref = [\\\"1\\\" + x for x in old[::-1]]\\n\\n old = [\\\"0\\\" + x for x in old]\\n\\n return old+ ref\\n print(gray(n))\\n return list(map(lambda x: int(x, 2), gray(n)))\\n\\n\\n\",\n \"memory\": \"26900\"\n },\n {\n \"code\": \"class Solution:\\n \\n \\n def grayCode(self, n: int) -> List[int]:\\n \\n def helper(n):\\n \\n if(n==1):\\n return [\\\"0\\\",\\\"1\\\"]\\n \\n x=helper(n-1)\\n res=[]\\n print(n, x)\\n for i in range(len(x)):\\n s=x[i]\\n res.append(\\\"0\\\"+s)\\n print(n, res) \\n for i in range(len(x)-1,-1,-1):\\n s=x[i]\\n res.append(\\\"1\\\"+s)\\n print(n, res)\\n return res\\n \\n res=helper(n)\\n fres=[]\\n for i in res:\\n fres.append(int(i,2))\\n return fres \\n \",\n \"memory\": \"27600\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n grey_codes = self.generate_grey_code(n-1, [\\\"0\\\",\\\"1\\\"])\\n #print(grey_codes)\\n return [int(each, 2) for each in grey_codes]\\n\\n def generate_grey_code(self, n, grey_codes):\\n if n == 0:\\n return grey_codes\\n else:\\n l1 = [each+\\\"0\\\" for each in grey_codes]\\n l2 = [each+\\\"1\\\" for each in grey_codes[::-1]]\\n return self.generate_grey_code(n-1, l1+l2)\",\n \"memory\": \"27800\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n lst = [[0, 1]]\\n\\n def maker(n):\\n a = []\\n for i in range(n//2):\\n a.append(0)\\n i = n/2\\n while i < n:\\n a.append(1)\\n i+=1\\n return a\\n\\n def join(a, b):\\n for i in b:\\n a.append(i)\\n return a\\n\\n def reverse(a):\\n o = []\\n\\n i = len(a)-1\\n\\n while i >=0:\\n o.append(a[i])\\n i -= 1\\n return o\\n\\n for i in range(n-1):\\n for ii in range(len(lst)):\\n lst[ii] = join(lst[ii], reverse(lst[ii]))\\n a = maker(len(lst[ii]))\\n lst.append(a)\\n\\n out = []\\n \\n for i in range(len(lst[0])):\\n a = 0\\n for ii in range(len(lst)):\\n if lst[ii][i] == 1:\\n a += 2 ** ii\\n out.append(a)\\n return out\\n \",\n \"memory\": \"28600\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]: \\n dict = {}\\n dict[1] = [0,1]\\n def dp(n):\\n if n in dict:\\n return dict[n]\\n ans = []\\n for num in dp(n-1):\\n ans.append(num *2)\\n for num in dp(n-1)[::-1]:\\n ans.append(num*2 +1)\\n dict[n] = ans\\n return ans\\n return dp(n)\\n\\n\\n \",\n \"memory\": \"28900\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n code_strs = self.gray_code_seq(\\\"0\\\" * n)\\n print(code_strs)\\n return [int(s, 2) for s in code_strs]\\n \\n def gray_code_seq(self, start_code: str) -> List[str]:\\n if len(start_code) == 0:\\n return [\\\"\\\"]\\n else:\\n print(start_code)\\n curr, next_code = start_code[0], start_code[1:]\\n code = []\\n if curr == \\\"0\\\":\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"0\\\" + s for s in next_code_seq])\\n next_code = next_code_seq[-1]\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"1\\\" + s for s in next_code_seq])\\n else:\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"1\\\" + s for s in next_code_seq])\\n next_code = next_code_seq[-1]\\n next_code_seq = self.gray_code_seq(next_code)\\n code.extend([\\\"0\\\" + s for s in next_code_seq])\\n\\n return code\\n \\n\",\n \"memory\": \"29200\"\n },\n {\n \"code\": \"class Solution:\\n @cache\\n def grayCode(self, n: int) -> List[int]:\\n if n < 1:\\n return []\\n if n < 2:\\n return [0, 1]\\n f = self.grayCode\\n prev = f(n - 1)\\n ret1, ret2 = [], []\\n for e in prev:\\n ret1.append(bin(e)[2:] + '0')\\n ret2.append(bin(e)[2:] + '1')\\n return list(map(lambda x: int(x, 2), ret1 + ret2[::-1]))\",\n \"memory\": \"29600\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n def get_bin_rep(input_str) -> int:\\n print(input_str)\\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\\n\\n return_dict = {1:[\\\"0\\\", \\\"1\\\"]}\\n\\n for i in range(2, n+1):\\n \\n options = return_dict.get(i-1)\\n zero_options = [f\\\"0{i}\\\" for i in options] \\n one_options = [f\\\"1{i}\\\" for i in options[::-1]]\\n options = zero_options + one_options\\n return_dict[i] = options\\n\\n \\n return [get_bin_rep(i) for i in return_dict[n]]\",\n \"memory\": \"29800\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.codes = [[\\\"0\\\", \\\"1\\\"]]\\n for i in range(2, 17):\\n codes = self.codes[i - 2]\\n new = list()\\n for c in codes:\\n new.append(c+\\\"0\\\")\\n for c in codes[::-1]:\\n new.append(c+\\\"1\\\")\\n self.codes.append(new)\\n\\n def grayCode(self, n: int) -> List[int]:\\n return list(map(lambda x: int(x, 2), self.codes[n - 1]))\",\n \"memory\": \"30000\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n def get_bin_rep(input_str) -> int:\\n print(input_str)\\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\\n\\n return_dict = {1:[\\\"0\\\", \\\"1\\\"]}\\n\\n for i in range(2, n+1):\\n \\n options = return_dict.get(i-1)\\n zero_options = [f\\\"0{i}\\\" for i in options] \\n one_options = [f\\\"1{i}\\\" for i in options[::-1]]\\n options = zero_options + one_options\\n return_dict[i] = options\\n\\n \\n return [get_bin_rep(i) for i in return_dict[n]]\",\n \"memory\": \"30200\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n def get_bin_rep(input_str) -> int:\\n print(input_str)\\n return sum([(2**int(len(input_str)-i-1)) * int(input_str[i]) for i in range(len(input_str))])\\n\\n return_dict = {1:[\\\"0\\\", \\\"1\\\"]}\\n\\n for i in range(2, n+1):\\n \\n options = return_dict.get(i-1)\\n zero_options = [f\\\"0{i}\\\" for i in options] \\n one_options = [f\\\"1{i}\\\" for i in options[::-1]]\\n options = zero_options + one_options\\n return_dict[i] = options\\n\\n \\n return [get_bin_rep(i) for i in return_dict[n]]\",\n \"memory\": \"30200\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n ans = [\\\"0\\\"]\\n for i in range(n):\\n next_ans = ans.copy()\\n for x in ans[::-1]:\\n next_ans.append(\\\"1\\\" + x[1:])\\n ans = [\\\"0\\\" + x for x in next_ans]\\n return [int(x, 2) for x in next_ans]\",\n \"memory\": \"30500\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def biDec(bi):\\n dec = 0\\n for i in range(len(bi)):\\n dec += bi[i] * pow(2, i)\\n return dec\\n\\n cur = [tuple([0] * n)]\\n \\n j = 0\\n while j < n:\\n l = len(cur)\\n for i in range(l-1, -1, -1):\\n cu = list(cur[i])\\n cu[j] = 1\\n cur.append(tuple(cu))\\n j += 1\\n \\n ans = []\\n for bi in cur:\\n ans.append(biDec(bi))\\n\\n return ans \",\n \"memory\": \"31100\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n r = []\\n array = [ False for _ in range(n) ] \\n i = 2**n # number of iterations\\n offset = i//2 \\n\\n for x in range(i):\\n # val = val if (x+1)%2 else not val\\n # val = val if (x+2)%4 else not val\\n # val = val if (x+4)%8 else not val \\n\\n val = i\\n for j in range(n):\\n array[j] = array[j] if (x+val//2)%val else not array[j]\\n val//=2\\n\\n r.append(array[:])\\n \\n return [ int('0b' + ''.join([ str(int(x)) for x in item ]),2) for item in r ]\\n\\n # iter = 1 * 2\\n # 0 \\n # 1\\n\\n # iter = 1 * 2 * 2\\n # 0 0\\n # 0 1\\n # 1 1\\n # 1 0\\n \\n # iter = 1 * 2 * 2 * 2\\n # 0 0 0 x = 1 \\n # 0 0 1 x = 2\\n # 0 1 1 x = 3\\n # 0 1 0\\n # 1 1 0\\n # 1 1 1\\n # 1 0 1\\n # 1 0 0\",\n \"memory\": \"31900\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n r = []\\n array = [ False for _ in range(n) ] \\n i = 2**n \\n offset = i//2 \\n\\n for x in range(i):\\n\\n val = i\\n for j in range(n):\\n array[j] = array[j] if (x+val//2)%val else not array[j]\\n val//=2\\n\\n r.append(array[:])\\n \\n return [ int('0b' + ''.join([ str(int(x)) for x in item ]),2) for item in r ]\\n\\n\",\n \"memory\": \"31900\"\n },\n {\n \"code\": \"import math\\n\\nlog = math.log\\n\\n\\nclass Solution(object):\\n def grayCode(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: List[int]\\n \\\"\\\"\\\"\\n\\n # [[0]]\\n # [[1]]\\n #\\n\\n bnums = [[0], [1]]\\n\\n if n != 1:\\n for i in range(n - 1):\\n for j in range(len(bnums) - 1, -1, -1):\\n bnums.append(bnums[j].copy())\\n for j in range(int(len(bnums) / 2)):\\n bnums[j].insert(0, 0)\\n for j in range(int(len(bnums) / 2), len(bnums)):\\n bnums[j].insert(0, 1)\\n\\n for i in range(len(bnums)):\\n dnum = 0\\n for b in range(n):\\n if bnums[i][b]:\\n dnum += pow(2, b)\\n bnums[i] = dnum\\n\\n # print(bnums)\\n return bnums\\n\\n\\n# 0,0\\n# ^\\n# 0,1\\n# ^\\n# 1,1\\n# ^\\n# 1,0\\n# ^\\n#\\n\",\n \"memory\": \"32600\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n self.n = n \\n self.result = [0]\\n self.visited = set([0])\\n self.generate_gray_code(0)\\n return self.result\\n\\n def generate_gray_code(self, num):\\n if len(self.result) == 2**self.n:\\n return True\\n for i in range(self.n):\\n next_num = num ^ (1 << i)\\n if next_num not in self.visited:\\n self.result.append(next_num)\\n self.visited.add(next_num)\\n \\n if self.generate_gray_code(next_num):\\n return True\\n \\n self.result.pop()\\n self.visited.remove(next_num)\\n return False\\n \",\n \"memory\": \"32900\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n def backtracking(track):\\n if len(track) == (1 << n):\\n self.res = track\\n return True\\n # flip one bit\\n # for each bit/pos in binary representation\\n for pos in range(n):\\n nxt = track[-1] ^ (1 << pos) #xor one bit\\n if not used[nxt]:\\n used[nxt] = True\\n track.append(nxt)\\n if backtracking(track):\\n return True\\n track.pop()\\n used[nxt] = False\\n return False\\n \\n self.res = []\\n used = [False] * (1<<n)\\n used[0] = True\\n backtracking([0])\\n return self.res\",\n \"memory\": \"33000\"\n },\n {\n \"code\": \"from copy import deepcopy\\n\\nclass Solution:\\n debugging = True\\n\\n def get_num_bits_diff(self, a: int, b: int) -> int:\\n '''Return the number of bits that a and b differ by'''\\n ab_xor = a ^ b\\n if ab_xor == 0:\\n return 0\\n \\n one_count = 0\\n while ab_xor > 0:\\n if ab_xor % 2 == 1:\\n one_count += 1\\n ab_xor = ab_xor >> 1\\n return one_count\\n\\n def backtracking_approach(self, n: int) -> List[int]:\\n '''Try backtracking until we get a valid sequence\\n pg 53: the alternative is trying to inductively notice a pattern from small n'''\\n first_gray_code_seen = []\\n\\n def recur(cur_sequence: List[int], visited: List[bool]) -> bool:\\n if self.debugging:\\n print(f'{cur_sequence=}')\\n if len(cur_sequence) == 2**n:\\n first_last_bit_diff = self.get_num_bits_diff(cur_sequence[0], cur_sequence[-1])\\n if first_last_bit_diff == 1:\\n if self.debugging:\\n print(f'\\\\tis a Gray code')\\n first_gray_code_seen.extend(cur_sequence)\\n return True\\n else:\\n if self.debugging:\\n print(f'\\\\tnot a Gray code because {first_last_bit_diff=}')\\n \\n for i in range(2**n):\\n if visited[i]:\\n continue\\n bit_diff_w_last = self.get_num_bits_diff(i, cur_sequence[-1])\\n if bit_diff_w_last != 1:\\n continue\\n \\n visited[i] = True # Try adding i to the sequence\\n found_gray_code = recur(cur_sequence + [i], visited)\\n if found_gray_code:\\n return True\\n visited[i] = False # If we get here, then this branch didn't work\\n \\n if self.debugging:\\n print(f'\\\\tfailed to lead to any Gray codes')\\n return False # None of the possibilities worked\\n\\n recur([0], [True if i == 0 else False for i in range(2**n)])\\n return first_gray_code_seen\\n\\n def check(self, gray_code: List[int]):\\n '''For debugging purposes, check bit diffs between the output of the above function\\n Don't forget to check bit diff between the first and the last'''\\n bit_diffs = []\\n for i in range(1, len(gray_code)):\\n bit_diffs.append(self.get_num_bits_diff(gray_code[i], gray_code[i-1]))\\n bit_diffs.append(self.get_num_bits_diff(gray_code[0], gray_code[-1]))\\n print(f'{bit_diffs=}')\\n\\n def reverse_and_prepend(self, n: int) -> List[List[int]]:\\n '''Much faster method to generate an n-bit Gray code:\\n Take the n-1 bit Gray code, append a reversed version of it\\n Then, prepend 0 to the original half, 1 to the reversed half'''\\n cur_gray_code = [[0], [1]]\\n for i in range(2, n+1):\\n half_to_append = deepcopy(list(reversed(cur_gray_code)))\\n for h in half_to_append:\\n h.append(1)\\n for c in cur_gray_code:\\n c.append(0)\\n cur_gray_code.extend(half_to_append)\\n if self.debugging:\\n print(f'{i=}, {cur_gray_code=}')\\n return cur_gray_code\\n\\n \\n def reversed_binary_to_int(self, reversed_digits: List[int]) -> int:\\n '''Convert binary number (given as least-to-most significant digits) to an int'''\\n int_repr = 0\\n for i in range(len(reversed_digits)):\\n int_repr += reversed_digits[i] * 2**(i)\\n return int_repr\\n\\n\\n def grayCode(self, n: int) -> List[int]:\\n self.debugging = False\\n # return self.backtracking_approach(n)\\n reversed_gray_code_bits = self.reverse_and_prepend(n)\\n return [self.reversed_binary_to_int(bits) for bits in reversed_gray_code_bits]\",\n \"memory\": \"33400\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res = [0]\\n\\n def helper(visited):\\n if len(res) == (1 << n):\\n return True\\n for i in range(n):\\n num = (1 << i) ^ res[-1]\\n if num not in visited:\\n visited.add(num)\\n res.append(num)\\n if helper(visited):\\n return True\\n visited.remove(num)\\n res.pop()\\n\\n helper({0})\\n return res\\n\",\n \"memory\": \"33900\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def grayCode(self, n: int) -> List[int]:\\n # return gray code of length n, in binary encoding\\n def gc(n):\\n if n == 1:\\n return np.array([0, 1])\\n sub = gc(n - 1)\\n return np.concat((sub, 2**(n-1) + sub[::-1]))\\n return gc(n)\\n\\n\\n\",\n \"memory\": \"34100\"\n },\n {\n \"code\": \"class Solution:\\n\\n def __init__(self):\\n self.res = []\\n self.path = []\\n self.used = set()\\n\\n def grayCode(self, n: int) -> List[int]:\\n if n < 0: return self.res\\n self.dfs(n, 0)\\n return self.res[0]\\n \\n def dfs(self, n: int, num:int):\\n if self.res: # there is one valid res, return\\n return\\n \\n if len(self.path) == (1 << n): # path has 2^n element, found a res\\n self.res.append(self.path[:])\\n return\\n \\n if num in self.used: # num visited\\n return\\n\\n self.path.append(num) # dfs, add node now\\n self.used.add(num)\\n\\n for i in range(n):\\n onediff = self.flipbit(num, i)\\n self.dfs(n, onediff)\\n\\n self.path.pop() # dfs, revert node now\\n self.used.remove(num)\\n\\n def flipbit(self, num:int, pos: int) -> int:\\n return num ^ (1 << pos) \\n\",\n \"memory\": \"34400\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n res = [0]\\n def dfs(visited):\\n if len(res) == 2 ** n and bin((res[0] ^ res[-1])).count('1') == 1:\\n return res\\n else:\\n for i in range(n):\\n num = res[-1] ^ (1 << i) # get next number\\n if num not in visited:\\n res.append(num)\\n visited.add(num)\\n if dfs(visited):\\n return res\\n res.pop()\\n visited.remove(num)\\n return False\\n\\n return dfs({0})\\n\",\n \"memory\": \"34500\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n \\n def backtracking(track, curr):\\n if len(self.res) != 0:\\n return True\\n if used[curr]:\\n return False\\n if len(track) == (1 << n) - 1:\\n self.res = track + [curr]\\n return True\\n track.append(curr)\\n used[curr] = True\\n # flip one bit for each pos\\n for pos in range(n):\\n nxt = curr ^ (1 << pos) #xor one bit\\n if backtracking(track, nxt):\\n return True\\n track.pop()\\n used[curr] = False\\n return False\\n \\n self.res = []\\n used = [False] * (1<<n)\\n backtracking([], 0)\\n return self.res\",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n# The binary representation of the first and last integers differs by exactly one bit.\\n# and\\n# The first integer is 0\\n# so\\n# the last integer is a power of 2\\n\\\"\\\"\\\"\\nclass Solution:\\n def grayCode(self, n: int) -> List[int]:\\n seq = [0]\\n visited = set([0])\\n\\n def dfs():\\n # print(seq)\\n if len(seq) == 2**n:\\n return True\\n \\n for i in range(n):\\n # wheter the integer differs by exactly one bit (from last inserted num)\\n if seq[-1] & 2**i:\\n # already set, remove that bit\\n next_num = seq[-1] - 2**i # improve this\\n else:\\n next_num = seq[-1] | 2**i\\n if next_num not in visited:\\n seq.append(next_num)\\n visited.add(next_num)\\n if dfs():\\n # found\\n return True\\n visited.remove(next_num)\\n seq.pop()\\n\\n return False\\n\\n dfs()\\n return seq\\n \\n def _differ_by_exactly_one_bit(self, int1, int2):\\n c = 0\\n\\n for i in range(16):\\n if int1 & 2**i != int2 & 2**i:\\n c += 1\\n \\n return c == 1\\n # find difference bit(s)\\n # check if difference is power of 2\\n\\n\\n\\\"\\\"\\\"\\n000000 -> \\n\\\"\\\"\\\"\\n\\n# [0,1,3,2,6,7,5,4,12,13,15,14,10,11,9,8]\\n# [0,1,3,2,6,7,5,4,12,13,15,14,10,11,9,8,24,25,27,26,30,31,29,28,20,21,23,22,18,19,17,16,48,49,51,50,54,55,53,52,60,61,63,62,58,59,57,56,40,41,43,42,46,47,45,44,36,37,39,38,34,35,33,32]\",\n \"memory\": \"34800\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n# The binary representation of the first and last integers differs by exactly one bit.\\n# and\\n# The first integer is 0\\n# so\\n# the last integer is a power of 2\\n\\\"\\\"\\\"\\nclass Solution:\\n def grayCode(self, n: int) -> List[int]:\\n seq = [0]\\n visited = set([0])\\n\\n def dfs():\\n # print(seq)\\n # initially: and self._differ_by_exactly_one_bit(seq[-1], 0)\\n # but it work even without it\\n # yeah, because only 1 sequence is possible?\\n if len(seq) == 2**n:\\n return True\\n \\n for i in range(n):\\n # wheter the integer differs by exactly one bit (from last inserted num)\\n if seq[-1] & 2**i:\\n # already set, remove that bit\\n next_num = seq[-1] - 2**i # improve this\\n else:\\n next_num = seq[-1] | 2**i\\n if next_num not in visited:\\n seq.append(next_num)\\n visited.add(next_num)\\n if dfs():\\n # found\\n return True\\n visited.remove(next_num)\\n seq.pop()\\n\\n return False\\n\\n dfs()\\n return seq\",\n \"memory\": \"34800\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n def backtrack(current, used):\\n if len(result) == 1 << n:\\n if (1 << n) - 1 in result:\\n return True\\n else:\\n return False\\n \\n for i in range(n):\\n next_num = current ^ (1 << i)\\n if next_num not in used:\\n used.add(next_num)\\n result.append(next_num)\\n if backtrack(next_num, used):\\n return True\\n result.pop()\\n used.remove(next_num)\\n return False\\n \\n result = [0]\\n used = set([0])\\n backtrack(0, used)\\n return result\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.grayCode(2)) # Output: [0, 1, 3, 2]\\nprint(solution.grayCode(1)) # Output: [0, 1]\",\n \"memory\": \"34900\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result\",\n \"memory\": \"35000\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result\",\n \"memory\": \"35100\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> list[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result \",\n \"memory\": \"35100\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n result = [0]\\n visited = set([0])\\n\\n def generateGrayCode(num):\\n if len(result) == 2 ** n:\\n return True\\n for i in range(n):\\n next_num = num ^ (1 << i)\\n\\n if next_num not in visited:\\n result.append(next_num)\\n visited.add(next_num)\\n\\n if generateGrayCode(next_num):\\n return True\\n\\n result.pop()\\n visited.remove(next_num)\\n return False\\n\\n generateGrayCode(0)\\n return result\\n\\n \",\n \"memory\": \"35200\"\n },\n {\n \"code\": \"class Solution:\\n def grayCode(self, n: int) -> List[int]:\\n\\n def dfs(val: int):\\n if val not in visited:\\n res.append(val)\\n visited.add(val)\\n for i in range(n):\\n t = val ^ (1 << i)\\n if t not in visited:\\n res.append(t)\\n visited.add(t)\\n dfs(t)\\n break\\n \\n\\n res, visited = [], set()\\n dfs(0)\\n return res\\n \",\n \"memory\": \"35300\"\n },\n {\n \"code\": \"# class Solution:\\n# def grayCode(self, n: int) -> List[int]:\\n\\n# TARGET = 2**n\\n\\n# result = []\\n# def dfs(running_list, running_set, last_int):\\n# if len(result):\\n# return\\n# if len(running_list) == TARGET:\\n# if (last_int & (last_int-1) == 0) and last_int != 0:\\n# result.append(running_list)\\n# return\\n# for i in range(n):\\n# new_int = (2**i) ^ last_int\\n# if new_int in running_set:\\n# continue\\n# else:\\n# running_set.add(new_int)\\n# dfs(running_list+[new_int], running_set, new_int)\\n# running_set.remove(new_int)\\n# dfs([0], set([0]), 0)\\n# return result[0]\\n\\nclass Solution:\\n def grayCode(self, n: int):\\n result = [0]\\n isPresent = {0}\\n self.grayCodeHelper(result, n, isPresent)\\n return result\\n\\n def grayCodeHelper(self, result, n, isPresent):\\n if len(result) == (1 << n):\\n return True\\n current = result[-1]\\n for i in range(n):\\n nextNum = current ^ (1 << i)\\n if nextNum not in isPresent:\\n isPresent.add(nextNum)\\n result.append(nextNum)\\n if self.grayCodeHelper(result, n, isPresent):\\n return True\\n isPresent.remove(nextNum)\\n result.pop()\\n return False\",\n \"memory\": \"35400\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":73,"string":"73"}}},{"rowIdx":44,"cells":{"question_id":{"kind":"number","value":90,"string":"90"},"name":{"kind":"string","value":"subsets-ii"},"content":{"kind":"string","value":"<p>Given an integer array <code>nums</code> that may contain duplicates, return <em>all possible</em> <span data-keyword=\"subset\"><em>subsets</em></span><em> (the power set)</em>.</p>\n\n<p>The solution set <strong>must not</strong> contain duplicate subsets. Return the solution in <strong>any order</strong>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<pre><strong>Input:</strong> nums = [1,2,2]\n<strong>Output:</strong> [[],[1],[1,2],[1,2,2],[2],[2,2]]\n</pre><p><strong class=\"example\">Example 2:</strong></p>\n<pre><strong>Input:</strong> nums = [0]\n<strong>Output:</strong> [[],[0]]\n</pre>\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 10</code></li>\n\t<li><code>-10 <= nums[i] <= 10</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":58.086000411027605,"string":"58.086"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","backtracking","bit-manipulation"],"string":"[\n \"array\",\n \"backtracking\",\n \"bit-manipulation\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16\", 0.0139], [\"17\", 0.0069], [\"18\", 0.0139], [\"19\", 0.0277], [\"20\", 0.0277], [\"21\", 0.0208], [\"22\", 0.1247], [\"23\", 0.1317], [\"24\", 0.3327], [\"25\", 0.1733], [\"26\", 0.5891], [\"27\", 0.5267], [\"28\", 1.0673], [\"29\", 1.0257], [\"30\", 1.9683], [\"31\", 1.8296], [\"32\", 3.2019], [\"33\", 3.2573], [\"34\", 4.1722], [\"35\", 3.6177], [\"36\", 6.3067], [\"37\", 6.6671], [\"38\", 6.5562], [\"39\", 5.6761], [\"40\", 7.1107], [\"41\", 7.5473], [\"42\", 7.0067], [\"43\", 5.3088], [\"44\", 5.1563], [\"45\", 4.5533], [\"46\", 3.6039], [\"47\", 3.2851], [\"48\", 2.2316], [\"49\", 1.393]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16100\", 0.0139], [\"16300\", 0.0139], [\"16400\", 0.0832], [\"16500\", 2.4742], [\"16600\", 18.5668], [\"16700\", 32.5178], [\"16800\", 34.6663]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = [[]]\n nums.sort()\n memory = {i: 0 for i in set(nums)}\n \n for num in nums:\n end = len(res)\n for s in res[memory[num] : end]: \n res.append(s + [num])\n memory[num] = end\n \n return res","runtime":"16"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n if not nums:\n return []\n nums = sorted(nums)\n res = []\n self.dfs(nums, 0, [], res)\n return res \n \n def dfs(self, nums, startIndex, subset, res):\n res.append(subset[:])\n\n for i in range(startIndex, len(nums)):\n if i > startIndex and nums[i] == nums[i-1]:\n continue \n subset.append(nums[i])\n self.dfs(nums, i+1, subset, res)\n subset.pop()\n ","runtime":"17"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n def combos(idx,arr,stack,res):\n res.append(stack.copy()) \n\n for i in range(idx,len(arr)):\n if i>idx and arr[i]==arr[i-1]:\n continue\n stack.append(arr[i])\n combos(i+1,arr,stack,res)\n stack.pop()\n \n\n res = []\n nums.sort()\n combos(0,nums,[],res)\n\n return res","runtime":"18"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n ans={}\n nums.sort()\n \n def solve(i, arr):\n ans[\"*\".join(map(str,arr))]=arr\n if i>=len(nums):\n return\n for j in range(i, len(nums)):\n solve(j+1, arr+[nums[j]])\n solve(0,[])\n return ans.values()\n","runtime":"19"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n \n res = []\n\n nums.sort()\n\n def backtrack(i, curr):\n if i == len(nums):\n res.append(curr[:])\n return\n\n curr.append(nums[i])\n\n backtrack(i+1, curr)\n curr.pop()\n\n while i + 1 < len(nums) and nums[i] == nums[i+1]:\n i += 1\n\n backtrack(i+1, curr)\n\n backtrack(0, [])\n\n return res","runtime":"20"},{"code":"class Solution:\n def generate(self, ind, subArr, nums, res):\n res.append(subArr[:])\n for i in range (ind, len(nums)):\n if(i > ind and nums[i] == nums[i - 1]):\n continue\n subArr.append(nums[i])\n self.generate(i + 1, subArr, nums, res)\n subArr.pop()\n\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n self.generate(0, [], nums, res)\n return res\n","runtime":"21"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n # Sort the array to group duplicates together\n nums.sort()\n \n result = []\n \n def backtrack(subset, start):\n # Add the current subset to the result\n result.append(subset[:])\n \n for i in range(start, len(nums)):\n # Skip duplicates to avoid duplicate subsets\n if i > start and nums[i] == nums[i-1]:\n continue\n # Include the current element in the subset\n subset.append(nums[i])\n # Explore further with the current element included\n backtrack(subset, i + 1)\n # Remove the current element from the subset to backtrack\n subset.pop()\n \n backtrack([], 0)\n return result\n\n# Example usage:\nsolution = Solution()\nnums = [1, 2, 2]\nprint(solution.subsetsWithDup(nums)) # Output: [[], [1], [1, 2], [1, 2, 2], [2], [2, 2]]","runtime":"22"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n \n nums.sort()\n ans = [[]]\n memory = {i: 0 for i in set(nums)}\n \n for i in nums:\n l = len(ans)\n for s in ans[memory[i]:l]: ans.append(s+[i])\n memory[i] = l\n \n return ans","runtime":"23"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n \n def backtracking(i, subset):\n if i == len(nums):\n res.append(subset.copy())\n return\n\n # All subsets that include the nums[i]\n subset.append(nums[i])\n backtracking(i+1, subset)\n subset.pop()\n\n # All subsets that do not include nums[i]\n while i+1 < len(nums) and nums[i] == nums[i+1]:\n i += 1 \n backtracking(i+1, subset)\n \n backtracking(0,[])\n return res\n ","runtime":"24"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n return self._subsetsWithDup(sorted(nums))\n \n def _subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n if len(nums) == 0:\n return [[]]\n\n n = nums.pop()\n subsets = self._subsetsWithDup(nums[:])\n if n in nums:\n return subsets + [subset + [n] for subset in subsets if subset + [n] not in subsets]\n return subsets + [subset + [n] for subset in subsets]\n","runtime":"25"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n\n nums.sort() \n subsets = [] \n curr = [] \n\n self.dfs(subsets, curr, nums,0)\n\n return subsets\n \n def dfs(self, subsets, curr, nums, index):\n subsets.append(list(curr))\n\n for i in range(index, len(nums)):\n if i !=index and nums[i]==nums[i-1]:\n continue \n curr.append(nums[i])\n self.dfs(subsets, curr, nums, i+1)\n curr.pop()\n \n ","runtime":"26"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n nums.sort()\n res = []\n def backTrack(start, path):\n res.append(path[:])\n for i in range(start, len(nums)):\n if not (i>start and nums[i] == nums[i-1]):\n path.append(nums[i])\n backTrack(i+1, path)\n path.pop()\n backTrack(0, [])\n return res","runtime":"26"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n\n nums.sort() \n\n curr = [] \n ans = []\n\n self.dfs(curr, ans, nums, 0)\n\n return ans \n \n def dfs(self, curr, ans, nums, index):\n ans.append(list(curr))\n\n for i in range(index, len(nums)):\n if i!= index and nums[i]==nums[i-1]:\n continue \n \n curr.append(nums[i])\n self.dfs(curr, ans, nums, i+1)\n curr.pop()\n \n\n ","runtime":"27"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n def dfs(idx, path):\n res.append(path)\n for i in range(idx, len(nums)):\n if i > idx and nums[i] == nums[i-1]:\n continue\n dfs(i+1, path+[nums[i]])\n dfs(0, [])\n return res","runtime":"28"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n \"\"\"\n def f(i, subset):\n if i==len(nums):\n res.add(tuple(subset))\n return\n\n #take curr ele\n subset.append(nums[i])\n #check for next ele\n f(i+1, subset)\n\n #not take -> pop the just added ele\n subset.pop() \n #check for next ele\n f(i+1, subset)\n\n ans=[] #to store the answer tuples as list\n res=set() #tuple to check duplicates subsets\n subset=[] #array to store each subset\n\n nums.sort()\n f(0, subset)\n\n #turn tuple into list\n for s in res:\n ans.append(list(s))\n\n return ans\n \"\"\"\n\n\n def f(ind, arr, ds):\n ans.append(ds[:])\n\n for i in range(ind, len(arr)):\n #check for duplicate\n if i!=ind and arr[i]==arr[i-1]:\n #go to next ind\n continue \n \n ds.append(arr[i])\n f(i+1, arr, ds)\n ds.pop()\n\n ans=[]\n ds=[]\n #array must be in sorting order to get the correct output\n nums.sort()\n f(0, nums, ds)\n return ans\n\n ","runtime":"29"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n nums.sort()\n self.ret = []\n self.dfs(nums, [], len(nums))\n return self.ret\n \n def dfs(self, nums, path, len_nums):\n if len(path) <= len_nums:\n self.ret.append(path)\n \n if len(path) > len_nums:\n return\n \n for i, num in enumerate(nums):\n if i > 0 and nums[i] == nums[i-1]:\n continue\n \n self.dfs(nums[i+1:], path+[num], len_nums)\n ","runtime":"29"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n nums.sort()\n subsets = {tuple()}\n for n in nums:\n subsets = subsets | {(n,)+s for s in subsets}\n return subsets","runtime":"30"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n\n def search(arr,index):\n res.append(arr)\n for i in range(index, len(nums)):\n if i > index and nums[i] == nums[i-1]:\n continue\n search(arr + [nums[i]], i+1)\n \n search([], 0)\n\n return res\n\n ","runtime":"30"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n nums.sort()\n res=[]\n def dfs(i,subset):\n if i==len(nums):\n res.append(subset.copy())\n return\n #including the element into the subset\n subset.append(nums[i])\n dfs(i+1,subset)\n subset.pop() #because till now we have reached at the end of the left \n #side of the tree \n #eg- we have [1,2,2,3], first i=1 then while loop wil run making i=2\n #but now while loop will not run so the next element to be added is 3\n #that is why we called the dfs at i+1\n while i+1<len(nums) and nums[i]==nums[i+1]:\n i+=1\n dfs(i+1,subset)\n dfs(0,[])\n return res\n ","runtime":"31"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n self.length = len(nums)\n def helper(cur, i):\n if i >= self.length:\n res.append(cur[:])\n return\n helper(cur + [nums[i]], i+1)\n if not (cur and nums[i] == cur[-1]):\n helper(cur, i+1)\n helper([], 0)\n return res","runtime":"31"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n def backtrack(i , subset):\n if i >= len(nums):\n res.append(subset.copy()) \n return \n subset.append(nums[i])\n backtrack(i + 1 , subset)\n subset.pop()\n while i + 1 < len(nums) and nums[i] == nums[i+1]:\n i += 1\n backtrack(i + 1 , subset)\n backtrack(0 , [])\n return res ","runtime":"32"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n nums.sort()\n result = []\n\n def dfs(i: int, subset: List[int]) -> None:\n if i == len(nums):\n result.append(subset)\n return\n\n # Include\n dfs(i+1, [*subset, nums[i]])\n\n # Exclude. If we exclude any num X, then also exclude potentially succeeding X's.\n x = nums[i]\n i = i+1\n while i < len(nums) and nums[i] == x:\n i = i+1\n dfs(i, [*subset])\n\n dfs(0, [])\n return result\n","runtime":"32"},{"code":"class Solution:\n def subsetsWithDup(self, nums: list[int]) -> list[list[int]]:\n res = []\n\n nums.sort()\n def backtrack(currSubset: list[int], index: int):\n # The Goal\n if index == len(nums):\n res.append(currSubset.copy())\n return\n\n # The Choices\n # Include the number\n currSubset.append(nums[index])\n backtrack(currSubset, index + 1)\n currSubset.pop()\n\n # Ignore the number (and all its duplicates)\n while index + 1 < len(nums) and nums[index] == nums[index + 1]:\n index += 1\n backtrack(currSubset, index + 1)\n\n backtrack([], 0)\n return res","runtime":"33"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n result = []\n def backtrack(curr, i):\n if i == len(nums):\n result.append(curr.copy())\n return\n \n curr.append(nums[i])\n backtrack(curr, i + 1)\n curr.pop()\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\n i += 1\n backtrack(curr, i + 1)\n\n nums.sort()\n backtrack([], 0)\n return result","runtime":"33"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n ans = []\n nums.sort()\n\n def unique_subset(index, currArr):\n ans.append(list(currArr))\n \n for i in range(index, len(nums)):\n\n if i > index and nums[i] == nums[i-1]: continue\n\n currArr.append(nums[i])\n unique_subset(i+1, currArr)\n currArr.pop()\n\n unique_subset(0, [])\n return ans","runtime":"34"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n \n nums = sorted(nums)\n \n sets = []\n\n def backtrack(curr, start):\n \n sets.append(curr[:])\n seen = set()\n for i in range(start,len(nums)):\n \n if nums[i] in seen: \n continue\n seen.add(nums[i])\n\n curr.append(nums[i])\n backtrack(curr, i+1)\n curr.pop()\n\n backtrack([], 0)\n return sets\n","runtime":"34"},{"code":"class Solution:\n \"\"\"\n We can use the solution to Subsets for this problem as well, but we need to\n add a few additional steps to ensure that we do not add duplicate subsets to\n the result array. To achieve this efficiently, first we sort the nums array, which\n groups the duplicate numbers together. Next, we run the DFS / backtracking algorithm\n as per the original Subsets problem. In order to avoid adding duplicate subsets, when\n we go down the includes path, after adding the ith number to curr. We first check\n if curr == result[-1]. If they are equal, then we don't recurse down this path as\n this path as already been explored and all of it's subpaths have been added to result.\n For this to work, we have to make sure that we run the includes path before the not\n includes path. By running the not includes path last, we ensure that the root of each\n path is added last and thus we can check it via result[-1]. For example, consider that\n we are at the node [1, 2]. Now we can either include or don't include the last 2. So,\n we will get [1, 2] or [1, 2 ,2]. To have the root node, [1, 2], added last, we will\n run the not includes path last.\n\n \"\"\"\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n result, curr = [], []\n nums.sort()\n length = len(nums)\n\n def helper(i):\n if i == length:\n result.append(curr[::])\n return\n\n # include number at i\n curr.append(nums[i])\n if not result or curr != result[-1]:\n helper(i + 1)\n curr.pop()\n\n # don't include number at i\n helper(i + 1)\n\n helper(0)\n return result\n ","runtime":"35"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n def backtrack(subset, start):\n result.append(subset.copy())\n\n for i in range(start, len(nums)):\n if i > start and nums[i] == nums[i - 1]:\n continue\n\n subset.append(nums[i])\n backtrack(subset, i + 1)\n subset.pop()\n nums.sort()\n result = []\n backtrack([], 0)\n return result","runtime":"35"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n subset = []\n\n def backtrack(i):\n if i >= len(nums):\n res.append(subset.copy())\n return\n \n subset.append(nums[i])\n backtrack(i + 1)\n subset.pop()\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\n i += 1\n backtrack(i + 1)\n\n backtrack(0)\n return res","runtime":"36"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n # dedup\n nums.sort()\n res = []\n arr = []\n\n def backtrack(start):\n res.append(arr[:])\n\n for i in range(start, len(nums)):\n # check for dup: i > start & has dup means already have one branch on track\n if i > start and nums[i - 1] == nums[i]:\n continue\n \n arr.append(nums[i])\n backtrack(i + 1)\n arr.pop()\n backtrack(0)\n\n return res","runtime":"37"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n result = set()\n nums.sort()\n def subsets(cur, index):\n if index >= len(nums):\n temp = tuple(cur)\n if temp not in result:\n result.add(temp)\n return\n cur.append(nums[index])\n subsets(cur,index+1)\n cur.pop()\n subsets(cur,index+1)\n subsets([],0)\n return result ","runtime":"37"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n def backtrack(start,path):\n result.append(path[:])\n\n for i in range(start,len(nums)):\n if i > start and nums[i] == nums[i-1]:\n continue\n\n path.append(nums[i])\n backtrack(i+1,path)\n\n path.pop()\n\n result =[]\n nums.sort()\n backtrack(0,[])\n return result\n\n \n\n ","runtime":"38"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res=set()\n sub=[]\n def solve(pos,sub):\n if pos>=len(nums):\n res.add(tuple(sorted(sub)))\n return \n # if pos<len(nums) and nums[pos]==nums[pos+1]:\n # solve(i+2,sub)\n solve(pos+1,sub+[nums[pos]])\n solve(pos+1,sub)\n solve(0,sub)\n return list(res)\n \n","runtime":"38"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n \"\"\"\n Intuition:\n - For this problem, we need to first add to the temporary list the first value,\n - perform backtracking to add the next value and repeat until we have no more value to add\n Ex:\n 1. at index 0, we have a choice of adding [] or 1 to the list and perform a backtrack\n 2. at index 1, we have a choice of add [], [2], or [1, 2] to the list and backtrack\n 3. so forth and so forth ( we need to emulate this )\n 4. we want to emulate a skip over if the same number will be added\n [1,2,1]\n\n [] [1]\n [] [1] [2] [1,2]\n [] [1] [2] [1,2] [1] [2,1] [1,2,1] # there duplicates here \n \"\"\"\n\n # sort the current list so that we always know if the next index is the same value\n nums.sort()\n\n ans = []\n temp = []\n\n # build the backtracking algorithm\n def backtracking(i, temp):\n # if there are no more values to add:\n if i == len(nums):\n ans.append(temp[::])\n return\n\n\n # at each stage we can choose to add the digit or not add the digit\n temp.append(nums[i])\n backtracking(i+1, temp)\n temp.pop()\n\n # check to see if we need to skip some same digit\n # becareful that i+1 can bring us out of bound\n while (i+1) < len(nums) and nums[i] == nums[i+1]:\n i+=1\n\n # call backtracking again\n backtracking(i+1, temp)\n \n backtracking(0,temp)\n return ans\n","runtime":"39"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n\n def backtrack(i, subset):\n if i == len(nums):\n res.append(subset[::])\n return\n\n subset.append(nums[i])\n backtrack(i + 1, subset)\n subset.pop()\n\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\n i += 1\n backtrack(i + 1, subset)\n\n backtrack(0, [])\n return res","runtime":"39"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n n = len(nums)\n ans = []\n subset = []\n nums = sorted(nums)\n def backtrack(index):\n ans.append(subset.copy())\n if index == n : \n return\n \n for i in range(index,n):\n if i > index and nums[i-1] == nums[i]:\n continue\n\n subset.append(nums[i])\n backtrack(i+1)\n subset.pop()\n\n backtrack(0)\n return ans\n \n","runtime":"40"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n n = len(nums)\n ans, subset = [], []\n nums = sorted(nums)\n def backtrack(index):\n ans.append(subset.copy())\n if index == n : return\n for i in range(index,n):\n if i > index and nums[i-1] == nums[i]:continue\n subset.append(nums[i])\n backtrack(i+1)\n subset.pop()\n backtrack(0)\n return ans\n \n","runtime":"40"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n ans=[]\n ds=[]\n\n def findSubsets(ind:int):\n ans.append(ds[:])\n for i in range(ind,len(nums)):\n if i != ind and nums[i] == nums[i-1]:\n continue\n ds.append(nums[i])\n findSubsets(i+1)\n ds.pop()\n nums.sort()\n findSubsets(0)\n return ans\n \n\n ","runtime":"41"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n subset = []\n nums.sort()\n\n def backtrack(i):\n if i >= len(nums):\n res.append(subset.copy())\n return\n # include nums[i]\n subset.append(nums[i])\n backtrack(i+1)\n\n # not include nums[i]\n subset.pop()\n j = i\n while j < len(nums) and nums[j] == nums[i]:\n j += 1\n backtrack(j)\n \n backtrack(0)\n return res","runtime":"41"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n D = {}\n nums.sort()\n def sol(nums, L):\n if len(nums) == 0:\n D[tuple(L)] = 1\n return\n sol(nums[:-1], L + [nums[-1]])\n sol(nums[:-1], L)\n \n sol(nums, [])\n return [list(k) for k in list(D.keys())]","runtime":"42"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = [[]]\n nums.sort()\n def helper(i, curr):\n \n if i >= len(nums):\n return\n \n curr.append(nums[i])\n res.append(curr.copy())\n helper(i+1, curr)\n curr.pop()\n while i + 1 < len(nums) and nums[i] == nums[i+1]:\n i += 1\n helper(i+1, curr)\n \n helper(0, [])\n print(res)\n return res","runtime":"42"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n tmp = []\n res = []\n \n nums.sort()\n # 1, 2, 2\n\n # 1, 1, 2, 1, 2, 3, 2, 2, 3 3\n \n # 1, 1, 2 1 2 2 2 2, 2, \n\n # \n def dfs(start):\n res.append(tmp[:])\n for i in range(start, len(nums)):\n if i > start and nums[i-1] == nums[i]:\n continue\n tmp.append(nums[i])\n dfs(i+1)\n tmp.pop()\n\n dfs(0)\n return res","runtime":"43"},{"code":"from itertools import combinations\nclass Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n l=[]\n for i in range(len(nums)):\n l.append(list(combinations(nums,i)))\n l1=[]\n l2=[]\n for i in l:\n for j in i:\n l1.append(list(j))\n l1.append(nums)\n for i in l1:\n i=i.sort()\n for i in l1:\n if i not in l2:\n l2.append(i)\n return(l2)","runtime":"43"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n subsets = []\n sorted_nums = sorted(nums)\n curr_set = []\n\n def append_subsets(index):\n if index == len(nums):\n subsets.append(curr_set.copy())\n return\n \n curr_set.append(sorted_nums[index])\n append_subsets(index + 1)\n curr_set.pop()\n \n while index + 1 < len(nums) and sorted_nums[index] == sorted_nums[index + 1]:\n index += 1\n append_subsets(index + 1)\n \n append_subsets(0)\n return subsets","runtime":"44"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n n = len(nums)\n nums.sort()\n all_subsets = []\n\n def subsetHelper(ind: int, current_subset: list):\n if ind == n:\n all_subsets.append(current_subset[:]) # Add a copy of the current subset\n return\n \n current_subset.append(nums[ind])\n subsetHelper(ind + 1, current_subset)\n\n \n current_subset.pop()\n subsetHelper(ind + 1, current_subset)\n\n subsetHelper(0, [])\n ans = reduce(lambda re, x: re+[x] if x not in re else re, all_subsets, [])\n print(ans)\n ans.sort()\n\n return ans","runtime":"44"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n n = len(nums)\n ans = []\n subset = []\n nums = sorted(nums)\n def backtrack(index):\n ans.append(subset.copy())\n if index == n : \n return\n \n for i in range(index,n):\n if i > index and nums[i-1] == nums[i]:\n continue\n\n subset.append(nums[i])\n backtrack(i+1)\n subset.pop()\n\n backtrack(0)\n return ans\n \n","runtime":"45"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n sub = []\n nums.sort()\n\n def dfs(i):\n if i == len(nums):\n res.append(sub[:])\n return\n \n sub.append(nums[i])\n dfs(i + 1)\n sub.pop()\n\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\n i += 1\n dfs(i + 1)\n \n dfs(0)\n return res","runtime":"45"},{"code":"class Solution:\n \"\"\"\n We can use the solution to Subsets for this problem as well, but we need to\n add a few additional steps to ensure that we do not add duplicate subsets to\n the result array. To achieve this efficiently, first we sort the nums array, which\n groups the duplicate numbers together. Next, we run the DFS / backtracking algorithm\n as per the original Subsets problem. In order to avoid adding duplicate subsets, when\n we go down the includes path, after adding the ith number to curr. We first check\n if curr == result[-1]. If they are equal, then we don't recurse down this path as\n this path as already been explored and all of it's subpaths have been added to result.\n For this to work, we have to make sure that we run the includes path before the not\n includes path. By running the not includes path last, we ensure that the root of each\n path is added last and thus we can check it via result[-1]. For example, consider that\n we are at the node [1, 2]. Now we can either include or don't include the last 2. So,\n we will get [1, 2] or [1, 2 ,2]. To have the root node, [1, 2], added last, we will\n run the not includes path last.\n\n \"\"\"\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n result, curr = [], []\n nums.sort()\n length = len(nums)\n\n def helper(i):\n if i == length:\n result.append(curr[::])\n return\n\n # include number at i\n curr.append(nums[i])\n if not result or curr != result[-1]:\n helper(i + 1)\n curr.pop()\n\n # don't include number at i\n helper(i + 1)\n\n helper(0)\n return result\n ","runtime":"46"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n \"\"\"\n Intuition:\n - For this problem, we need to first add to the temporary list the first value,\n - perform backtracking to add the next value and repeat until we have no more value to add\n Ex:\n 1. at index 0, we have a choice of adding [] or 1 to the list and perform a backtrack\n 2. at index 1, we have a choice of add [], [2], or [1, 2] to the list and backtrack\n 3. so forth and so forth ( we need to emulate this )\n 4. we want to emulate a skip over if the same number will be added\n [1,2,1]\n\n [] [1]\n [] [1] [2] [1,2]\n [] [1] [2] [1,2] [1] [2,1] [1,2,1] # there duplicates here \n\n O(NLOGN) time\n O(N) space\n \"\"\"\n\n # sort the current list so that we always know if the next index is the same value\n nums.sort()\n\n ans = []\n temp = []\n\n # build the backtracking algorithm\n def backtracking(i, temp):\n # if there are no more values to add:\n if i == len(nums):\n ans.append(temp[::])\n return\n\n\n # at each stage we can choose to add the digit or not add the digit\n temp.append(nums[i])\n backtracking(i+1, temp)\n temp.pop()\n\n # check to see if we need to skip some same digit\n # becareful that i+1 can bring us out of bound\n while (i+1) < len(nums) and nums[i] == nums[i+1]:\n i+=1\n\n # call backtracking again\n backtracking(i+1, temp)\n \n backtracking(0,temp)\n return ans\n","runtime":"46"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n result = list()\n path = list()\n\n nums.sort()\n\n def bt(start_idx):\n result.append(path[:])\n for i in range(start_idx, len(nums)):\n if i > start_idx and nums[i] == nums[i - 1]:\n continue\n else:\n path.append(nums[i])\n bt(i + 1)\n path.pop()\n\n bt(0)\n return result\n\n","runtime":"47"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n \n nums = sorted(nums)\n \n res, sub = [], []\n\n def dfs(i):\n \n if i >= len(nums):\n if sub not in res:\n res.append(sub.copy())\n return\n\n sub.append(nums[i])\n dfs(i+1)\n\n sub.pop()\n dfs(i+1)\n\n dfs(0)\n return res","runtime":"47"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n n = len(nums)\n ans, subset = [], []\n nums = sorted(nums)\n def backtrack(index):\n ans.append(subset.copy())\n if index == n : return\n for i in range(index,n):\n if i > index and nums[i-1] == nums[i]:continue\n subset.append(nums[i])\n backtrack(i+1)\n subset.pop()\n backtrack(0)\n return ans\n \n","runtime":"48"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n subset = []\n nums = sorted(nums)\n res = []\n def dfs(i):\n if i == len(nums):\n res.append(subset.copy())\n return\n subset.append(nums[i])\n dfs(i+1)\n subset.pop()\n while i + 1 < len(nums) and nums[i] == nums[i+1]:\n i+=1\n dfs(i+1)\n \n dfs(0)\n return res\n ","runtime":"48"},{"code":"\"\"\"\n・答えをsetに\n 無駄が多い\n・リストじゃなくて、個数で管理\n\"\"\"\n\nfrom collections import Counter\n\nclass Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n subsets = []\n counts = Counter(nums)\n unique_nums = list(counts.keys())\n curr_subset = []\n \n def dfs(index):\n if index == len(unique_nums):\n subsets.append(curr_subset.copy())\n return\n \n num = unique_nums[index]\n dfs(index + 1)\n for _ in range(counts[num]):\n curr_subset.append(num)\n dfs(index + 1)\n for _ in range(counts[num]):\n curr_subset.pop()\n \n dfs(0)\n return subsets\n","runtime":"49"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n n = len(nums)\n nums.sort()\n all_subsets = []\n\n def subsetHelper(ind: int, current_subset: list):\n if ind == n:\n all_subsets.append(current_subset[:]) \n return\n \n current_subset.append(nums[ind])\n subsetHelper(ind + 1, current_subset)\n\n \n current_subset.pop()\n subsetHelper(ind + 1, current_subset)\n\n subsetHelper(0, [])\n ans = reduce(lambda re, x: re+[x] if x not in re else re, all_subsets, [])\n print(ans)\n ans.sort()\n\n return ans","runtime":"49"}],"string":"[\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = [[]]\\n nums.sort()\\n memory = {i: 0 for i in set(nums)}\\n \\n for num in nums:\\n end = len(res)\\n for s in res[memory[num] : end]: \\n res.append(s + [num])\\n memory[num] = end\\n \\n return res\",\n \"runtime\": \"16\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n if not nums:\\n return []\\n nums = sorted(nums)\\n res = []\\n self.dfs(nums, 0, [], res)\\n return res \\n \\n def dfs(self, nums, startIndex, subset, res):\\n res.append(subset[:])\\n\\n for i in range(startIndex, len(nums)):\\n if i > startIndex and nums[i] == nums[i-1]:\\n continue \\n subset.append(nums[i])\\n self.dfs(nums, i+1, subset, res)\\n subset.pop()\\n \",\n \"runtime\": \"17\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n def combos(idx,arr,stack,res):\\n res.append(stack.copy()) \\n\\n for i in range(idx,len(arr)):\\n if i>idx and arr[i]==arr[i-1]:\\n continue\\n stack.append(arr[i])\\n combos(i+1,arr,stack,res)\\n stack.pop()\\n \\n\\n res = []\\n nums.sort()\\n combos(0,nums,[],res)\\n\\n return res\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n ans={}\\n nums.sort()\\n \\n def solve(i, arr):\\n ans[\\\"*\\\".join(map(str,arr))]=arr\\n if i>=len(nums):\\n return\\n for j in range(i, len(nums)):\\n solve(j+1, arr+[nums[j]])\\n solve(0,[])\\n return ans.values()\\n\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n \\n res = []\\n\\n nums.sort()\\n\\n def backtrack(i, curr):\\n if i == len(nums):\\n res.append(curr[:])\\n return\\n\\n curr.append(nums[i])\\n\\n backtrack(i+1, curr)\\n curr.pop()\\n\\n while i + 1 < len(nums) and nums[i] == nums[i+1]:\\n i += 1\\n\\n backtrack(i+1, curr)\\n\\n backtrack(0, [])\\n\\n return res\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"class Solution:\\n def generate(self, ind, subArr, nums, res):\\n res.append(subArr[:])\\n for i in range (ind, len(nums)):\\n if(i > ind and nums[i] == nums[i - 1]):\\n continue\\n subArr.append(nums[i])\\n self.generate(i + 1, subArr, nums, res)\\n subArr.pop()\\n\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n nums.sort()\\n self.generate(0, [], nums, res)\\n return res\\n\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n # Sort the array to group duplicates together\\n nums.sort()\\n \\n result = []\\n \\n def backtrack(subset, start):\\n # Add the current subset to the result\\n result.append(subset[:])\\n \\n for i in range(start, len(nums)):\\n # Skip duplicates to avoid duplicate subsets\\n if i > start and nums[i] == nums[i-1]:\\n continue\\n # Include the current element in the subset\\n subset.append(nums[i])\\n # Explore further with the current element included\\n backtrack(subset, i + 1)\\n # Remove the current element from the subset to backtrack\\n subset.pop()\\n \\n backtrack([], 0)\\n return result\\n\\n# Example usage:\\nsolution = Solution()\\nnums = [1, 2, 2]\\nprint(solution.subsetsWithDup(nums)) # Output: [[], [1], [1, 2], [1, 2, 2], [2], [2, 2]]\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n \\n nums.sort()\\n ans = [[]]\\n memory = {i: 0 for i in set(nums)}\\n \\n for i in nums:\\n l = len(ans)\\n for s in ans[memory[i]:l]: ans.append(s+[i])\\n memory[i] = l\\n \\n return ans\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n nums.sort()\\n \\n def backtracking(i, subset):\\n if i == len(nums):\\n res.append(subset.copy())\\n return\\n\\n # All subsets that include the nums[i]\\n subset.append(nums[i])\\n backtracking(i+1, subset)\\n subset.pop()\\n\\n # All subsets that do not include nums[i]\\n while i+1 < len(nums) and nums[i] == nums[i+1]:\\n i += 1 \\n backtracking(i+1, subset)\\n \\n backtracking(0,[])\\n return res\\n \",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n return self._subsetsWithDup(sorted(nums))\\n \\n def _subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n if len(nums) == 0:\\n return [[]]\\n\\n n = nums.pop()\\n subsets = self._subsetsWithDup(nums[:])\\n if n in nums:\\n return subsets + [subset + [n] for subset in subsets if subset + [n] not in subsets]\\n return subsets + [subset + [n] for subset in subsets]\\n\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n\\n nums.sort() \\n subsets = [] \\n curr = [] \\n\\n self.dfs(subsets, curr, nums,0)\\n\\n return subsets\\n \\n def dfs(self, subsets, curr, nums, index):\\n subsets.append(list(curr))\\n\\n for i in range(index, len(nums)):\\n if i !=index and nums[i]==nums[i-1]:\\n continue \\n curr.append(nums[i])\\n self.dfs(subsets, curr, nums, i+1)\\n curr.pop()\\n \\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n nums.sort()\\n res = []\\n def backTrack(start, path):\\n res.append(path[:])\\n for i in range(start, len(nums)):\\n if not (i>start and nums[i] == nums[i-1]):\\n path.append(nums[i])\\n backTrack(i+1, path)\\n path.pop()\\n backTrack(0, [])\\n return res\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n\\n nums.sort() \\n\\n curr = [] \\n ans = []\\n\\n self.dfs(curr, ans, nums, 0)\\n\\n return ans \\n \\n def dfs(self, curr, ans, nums, index):\\n ans.append(list(curr))\\n\\n for i in range(index, len(nums)):\\n if i!= index and nums[i]==nums[i-1]:\\n continue \\n \\n curr.append(nums[i])\\n self.dfs(curr, ans, nums, i+1)\\n curr.pop()\\n \\n\\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n nums.sort()\\n def dfs(idx, path):\\n res.append(path)\\n for i in range(idx, len(nums)):\\n if i > idx and nums[i] == nums[i-1]:\\n continue\\n dfs(i+1, path+[nums[i]])\\n dfs(0, [])\\n return res\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n \\\"\\\"\\\"\\n def f(i, subset):\\n if i==len(nums):\\n res.add(tuple(subset))\\n return\\n\\n #take curr ele\\n subset.append(nums[i])\\n #check for next ele\\n f(i+1, subset)\\n\\n #not take -> pop the just added ele\\n subset.pop() \\n #check for next ele\\n f(i+1, subset)\\n\\n ans=[] #to store the answer tuples as list\\n res=set() #tuple to check duplicates subsets\\n subset=[] #array to store each subset\\n\\n nums.sort()\\n f(0, subset)\\n\\n #turn tuple into list\\n for s in res:\\n ans.append(list(s))\\n\\n return ans\\n \\\"\\\"\\\"\\n\\n\\n def f(ind, arr, ds):\\n ans.append(ds[:])\\n\\n for i in range(ind, len(arr)):\\n #check for duplicate\\n if i!=ind and arr[i]==arr[i-1]:\\n #go to next ind\\n continue \\n \\n ds.append(arr[i])\\n f(i+1, arr, ds)\\n ds.pop()\\n\\n ans=[]\\n ds=[]\\n #array must be in sorting order to get the correct output\\n nums.sort()\\n f(0, nums, ds)\\n return ans\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n nums.sort()\\n self.ret = []\\n self.dfs(nums, [], len(nums))\\n return self.ret\\n \\n def dfs(self, nums, path, len_nums):\\n if len(path) <= len_nums:\\n self.ret.append(path)\\n \\n if len(path) > len_nums:\\n return\\n \\n for i, num in enumerate(nums):\\n if i > 0 and nums[i] == nums[i-1]:\\n continue\\n \\n self.dfs(nums[i+1:], path+[num], len_nums)\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n nums.sort()\\n subsets = {tuple()}\\n for n in nums:\\n subsets = subsets | {(n,)+s for s in subsets}\\n return subsets\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n nums.sort()\\n\\n def search(arr,index):\\n res.append(arr)\\n for i in range(index, len(nums)):\\n if i > index and nums[i] == nums[i-1]:\\n continue\\n search(arr + [nums[i]], i+1)\\n \\n search([], 0)\\n\\n return res\\n\\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n nums.sort()\\n res=[]\\n def dfs(i,subset):\\n if i==len(nums):\\n res.append(subset.copy())\\n return\\n #including the element into the subset\\n subset.append(nums[i])\\n dfs(i+1,subset)\\n subset.pop() #because till now we have reached at the end of the left \\n #side of the tree \\n #eg- we have [1,2,2,3], first i=1 then while loop wil run making i=2\\n #but now while loop will not run so the next element to be added is 3\\n #that is why we called the dfs at i+1\\n while i+1<len(nums) and nums[i]==nums[i+1]:\\n i+=1\\n dfs(i+1,subset)\\n dfs(0,[])\\n return res\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n nums.sort()\\n self.length = len(nums)\\n def helper(cur, i):\\n if i >= self.length:\\n res.append(cur[:])\\n return\\n helper(cur + [nums[i]], i+1)\\n if not (cur and nums[i] == cur[-1]):\\n helper(cur, i+1)\\n helper([], 0)\\n return res\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n nums.sort()\\n def backtrack(i , subset):\\n if i >= len(nums):\\n res.append(subset.copy()) \\n return \\n subset.append(nums[i])\\n backtrack(i + 1 , subset)\\n subset.pop()\\n while i + 1 < len(nums) and nums[i] == nums[i+1]:\\n i += 1\\n backtrack(i + 1 , subset)\\n backtrack(0 , [])\\n return res \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n nums.sort()\\n result = []\\n\\n def dfs(i: int, subset: List[int]) -> None:\\n if i == len(nums):\\n result.append(subset)\\n return\\n\\n # Include\\n dfs(i+1, [*subset, nums[i]])\\n\\n # Exclude. If we exclude any num X, then also exclude potentially succeeding X's.\\n x = nums[i]\\n i = i+1\\n while i < len(nums) and nums[i] == x:\\n i = i+1\\n dfs(i, [*subset])\\n\\n dfs(0, [])\\n return result\\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: list[int]) -> list[list[int]]:\\n res = []\\n\\n nums.sort()\\n def backtrack(currSubset: list[int], index: int):\\n # The Goal\\n if index == len(nums):\\n res.append(currSubset.copy())\\n return\\n\\n # The Choices\\n # Include the number\\n currSubset.append(nums[index])\\n backtrack(currSubset, index + 1)\\n currSubset.pop()\\n\\n # Ignore the number (and all its duplicates)\\n while index + 1 < len(nums) and nums[index] == nums[index + 1]:\\n index += 1\\n backtrack(currSubset, index + 1)\\n\\n backtrack([], 0)\\n return res\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n result = []\\n def backtrack(curr, i):\\n if i == len(nums):\\n result.append(curr.copy())\\n return\\n \\n curr.append(nums[i])\\n backtrack(curr, i + 1)\\n curr.pop()\\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\\n i += 1\\n backtrack(curr, i + 1)\\n\\n nums.sort()\\n backtrack([], 0)\\n return result\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n ans = []\\n nums.sort()\\n\\n def unique_subset(index, currArr):\\n ans.append(list(currArr))\\n \\n for i in range(index, len(nums)):\\n\\n if i > index and nums[i] == nums[i-1]: continue\\n\\n currArr.append(nums[i])\\n unique_subset(i+1, currArr)\\n currArr.pop()\\n\\n unique_subset(0, [])\\n return ans\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n \\n nums = sorted(nums)\\n \\n sets = []\\n\\n def backtrack(curr, start):\\n \\n sets.append(curr[:])\\n seen = set()\\n for i in range(start,len(nums)):\\n \\n if nums[i] in seen: \\n continue\\n seen.add(nums[i])\\n\\n curr.append(nums[i])\\n backtrack(curr, i+1)\\n curr.pop()\\n\\n backtrack([], 0)\\n return sets\\n\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n \\\"\\\"\\\"\\n We can use the solution to Subsets for this problem as well, but we need to\\n add a few additional steps to ensure that we do not add duplicate subsets to\\n the result array. To achieve this efficiently, first we sort the nums array, which\\n groups the duplicate numbers together. Next, we run the DFS / backtracking algorithm\\n as per the original Subsets problem. In order to avoid adding duplicate subsets, when\\n we go down the includes path, after adding the ith number to curr. We first check\\n if curr == result[-1]. If they are equal, then we don't recurse down this path as\\n this path as already been explored and all of it's subpaths have been added to result.\\n For this to work, we have to make sure that we run the includes path before the not\\n includes path. By running the not includes path last, we ensure that the root of each\\n path is added last and thus we can check it via result[-1]. For example, consider that\\n we are at the node [1, 2]. Now we can either include or don't include the last 2. So,\\n we will get [1, 2] or [1, 2 ,2]. To have the root node, [1, 2], added last, we will\\n run the not includes path last.\\n\\n \\\"\\\"\\\"\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n result, curr = [], []\\n nums.sort()\\n length = len(nums)\\n\\n def helper(i):\\n if i == length:\\n result.append(curr[::])\\n return\\n\\n # include number at i\\n curr.append(nums[i])\\n if not result or curr != result[-1]:\\n helper(i + 1)\\n curr.pop()\\n\\n # don't include number at i\\n helper(i + 1)\\n\\n helper(0)\\n return result\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n def backtrack(subset, start):\\n result.append(subset.copy())\\n\\n for i in range(start, len(nums)):\\n if i > start and nums[i] == nums[i - 1]:\\n continue\\n\\n subset.append(nums[i])\\n backtrack(subset, i + 1)\\n subset.pop()\\n nums.sort()\\n result = []\\n backtrack([], 0)\\n return result\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n nums.sort()\\n subset = []\\n\\n def backtrack(i):\\n if i >= len(nums):\\n res.append(subset.copy())\\n return\\n \\n subset.append(nums[i])\\n backtrack(i + 1)\\n subset.pop()\\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\\n i += 1\\n backtrack(i + 1)\\n\\n backtrack(0)\\n return res\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n # dedup\\n nums.sort()\\n res = []\\n arr = []\\n\\n def backtrack(start):\\n res.append(arr[:])\\n\\n for i in range(start, len(nums)):\\n # check for dup: i > start & has dup means already have one branch on track\\n if i > start and nums[i - 1] == nums[i]:\\n continue\\n \\n arr.append(nums[i])\\n backtrack(i + 1)\\n arr.pop()\\n backtrack(0)\\n\\n return res\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n result = set()\\n nums.sort()\\n def subsets(cur, index):\\n if index >= len(nums):\\n temp = tuple(cur)\\n if temp not in result:\\n result.add(temp)\\n return\\n cur.append(nums[index])\\n subsets(cur,index+1)\\n cur.pop()\\n subsets(cur,index+1)\\n subsets([],0)\\n return result \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n def backtrack(start,path):\\n result.append(path[:])\\n\\n for i in range(start,len(nums)):\\n if i > start and nums[i] == nums[i-1]:\\n continue\\n\\n path.append(nums[i])\\n backtrack(i+1,path)\\n\\n path.pop()\\n\\n result =[]\\n nums.sort()\\n backtrack(0,[])\\n return result\\n\\n \\n\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res=set()\\n sub=[]\\n def solve(pos,sub):\\n if pos>=len(nums):\\n res.add(tuple(sorted(sub)))\\n return \\n # if pos<len(nums) and nums[pos]==nums[pos+1]:\\n # solve(i+2,sub)\\n solve(pos+1,sub+[nums[pos]])\\n solve(pos+1,sub)\\n solve(0,sub)\\n return list(res)\\n \\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n \\\"\\\"\\\"\\n Intuition:\\n - For this problem, we need to first add to the temporary list the first value,\\n - perform backtracking to add the next value and repeat until we have no more value to add\\n Ex:\\n 1. at index 0, we have a choice of adding [] or 1 to the list and perform a backtrack\\n 2. at index 1, we have a choice of add [], [2], or [1, 2] to the list and backtrack\\n 3. so forth and so forth ( we need to emulate this )\\n 4. we want to emulate a skip over if the same number will be added\\n [1,2,1]\\n\\n [] [1]\\n [] [1] [2] [1,2]\\n [] [1] [2] [1,2] [1] [2,1] [1,2,1] # there duplicates here \\n \\\"\\\"\\\"\\n\\n # sort the current list so that we always know if the next index is the same value\\n nums.sort()\\n\\n ans = []\\n temp = []\\n\\n # build the backtracking algorithm\\n def backtracking(i, temp):\\n # if there are no more values to add:\\n if i == len(nums):\\n ans.append(temp[::])\\n return\\n\\n\\n # at each stage we can choose to add the digit or not add the digit\\n temp.append(nums[i])\\n backtracking(i+1, temp)\\n temp.pop()\\n\\n # check to see if we need to skip some same digit\\n # becareful that i+1 can bring us out of bound\\n while (i+1) < len(nums) and nums[i] == nums[i+1]:\\n i+=1\\n\\n # call backtracking again\\n backtracking(i+1, temp)\\n \\n backtracking(0,temp)\\n return ans\\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n nums.sort()\\n\\n def backtrack(i, subset):\\n if i == len(nums):\\n res.append(subset[::])\\n return\\n\\n subset.append(nums[i])\\n backtrack(i + 1, subset)\\n subset.pop()\\n\\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\\n i += 1\\n backtrack(i + 1, subset)\\n\\n backtrack(0, [])\\n return res\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n n = len(nums)\\n ans = []\\n subset = []\\n nums = sorted(nums)\\n def backtrack(index):\\n ans.append(subset.copy())\\n if index == n : \\n return\\n \\n for i in range(index,n):\\n if i > index and nums[i-1] == nums[i]:\\n continue\\n\\n subset.append(nums[i])\\n backtrack(i+1)\\n subset.pop()\\n\\n backtrack(0)\\n return ans\\n \\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n n = len(nums)\\n ans, subset = [], []\\n nums = sorted(nums)\\n def backtrack(index):\\n ans.append(subset.copy())\\n if index == n : return\\n for i in range(index,n):\\n if i > index and nums[i-1] == nums[i]:continue\\n subset.append(nums[i])\\n backtrack(i+1)\\n subset.pop()\\n backtrack(0)\\n return ans\\n \\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n ans=[]\\n ds=[]\\n\\n def findSubsets(ind:int):\\n ans.append(ds[:])\\n for i in range(ind,len(nums)):\\n if i != ind and nums[i] == nums[i-1]:\\n continue\\n ds.append(nums[i])\\n findSubsets(i+1)\\n ds.pop()\\n nums.sort()\\n findSubsets(0)\\n return ans\\n \\n\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n subset = []\\n nums.sort()\\n\\n def backtrack(i):\\n if i >= len(nums):\\n res.append(subset.copy())\\n return\\n # include nums[i]\\n subset.append(nums[i])\\n backtrack(i+1)\\n\\n # not include nums[i]\\n subset.pop()\\n j = i\\n while j < len(nums) and nums[j] == nums[i]:\\n j += 1\\n backtrack(j)\\n \\n backtrack(0)\\n return res\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n D = {}\\n nums.sort()\\n def sol(nums, L):\\n if len(nums) == 0:\\n D[tuple(L)] = 1\\n return\\n sol(nums[:-1], L + [nums[-1]])\\n sol(nums[:-1], L)\\n \\n sol(nums, [])\\n return [list(k) for k in list(D.keys())]\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = [[]]\\n nums.sort()\\n def helper(i, curr):\\n \\n if i >= len(nums):\\n return\\n \\n curr.append(nums[i])\\n res.append(curr.copy())\\n helper(i+1, curr)\\n curr.pop()\\n while i + 1 < len(nums) and nums[i] == nums[i+1]:\\n i += 1\\n helper(i+1, curr)\\n \\n helper(0, [])\\n print(res)\\n return res\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n tmp = []\\n res = []\\n \\n nums.sort()\\n # 1, 2, 2\\n\\n # 1, 1, 2, 1, 2, 3, 2, 2, 3 3\\n \\n # 1, 1, 2 1 2 2 2 2, 2, \\n\\n # \\n def dfs(start):\\n res.append(tmp[:])\\n for i in range(start, len(nums)):\\n if i > start and nums[i-1] == nums[i]:\\n continue\\n tmp.append(nums[i])\\n dfs(i+1)\\n tmp.pop()\\n\\n dfs(0)\\n return res\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"from itertools import combinations\\nclass Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n l=[]\\n for i in range(len(nums)):\\n l.append(list(combinations(nums,i)))\\n l1=[]\\n l2=[]\\n for i in l:\\n for j in i:\\n l1.append(list(j))\\n l1.append(nums)\\n for i in l1:\\n i=i.sort()\\n for i in l1:\\n if i not in l2:\\n l2.append(i)\\n return(l2)\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n subsets = []\\n sorted_nums = sorted(nums)\\n curr_set = []\\n\\n def append_subsets(index):\\n if index == len(nums):\\n subsets.append(curr_set.copy())\\n return\\n \\n curr_set.append(sorted_nums[index])\\n append_subsets(index + 1)\\n curr_set.pop()\\n \\n while index + 1 < len(nums) and sorted_nums[index] == sorted_nums[index + 1]:\\n index += 1\\n append_subsets(index + 1)\\n \\n append_subsets(0)\\n return subsets\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n n = len(nums)\\n nums.sort()\\n all_subsets = []\\n\\n def subsetHelper(ind: int, current_subset: list):\\n if ind == n:\\n all_subsets.append(current_subset[:]) # Add a copy of the current subset\\n return\\n \\n current_subset.append(nums[ind])\\n subsetHelper(ind + 1, current_subset)\\n\\n \\n current_subset.pop()\\n subsetHelper(ind + 1, current_subset)\\n\\n subsetHelper(0, [])\\n ans = reduce(lambda re, x: re+[x] if x not in re else re, all_subsets, [])\\n print(ans)\\n ans.sort()\\n\\n return ans\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n n = len(nums)\\n ans = []\\n subset = []\\n nums = sorted(nums)\\n def backtrack(index):\\n ans.append(subset.copy())\\n if index == n : \\n return\\n \\n for i in range(index,n):\\n if i > index and nums[i-1] == nums[i]:\\n continue\\n\\n subset.append(nums[i])\\n backtrack(i+1)\\n subset.pop()\\n\\n backtrack(0)\\n return ans\\n \\n\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n sub = []\\n nums.sort()\\n\\n def dfs(i):\\n if i == len(nums):\\n res.append(sub[:])\\n return\\n \\n sub.append(nums[i])\\n dfs(i + 1)\\n sub.pop()\\n\\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\\n i += 1\\n dfs(i + 1)\\n \\n dfs(0)\\n return res\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n \\\"\\\"\\\"\\n We can use the solution to Subsets for this problem as well, but we need to\\n add a few additional steps to ensure that we do not add duplicate subsets to\\n the result array. To achieve this efficiently, first we sort the nums array, which\\n groups the duplicate numbers together. Next, we run the DFS / backtracking algorithm\\n as per the original Subsets problem. In order to avoid adding duplicate subsets, when\\n we go down the includes path, after adding the ith number to curr. We first check\\n if curr == result[-1]. If they are equal, then we don't recurse down this path as\\n this path as already been explored and all of it's subpaths have been added to result.\\n For this to work, we have to make sure that we run the includes path before the not\\n includes path. By running the not includes path last, we ensure that the root of each\\n path is added last and thus we can check it via result[-1]. For example, consider that\\n we are at the node [1, 2]. Now we can either include or don't include the last 2. So,\\n we will get [1, 2] or [1, 2 ,2]. To have the root node, [1, 2], added last, we will\\n run the not includes path last.\\n\\n \\\"\\\"\\\"\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n result, curr = [], []\\n nums.sort()\\n length = len(nums)\\n\\n def helper(i):\\n if i == length:\\n result.append(curr[::])\\n return\\n\\n # include number at i\\n curr.append(nums[i])\\n if not result or curr != result[-1]:\\n helper(i + 1)\\n curr.pop()\\n\\n # don't include number at i\\n helper(i + 1)\\n\\n helper(0)\\n return result\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n \\\"\\\"\\\"\\n Intuition:\\n - For this problem, we need to first add to the temporary list the first value,\\n - perform backtracking to add the next value and repeat until we have no more value to add\\n Ex:\\n 1. at index 0, we have a choice of adding [] or 1 to the list and perform a backtrack\\n 2. at index 1, we have a choice of add [], [2], or [1, 2] to the list and backtrack\\n 3. so forth and so forth ( we need to emulate this )\\n 4. we want to emulate a skip over if the same number will be added\\n [1,2,1]\\n\\n [] [1]\\n [] [1] [2] [1,2]\\n [] [1] [2] [1,2] [1] [2,1] [1,2,1] # there duplicates here \\n\\n O(NLOGN) time\\n O(N) space\\n \\\"\\\"\\\"\\n\\n # sort the current list so that we always know if the next index is the same value\\n nums.sort()\\n\\n ans = []\\n temp = []\\n\\n # build the backtracking algorithm\\n def backtracking(i, temp):\\n # if there are no more values to add:\\n if i == len(nums):\\n ans.append(temp[::])\\n return\\n\\n\\n # at each stage we can choose to add the digit or not add the digit\\n temp.append(nums[i])\\n backtracking(i+1, temp)\\n temp.pop()\\n\\n # check to see if we need to skip some same digit\\n # becareful that i+1 can bring us out of bound\\n while (i+1) < len(nums) and nums[i] == nums[i+1]:\\n i+=1\\n\\n # call backtracking again\\n backtracking(i+1, temp)\\n \\n backtracking(0,temp)\\n return ans\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n result = list()\\n path = list()\\n\\n nums.sort()\\n\\n def bt(start_idx):\\n result.append(path[:])\\n for i in range(start_idx, len(nums)):\\n if i > start_idx and nums[i] == nums[i - 1]:\\n continue\\n else:\\n path.append(nums[i])\\n bt(i + 1)\\n path.pop()\\n\\n bt(0)\\n return result\\n\\n\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n \\n nums = sorted(nums)\\n \\n res, sub = [], []\\n\\n def dfs(i):\\n \\n if i >= len(nums):\\n if sub not in res:\\n res.append(sub.copy())\\n return\\n\\n sub.append(nums[i])\\n dfs(i+1)\\n\\n sub.pop()\\n dfs(i+1)\\n\\n dfs(0)\\n return res\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n n = len(nums)\\n ans, subset = [], []\\n nums = sorted(nums)\\n def backtrack(index):\\n ans.append(subset.copy())\\n if index == n : return\\n for i in range(index,n):\\n if i > index and nums[i-1] == nums[i]:continue\\n subset.append(nums[i])\\n backtrack(i+1)\\n subset.pop()\\n backtrack(0)\\n return ans\\n \\n\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n subset = []\\n nums = sorted(nums)\\n res = []\\n def dfs(i):\\n if i == len(nums):\\n res.append(subset.copy())\\n return\\n subset.append(nums[i])\\n dfs(i+1)\\n subset.pop()\\n while i + 1 < len(nums) and nums[i] == nums[i+1]:\\n i+=1\\n dfs(i+1)\\n \\n dfs(0)\\n return res\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n・答えをsetに\\n 無駄が多い\\n・リストじゃなくて、個数で管理\\n\\\"\\\"\\\"\\n\\nfrom collections import Counter\\n\\nclass Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n subsets = []\\n counts = Counter(nums)\\n unique_nums = list(counts.keys())\\n curr_subset = []\\n \\n def dfs(index):\\n if index == len(unique_nums):\\n subsets.append(curr_subset.copy())\\n return\\n \\n num = unique_nums[index]\\n dfs(index + 1)\\n for _ in range(counts[num]):\\n curr_subset.append(num)\\n dfs(index + 1)\\n for _ in range(counts[num]):\\n curr_subset.pop()\\n \\n dfs(0)\\n return subsets\\n\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n n = len(nums)\\n nums.sort()\\n all_subsets = []\\n\\n def subsetHelper(ind: int, current_subset: list):\\n if ind == n:\\n all_subsets.append(current_subset[:]) \\n return\\n \\n current_subset.append(nums[ind])\\n subsetHelper(ind + 1, current_subset)\\n\\n \\n current_subset.pop()\\n subsetHelper(ind + 1, current_subset)\\n\\n subsetHelper(0, [])\\n ans = reduce(lambda re, x: re+[x] if x not in re else re, all_subsets, [])\\n print(ans)\\n ans.sort()\\n\\n return ans\",\n \"runtime\": \"49\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":55,"string":"55"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n ans = set()\n nums.sort()\n def backtracking(path, idx):\n \n if len(path) <= len(nums):\n ans.add(tuple(path))\n \n\n for i in range(idx, len(nums)):\n \n path.append(nums[i])\n backtracking(path, i+1)\n path.pop()\n backtracking([], 0)\n return list(ans)","memory":"16100"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n ans = []\n nums.sort()\n def dfs(i,currSet):\n nonlocal ans\n if i == len(nums):\n ans.append(currSet)\n return\n #include\n dfs(i+1,currSet+[nums[i]]) \n #VVIMP to include first and then move pointer to next uniq num\n\n while i < len(nums)-1 and nums[i] == nums[i+1]:\n i += 1\n dfs(i+1,currSet)\n return\n dfs(0,[])\n return ans","memory":"16300"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n subset = []\n\n def backtrack(i):\n if i >= len(nums):\n res.append(subset.copy())\n return\n \n subset.append(nums[i])\n backtrack(i + 1)\n subset.pop()\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\n i += 1\n backtrack(i + 1)\n\n backtrack(0)\n return res","memory":"16400"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n ans = []\n nums.sort()\n\n def unique_subset(index, currArr):\n ans.append(list(currArr))\n \n for i in range(index, len(nums)):\n\n if i > index and nums[i] == nums[i-1]: continue\n\n currArr.append(nums[i])\n unique_subset(i+1, currArr)\n currArr.pop()\n\n unique_subset(0, [])\n return ans","memory":"16500"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n sub = []\n nums.sort()\n\n def dfs(i):\n if i == len(nums):\n res.append(sub[:])\n return\n \n sub.append(nums[i])\n dfs(i + 1)\n sub.pop()\n\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\n i += 1\n dfs(i + 1)\n \n dfs(0)\n return res","memory":"16500"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n result = set()\n nums.sort()\n def subsets(cur, index):\n if index >= len(nums):\n temp = tuple(cur)\n if temp not in result:\n result.add(temp)\n return\n cur.append(nums[index])\n subsets(cur,index+1)\n cur.pop()\n subsets(cur,index+1)\n subsets([],0)\n return result ","memory":"16600"},{"code":"class Solution:\n def subsetsWithDupHelper(self, nums, path):\n if path not in self.res:\n self.res.append(path)\n\n if not nums:\n return\n\n for i in range(len(nums)):\n if i != 0 and nums[i] == nums[i-1]:\n continue\n else:\n self.subsetsWithDupHelper(nums[i+1:], path + [nums[i]])\n\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n self.res = []\n nums.sort()\n self.subsetsWithDupHelper(nums, [])\n\n return self.res","memory":"16600"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n nums.sort()\n l=[[]]\n for i in nums:\n m = l.copy()\n for j in m:\n k= j+[i]\n if k not in l:\n l.append(k)\n\n \n return l","memory":"16700"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n def dfs(idx, path):\n res.append(path)\n for i in range(idx, len(nums)):\n if i > idx and nums[i] == nums[i-1]:\n continue\n dfs(i+1, path+[nums[i]])\n dfs(0, [])\n return res","memory":"16700"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n \n def dfs(i, curr):\n if i == len(nums):\n ans.append(curr.copy())\n return\n \n dfs(i+1, curr + [nums[i]])\n\n while i+1 < len(nums) and nums[i] == nums[i+1]:\n i+=1\n dfs(i+1, curr)\n \n ans = []\n nums.sort()\n dfs(0, [])\n \n return ans","memory":"16800"},{"code":"class Solution:\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n nums.sort()\n result = []\n \n def backtrack(start, subset):\n # Add a copy of the current subset to the result\n result.append(subset[:])\n \n for i in range(start, len(nums)):\n # Skip duplicates by ensuring we don't choose the same element\n if i > start and nums[i] == nums[i - 1]:\n continue\n # Include nums[i] in the current subset and move forward\n subset.append(nums[i])\n backtrack(i + 1, subset)\n # Backtrack by removing the last element to explore new subsets\n subset.pop()\n \n backtrack(0, [])\n return result\n ","memory":"16800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n ans = set()\\n nums.sort()\\n def backtracking(path, idx):\\n \\n if len(path) <= len(nums):\\n ans.add(tuple(path))\\n \\n\\n for i in range(idx, len(nums)):\\n \\n path.append(nums[i])\\n backtracking(path, i+1)\\n path.pop()\\n backtracking([], 0)\\n return list(ans)\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n ans = []\\n nums.sort()\\n def dfs(i,currSet):\\n nonlocal ans\\n if i == len(nums):\\n ans.append(currSet)\\n return\\n #include\\n dfs(i+1,currSet+[nums[i]]) \\n #VVIMP to include first and then move pointer to next uniq num\\n\\n while i < len(nums)-1 and nums[i] == nums[i+1]:\\n i += 1\\n dfs(i+1,currSet)\\n return\\n dfs(0,[])\\n return ans\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n nums.sort()\\n subset = []\\n\\n def backtrack(i):\\n if i >= len(nums):\\n res.append(subset.copy())\\n return\\n \\n subset.append(nums[i])\\n backtrack(i + 1)\\n subset.pop()\\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\\n i += 1\\n backtrack(i + 1)\\n\\n backtrack(0)\\n return res\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n ans = []\\n nums.sort()\\n\\n def unique_subset(index, currArr):\\n ans.append(list(currArr))\\n \\n for i in range(index, len(nums)):\\n\\n if i > index and nums[i] == nums[i-1]: continue\\n\\n currArr.append(nums[i])\\n unique_subset(i+1, currArr)\\n currArr.pop()\\n\\n unique_subset(0, [])\\n return ans\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n sub = []\\n nums.sort()\\n\\n def dfs(i):\\n if i == len(nums):\\n res.append(sub[:])\\n return\\n \\n sub.append(nums[i])\\n dfs(i + 1)\\n sub.pop()\\n\\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\\n i += 1\\n dfs(i + 1)\\n \\n dfs(0)\\n return res\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n result = set()\\n nums.sort()\\n def subsets(cur, index):\\n if index >= len(nums):\\n temp = tuple(cur)\\n if temp not in result:\\n result.add(temp)\\n return\\n cur.append(nums[index])\\n subsets(cur,index+1)\\n cur.pop()\\n subsets(cur,index+1)\\n subsets([],0)\\n return result \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDupHelper(self, nums, path):\\n if path not in self.res:\\n self.res.append(path)\\n\\n if not nums:\\n return\\n\\n for i in range(len(nums)):\\n if i != 0 and nums[i] == nums[i-1]:\\n continue\\n else:\\n self.subsetsWithDupHelper(nums[i+1:], path + [nums[i]])\\n\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n self.res = []\\n nums.sort()\\n self.subsetsWithDupHelper(nums, [])\\n\\n return self.res\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n nums.sort()\\n l=[[]]\\n for i in nums:\\n m = l.copy()\\n for j in m:\\n k= j+[i]\\n if k not in l:\\n l.append(k)\\n\\n \\n return l\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n res = []\\n nums.sort()\\n def dfs(idx, path):\\n res.append(path)\\n for i in range(idx, len(nums)):\\n if i > idx and nums[i] == nums[i-1]:\\n continue\\n dfs(i+1, path+[nums[i]])\\n dfs(0, [])\\n return res\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n \\n def dfs(i, curr):\\n if i == len(nums):\\n ans.append(curr.copy())\\n return\\n \\n dfs(i+1, curr + [nums[i]])\\n\\n while i+1 < len(nums) and nums[i] == nums[i+1]:\\n i+=1\\n dfs(i+1, curr)\\n \\n ans = []\\n nums.sort()\\n dfs(0, [])\\n \\n return ans\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n nums.sort()\\n result = []\\n \\n def backtrack(start, subset):\\n # Add a copy of the current subset to the result\\n result.append(subset[:])\\n \\n for i in range(start, len(nums)):\\n # Skip duplicates by ensuring we don't choose the same element\\n if i > start and nums[i] == nums[i - 1]:\\n continue\\n # Include nums[i] in the current subset and move forward\\n subset.append(nums[i])\\n backtrack(i + 1, subset)\\n # Backtrack by removing the last element to explore new subsets\\n subset.pop()\\n \\n backtrack(0, [])\\n return result\\n \",\n \"memory\": \"16800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":11,"string":"11"}}},{"rowIdx":45,"cells":{"question_id":{"kind":"number","value":141,"string":"141"},"name":{"kind":"string","value":"linked-list-cycle"},"content":{"kind":"string","value":"<p>Given <code>head</code>, the head of a linked list, determine if the linked list has a cycle in it.</p>\n\n<p>There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the <code>next</code> pointer. Internally, <code>pos</code> is used to denote the index of the node that tail's <code>next</code> pointer is connected to. <strong>Note that <code>pos</code> is not passed as a parameter</strong>.</p>\n\n<p>Return <code>true</code><em> if there is a cycle in the linked list</em>. Otherwise, return <code>false</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png\" style=\"width: 300px; height: 97px; margin-top: 8px; margin-bottom: 8px;\" />\n<pre>\n<strong>Input:</strong> head = [3,2,0,-4], pos = 1\n<strong>Output:</strong> true\n<strong>Explanation:</strong> There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png\" style=\"width: 141px; height: 74px;\" />\n<pre>\n<strong>Input:</strong> head = [1,2], pos = 0\n<strong>Output:</strong> true\n<strong>Explanation:</strong> There is a cycle in the linked list, where the tail connects to the 0th node.\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png\" style=\"width: 45px; height: 45px;\" />\n<pre>\n<strong>Input:</strong> head = [1], pos = -1\n<strong>Output:</strong> false\n<strong>Explanation:</strong> There is no cycle in the linked list.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of the nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.</li>\n\t<li><code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code></li>\n\t<li><code>pos</code> is <code>-1</code> or a <strong>valid index</strong> in the linked-list.</li>\n</ul>\n\n<p> </p>\n<p><strong>Follow up:</strong> Can you solve it using <code>O(1)</code> (i.e. constant) memory?</p>\n"},"acRate":{"kind":"number","value":51.1096945218216,"string":"51.109695"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["hash-table","linked-list","two-pointers"],"string":"[\n \"hash-table\",\n \"linked-list\",\n \"two-pointers\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"18\", 0.0074], [\"19\", 0.0025], [\"20\", 0.0025], [\"22\", 0.0074], [\"23\", 0.0098], [\"24\", 0.0172], [\"25\", 0.0172], [\"26\", 0.0613], [\"27\", 0.1128], [\"28\", 0.1422], [\"29\", 0.1005], [\"30\", 0.2624], [\"31\", 0.4732], [\"32\", 0.5247], [\"33\", 0.5811], [\"34\", 0.8533], [\"35\", 1.6429], [\"36\", 1.8636], [\"37\", 1.9911], [\"38\", 2.3197], [\"39\", 4.4848], [\"40\", 4.2568], [\"41\", 4.3328], [\"42\", 4.4677], [\"43\", 7.1306], [\"44\", 6.932], [\"45\", 6.4612], [\"46\", 5.5735], [\"47\", 7.6112], [\"48\", 6.8216], [\"49\", 5.4607], [\"50\", 4.7227], [\"51\", 4.654], [\"52\", 3.3912], [\"53\", 2.7806], [\"54\", 1.7998], [\"55\", 1.3756], [\"56\", 0.8116], [\"57\", 0.4365], [\"58\", 0.2673], [\"59\", 0.1667]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16600\", 0.0147], [\"16700\", 0.0098], [\"16800\", 0.0049], [\"17800\", 0.0466], [\"17900\", 0.0907], [\"18000\", 0.1643], [\"18100\", 0.0147], [\"18200\", 0.0123], [\"18300\", 0.0245], [\"18400\", 0.1471], [\"18500\", 0.8214], [\"18600\", 0.4708], [\"18700\", 0.0638], [\"18800\", 0.2501], [\"18900\", 3.6536], [\"19000\", 31.6022], [\"19100\", 42.1779], [\"19200\", 1.9347], [\"19300\", 0.5149], [\"19400\", 3.6217]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast = head\n slow = head\n \n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n \n if fast == slow:\n return True\n \n return False","runtime":"18"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n \n fast=head\n while fast and fast.next:\n head=head.next\n fast=fast.next.next\n if head==fast:\n return True\n return False\n","runtime":"19"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n s=set()\n l=head\n while l:\n if l not in s:\n s.add(l)\n l=l.next\n else:\n return True\n return False\n ","runtime":"20"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if head is None or head.next is None:\n return False\n hashmap = {}\n current = head \n while current:\n if current in hashmap:\n return True\n hashmap[current] = True\n current = current.next\n return False\n \n \n\n ","runtime":"22"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n nodes_seen = set()\n while head:\n if head in nodes_seen:\n return True\n \n nodes_seen.add(head)\n head = head.next\n\n return False","runtime":"23"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n # See if the hare catches up with the tortoise\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n return True\n return False\n","runtime":"24"},{"code":"class Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if not head or not head.next:\n return False\n \n slow, fast = head, head.next\n \n while slow != fast:\n if not fast or not fast.next:\n return False\n slow = slow.next\n fast = fast.next.next\n \n return True","runtime":"25"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow = head\n fast = head\n while fast is not None and fast.next is not None:\n slow = slow.next\n fast = fast.next.next\n if slow==fast:\n return True\n return False","runtime":"26"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n #brute \n while head is not None:\n if head.val == '':\n return True\n head.val = ''\n head = head.next\n return False\n\n","runtime":"27"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n \n node_map = dict()\n curr = head\n while curr: \n if curr not in node_map:\n node_map[curr] = 0\n else: \n return True\n curr = curr.next\n \n return False","runtime":"28"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if not head:\n return False\n node_set = set()\n while head.next != None:\n node_set.add(head)\n head = head.next\n if head in node_set:\n return True\n return False\n\n","runtime":"29"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n #Tortoise and hare algorithm, one node goes at speed 1, one node goes at speed 2\n #If they are equivalent, there was a cycle somewhere\n rabbit = head\n tortoise = head\n\n while rabbit and rabbit.next:\n tortoise = tortoise.next\n rabbit = rabbit.next.next\n\n if tortoise == rabbit:\n return True\n\n return False","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n\n temp = ListNode()\n temp.next = head\n\n #slow and fast pointer ( small +=1 ; fast +=2)\n slow = fast = temp\n\n while fast and fast.next:\n\n #fast jumps 2 place\n fast = fast.next.next\n\n #slow jumps 1 place\n slow = slow.next\n\n #if both equal there is a cycle\n if slow == fast:\n return True\n\n return False \n ","runtime":"30"},{"code":"class ListNode:\n def __init__(self, x):\n self.val = x\n self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n # Initialize two pointers\n slow = head\n fast = head\n \n \n while fast is not None and fast.next is not None:\n slow = slow.next \n fast = fast.next.next \n if slow == fast:\n return True\n return False\n","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if not head:\n return False \n dummy = ListNode()\n dummy.next = head \n slow = fast = dummy\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if fast == slow: \n return True\n return False","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow = head\n fast = head\n\n while fast and slow:\n fast = fast.next\n if slow == fast:\n return True\n if fast == None:\n return False\n fast = fast.next\n slow = slow.next\n return False","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if not head:\n return False\n\n current = head\n visited = set()\n\n while current:\n visited.add(current)\n \n if current.next in visited:\n return True\n\n current = current.next\n\n return False","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n i = head \n j = head\n while j and j.next:\n i = i.next\n j = j.next.next\n if i is j :\n return 1\n break\n return 0\n \n ","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n \n slow = fast = head\n \n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n \n if fast == slow:\n return True\n \n return False","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n s = set()\n while head:\n if head in s:\n return True\n s.add(head)\n head = head.next\n return False","runtime":"34"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast = head\n while fast and fast.next:\n head = head.next\n fast = fast.next.next\n if head == fast:\n return True\n return False\n\n # n = 0\n # while head:\n # n += 1\n # if n > pow(10, 4):\n # return True\n # head = head.next\n # return False","runtime":"34"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast=head\n slow=head\n while fast and fast.next is not None:\n fast=fast.next.next\n slow=slow.next\n if fast==slow:\n return True\n return False\n","runtime":"35"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow = head\n fast = head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n return True\n return False","runtime":"35"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow=head\n fast=head\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n if slow ==fast:\n return True\n return False","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast = head\n slow = head\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n if fast == slow:\n return True\n return False\n ","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n h1,h2 = head,head\n while h1 and h1.next:\n h1 = h1.next.next\n h2 = h2.next\n if h1 == h2:\n return True\n return False\n\n\n","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n s = set()\n while head:\n if head in s:\n return True\n s.add(head)\n head = head.next\n return False","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow=fast=head\n current = head\n if head == None or head.next == None:\n return False\n \n while fast and fast.next != None:\n current = current.next\n fast = fast.next.next\n if current == fast:\n return True\n return False","runtime":"38"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if not head:\n return False\n\n slow = head\n fast = head.next\n\n while slow != fast:\n if not fast or not fast.next:\n return False\n\n slow = slow.next\n fast = fast.next.next\n return True\n\n # slow: one step, fast:two step\n # if there is cycle, fast will catch slow in some time\n\n # Time complexity：O(N+K), K: cycle length\n # 最坏的情况就是N次iter，因为N/(2-1) = N,(K = N)\n","runtime":"38"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n\nclass Solution:\n def hasCycle(self, head: ListNode) -> bool:\n slow, fast = head, head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n return True\n return False\n","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast = head\n while (fast and fast.next):\n head = head.next\n fast = fast.next.next\n if head is fast:\n return True\n return False","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n return True\n return False","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n s = set()\n while head:\n if head in s:\n return True\n s.add(head)\n head = head.next\n return False","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow=fast=head\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n if fast == slow:\n return True\n return False","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n curr = head\n\n while curr and curr.next:\n curr.val = str(curr.val) + \"!\"\n curr = curr.next\n if str(curr.val)[-1] == \"!\":\n return True\n\n return False\n\n ","runtime":"42"},{"code":"class Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast = head\n while fast and fast.next:\n head = head.next\n fast = fast.next.next\n if head is fast:\n return True\n return False","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n # If the list is empty or list has only one item\n # It cannot have a cycle\n if not head or not head.next:\n return False\n\n # Initialize two pointers\n slow = head\n fast = head\n\n # Traverse the list\n while fast and fast.next:\n # Move slow pointer one step\n slow = slow.next\n # Move fast pointer two steps\n fast = fast.next.next\n\n # If two pointers meet somewhere, cycle detected\n if slow == fast:\n return True\n\n # Finally, not cycle has been detected\n return False","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow, fast = head, head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n return True\n\n return False\n","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow, fast = head, head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n if slow == fast:\n return True\n \n return False","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n\n s=set()\n temp=head\n cycle=False\n while temp!=None:\n if temp not in s:\n #print(\"here\",temp)\n s.add(temp)\n else:\n cycle=True\n #print(\"cycle\",cycle)\n break\n temp=temp.next\n\n return cycle\n\n\n\n\n\n\n\n ","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast, slow = head, head\n\n while fast and fast.next and fast.next.next:\n fast = fast.next.next\n slow = slow.next\n if slow == fast:\n return True\n return False","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow=fast=head\n current = head\n if head == None or head.next == None:\n return False\n \n while fast and fast.next:\n current = current.next\n fast = fast.next.next\n if current == fast:\n return True\n return False","runtime":"46"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n s = set()\n while head:\n if head in s:\n return True\n s.add(head)\n head = head.next\n return False","runtime":"46"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n cur = head\n fast = slow = head\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n\n if slow is fast:\n return True\n return False\n\n ","runtime":"47"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n return True\n return False\n ","runtime":"47"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n\n if head == None or head.next == None: \n return False\n slow = head\n fast = head.next\n while fast != None:\n if slow == fast:\n return True\n slow = slow.next\n try:\n fast = fast.next.next\n except:\n return False\n return False\n ","runtime":"48"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n\n st=set()\n temp=head\n\n while temp is not None:\n\n if temp in st:return True\n st.add(temp)\n\n temp=temp.next\n\n return False\n\n ","runtime":"48"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow = head\n fast = head\n while (fast):\n if slow and slow.next:\n slow = slow.next\n elif slow:\n return False\n if fast and fast.next and fast.next.next:\n fast = fast.next.next\n elif fast:\n return False\n elif fast.next:\n return False\n \n if slow == fast:\n return True\n return False","runtime":"49"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n mySet=set()\n curr = head\n while curr:\n if curr not in mySet:\n mySet.add(curr)\n curr=curr.next\n else:\n return True\n return False","runtime":"49"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if head is None:\n return False\n hashtable = {}\n curr = head\n while curr:\n if curr not in hashtable:\n hashtable[curr] = 1\n else:\n return True\n curr = curr.next\n return False","runtime":"50"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast: return True\n return False","runtime":"50"},{"code":"class Solution:\n def hasCycle(self, head: ListNode) -> bool:\n slow = fast = head\n while fast and fast.next:\n slow, fast = slow.next, fast.next.next\n if slow == fast:\n return True\n return False","runtime":"51"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, x):\n self.val = x\n self.next = None\nfrom typing import Optional\n\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if not head or not head.next:\n return False\n slow = head\n fast = head.next\n while fast and fast.next:\n if fast == slow:\n return True\n fast = fast.next.next\n slow = slow.next\n\n return False\n\n","runtime":"51"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n p1 = head\n p2 = head\n\n while p2 is not None and p2.next is not None:\n p2 = p2.next.next\n \n if p2 == p1:\n return True\n\n p1 = p1.next\n \n return False","runtime":"52"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n curr = head\n\n while curr and curr.next:\n curr.val = str(curr.val) + \"!\"\n curr = curr.next\n if str(curr.val)[-1] == \"!\":\n return True\n\n return False\n \n\n \n \n \n ","runtime":"52"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n # using hare and tortoise or hash table approaches\n hare = head \n tort = head \n \n while hare and hare.next:\n hare = hare.next.next\n tort = tort.next\n if hare == tort:\n return True\n \n return False","runtime":"53"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow = fast = head\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n if slow == fast:\n return True\n return False\n ","runtime":"53"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast = head\n slow = head\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n if fast == slow:\n return True\n \n return False\n ","runtime":"54"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, x):\n self.val = x\n self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n turtle = head\n if head == None:\n return False\n rabbit = head.next\n if rabbit == None:\n return False\n else:\n while rabbit != None:\n if rabbit == turtle:\n return True\n else:\n turtle = turtle.next\n if rabbit.next == None:\n return False\n else:\n rabbit = rabbit.next\n if rabbit.next == None:\n return False\n else:\n rabbit = rabbit.next\n return False","runtime":"54"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n \n fast = head\n slow = head\n \n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n \n if fast == slow:\n return True\n \n return False","runtime":"55"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if head is None or head.next is None:\n return False\n\n slow = head\n fast = head.next\n while slow:\n if slow == fast:\n return True\n if fast.next is None or fast.next.next is None:\n return False\n slow = slow.next\n fast = fast.next.next\n return False","runtime":"55"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if not head:\n return False\n node_set = set()\n while head.next != None:\n node_set.add(head)\n head = head.next\n if head in node_set:\n return True\n return False\n\n","runtime":"56"},{"code":"from collections import defaultdict\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if head is None:\n return False\n count = defaultdict(int)\n cur = head\n while cur is not None:\n if count[cur] == 1:\n return True\n else:\n count[cur] += 1\n cur = cur.next\n return False\n ","runtime":"56"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n curr = head\n\n while curr and curr.next:\n curr.val = str(curr.val) + \"!\"\n curr = curr.next\n if str(curr.val)[-1] == \"!\":\n return True\n\n return False\n \n\n \n \n \n ","runtime":"57"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast, slow = head, head\n\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n if fast == slow:\n return True\n \n return False","runtime":"57"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n n = 0\n while head:\n n += 1\n if n > pow(10, 4):\n return True\n head = head.next\n return False","runtime":"58"},{"code":"from collections import defaultdict\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if head is None:\n return False\n count = defaultdict(int)\n cur = head\n while cur is not None:\n if cur.next is not None:\n if count[cur.next] == 1:\n return True\n else:\n count[cur.next] += 1\n cur = cur.next\n return False\n ","runtime":"58"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if not head or not head.next:\n return False\n fast = head.next\n slow = head\n while slow!=fast and fast!= None:\n if fast.next == None:\n return False\n fast = fast.next.next\n slow = slow.next\n if slow==fast:\n return True\n return False","runtime":"59"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n\n seen = set()\n\n while head:\n if head in seen:\n return True\n seen.add(head)\n head = head.next\n \n return False\n\n ","runtime":"59"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast = head\\n slow = head\\n \\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n \\n if fast == slow:\\n return True\\n \\n return False\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n \\n fast=head\\n while fast and fast.next:\\n head=head.next\\n fast=fast.next.next\\n if head==fast:\\n return True\\n return False\\n\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n s=set()\\n l=head\\n while l:\\n if l not in s:\\n s.add(l)\\n l=l.next\\n else:\\n return True\\n return False\\n \",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if head is None or head.next is None:\\n return False\\n hashmap = {}\\n current = head \\n while current:\\n if current in hashmap:\\n return True\\n hashmap[current] = True\\n current = current.next\\n return False\\n \\n \\n\\n \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n nodes_seen = set()\\n while head:\\n if head in nodes_seen:\\n return True\\n \\n nodes_seen.add(head)\\n head = head.next\\n\\n return False\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n # See if the hare catches up with the tortoise\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n return True\\n return False\\n\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if not head or not head.next:\\n return False\\n \\n slow, fast = head, head.next\\n \\n while slow != fast:\\n if not fast or not fast.next:\\n return False\\n slow = slow.next\\n fast = fast.next.next\\n \\n return True\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow = head\\n fast = head\\n while fast is not None and fast.next is not None:\\n slow = slow.next\\n fast = fast.next.next\\n if slow==fast:\\n return True\\n return False\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n #brute \\n while head is not None:\\n if head.val == '':\\n return True\\n head.val = ''\\n head = head.next\\n return False\\n\\n\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n \\n node_map = dict()\\n curr = head\\n while curr: \\n if curr not in node_map:\\n node_map[curr] = 0\\n else: \\n return True\\n curr = curr.next\\n \\n return False\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if not head:\\n return False\\n node_set = set()\\n while head.next != None:\\n node_set.add(head)\\n head = head.next\\n if head in node_set:\\n return True\\n return False\\n\\n\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n #Tortoise and hare algorithm, one node goes at speed 1, one node goes at speed 2\\n #If they are equivalent, there was a cycle somewhere\\n rabbit = head\\n tortoise = head\\n\\n while rabbit and rabbit.next:\\n tortoise = tortoise.next\\n rabbit = rabbit.next.next\\n\\n if tortoise == rabbit:\\n return True\\n\\n return False\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n\\n temp = ListNode()\\n temp.next = head\\n\\n #slow and fast pointer ( small +=1 ; fast +=2)\\n slow = fast = temp\\n\\n while fast and fast.next:\\n\\n #fast jumps 2 place\\n fast = fast.next.next\\n\\n #slow jumps 1 place\\n slow = slow.next\\n\\n #if both equal there is a cycle\\n if slow == fast:\\n return True\\n\\n return False \\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, x):\\n self.val = x\\n self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n # Initialize two pointers\\n slow = head\\n fast = head\\n \\n \\n while fast is not None and fast.next is not None:\\n slow = slow.next \\n fast = fast.next.next \\n if slow == fast:\\n return True\\n return False\\n\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if not head:\\n return False \\n dummy = ListNode()\\n dummy.next = head \\n slow = fast = dummy\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if fast == slow: \\n return True\\n return False\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow = head\\n fast = head\\n\\n while fast and slow:\\n fast = fast.next\\n if slow == fast:\\n return True\\n if fast == None:\\n return False\\n fast = fast.next\\n slow = slow.next\\n return False\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if not head:\\n return False\\n\\n current = head\\n visited = set()\\n\\n while current:\\n visited.add(current)\\n \\n if current.next in visited:\\n return True\\n\\n current = current.next\\n\\n return False\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n i = head \\n j = head\\n while j and j.next:\\n i = i.next\\n j = j.next.next\\n if i is j :\\n return 1\\n break\\n return 0\\n \\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n \\n slow = fast = head\\n \\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n \\n if fast == slow:\\n return True\\n \\n return False\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n s = set()\\n while head:\\n if head in s:\\n return True\\n s.add(head)\\n head = head.next\\n return False\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast = head\\n while fast and fast.next:\\n head = head.next\\n fast = fast.next.next\\n if head == fast:\\n return True\\n return False\\n\\n # n = 0\\n # while head:\\n # n += 1\\n # if n > pow(10, 4):\\n # return True\\n # head = head.next\\n # return False\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast=head\\n slow=head\\n while fast and fast.next is not None:\\n fast=fast.next.next\\n slow=slow.next\\n if fast==slow:\\n return True\\n return False\\n\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow = head\\n fast = head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n return True\\n return False\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow=head\\n fast=head\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n if slow ==fast:\\n return True\\n return False\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast = head\\n slow = head\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n if fast == slow:\\n return True\\n return False\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n h1,h2 = head,head\\n while h1 and h1.next:\\n h1 = h1.next.next\\n h2 = h2.next\\n if h1 == h2:\\n return True\\n return False\\n\\n\\n\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n s = set()\\n while head:\\n if head in s:\\n return True\\n s.add(head)\\n head = head.next\\n return False\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow=fast=head\\n current = head\\n if head == None or head.next == None:\\n return False\\n \\n while fast and fast.next != None:\\n current = current.next\\n fast = fast.next.next\\n if current == fast:\\n return True\\n return False\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if not head:\\n return False\\n\\n slow = head\\n fast = head.next\\n\\n while slow != fast:\\n if not fast or not fast.next:\\n return False\\n\\n slow = slow.next\\n fast = fast.next.next\\n return True\\n\\n # slow: one step, fast:two step\\n # if there is cycle, fast will catch slow in some time\\n\\n # Time complexity：O(N+K), K: cycle length\\n # 最坏的情况就是N次iter，因为N/(2-1) = N,(K = N)\\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n\\nclass Solution:\\n def hasCycle(self, head: ListNode) -> bool:\\n slow, fast = head, head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n return True\\n return False\\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast = head\\n while (fast and fast.next):\\n head = head.next\\n fast = fast.next.next\\n if head is fast:\\n return True\\n return False\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n return True\\n return False\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n s = set()\\n while head:\\n if head in s:\\n return True\\n s.add(head)\\n head = head.next\\n return False\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow=fast=head\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n if fast == slow:\\n return True\\n return False\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n curr = head\\n\\n while curr and curr.next:\\n curr.val = str(curr.val) + \\\"!\\\"\\n curr = curr.next\\n if str(curr.val)[-1] == \\\"!\\\":\\n return True\\n\\n return False\\n\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast = head\\n while fast and fast.next:\\n head = head.next\\n fast = fast.next.next\\n if head is fast:\\n return True\\n return False\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n # If the list is empty or list has only one item\\n # It cannot have a cycle\\n if not head or not head.next:\\n return False\\n\\n # Initialize two pointers\\n slow = head\\n fast = head\\n\\n # Traverse the list\\n while fast and fast.next:\\n # Move slow pointer one step\\n slow = slow.next\\n # Move fast pointer two steps\\n fast = fast.next.next\\n\\n # If two pointers meet somewhere, cycle detected\\n if slow == fast:\\n return True\\n\\n # Finally, not cycle has been detected\\n return False\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow, fast = head, head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n return True\\n\\n return False\\n\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow, fast = head, head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n if slow == fast:\\n return True\\n \\n return False\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n\\n s=set()\\n temp=head\\n cycle=False\\n while temp!=None:\\n if temp not in s:\\n #print(\\\"here\\\",temp)\\n s.add(temp)\\n else:\\n cycle=True\\n #print(\\\"cycle\\\",cycle)\\n break\\n temp=temp.next\\n\\n return cycle\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast, slow = head, head\\n\\n while fast and fast.next and fast.next.next:\\n fast = fast.next.next\\n slow = slow.next\\n if slow == fast:\\n return True\\n return False\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow=fast=head\\n current = head\\n if head == None or head.next == None:\\n return False\\n \\n while fast and fast.next:\\n current = current.next\\n fast = fast.next.next\\n if current == fast:\\n return True\\n return False\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n s = set()\\n while head:\\n if head in s:\\n return True\\n s.add(head)\\n head = head.next\\n return False\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n cur = head\\n fast = slow = head\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n\\n if slow is fast:\\n return True\\n return False\\n\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n return True\\n return False\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n\\n if head == None or head.next == None: \\n return False\\n slow = head\\n fast = head.next\\n while fast != None:\\n if slow == fast:\\n return True\\n slow = slow.next\\n try:\\n fast = fast.next.next\\n except:\\n return False\\n return False\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n\\n st=set()\\n temp=head\\n\\n while temp is not None:\\n\\n if temp in st:return True\\n st.add(temp)\\n\\n temp=temp.next\\n\\n return False\\n\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow = head\\n fast = head\\n while (fast):\\n if slow and slow.next:\\n slow = slow.next\\n elif slow:\\n return False\\n if fast and fast.next and fast.next.next:\\n fast = fast.next.next\\n elif fast:\\n return False\\n elif fast.next:\\n return False\\n \\n if slow == fast:\\n return True\\n return False\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n mySet=set()\\n curr = head\\n while curr:\\n if curr not in mySet:\\n mySet.add(curr)\\n curr=curr.next\\n else:\\n return True\\n return False\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if head is None:\\n return False\\n hashtable = {}\\n curr = head\\n while curr:\\n if curr not in hashtable:\\n hashtable[curr] = 1\\n else:\\n return True\\n curr = curr.next\\n return False\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast: return True\\n return False\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def hasCycle(self, head: ListNode) -> bool:\\n slow = fast = head\\n while fast and fast.next:\\n slow, fast = slow.next, fast.next.next\\n if slow == fast:\\n return True\\n return False\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, x):\\n self.val = x\\n self.next = None\\nfrom typing import Optional\\n\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if not head or not head.next:\\n return False\\n slow = head\\n fast = head.next\\n while fast and fast.next:\\n if fast == slow:\\n return True\\n fast = fast.next.next\\n slow = slow.next\\n\\n return False\\n\\n\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n p1 = head\\n p2 = head\\n\\n while p2 is not None and p2.next is not None:\\n p2 = p2.next.next\\n \\n if p2 == p1:\\n return True\\n\\n p1 = p1.next\\n \\n return False\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n curr = head\\n\\n while curr and curr.next:\\n curr.val = str(curr.val) + \\\"!\\\"\\n curr = curr.next\\n if str(curr.val)[-1] == \\\"!\\\":\\n return True\\n\\n return False\\n \\n\\n \\n \\n \\n \",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n # using hare and tortoise or hash table approaches\\n hare = head \\n tort = head \\n \\n while hare and hare.next:\\n hare = hare.next.next\\n tort = tort.next\\n if hare == tort:\\n return True\\n \\n return False\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow = fast = head\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n if slow == fast:\\n return True\\n return False\\n \",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast = head\\n slow = head\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n if fast == slow:\\n return True\\n \\n return False\\n \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, x):\\n self.val = x\\n self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n turtle = head\\n if head == None:\\n return False\\n rabbit = head.next\\n if rabbit == None:\\n return False\\n else:\\n while rabbit != None:\\n if rabbit == turtle:\\n return True\\n else:\\n turtle = turtle.next\\n if rabbit.next == None:\\n return False\\n else:\\n rabbit = rabbit.next\\n if rabbit.next == None:\\n return False\\n else:\\n rabbit = rabbit.next\\n return False\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n \\n fast = head\\n slow = head\\n \\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n \\n if fast == slow:\\n return True\\n \\n return False\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if head is None or head.next is None:\\n return False\\n\\n slow = head\\n fast = head.next\\n while slow:\\n if slow == fast:\\n return True\\n if fast.next is None or fast.next.next is None:\\n return False\\n slow = slow.next\\n fast = fast.next.next\\n return False\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if not head:\\n return False\\n node_set = set()\\n while head.next != None:\\n node_set.add(head)\\n head = head.next\\n if head in node_set:\\n return True\\n return False\\n\\n\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"from collections import defaultdict\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if head is None:\\n return False\\n count = defaultdict(int)\\n cur = head\\n while cur is not None:\\n if count[cur] == 1:\\n return True\\n else:\\n count[cur] += 1\\n cur = cur.next\\n return False\\n \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n curr = head\\n\\n while curr and curr.next:\\n curr.val = str(curr.val) + \\\"!\\\"\\n curr = curr.next\\n if str(curr.val)[-1] == \\\"!\\\":\\n return True\\n\\n return False\\n \\n\\n \\n \\n \\n \",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast, slow = head, head\\n\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n if fast == slow:\\n return True\\n \\n return False\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n n = 0\\n while head:\\n n += 1\\n if n > pow(10, 4):\\n return True\\n head = head.next\\n return False\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"from collections import defaultdict\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if head is None:\\n return False\\n count = defaultdict(int)\\n cur = head\\n while cur is not None:\\n if cur.next is not None:\\n if count[cur.next] == 1:\\n return True\\n else:\\n count[cur.next] += 1\\n cur = cur.next\\n return False\\n \",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if not head or not head.next:\\n return False\\n fast = head.next\\n slow = head\\n while slow!=fast and fast!= None:\\n if fast.next == None:\\n return False\\n fast = fast.next.next\\n slow = slow.next\\n if slow==fast:\\n return True\\n return False\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n\\n seen = set()\\n\\n while head:\\n if head in seen:\\n return True\\n seen.add(head)\\n head = head.next\\n \\n return False\\n\\n \",\n \"runtime\": \"59\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":69,"string":"69"},"mm_list":{"kind":"list like","value":[{"code":"# # Definition for singly-linked list.\n# # class ListNode:\n# # def __init__(self, x):\n# # self.val = x\n# # self.next = None\n\n# class Solution:\n# def hasCycle(self, head: Optional[ListNode]) -> bool:\n# if not head.next:\n# return False\n# pointer = head\n# for i in range(6):\n# print(pointer.val)\n# pointer = pointer.next\n\n\nimport sys\n\nwith open('user.out', 'w') as f:\n count = 0\n while True:\n line = sys.stdin.readline().strip()#[1:-1]\n # print(f\"in loop : {line}\")\n if not line:\n break\n if count %2 ==1:\n f.write('true\\n' if int(line)>=0 else 'false\\n')\n count +=1\n\nexit(0)\n","memory":"16600"},{"code":"# # Definition for singly-linked list.\n# # class ListNode:\n# # def __init__(self, x):\n# # self.val = x\n# # self.next = None\n\n# class Solution:\n# def hasCycle(self, head: Optional[ListNode]) -> bool:\n# if not head.next:\n# return False\n# pointer = head\n# for i in range(6):\n# print(pointer.val)\n# pointer = pointer.next\n\n\nimport sys\n\nwith open('user.out', 'w') as f:\n count = 0\n while True:\n line = sys.stdin.readline().strip()#[1:-1]\n # print(f\"in loop : {line}\")\n if not line:\n break\n if count %2 ==1:\n f.write('true\\n' if int(line)>=0 else 'false\\n')\n count +=1\n\nexit(0)\n","memory":"16700"},{"code":"# # Definition for singly-linked list.\n# # class ListNode:\n# # def __init__(self, x):\n# # self.val = x\n# # self.next = None\n\n# class Solution:\n# def hasCycle(self, head: Optional[ListNode]) -> bool:\n# if not head.next:\n# return False\n# pointer = head\n# for i in range(6):\n# print(pointer.val)\n# pointer = pointer.next\n\n\nimport sys\n\nwith open('user.out', 'w') as f:\n count = 0\n while True:\n line = sys.stdin.readline().strip()#[1:-1]\n # print(f\"in loop : {line}\")\n if not line:\n break\n if count %2:\n f.write('true\\n' if int(line)>=0 else 'false\\n')\n count +=1\n\nexit(0)\n","memory":"16800"},{"code":"# # Definition for singly-linked list.\n# # class ListNode:\n# # def __init__(self, x):\n# # self.val = x\n# # self.next = None\n\n# class Solution:\n# def hasCycle(self, head: Optional[ListNode]) -> bool:\n# if not head.next:\n# return False\n# pointer = head\n# for i in range(6):\n# print(pointer.val)\n# pointer = pointer.next\n\n\nimport sys\n\nwith open('user.out', 'w') as f:\n count = 0\n while True:\n line = sys.stdin.readline().strip()#[1:-1]\n # print(f\"in loop : {line}\")\n if not line:\n break\n if count %2:\n f.write('true\\n' if int(line)>=0 else 'false\\n')\n count +=1\n\nexit(0)\n","memory":"16800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n\n current = head\n while current is not None:\n if current.next == head:\n return True\n else:\n next = current.next\n current.next = head\n current = next\n \n return False","memory":"17800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if not head:\n return False\n sink = ListNode(10e6)\n while head.next:\n temp = head.next\n head.next = sink\n head = temp\n\n return head.val == 10e6","memory":"17900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n prev=None\n curr=head\n while curr:\n nxt=curr.next\n curr.next=prev\n prev=curr\n curr=nxt\n if nxt==head:\n return True\n return False\n","memory":"18000"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, x):\n self.val = x\n self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n magic_node = ListNode(2)\n while head:\n if head.next == magic_node:\n return True\n if head == None:\n return False\n else:\n next_head = head.next\n head.next= magic_node\n head = next_head\n \n","memory":"18100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if head == None:\n return False\n # move the next ptr to be 2 ahead\n while head != None and head.next != None:\n head.next = head.next.next\n if head.next == head:\n return True\n head = head.next\n return False","memory":"18200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n # pos != -1\n # at least one node\n # retrieve final next\n if head is None:\n return False\n\n # continually traverse \n # how do i keep track of nodes i have seen?\n seen = []\n\n while True:\n if head in seen:\n return True\n\n if head.next is None:\n return False\n \n seen.append(head)\n head = head.next\n\n ","memory":"18300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n cur = head\n while cur:\n if cur.val == 'OilGas':\n return True\n cur.val = 'OilGas'\n cur = cur.next\n return False","memory":"18400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n # curr = head\n # seen = set()\n\n # while curr:\n # if curr.next in seen and curr.next is not None:\n # return True\n # seen.add(curr.next)\n # curr = curr.next\n \n # return False\n\n while head:\n if head.val is None:\n return True\n\n head.val = None\n head = head.next\n return False","memory":"18400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n \n current = head\n while current is not None:\n if current.val == \"visited\":\n return True\n current.val = \"visited\"\n current = current.next\n return False\n ","memory":"18500"},{"code":"class Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n\n curr = head\n while curr:\n if curr.val == 100001:\n return True\n curr.val = 100001\n curr = curr.next\n\n return False","memory":"18500"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, x):\n self.val = x\n self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n curr=head\n while curr is not None:\n curr.val='x'\n curr=curr.next\n if curr is not None and curr.val=='x':\n return True\n return False\n ","memory":"18600"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, x):\n self.val = x\n self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n curr=head\n while curr is not None:\n curr.val='x'\n curr=curr.next\n if curr is not None and curr.val=='x':\n return True\n return False\n ","memory":"18600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if not head:\n return False\n\n slow = head\n fast = head.next\n\n while slow and fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n return True\n \n return False","memory":"18700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n \n slow = fast = head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n return True\n \n return False","memory":"18800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow = head\n fast = head\n while fast != None and fast.next != None:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n return True\n return False\n ","memory":"18800"},{"code":"class Solution:\n def hasCycle(self, head: ListNode) -> bool:\n slow = fast = head\n while fast and fast.next:\n slow, fast = slow.next, fast.next.next\n if slow == fast:\n return True\n return False","memory":"18900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow=fast=head\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n if fast == slow:\n return True\n return False","memory":"18900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast = head \n slow = head \n while fast and fast.next : \n slow = slow.next\n fast = fast.next.next \n if slow is fast :\n return True \n return False\n\n\n","memory":"19000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast=head\n while fast and fast.next:\n head=head.next\n fast=fast.next.next\n if head is fast:\n return True\n return False\n\n ","memory":"19100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n pointer_1 = head\n pointer_2 = head\n\n while pointer_1 and pointer_1.next:\n pointer_1 = pointer_1.next.next\n pointer_2 = pointer_2.next\n if pointer_1 == pointer_2:\n return True\n \n return False","memory":"19100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n fast=head\n slow=head\n while fast and fast.next is not None:\n fast=fast.next.next\n slow=slow.next\n if fast==slow:\n return True\n return False\n","memory":"19200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n h1,h2 = head,head\n while h1 and h1.next:\n h1 = h1.next.next\n h2 = h2.next\n if h1 == h2:\n return True\n return False\n\n\n","memory":"19200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n nodes, cur = {}, head\n \n while cur:\n if cur in nodes:\n return True\n nodes[cur] = 1\n cur = cur.next\n\n return False\n","memory":"19300"},{"code":"from collections import defaultdict\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n if head is None:\n return False\n count = defaultdict(int)\n cur = head\n while cur is not None:\n if cur.next is not None:\n if count[cur.next] == 1:\n return True\n else:\n count[cur.next] += 1\n cur = cur.next\n return False\n# class Solution:\n# def hasCycle(self, head: Optional[ListNode]) -> bool:\n# if head is None:\n# return False\n# # pos is a dictionary of key=ListNode and value=how many links to that node are found\n# links = defaultdict(int)\n# node = head\n# while node is not None:\n# if node.next is not None:\n# if links[node.next] == 1:\n# return True\n# else:\n# links[node.next] += 1\n# node = node.next\n# return False","memory":"19300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n seen = set()\n while head:\n if head in seen:\n return True\n seen.add(head)\n head = head.next\n return False\n","memory":"19400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n s = set()\n while head:\n if head in s:\n return True\n s.add(head)\n head = head.next\n return False","memory":"19400"}],"string":"[\n {\n \"code\": \"# # Definition for singly-linked list.\\n# # class ListNode:\\n# # def __init__(self, x):\\n# # self.val = x\\n# # self.next = None\\n\\n# class Solution:\\n# def hasCycle(self, head: Optional[ListNode]) -> bool:\\n# if not head.next:\\n# return False\\n# pointer = head\\n# for i in range(6):\\n# print(pointer.val)\\n# pointer = pointer.next\\n\\n\\nimport sys\\n\\nwith open('user.out', 'w') as f:\\n count = 0\\n while True:\\n line = sys.stdin.readline().strip()#[1:-1]\\n # print(f\\\"in loop : {line}\\\")\\n if not line:\\n break\\n if count %2 ==1:\\n f.write('true\\\\n' if int(line)>=0 else 'false\\\\n')\\n count +=1\\n\\nexit(0)\\n\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"# # Definition for singly-linked list.\\n# # class ListNode:\\n# # def __init__(self, x):\\n# # self.val = x\\n# # self.next = None\\n\\n# class Solution:\\n# def hasCycle(self, head: Optional[ListNode]) -> bool:\\n# if not head.next:\\n# return False\\n# pointer = head\\n# for i in range(6):\\n# print(pointer.val)\\n# pointer = pointer.next\\n\\n\\nimport sys\\n\\nwith open('user.out', 'w') as f:\\n count = 0\\n while True:\\n line = sys.stdin.readline().strip()#[1:-1]\\n # print(f\\\"in loop : {line}\\\")\\n if not line:\\n break\\n if count %2 ==1:\\n f.write('true\\\\n' if int(line)>=0 else 'false\\\\n')\\n count +=1\\n\\nexit(0)\\n\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"# # Definition for singly-linked list.\\n# # class ListNode:\\n# # def __init__(self, x):\\n# # self.val = x\\n# # self.next = None\\n\\n# class Solution:\\n# def hasCycle(self, head: Optional[ListNode]) -> bool:\\n# if not head.next:\\n# return False\\n# pointer = head\\n# for i in range(6):\\n# print(pointer.val)\\n# pointer = pointer.next\\n\\n\\nimport sys\\n\\nwith open('user.out', 'w') as f:\\n count = 0\\n while True:\\n line = sys.stdin.readline().strip()#[1:-1]\\n # print(f\\\"in loop : {line}\\\")\\n if not line:\\n break\\n if count %2:\\n f.write('true\\\\n' if int(line)>=0 else 'false\\\\n')\\n count +=1\\n\\nexit(0)\\n\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"# # Definition for singly-linked list.\\n# # class ListNode:\\n# # def __init__(self, x):\\n# # self.val = x\\n# # self.next = None\\n\\n# class Solution:\\n# def hasCycle(self, head: Optional[ListNode]) -> bool:\\n# if not head.next:\\n# return False\\n# pointer = head\\n# for i in range(6):\\n# print(pointer.val)\\n# pointer = pointer.next\\n\\n\\nimport sys\\n\\nwith open('user.out', 'w') as f:\\n count = 0\\n while True:\\n line = sys.stdin.readline().strip()#[1:-1]\\n # print(f\\\"in loop : {line}\\\")\\n if not line:\\n break\\n if count %2:\\n f.write('true\\\\n' if int(line)>=0 else 'false\\\\n')\\n count +=1\\n\\nexit(0)\\n\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n\\n current = head\\n while current is not None:\\n if current.next == head:\\n return True\\n else:\\n next = current.next\\n current.next = head\\n current = next\\n \\n return False\",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if not head:\\n return False\\n sink = ListNode(10e6)\\n while head.next:\\n temp = head.next\\n head.next = sink\\n head = temp\\n\\n return head.val == 10e6\",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n prev=None\\n curr=head\\n while curr:\\n nxt=curr.next\\n curr.next=prev\\n prev=curr\\n curr=nxt\\n if nxt==head:\\n return True\\n return False\\n\",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, x):\\n self.val = x\\n self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n magic_node = ListNode(2)\\n while head:\\n if head.next == magic_node:\\n return True\\n if head == None:\\n return False\\n else:\\n next_head = head.next\\n head.next= magic_node\\n head = next_head\\n \\n\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if head == None:\\n return False\\n # move the next ptr to be 2 ahead\\n while head != None and head.next != None:\\n head.next = head.next.next\\n if head.next == head:\\n return True\\n head = head.next\\n return False\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n # pos != -1\\n # at least one node\\n # retrieve final next\\n if head is None:\\n return False\\n\\n # continually traverse \\n # how do i keep track of nodes i have seen?\\n seen = []\\n\\n while True:\\n if head in seen:\\n return True\\n\\n if head.next is None:\\n return False\\n \\n seen.append(head)\\n head = head.next\\n\\n \",\n \"memory\": \"18300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n cur = head\\n while cur:\\n if cur.val == 'OilGas':\\n return True\\n cur.val = 'OilGas'\\n cur = cur.next\\n return False\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n # curr = head\\n # seen = set()\\n\\n # while curr:\\n # if curr.next in seen and curr.next is not None:\\n # return True\\n # seen.add(curr.next)\\n # curr = curr.next\\n \\n # return False\\n\\n while head:\\n if head.val is None:\\n return True\\n\\n head.val = None\\n head = head.next\\n return False\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n \\n current = head\\n while current is not None:\\n if current.val == \\\"visited\\\":\\n return True\\n current.val = \\\"visited\\\"\\n current = current.next\\n return False\\n \",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"class Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n\\n curr = head\\n while curr:\\n if curr.val == 100001:\\n return True\\n curr.val = 100001\\n curr = curr.next\\n\\n return False\",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, x):\\n self.val = x\\n self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n curr=head\\n while curr is not None:\\n curr.val='x'\\n curr=curr.next\\n if curr is not None and curr.val=='x':\\n return True\\n return False\\n \",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, x):\\n self.val = x\\n self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n curr=head\\n while curr is not None:\\n curr.val='x'\\n curr=curr.next\\n if curr is not None and curr.val=='x':\\n return True\\n return False\\n \",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if not head:\\n return False\\n\\n slow = head\\n fast = head.next\\n\\n while slow and fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n return True\\n \\n return False\",\n \"memory\": \"18700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n \\n slow = fast = head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n return True\\n \\n return False\",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow = head\\n fast = head\\n while fast != None and fast.next != None:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n return True\\n return False\\n \",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"class Solution:\\n def hasCycle(self, head: ListNode) -> bool:\\n slow = fast = head\\n while fast and fast.next:\\n slow, fast = slow.next, fast.next.next\\n if slow == fast:\\n return True\\n return False\",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n slow=fast=head\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n if fast == slow:\\n return True\\n return False\",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast = head \\n slow = head \\n while fast and fast.next : \\n slow = slow.next\\n fast = fast.next.next \\n if slow is fast :\\n return True \\n return False\\n\\n\\n\",\n \"memory\": \"19000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast=head\\n while fast and fast.next:\\n head=head.next\\n fast=fast.next.next\\n if head is fast:\\n return True\\n return False\\n\\n \",\n \"memory\": \"19100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n pointer_1 = head\\n pointer_2 = head\\n\\n while pointer_1 and pointer_1.next:\\n pointer_1 = pointer_1.next.next\\n pointer_2 = pointer_2.next\\n if pointer_1 == pointer_2:\\n return True\\n \\n return False\",\n \"memory\": \"19100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n fast=head\\n slow=head\\n while fast and fast.next is not None:\\n fast=fast.next.next\\n slow=slow.next\\n if fast==slow:\\n return True\\n return False\\n\",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n h1,h2 = head,head\\n while h1 and h1.next:\\n h1 = h1.next.next\\n h2 = h2.next\\n if h1 == h2:\\n return True\\n return False\\n\\n\\n\",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n nodes, cur = {}, head\\n \\n while cur:\\n if cur in nodes:\\n return True\\n nodes[cur] = 1\\n cur = cur.next\\n\\n return False\\n\",\n \"memory\": \"19300\"\n },\n {\n \"code\": \"from collections import defaultdict\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n if head is None:\\n return False\\n count = defaultdict(int)\\n cur = head\\n while cur is not None:\\n if cur.next is not None:\\n if count[cur.next] == 1:\\n return True\\n else:\\n count[cur.next] += 1\\n cur = cur.next\\n return False\\n# class Solution:\\n# def hasCycle(self, head: Optional[ListNode]) -> bool:\\n# if head is None:\\n# return False\\n# # pos is a dictionary of key=ListNode and value=how many links to that node are found\\n# links = defaultdict(int)\\n# node = head\\n# while node is not None:\\n# if node.next is not None:\\n# if links[node.next] == 1:\\n# return True\\n# else:\\n# links[node.next] += 1\\n# node = node.next\\n# return False\",\n \"memory\": \"19300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n seen = set()\\n while head:\\n if head in seen:\\n return True\\n seen.add(head)\\n head = head.next\\n return False\\n\",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n\\nclass Solution:\\n def hasCycle(self, head: Optional[ListNode]) -> bool:\\n s = set()\\n while head:\\n if head in s:\\n return True\\n s.add(head)\\n head = head.next\\n return False\",\n \"memory\": \"19400\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":30,"string":"30"}}},{"rowIdx":46,"cells":{"question_id":{"kind":"number","value":142,"string":"142"},"name":{"kind":"string","value":"linked-list-cycle-ii"},"content":{"kind":"string","value":"<p>Given the <code>head</code> of a linked list, return <em>the node where the cycle begins. If there is no cycle, return </em><code>null</code>.</p>\n\n<p>There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the <code>next</code> pointer. Internally, <code>pos</code> is used to denote the index of the node that tail's <code>next</code> pointer is connected to (<strong>0-indexed</strong>). It is <code>-1</code> if there is no cycle. <strong>Note that</strong> <code>pos</code> <strong>is not passed as a parameter</strong>.</p>\n\n<p><strong>Do not modify</strong> the linked list.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png\" style=\"height: 145px; width: 450px;\" />\n<pre>\n<strong>Input:</strong> head = [3,2,0,-4], pos = 1\n<strong>Output:</strong> tail connects to node index 1\n<strong>Explanation:</strong> There is a cycle in the linked list, where tail connects to the second node.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png\" style=\"height: 105px; width: 201px;\" />\n<pre>\n<strong>Input:</strong> head = [1,2], pos = 0\n<strong>Output:</strong> tail connects to node index 0\n<strong>Explanation:</strong> There is a cycle in the linked list, where tail connects to the first node.\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png\" style=\"height: 65px; width: 65px;\" />\n<pre>\n<strong>Input:</strong> head = [1], pos = -1\n<strong>Output:</strong> no cycle\n<strong>Explanation:</strong> There is no cycle in the linked list.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of the nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.</li>\n\t<li><code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code></li>\n\t<li><code>pos</code> is <code>-1</code> or a <strong>valid index</strong> in the linked-list.</li>\n</ul>\n\n<p> </p>\n<p><strong>Follow up:</strong> Can you solve it using <code>O(1)</code> (i.e. constant) memory?</p>\n"},"acRate":{"kind":"number","value":52.607954551821955,"string":"52.607955"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["hash-table","linked-list","two-pointers"],"string":"[\n \"hash-table\",\n \"linked-list\",\n \"two-pointers\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"18\", 0.0109], [\"22\", 0.0109], [\"23\", 0.0326], [\"24\", 0.0218], [\"25\", 0.0544], [\"26\", 0.0979], [\"27\", 0.1958], [\"28\", 0.1305], [\"29\", 0.1632], [\"30\", 0.5548], [\"31\", 0.9465], [\"32\", 0.5875], [\"33\", 0.9574], [\"34\", 2.2302], [\"35\", 2.4369], [\"36\", 1.6536], [\"37\", 2.4151], [\"38\", 5.2654], [\"39\", 5.2872], [\"40\", 4.2646], [\"41\", 4.4822], [\"42\", 8.6706], [\"43\", 7.2019], [\"44\", 5.5265], [\"45\", 6.0705], [\"46\", 7.6371], [\"47\", 6.4513], [\"48\", 5.1784], [\"49\", 4.1993], [\"50\", 4.134], [\"51\", 3.416], [\"52\", 2.1432], [\"53\", 1.5231], [\"54\", 0.9574]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"18100\", 0.0218], [\"18200\", 0.2067], [\"18300\", 0.3155], [\"18400\", 0.0544], [\"18500\", 0.0218], [\"18600\", 0.087], [\"18700\", 1.6971], [\"18800\", 11.1619], [\"18900\", 10.6832], [\"19000\", 15.9051], [\"19100\", 35.7158], [\"19200\", 3.1005], [\"19300\", 0.4896], [\"19400\", 3.8512], [\"19500\", 10.0196]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: ListNode) -> ListNode:\n if not head or not head.next:\n return None\n \n # 步驟 1: 使用快慢指針找到相遇點\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n break\n else:\n return None # 沒有環\n \n # 步驟 2: 找到環的起始點\n slow = head\n while slow != fast:\n slow = slow.next\n fast = fast.next\n \n return slow","runtime":"18"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None: return None\n slow=head\n fast=head\n\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n if slow==fast: break\n else:\n return None\n\n temp=head \n while slow!=temp:\n slow=slow.next\n temp=temp.next\n return temp\n ","runtime":"22"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow,fast=head,head\n while fast and fast.next:\n slow= slow.next\n fast = fast.next.next\n if fast == slow :\n slow=head\n while slow!=fast:\n slow=slow.next\n fast = fast.next\n return fast\n return None ","runtime":"23"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n nodes = set()\n cur = head\n \n while cur:\n if cur in nodes: return cur\n nodes.add(cur)\n cur = cur.next\n return None\n ","runtime":"24"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = fast = head\n\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n\n if fast == slow:\n break\n \n else:\n return None\n\n while head != slow:\n head, slow = head.next, slow.next\n return head\n ","runtime":"25"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n break\n if not fast or not fast.next:\n return None\n while head != slow:\n head, slow = head.next, slow.next\n return head\n ","runtime":"26"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n nodeSet = set()\n curr = head\n while curr:\n if curr in nodeSet:\n return curr\n nodeSet.add(curr)\n curr = curr.next\n\n return None","runtime":"27"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return None\n slow=fast=head\n \n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow==fast:\n break\n else:\n return None\n\n slow = head\n while slow != fast:\n slow = slow.next\n fast = fast.next\n return slow \n\n ","runtime":"28"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = fast = head\n while fast and fast.next:\n slow, fast = slow.next, fast.next.next\n if slow == fast: break\n else: return None # if not (fast and fast.next): return None\n while head != slow:\n head, slow = head.next, slow.next\n return head\n ","runtime":"29"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n f = s = head\n while f and f.next:\n s = s.next\n f = f.next.next\n \n if s == f:\n f = head\n while s != f:\n s = s.next\n f = f.next\n \n return s","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None or head.next.next is None:\n return None\n\n fast = head.next.next\n slow = head.next\n while True:\n if fast == slow:\n slow = head\n while fast != slow:\n fast = fast.next\n slow = slow.next\n return slow\n else:\n if fast.next is None or fast.next.next is None:\n return None\n fast = fast.next.next\n slow = slow.next\n \n\n","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n slow = head\n fast = head\n\n while fast and fast.next:\n slow=slow.next\n fast = fast.next.next\n if slow == fast:\n while fast != head:\n head = head.next\n fast = fast.next\n return head\n \n\n return None\n ","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return None\n \n slow = head\n fast = head\n has_cycle = False\n \n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n if slow == fast:\n has_cycle = True\n break\n \n if not has_cycle:\n return None\n \n slow = head\n while slow != fast:\n slow = slow.next\n fast = fast.next\n \n return slow\n ","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None :\n return\n else:\n fp=head\n sl=head\n while fp!=None and fp.next!=None:\n sl=sl.next\n fp=fp.next.next\n if sl==fp:\n sl=head\n p=0\n while sl!=fp:\n sl=sl.next\n fp=fp.next\n p+=1\n return sl\n return None","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n turtle, hare = head,head\n prev = None\n \n if head == []:\n return None\n if not head or not head.next:\n return None\n\n isCycle = False\n while hare and hare.next:\n hare = hare.next.next\n turtle = turtle.next\n if hare == turtle:\n isCycle = True\n break\n\n if isCycle == False:\n return prev\n prev = head\n while prev != turtle:\n prev = prev.next\n turtle = turtle.next\n return prev\n\n ","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return None\n f = s = head\n while f and f.next:\n s = s.next\n f = f.next.next\n if s == f:\n break\n else:\n return None\n s = head\n while s != f:\n s = s.next\n f = f.next\n return s\n \n","runtime":"34"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow=fast=head\n if not (fast and fast.next):\n return None\n while fast and fast.next:\n fast=fast.next.next\n slow=slow.next\n if slow==fast:\n break\n slow2=head\n while slow and slow2 and slow2!=slow:\n slow=slow.next\n slow2=slow2.next\n return slow\n \n ","runtime":"34"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return None\n ptr = head\n ptr_map = set()\n while not ptr is None:\n if ptr in ptr_map:\n return ptr\n ptr_map.add(ptr)\n ptr = ptr.next\n return None\n","runtime":"35"},{"code":"class Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n if head is None:\n return None\n\n slow = head\n fast = head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n if slow == fast:\n break\n else:\n\n return None\n\n \n slow = head\n while slow != fast:\n slow = slow.next\n fast = fast.next\n\n\n return slow\n","runtime":"35"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = head\n fast = head\n while fast and fast.next:\n slow = slow.next \n fast = fast.next.next\n if slow is fast:\n start = head \n while start != slow:\n start = start.next\n slow = slow.next\n return start\n return None\n\n ","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if (not head) or (not head.next):\n return None\n \n slow = head.next\n fast = slow.next\n\n while slow != fast:\n slow = slow.next\n try:\n fast = fast.next.next\n except AttributeError:\n return None\n slow = head\n while slow != fast:\n slow = slow.next\n fast = fast.next\n return slow\n\n while fast:\n fast = fast.next\n if slow == fast:\n return slow.val\n if fast == None:\n return False\n fast = fast.next\n slow = slow.next\n return None","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow=fast=head\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n if slow==fast:\n slow=head\n while slow!=fast:\n slow=slow.next\n fast=fast.next\n return slow\n return None\n ","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow is fast:\n while head is not slow:\n slow = slow.next\n head = head.next\n return slow\n return None\n ","runtime":"38"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = fast = head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n break\n\n if fast is None or fast.next is None:\n return None\n\n fast = head\n\n while fast != slow:\n fast = fast.next\n slow = slow.next\n\n return slow","runtime":"38"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return None\n slow_ptr, fast_ptr = head.next, head.next.next\n\n while slow_ptr != fast_ptr:\n if fast_ptr is None or fast_ptr.next is None:\n return None\n slow_ptr = slow_ptr.next\n fast_ptr = fast_ptr.next.next\n \n slow_ptr = head\n while slow_ptr != fast_ptr:\n slow_ptr = slow_ptr.next\n fast_ptr = fast_ptr.next\n return slow_ptr","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = head\n fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n slow = head\n while slow != fast:\n slow = slow.next\n fast = fast.next\n return slow\n return None\n\n ","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = head\n fast = head\n collision = False\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n collision = True\n break\n if not collision:\n return None\n\n slow = head\n while slow != fast:\n slow = slow.next\n fast = fast.next\n return fast","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \"\"\"\n Every node as a unique id\n We loop through the linked list\n if we enounter an id we've seen before,\n then it's a cycle\n \n if we reach the end, return -1\n \n \"\"\"\n \n if head == None:\n return None\n \n ids = set()\n \n current = head\n \n while current:\n ID = id(current)\n \n if ID in ids:\n return current\n \n else:\n ids.add(ID)\n \n current = current.next\n \n return None\n ","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # Sol 1 maintain set\n # seen = set()\n # index = 0\n # while head and head not in seen:\n # seen.add(head)\n # head = head.next\n # return head\n\n slow = head\n fast = head\n\n while fast and fast.next: # Key point\n fast = fast.next.next\n slow = slow.next\n if slow == fast:\n break\n \n if not fast or not fast.next: # Key point\n return None\n \n while head != slow:\n head = head.next\n slow = slow.next\n return slow\n","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: return None\n slow, fast = head, head.next\n lam = pow = 1\n while slow != fast:\n if not fast: return None\n if lam == pow:\n pow <<= 1\n slow, lam = fast, 0\n fast = fast.next\n lam += 1\n mu = 0\n slow = fast = head\n for _ in range(lam): fast = fast.next\n while slow != fast:\n slow, fast = slow.next, fast.next\n mu += 1\n return slow\n ","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n\n p1 = head\n p2 = head\n\n while p2:\n p1 = p1.next\n p2 = p2.next\n if p2:\n p2 = p2.next\n\n if p1 == p2:\n break\n\n if not p2:\n return None\n\n p2 = head\n while p1 != p2:\n p1 = p1.next\n p2 = p2.next\n\n return p1\n ","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n f=head\n s=head\n while f and f.next:\n f=f.next.next\n s=s.next\n if(f==s):\n s=head\n while f!=s:\n s=s.next\n f=f.next\n return s\n return None","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return None\n\n slow = head\n fast = head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n break\n \n else:\n return None\n\n ptr1 = head\n ptr2 = slow\n\n while ptr1 != ptr2:\n ptr1 = ptr1.next\n ptr2 = ptr2.next\n\n return ptr1","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n\n # Solution 1 - using floyd's tortoise and hare\n # Time - O(n)\n # Space - O(1)\n\n if not head:\n return None\n\n flag = False\n\n slow, fast = head, head\n\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n\n if fast == slow:\n flag = True\n break\n\n if not flag:\n return None\n\n slow2 = head\n\n while True and slow:\n\n if slow == slow2:\n return slow\n slow = slow.next\n slow2 = slow2.next\n\n return None\n","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return None\n has_cycle = 0 \n slow,fast = head,head\n while(fast and fast.next):\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n has_cycle = 1\n break\n \n if not has_cycle:\n return None\n slow = head\n while(slow!=fast):\n slow = slow.next\n fast = fast.next\n return slow\n\n \n ","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow=fast=head\n while fast and fast.next:\n slow,fast=slow.next,fast.next.next\n if slow==fast:\n break\n else:\n return None\n while head!=slow:\n head,slow=head.next,slow.next\n return head\n \n\n \n ","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow=fast=head\n while fast and fast.next and fast.next.next:\n slow=slow.next\n fast=fast.next.next\n if slow==fast:\n break\n else:\n return None\n slow=head\n while slow!=fast:\n slow=slow.next\n fast=fast.next\n return slow\n \n\n \n ","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\nfrom typing import Optional\n\nclass Solution:\n def detectCycle(self, head):\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n slow2 = head\n while slow != slow2:\n slow = slow.next\n slow2 = slow2.next\n return slow2\n\n return None\n \n","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n\n # Solution 1 - using floyd's tortoise and hare\n # Time - O(n)\n # Space - O(1)\n\n if not head:\n return None\n\n flag = False\n\n slow, fast = head, head\n\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n\n if fast == slow:\n flag = True\n break\n\n if not flag:\n return None\n\n slow2 = head\n\n while slow:\n\n if slow == slow2:\n return slow\n slow = slow.next\n slow2 = slow2.next\n\n return None\n","runtime":"46"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n if slow is fast:\n break\n else:\n return None\n \n slow = head\n while slow is not fast:\n slow = slow.next\n fast = fast.next\n \n return slow","runtime":"46"},{"code":"# Definition for singly-linked list. \n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return None\n \n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n if fast == slow:\n break\n \n if fast is None or fast.next is None:\n return None\n \n slow = head\n while True:\n if slow == fast:\n return slow\n slow = slow.next\n fast = fast.next\n\n return None\n \n\n ","runtime":"47"},{"code":"class Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n\n slow, fast = head, head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n while fast != head:\n head = head.next\n fast = fast.next\n return head\n\n return None","runtime":"47"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = head\n fast = head\n while (fast):\n if slow and slow.next:\n slow = slow.next\n elif slow:\n return None\n if fast and fast.next and fast.next.next:\n fast = fast.next.next\n elif fast:\n return None\n elif fast.next:\n return None\n \n if slow == fast:\n ptr = head\n while(ptr):\n if ptr == slow:\n return ptr\n ptr = ptr.next\n slow = slow.next\n return None","runtime":"48"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n if not head:\n return\n \n slow = fast = head\n \n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n break\n \n if not fast.next or not fast.next.next:\n return\n \n slow2 = head\n \n while slow.next:\n if slow == slow2:\n return slow\n slow = slow.next\n slow2 = slow2.next\n return\n ","runtime":"48"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: return None\n slow, fast = head, head.next\n lam = pow = 1\n while slow != fast:\n if not fast: return None\n if lam == pow:\n pow <<= 1\n slow, lam = fast, 0\n fast = fast.next\n lam += 1\n mu = 0\n slow = fast = head\n for _ in range(lam): fast = fast.next\n while slow != fast:\n slow, fast = slow.next, fast.next\n mu += 1\n return slow\n ","runtime":"49"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: return None\n slow, fast = head, head.next\n lam = pow = 1\n while slow != fast:\n if not fast: return None\n if lam == pow:\n pow <<= 1\n slow, lam = fast, 0\n fast = fast.next\n lam += 1\n mu = 0\n slow = fast = head\n for _ in range(lam): fast = fast.next\n while slow != fast:\n slow, fast = slow.next, fast.next\n mu += 1\n return slow\n ","runtime":"49"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return None\n slow, fast = head.next, head.next.next\n while fast and fast.next and slow != fast:\n slow = slow.next\n fast = fast.next.next\n if fast != slow:\n return None\n ptr1, ptr2 = head, fast\n while ptr1 != ptr2:\n ptr1 = ptr1.next\n ptr2 = ptr2.next\n return ptr1","runtime":"50"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sett = set()\n curr = head\n\n while curr:\n if curr in sett:\n return curr\n sett.add(curr)\n curr = curr.next\n return None\n\n ","runtime":"50"},{"code":"class Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow_node = head\n fast_node = head\n while fast_node and fast_node.next:\n fast_node = fast_node.next.next\n slow_node = slow_node.next\n if slow_node == fast_node:\n slow_node = head\n while slow_node != fast_node:\n slow_node = slow_node.next\n fast_node = fast_node.next\n return fast_node\n return None","runtime":"51"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\"\"\"\nO1的空间复杂度，快慢指针\nfast和slow都指向head\nfast走两步，slow走一步\n在循环里判断这两个指针是否相等，如果相等，立刻发现cycle\n如果循环结束，都没有发现两个指针相等的情况，说明no cycle\n\n本题开始找环的起点\n在循环里判断这两个指针是否相等，如果相等\n\n\n\n\n简单证明\n\n\"\"\"\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow, fast = head, head\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n if slow == fast:\n idx1 = fast\n idx2 = head\n while idx1 != idx2:\n idx1 = idx1.next\n idx2 = idx2.next\n return idx1\n return None\n ","runtime":"51"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow is fast:\n while head is not slow:\n slow = slow.next\n head = head.next\n return head\n return None\n ","runtime":"52"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n seen = set()\n cur = head\n while cur:\n if cur in seen:\n return cur\n \n seen.add(cur)\n cur = cur.next\n\n return None","runtime":"54"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n fast = head\n slow = head\n\n\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n\n if slow == fast:\n break # collision spot\n\n # if fast pointer is none then there is no intersection\n if not fast or not fast.next:\n return None\n\n\n # move slow to head\n slow = head\n\n while slow != fast:\n slow = slow.next\n fast = fast.next\n\n return slow\n\n ","runtime":"54"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: ListNode) -> ListNode:\\n if not head or not head.next:\\n return None\\n \\n # 步驟 1: 使用快慢指針找到相遇點\\n slow = fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n break\\n else:\\n return None # 沒有環\\n \\n # 步驟 2: 找到環的起始點\\n slow = head\\n while slow != fast:\\n slow = slow.next\\n fast = fast.next\\n \\n return slow\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None: return None\\n slow=head\\n fast=head\\n\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n if slow==fast: break\\n else:\\n return None\\n\\n temp=head \\n while slow!=temp:\\n slow=slow.next\\n temp=temp.next\\n return temp\\n \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow,fast=head,head\\n while fast and fast.next:\\n slow= slow.next\\n fast = fast.next.next\\n if fast == slow :\\n slow=head\\n while slow!=fast:\\n slow=slow.next\\n fast = fast.next\\n return fast\\n return None \",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n nodes = set()\\n cur = head\\n \\n while cur:\\n if cur in nodes: return cur\\n nodes.add(cur)\\n cur = cur.next\\n return None\\n \",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = fast = head\\n\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n\\n if fast == slow:\\n break\\n \\n else:\\n return None\\n\\n while head != slow:\\n head, slow = head.next, slow.next\\n return head\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n slow = fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n break\\n if not fast or not fast.next:\\n return None\\n while head != slow:\\n head, slow = head.next, slow.next\\n return head\\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n nodeSet = set()\\n curr = head\\n while curr:\\n if curr in nodeSet:\\n return curr\\n nodeSet.add(curr)\\n curr = curr.next\\n\\n return None\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return None\\n slow=fast=head\\n \\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow==fast:\\n break\\n else:\\n return None\\n\\n slow = head\\n while slow != fast:\\n slow = slow.next\\n fast = fast.next\\n return slow \\n\\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = fast = head\\n while fast and fast.next:\\n slow, fast = slow.next, fast.next.next\\n if slow == fast: break\\n else: return None # if not (fast and fast.next): return None\\n while head != slow:\\n head, slow = head.next, slow.next\\n return head\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n f = s = head\\n while f and f.next:\\n s = s.next\\n f = f.next.next\\n \\n if s == f:\\n f = head\\n while s != f:\\n s = s.next\\n f = f.next\\n \\n return s\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None or head.next.next is None:\\n return None\\n\\n fast = head.next.next\\n slow = head.next\\n while True:\\n if fast == slow:\\n slow = head\\n while fast != slow:\\n fast = fast.next\\n slow = slow.next\\n return slow\\n else:\\n if fast.next is None or fast.next.next is None:\\n return None\\n fast = fast.next.next\\n slow = slow.next\\n \\n\\n\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n slow = head\\n fast = head\\n\\n while fast and fast.next:\\n slow=slow.next\\n fast = fast.next.next\\n if slow == fast:\\n while fast != head:\\n head = head.next\\n fast = fast.next\\n return head\\n \\n\\n return None\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return None\\n \\n slow = head\\n fast = head\\n has_cycle = False\\n \\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n if slow == fast:\\n has_cycle = True\\n break\\n \\n if not has_cycle:\\n return None\\n \\n slow = head\\n while slow != fast:\\n slow = slow.next\\n fast = fast.next\\n \\n return slow\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None :\\n return\\n else:\\n fp=head\\n sl=head\\n while fp!=None and fp.next!=None:\\n sl=sl.next\\n fp=fp.next.next\\n if sl==fp:\\n sl=head\\n p=0\\n while sl!=fp:\\n sl=sl.next\\n fp=fp.next\\n p+=1\\n return sl\\n return None\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n turtle, hare = head,head\\n prev = None\\n \\n if head == []:\\n return None\\n if not head or not head.next:\\n return None\\n\\n isCycle = False\\n while hare and hare.next:\\n hare = hare.next.next\\n turtle = turtle.next\\n if hare == turtle:\\n isCycle = True\\n break\\n\\n if isCycle == False:\\n return prev\\n prev = head\\n while prev != turtle:\\n prev = prev.next\\n turtle = turtle.next\\n return prev\\n\\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return None\\n f = s = head\\n while f and f.next:\\n s = s.next\\n f = f.next.next\\n if s == f:\\n break\\n else:\\n return None\\n s = head\\n while s != f:\\n s = s.next\\n f = f.next\\n return s\\n \\n\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow=fast=head\\n if not (fast and fast.next):\\n return None\\n while fast and fast.next:\\n fast=fast.next.next\\n slow=slow.next\\n if slow==fast:\\n break\\n slow2=head\\n while slow and slow2 and slow2!=slow:\\n slow=slow.next\\n slow2=slow2.next\\n return slow\\n \\n \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return None\\n ptr = head\\n ptr_map = set()\\n while not ptr is None:\\n if ptr in ptr_map:\\n return ptr\\n ptr_map.add(ptr)\\n ptr = ptr.next\\n return None\\n\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n if head is None:\\n return None\\n\\n slow = head\\n fast = head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n if slow == fast:\\n break\\n else:\\n\\n return None\\n\\n \\n slow = head\\n while slow != fast:\\n slow = slow.next\\n fast = fast.next\\n\\n\\n return slow\\n\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = head\\n fast = head\\n while fast and fast.next:\\n slow = slow.next \\n fast = fast.next.next\\n if slow is fast:\\n start = head \\n while start != slow:\\n start = start.next\\n slow = slow.next\\n return start\\n return None\\n\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if (not head) or (not head.next):\\n return None\\n \\n slow = head.next\\n fast = slow.next\\n\\n while slow != fast:\\n slow = slow.next\\n try:\\n fast = fast.next.next\\n except AttributeError:\\n return None\\n slow = head\\n while slow != fast:\\n slow = slow.next\\n fast = fast.next\\n return slow\\n\\n while fast:\\n fast = fast.next\\n if slow == fast:\\n return slow.val\\n if fast == None:\\n return False\\n fast = fast.next\\n slow = slow.next\\n return None\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow=fast=head\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n if slow==fast:\\n slow=head\\n while slow!=fast:\\n slow=slow.next\\n fast=fast.next\\n return slow\\n return None\\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow is fast:\\n while head is not slow:\\n slow = slow.next\\n head = head.next\\n return slow\\n return None\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = fast = head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n break\\n\\n if fast is None or fast.next is None:\\n return None\\n\\n fast = head\\n\\n while fast != slow:\\n fast = fast.next\\n slow = slow.next\\n\\n return slow\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return None\\n slow_ptr, fast_ptr = head.next, head.next.next\\n\\n while slow_ptr != fast_ptr:\\n if fast_ptr is None or fast_ptr.next is None:\\n return None\\n slow_ptr = slow_ptr.next\\n fast_ptr = fast_ptr.next.next\\n \\n slow_ptr = head\\n while slow_ptr != fast_ptr:\\n slow_ptr = slow_ptr.next\\n fast_ptr = fast_ptr.next\\n return slow_ptr\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = head\\n fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n slow = head\\n while slow != fast:\\n slow = slow.next\\n fast = fast.next\\n return slow\\n return None\\n\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = head\\n fast = head\\n collision = False\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n collision = True\\n break\\n if not collision:\\n return None\\n\\n slow = head\\n while slow != fast:\\n slow = slow.next\\n fast = fast.next\\n return fast\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\\"\\\"\\\"\\n Every node as a unique id\\n We loop through the linked list\\n if we enounter an id we've seen before,\\n then it's a cycle\\n \\n if we reach the end, return -1\\n \\n \\\"\\\"\\\"\\n \\n if head == None:\\n return None\\n \\n ids = set()\\n \\n current = head\\n \\n while current:\\n ID = id(current)\\n \\n if ID in ids:\\n return current\\n \\n else:\\n ids.add(ID)\\n \\n current = current.next\\n \\n return None\\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # Sol 1 maintain set\\n # seen = set()\\n # index = 0\\n # while head and head not in seen:\\n # seen.add(head)\\n # head = head.next\\n # return head\\n\\n slow = head\\n fast = head\\n\\n while fast and fast.next: # Key point\\n fast = fast.next.next\\n slow = slow.next\\n if slow == fast:\\n break\\n \\n if not fast or not fast.next: # Key point\\n return None\\n \\n while head != slow:\\n head = head.next\\n slow = slow.next\\n return slow\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: return None\\n slow, fast = head, head.next\\n lam = pow = 1\\n while slow != fast:\\n if not fast: return None\\n if lam == pow:\\n pow <<= 1\\n slow, lam = fast, 0\\n fast = fast.next\\n lam += 1\\n mu = 0\\n slow = fast = head\\n for _ in range(lam): fast = fast.next\\n while slow != fast:\\n slow, fast = slow.next, fast.next\\n mu += 1\\n return slow\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n\\n p1 = head\\n p2 = head\\n\\n while p2:\\n p1 = p1.next\\n p2 = p2.next\\n if p2:\\n p2 = p2.next\\n\\n if p1 == p2:\\n break\\n\\n if not p2:\\n return None\\n\\n p2 = head\\n while p1 != p2:\\n p1 = p1.next\\n p2 = p2.next\\n\\n return p1\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n f=head\\n s=head\\n while f and f.next:\\n f=f.next.next\\n s=s.next\\n if(f==s):\\n s=head\\n while f!=s:\\n s=s.next\\n f=f.next\\n return s\\n return None\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return None\\n\\n slow = head\\n fast = head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n break\\n \\n else:\\n return None\\n\\n ptr1 = head\\n ptr2 = slow\\n\\n while ptr1 != ptr2:\\n ptr1 = ptr1.next\\n ptr2 = ptr2.next\\n\\n return ptr1\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n\\n # Solution 1 - using floyd's tortoise and hare\\n # Time - O(n)\\n # Space - O(1)\\n\\n if not head:\\n return None\\n\\n flag = False\\n\\n slow, fast = head, head\\n\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n\\n if fast == slow:\\n flag = True\\n break\\n\\n if not flag:\\n return None\\n\\n slow2 = head\\n\\n while True and slow:\\n\\n if slow == slow2:\\n return slow\\n slow = slow.next\\n slow2 = slow2.next\\n\\n return None\\n\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return None\\n has_cycle = 0 \\n slow,fast = head,head\\n while(fast and fast.next):\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n has_cycle = 1\\n break\\n \\n if not has_cycle:\\n return None\\n slow = head\\n while(slow!=fast):\\n slow = slow.next\\n fast = fast.next\\n return slow\\n\\n \\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow=fast=head\\n while fast and fast.next:\\n slow,fast=slow.next,fast.next.next\\n if slow==fast:\\n break\\n else:\\n return None\\n while head!=slow:\\n head,slow=head.next,slow.next\\n return head\\n \\n\\n \\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow=fast=head\\n while fast and fast.next and fast.next.next:\\n slow=slow.next\\n fast=fast.next.next\\n if slow==fast:\\n break\\n else:\\n return None\\n slow=head\\n while slow!=fast:\\n slow=slow.next\\n fast=fast.next\\n return slow\\n \\n\\n \\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\nfrom typing import Optional\\n\\nclass Solution:\\n def detectCycle(self, head):\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n slow2 = head\\n while slow != slow2:\\n slow = slow.next\\n slow2 = slow2.next\\n return slow2\\n\\n return None\\n \\n\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n\\n # Solution 1 - using floyd's tortoise and hare\\n # Time - O(n)\\n # Space - O(1)\\n\\n if not head:\\n return None\\n\\n flag = False\\n\\n slow, fast = head, head\\n\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n\\n if fast == slow:\\n flag = True\\n break\\n\\n if not flag:\\n return None\\n\\n slow2 = head\\n\\n while slow:\\n\\n if slow == slow2:\\n return slow\\n slow = slow.next\\n slow2 = slow2.next\\n\\n return None\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n if slow is fast:\\n break\\n else:\\n return None\\n \\n slow = head\\n while slow is not fast:\\n slow = slow.next\\n fast = fast.next\\n \\n return slow\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list. \\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return None\\n \\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n if fast == slow:\\n break\\n \\n if fast is None or fast.next is None:\\n return None\\n \\n slow = head\\n while True:\\n if slow == fast:\\n return slow\\n slow = slow.next\\n fast = fast.next\\n\\n return None\\n \\n\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n\\n slow, fast = head, head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n while fast != head:\\n head = head.next\\n fast = fast.next\\n return head\\n\\n return None\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = head\\n fast = head\\n while (fast):\\n if slow and slow.next:\\n slow = slow.next\\n elif slow:\\n return None\\n if fast and fast.next and fast.next.next:\\n fast = fast.next.next\\n elif fast:\\n return None\\n elif fast.next:\\n return None\\n \\n if slow == fast:\\n ptr = head\\n while(ptr):\\n if ptr == slow:\\n return ptr\\n ptr = ptr.next\\n slow = slow.next\\n return None\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n if not head:\\n return\\n \\n slow = fast = head\\n \\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n break\\n \\n if not fast.next or not fast.next.next:\\n return\\n \\n slow2 = head\\n \\n while slow.next:\\n if slow == slow2:\\n return slow\\n slow = slow.next\\n slow2 = slow2.next\\n return\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: return None\\n slow, fast = head, head.next\\n lam = pow = 1\\n while slow != fast:\\n if not fast: return None\\n if lam == pow:\\n pow <<= 1\\n slow, lam = fast, 0\\n fast = fast.next\\n lam += 1\\n mu = 0\\n slow = fast = head\\n for _ in range(lam): fast = fast.next\\n while slow != fast:\\n slow, fast = slow.next, fast.next\\n mu += 1\\n return slow\\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: return None\\n slow, fast = head, head.next\\n lam = pow = 1\\n while slow != fast:\\n if not fast: return None\\n if lam == pow:\\n pow <<= 1\\n slow, lam = fast, 0\\n fast = fast.next\\n lam += 1\\n mu = 0\\n slow = fast = head\\n for _ in range(lam): fast = fast.next\\n while slow != fast:\\n slow, fast = slow.next, fast.next\\n mu += 1\\n return slow\\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return None\\n slow, fast = head.next, head.next.next\\n while fast and fast.next and slow != fast:\\n slow = slow.next\\n fast = fast.next.next\\n if fast != slow:\\n return None\\n ptr1, ptr2 = head, fast\\n while ptr1 != ptr2:\\n ptr1 = ptr1.next\\n ptr2 = ptr2.next\\n return ptr1\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sett = set()\\n curr = head\\n\\n while curr:\\n if curr in sett:\\n return curr\\n sett.add(curr)\\n curr = curr.next\\n return None\\n\\n \",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow_node = head\\n fast_node = head\\n while fast_node and fast_node.next:\\n fast_node = fast_node.next.next\\n slow_node = slow_node.next\\n if slow_node == fast_node:\\n slow_node = head\\n while slow_node != fast_node:\\n slow_node = slow_node.next\\n fast_node = fast_node.next\\n return fast_node\\n return None\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\\"\\\"\\\"\\nO1的空间复杂度，快慢指针\\nfast和slow都指向head\\nfast走两步，slow走一步\\n在循环里判断这两个指针是否相等，如果相等，立刻发现cycle\\n如果循环结束，都没有发现两个指针相等的情况，说明no cycle\\n\\n本题开始找环的起点\\n在循环里判断这两个指针是否相等，如果相等\\n\\n\\n\\n\\n简单证明\\n\\n\\\"\\\"\\\"\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow, fast = head, head\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n if slow == fast:\\n idx1 = fast\\n idx2 = head\\n while idx1 != idx2:\\n idx1 = idx1.next\\n idx2 = idx2.next\\n return idx1\\n return None\\n \",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow is fast:\\n while head is not slow:\\n slow = slow.next\\n head = head.next\\n return head\\n return None\\n \",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n seen = set()\\n cur = head\\n while cur:\\n if cur in seen:\\n return cur\\n \\n seen.add(cur)\\n cur = cur.next\\n\\n return None\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n fast = head\\n slow = head\\n\\n\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n\\n if slow == fast:\\n break # collision spot\\n\\n # if fast pointer is none then there is no intersection\\n if not fast or not fast.next:\\n return None\\n\\n\\n # move slow to head\\n slow = head\\n\\n while slow != fast:\\n slow = slow.next\\n fast = fast.next\\n\\n return slow\\n\\n \",\n \"runtime\": \"54\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":53,"string":"53"},"mm_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = head\n while slow:\n if slow.val == \"a\":\n return slow\n slow.val = \"a\"\n slow = slow.next\n return None","memory":"18100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n c = 0\n temp = head\n d = {}\n while head:\n if head.val == \"\":\n head = temp \n return head\n head.val = \"\"\n d[temp.val] = c\n\n head = head.next\n temp = temp.next\n c += 1\n return None","memory":"18200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n c = 0\n temp = head\n while head:\n if head.val == \"\":\n return temp\n head.val = \"\"\n head = head.next\n temp = temp.next","memory":"18200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n c = 0\n temp = head\n while head:\n if head.val == \"\":\n return temp\n head.val = \"\"\n head = head.next\n temp = temp.next","memory":"18300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n while head != None:\n if head.val == 1000000:\n return head\n head.val = 1000000\n head = head.next\n\n return","memory":"18400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n break\n\n # detect if no cycle\n if not fast or not fast.next:\n return None\n\n fast = head\n\n while slow != fast:\n slow = slow.next\n fast = fast.next\n\n return slow","memory":"18500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = head\n fast = head\n while fast is not None and fast.next is not None:\n slow = slow.next\n fast = fast.next.next\n if fast == slow:\n slow = head\n while slow!=fast:\n slow = slow.next\n fast = fast.next\n return fast\n return None","memory":"18600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow is fast:\n while head is not slow:\n slow = slow.next\n head = head.next\n return slow\n return None\n ","memory":"18700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow is fast:\n while head is not slow:\n slow = slow.next\n head = head.next\n return head\n return None\n ","memory":"18700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n\n # Solution 1 - using floyd's tortoise and hare\n # Time - O(n)\n # Space - O(1)\n\n if not head:\n return None\n\n flag = False\n\n slow, fast = head, head\n\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n\n if fast == slow:\n flag = True\n break\n\n if not flag:\n return None\n\n slow2 = head\n\n while slow:\n\n if slow == slow2:\n return slow\n slow = slow.next\n slow2 = slow2.next\n\n return None\n","memory":"18800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None :\n return\n else:\n fp=head\n sl=head\n while fp!=None and fp.next!=None:\n sl=sl.next\n fp=fp.next.next\n if sl==fp:\n sl=head\n p=0\n while sl!=fp:\n sl=sl.next\n fp=fp.next\n p+=1\n return sl\n return None","memory":"18800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n\n # Solution 1 - using floyd's tortoise and hare\n # Time - O(n)\n # Space - O(1)\n\n if not head:\n return None\n\n flag = False\n\n slow, fast = head, head\n\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n\n if fast == slow:\n flag = True\n break\n\n if not flag:\n return None\n\n slow2 = head\n\n while True and slow:\n\n if slow == slow2:\n return slow\n slow = slow.next\n slow2 = slow2.next\n\n return None\n","memory":"18900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow=fast=head\n if not (fast and fast.next):\n return None\n while fast and fast.next:\n fast=fast.next.next\n slow=slow.next\n if slow==fast:\n break\n slow2=head\n while slow and slow2 and slow2!=slow:\n slow=slow.next\n slow2=slow2.next\n return slow\n \n ","memory":"18900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n slow = head\n fast = head\n while (fast):\n if slow and slow.next:\n slow = slow.next\n elif slow:\n return None\n if fast and fast.next and fast.next.next:\n fast = fast.next.next\n elif fast:\n return None\n elif fast.next:\n return None\n \n if slow == fast:\n ptr = head\n while(ptr):\n if ptr == slow:\n return ptr\n ptr = ptr.next\n slow = slow.next\n return None","memory":"19000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n\n p1 = head\n p2 = head\n\n while p2:\n p1 = p1.next\n p2 = p2.next\n if p2:\n p2 = p2.next\n\n if p1 == p2:\n break\n\n if not p2:\n return None\n\n p2 = head\n while p1 != p2:\n p1 = p1.next\n p2 = p2.next\n\n return p1\n ","memory":"19000"},{"code":"class Solution:\n def detectCycle(self, head: ListNode) -> ListNode:\n slow = head\n fast = head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n slow = head\n while slow != fast:\n slow = slow.next\n fast = fast.next\n return slow\n\n return None","memory":"19100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: return None\n slow, fast = head, head.next\n lam = pow = 1\n while slow != fast:\n if not fast: return None\n if lam == pow:\n pow <<= 1\n slow, lam = fast, 0\n fast = fast.next\n lam += 1\n mu = 0\n slow = fast = head\n for _ in range(lam): fast = fast.next\n while slow != fast:\n slow, fast = slow.next, fast.next\n mu += 1\n return slow\n ","memory":"19100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n first = head\n second = head\n\n while first is not None and second is not None:\n first = first.next\n\n second = second.next\n if second is not None:\n second = second.next\n else:\n return None\n\n if first is second:\n break\n \n if first is None or second is None:\n return None\n\n second = head\n while first is not second:\n first = first.next\n second = second.next\n\n\n return first","memory":"19200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: return None\n slow, fast = head, head.next\n lam = pow = 1\n while slow != fast:\n if not fast: return None\n if lam == pow:\n pow <<= 1\n slow, lam = fast, 0\n fast = fast.next\n lam += 1\n mu = 0\n slow = fast = head\n for _ in range(lam): fast = fast.next\n while slow != fast:\n slow, fast = slow.next, fast.next\n mu += 1\n return slow\n ","memory":"19200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n visited = {}\n # n = len(head)\n i = 0\n while head:\n if head not in visited:\n visited[head]=i\n else:\n return head\n i+=1\n head= head.next\n return None\n ","memory":"19300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n temp_map = dict()\n\n temp = head\n while temp!=None:\n if temp in temp_map:\n return temp \n temp_map[temp] = True\n \n temp=temp.next","memory":"19400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \"\"\"\n Every node as a unique id\n We loop through the linked list\n if we enounter an id we've seen before,\n then it's a cycle\n \n if we reach the end, return -1\n \n \"\"\"\n \n if head == None:\n return None\n \n ids = set()\n \n current = head\n \n while current:\n ID = id(current)\n \n if ID in ids:\n return current\n \n else:\n ids.add(ID)\n \n current = current.next\n \n return None\n ","memory":"19400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return None\n ptr = head\n ptr_map = set()\n while not ptr is None:\n if ptr in ptr_map:\n return ptr\n ptr_map.add(ptr)\n ptr = ptr.next\n return None\n","memory":"19500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\n d = {}\n i = 0\n while head:\n if head not in d:\n d[head] = i\n else:\n return head\n i += 1\n head = head.next\n ","memory":"19500"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = head\\n while slow:\\n if slow.val == \\\"a\\\":\\n return slow\\n slow.val = \\\"a\\\"\\n slow = slow.next\\n return None\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n c = 0\\n temp = head\\n d = {}\\n while head:\\n if head.val == \\\"\\\":\\n head = temp \\n return head\\n head.val = \\\"\\\"\\n d[temp.val] = c\\n\\n head = head.next\\n temp = temp.next\\n c += 1\\n return None\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n c = 0\\n temp = head\\n while head:\\n if head.val == \\\"\\\":\\n return temp\\n head.val = \\\"\\\"\\n head = head.next\\n temp = temp.next\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n c = 0\\n temp = head\\n while head:\\n if head.val == \\\"\\\":\\n return temp\\n head.val = \\\"\\\"\\n head = head.next\\n temp = temp.next\",\n \"memory\": \"18300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n while head != None:\\n if head.val == 1000000:\\n return head\\n head.val = 1000000\\n head = head.next\\n\\n return\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n break\\n\\n # detect if no cycle\\n if not fast or not fast.next:\\n return None\\n\\n fast = head\\n\\n while slow != fast:\\n slow = slow.next\\n fast = fast.next\\n\\n return slow\",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = head\\n fast = head\\n while fast is not None and fast.next is not None:\\n slow = slow.next\\n fast = fast.next.next\\n if fast == slow:\\n slow = head\\n while slow!=fast:\\n slow = slow.next\\n fast = fast.next\\n return fast\\n return None\",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow is fast:\\n while head is not slow:\\n slow = slow.next\\n head = head.next\\n return slow\\n return None\\n \",\n \"memory\": \"18700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow is fast:\\n while head is not slow:\\n slow = slow.next\\n head = head.next\\n return head\\n return None\\n \",\n \"memory\": \"18700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n\\n # Solution 1 - using floyd's tortoise and hare\\n # Time - O(n)\\n # Space - O(1)\\n\\n if not head:\\n return None\\n\\n flag = False\\n\\n slow, fast = head, head\\n\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n\\n if fast == slow:\\n flag = True\\n break\\n\\n if not flag:\\n return None\\n\\n slow2 = head\\n\\n while slow:\\n\\n if slow == slow2:\\n return slow\\n slow = slow.next\\n slow2 = slow2.next\\n\\n return None\\n\",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None :\\n return\\n else:\\n fp=head\\n sl=head\\n while fp!=None and fp.next!=None:\\n sl=sl.next\\n fp=fp.next.next\\n if sl==fp:\\n sl=head\\n p=0\\n while sl!=fp:\\n sl=sl.next\\n fp=fp.next\\n p+=1\\n return sl\\n return None\",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n\\n # Solution 1 - using floyd's tortoise and hare\\n # Time - O(n)\\n # Space - O(1)\\n\\n if not head:\\n return None\\n\\n flag = False\\n\\n slow, fast = head, head\\n\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n\\n if fast == slow:\\n flag = True\\n break\\n\\n if not flag:\\n return None\\n\\n slow2 = head\\n\\n while True and slow:\\n\\n if slow == slow2:\\n return slow\\n slow = slow.next\\n slow2 = slow2.next\\n\\n return None\\n\",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow=fast=head\\n if not (fast and fast.next):\\n return None\\n while fast and fast.next:\\n fast=fast.next.next\\n slow=slow.next\\n if slow==fast:\\n break\\n slow2=head\\n while slow and slow2 and slow2!=slow:\\n slow=slow.next\\n slow2=slow2.next\\n return slow\\n \\n \",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n slow = head\\n fast = head\\n while (fast):\\n if slow and slow.next:\\n slow = slow.next\\n elif slow:\\n return None\\n if fast and fast.next and fast.next.next:\\n fast = fast.next.next\\n elif fast:\\n return None\\n elif fast.next:\\n return None\\n \\n if slow == fast:\\n ptr = head\\n while(ptr):\\n if ptr == slow:\\n return ptr\\n ptr = ptr.next\\n slow = slow.next\\n return None\",\n \"memory\": \"19000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n\\n p1 = head\\n p2 = head\\n\\n while p2:\\n p1 = p1.next\\n p2 = p2.next\\n if p2:\\n p2 = p2.next\\n\\n if p1 == p2:\\n break\\n\\n if not p2:\\n return None\\n\\n p2 = head\\n while p1 != p2:\\n p1 = p1.next\\n p2 = p2.next\\n\\n return p1\\n \",\n \"memory\": \"19000\"\n },\n {\n \"code\": \"class Solution:\\n def detectCycle(self, head: ListNode) -> ListNode:\\n slow = head\\n fast = head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n if slow == fast:\\n slow = head\\n while slow != fast:\\n slow = slow.next\\n fast = fast.next\\n return slow\\n\\n return None\",\n \"memory\": \"19100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: return None\\n slow, fast = head, head.next\\n lam = pow = 1\\n while slow != fast:\\n if not fast: return None\\n if lam == pow:\\n pow <<= 1\\n slow, lam = fast, 0\\n fast = fast.next\\n lam += 1\\n mu = 0\\n slow = fast = head\\n for _ in range(lam): fast = fast.next\\n while slow != fast:\\n slow, fast = slow.next, fast.next\\n mu += 1\\n return slow\\n \",\n \"memory\": \"19100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n first = head\\n second = head\\n\\n while first is not None and second is not None:\\n first = first.next\\n\\n second = second.next\\n if second is not None:\\n second = second.next\\n else:\\n return None\\n\\n if first is second:\\n break\\n \\n if first is None or second is None:\\n return None\\n\\n second = head\\n while first is not second:\\n first = first.next\\n second = second.next\\n\\n\\n return first\",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: return None\\n slow, fast = head, head.next\\n lam = pow = 1\\n while slow != fast:\\n if not fast: return None\\n if lam == pow:\\n pow <<= 1\\n slow, lam = fast, 0\\n fast = fast.next\\n lam += 1\\n mu = 0\\n slow = fast = head\\n for _ in range(lam): fast = fast.next\\n while slow != fast:\\n slow, fast = slow.next, fast.next\\n mu += 1\\n return slow\\n \",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n visited = {}\\n # n = len(head)\\n i = 0\\n while head:\\n if head not in visited:\\n visited[head]=i\\n else:\\n return head\\n i+=1\\n head= head.next\\n return None\\n \",\n \"memory\": \"19300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n temp_map = dict()\\n\\n temp = head\\n while temp!=None:\\n if temp in temp_map:\\n return temp \\n temp_map[temp] = True\\n \\n temp=temp.next\",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\\"\\\"\\\"\\n Every node as a unique id\\n We loop through the linked list\\n if we enounter an id we've seen before,\\n then it's a cycle\\n \\n if we reach the end, return -1\\n \\n \\\"\\\"\\\"\\n \\n if head == None:\\n return None\\n \\n ids = set()\\n \\n current = head\\n \\n while current:\\n ID = id(current)\\n \\n if ID in ids:\\n return current\\n \\n else:\\n ids.add(ID)\\n \\n current = current.next\\n \\n return None\\n \",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return None\\n ptr = head\\n ptr_map = set()\\n while not ptr is None:\\n if ptr in ptr_map:\\n return ptr\\n ptr_map.add(ptr)\\n ptr = ptr.next\\n return None\\n\",\n \"memory\": \"19500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n d = {}\\n i = 0\\n while head:\\n if head not in d:\\n d[head] = i\\n else:\\n return head\\n i += 1\\n head = head.next\\n \",\n \"memory\": \"19500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":24,"string":"24"}}},{"rowIdx":47,"cells":{"question_id":{"kind":"number","value":143,"string":"143"},"name":{"kind":"string","value":"reorder-list"},"content":{"kind":"string","value":"<p>You are given the head of a singly linked-list. The list can be represented as:</p>\n\n<pre>\nL<sub>0</sub> → L<sub>1</sub> → … → L<sub>n - 1</sub> → L<sub>n</sub>\n</pre>\n\n<p><em>Reorder the list to be on the following form:</em></p>\n\n<pre>\nL<sub>0</sub> → L<sub>n</sub> → L<sub>1</sub> → L<sub>n - 1</sub> → L<sub>2</sub> → L<sub>n - 2</sub> → …\n</pre>\n\n<p>You may not modify the values in the list's nodes. Only nodes themselves may be changed.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/03/04/reorder1linked-list.jpg\" style=\"width: 422px; height: 222px;\" />\n<pre>\n<strong>Input:</strong> head = [1,2,3,4]\n<strong>Output:</strong> [1,4,2,3]\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/03/09/reorder2-linked-list.jpg\" style=\"width: 542px; height: 222px;\" />\n<pre>\n<strong>Input:</strong> head = [1,2,3,4,5]\n<strong>Output:</strong> [1,5,2,4,3]\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of nodes in the list is in the range <code>[1, 5 * 10<sup>4</sup>]</code>.</li>\n\t<li><code>1 <= Node.val <= 1000</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":60.092020825765836,"string":"60.092021"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["linked-list","two-pointers","stack","recursion"],"string":"[\n \"linked-list\",\n \"two-pointers\",\n \"stack\",\n \"recursion\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"28\", 0.0128], [\"31\", 0.0191], [\"32\", 0.0319], [\"33\", 0.0255], [\"34\", 0.0447], [\"35\", 0.0447], [\"36\", 0.0893], [\"37\", 0.0574], [\"38\", 0.1212], [\"39\", 0.3382], [\"40\", 0.2808], [\"41\", 0.3318], [\"42\", 0.6827], [\"43\", 0.9252], [\"44\", 1.0209], [\"45\", 1.2698], [\"46\", 1.7164], [\"47\", 2.6417], [\"48\", 2.6672], [\"49\", 2.9033], [\"50\", 3.3946], [\"51\", 5.3152], [\"52\", 4.6006], [\"53\", 4.8749], [\"54\", 5.1429], [\"55\", 6.3999], [\"56\", 6.3361], [\"57\", 5.5768], [\"58\", 5.3025], [\"59\", 5.6981], [\"60\", 5.2833], [\"61\", 4.5304], [\"62\", 3.72], [\"63\", 3.0436], [\"64\", 2.463], [\"65\", 1.793], [\"66\", 1.4548], [\"67\", 1.2379], [\"68\", 0.721], [\"69\", 0.4275], [\"70\", 0.3637], [\"71\", 0.268], [\"72\", 0.2297], [\"73\", 0.2297], [\"74\", 0.1085], [\"75\", 0.1212], [\"76\", 0.185], [\"77\", 0.1021], [\"78\", 0.1149], [\"79\", 0.0893], [\"80\", 0.1021], [\"81\", 0.0702], [\"82\", 0.134], [\"83\", 0.0319], [\"84\", 0.0638], [\"85\", 0.051], [\"86\", 0.083], [\"87\", 0.0638], [\"88\", 0.0191]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"22000\", 0.0064], [\"22200\", 0.0064], [\"22300\", 0.0128], [\"22600\", 0.0128], [\"22900\", 0.0064], [\"23000\", 0.0064], [\"23100\", 0.0064], [\"23600\", 0.0191], [\"23700\", 0.0064], [\"23800\", 0.1212], [\"23900\", 0.2552], [\"24000\", 0.1149], [\"24100\", 0.1212], [\"24200\", 0.1021], [\"24300\", 0.1276], [\"24400\", 0.8742], [\"24500\", 10.1519], [\"24600\", 48.5707], [\"24700\", 28.2032], [\"24800\", 4.8749]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow,fast=head,head.next\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n second=slow.next\n slow.next=prev=None\n while second:\n nxt=second.next\n second.next=prev\n prev=second\n second=nxt\n first,second=head,prev\n while second:\n tmp1,tmp2=first.next,second.next\n first.next=second\n second.next=tmp1\n first=tmp1\n second=tmp2\n ","runtime":"28"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # Get middle of list\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n # Disconnect end of l1\n l2 = slow.next\n slow.next = None\n\n # Reverse l2\n prev = None\n while l2:\n temp = l2.next\n l2.next = prev\n prev = l2\n l2 = temp\n\n # Merge lists\n first, second = head, prev\n while second:\n tmp1, tmp2 = first.next, second.next\n first.next = second\n second.next = tmp1\n first, second = tmp1, tmp2","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n\n slow,fast = head,head\n\n # find half way mark\n\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n\n curr = slow.next\n prev = None\n slow.next = None\n # reverse the second portion of the list\n while curr:\n tmp = curr.next\n curr.next = prev\n prev = curr\n curr = tmp\n\n\n first = head\n second = prev\n\n # merge two lists\n\n while second:\n tmp1,tmp2 = first.next, second.next\n\n first.next = second\n second.next = tmp1\n\n first = tmp1\n second = tmp2\n\n\n return head\n\n ","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n second = slow.next\n prev = slow.next = None\n\n while second:\n nxt = second.next\n second.next = prev\n prev = second\n second = nxt\n \n first, second = head, prev\n\n while second:\n tmp1, tmp2 = first.next, second.next\n first.next = second\n second.next = tmp1\n first, second = tmp1, tmp2","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head or not head.next:\n return \n \n # Step 1: Find the middle of the linked list\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n # Step 2: Reverse the second half of the list\n prev, curr = None, slow\n while curr:\n next_temp = curr.next\n curr.next = prev\n prev = curr\n curr = next_temp\n \n # Step 3: Merge the two halves\n first, second = head, prev\n while second.next:\n temp1, temp2 = first.next, second.next\n first.next = second\n second.next = temp1\n first, second = temp1, temp2\n","runtime":"34"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n second = slow.next\n prev = slow.next = None\n while second:\n temp = second.next\n second.next = prev\n prev = second\n second = temp\n\n first, second = head, prev\n while second:\n temp1, temp2 = first.next, second.next\n first.next = second\n second.next = temp1\n first, second = temp1, temp2","runtime":"35"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # aliter - https://leetcode.com/problems/reorder-list/editorial/comments/1088802\n\n\n #less than 2 nodes\n if not head or not head.next:\n return head\n\n #reverse second part of the list and merge 2 sorted lists\n\n #find mid (mid = slow)\n fast=slow=head\n while fast and fast.next:\n fast=fast.next.next\n slow=slow.next\n\n #reverse the 2nd part of the list\n prev= None #prev is the start of this list\n curr= slow\n while curr:\n nex = curr.next\n curr.next=prev\n prev=curr\n curr=nex\n # curr.next, prev, curr = prev, curr, curr.next\n \n #merge 2 sorted lists\n p1,p2 = head, prev\n while p2.next:\n nex1 = p1.next\n p1.next= p2\n p1= nex1\n\n nex2=p2.next\n p2.next=nex1\n p2=nex2\n \n\n\n\n\n\n\n\n\n \n\n\n\n\n\n ","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head:\n return\n ls=[]\n temp=head\n while temp:\n ls.append(temp)\n temp=temp.next\n\n n=len(ls)\n prev=None\n\n for i in range((n+1)//2):\n cur=ls[i]\n last=ls[n-i-1]\n cur.next=last\n if prev:\n prev.next=cur\n prev=last\n prev.next=None\n \n","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n \n slow, fast = head, head.next\n \n while fast and fast.next:\n slow, fast = slow.next, fast.next.next\n \n temp = slow.next\n prev = slow.next = None\n before = None\n\n while temp:\n after = temp.next\n temp.next = before\n before = temp\n temp = after\n \n first, second = head, before\n\n while second:\n t1, t2 = first.next, second.next\n \n first.next = second\n second.next = t1\n\n first, second = t1, t2\n \n","runtime":"38"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head: return None\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n cur = slow.next\n slow.next = None\n prev = None\n while cur:\n nxt = cur.next\n cur.next = prev\n prev = cur\n cur = nxt\n \n list1, list2 = head, prev\n while list2:\n nxt1, nxt2 = list1.next, list2.next\n list1.next = list2\n list2.next = nxt1\n list1 = nxt1\n list2 = nxt2\n ","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head:\n return\n # 1, 2, 3, 4, 5, 6\n # 1. find middle\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n prev, curr = None, slow\n # 2. reverse second list\n while curr:\n curr.next, prev, curr = prev, curr, curr.next\n\n first, second = head, prev\n #3 merge\n while second.next:\n first.next, first = second, first.next\n second.next, second = first, second.next\n ","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n import math\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n first = head; n = 0\n while head:\n n += 1; head = head.next\n\n start_idx = math.ceil(n/2 + 1)\n i = 1; new_head = first\n while i < start_idx - 1:\n new_head = new_head.next\n i += 1\n tmp = new_head.next; new_head.next = None; new_head = tmp\n\n prev = None\n while new_head:\n tmp = new_head.next\n new_head.next = prev\n prev = new_head\n new_head = tmp\n left_head = first; right_head = prev\n # print(left_head, right_head)\n while left_head and right_head:\n tmp_left = left_head.next\n left_head.next = right_head\n tmp_right = right_head.next\n right_head.next = tmp_left\n left_head = tmp_left; right_head = tmp_right\n # print(first)\n return prev\n","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n'''\nd->1->2->3->4\n s\n f\n\nd->1->2->3->4->5\n s\n f\n\nd->1\n s\n f\n'''\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n\n def middle(head):\n dummy_head = ListNode()\n dummy_head.next = head\n slow = dummy_head\n fast = dummy_head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def reverse(node):\n prev = None\n curr = node\n while curr:\n nxt = curr.next\n curr.next = prev\n prev = curr\n curr = nxt\n return prev\n \n '''\n 1->4->2\n\n 1->2\n l1\n\n 4\n l2\n '''\n def merge(list_one, list_two):\n while list_one and list_two:\n next_one = list_one.next\n next_two = list_two.next\n list_one.next = list_two\n list_two.next = next_one\n list_one = next_one\n list_two = next_two\n \n list_one = head\n mid = middle(head)\n list_two = mid.next\n mid.next = None\n list_two = reverse(list_two)\n \n return merge(list_one, list_two)","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n lst = []\n cur = head\n while cur is not None:\n lst.append(cur)\n cur = cur.next\n l, r = 1, len(lst) - 1\n while l < r:\n head.next = lst[r]\n head = head.next\n head.next = lst[l]\n head = head.next\n l += 1\n r -= 1\n if l == r:\n head.next = lst[l]\n head = head.next\n head.next = None\n ","runtime":"41"},{"code":"class ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\nclass Solution:\n def reorderList(self, head: ListNode) -> None:\n if not head:\n return\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n prev, curr = None, slow\n while curr:\n next_node = curr.next\n curr.next = prev\n prev = curr\n curr = next_node\n first, second = head, prev\n while second.next:\n temp1, temp2 = first.next, second.next\n first.next = second\n second.next = temp1\n first, second = temp1, temp2\n ","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # print(f\"head:{head}\")\n if not head: return\n # First find mid-point\n slow = head\n fast = head\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n \n # print(f\"mid point is: {slow}\")\n\n # Reverse list from mid point on wards\n prev = None\n current = slow\n while current:\n prev, current.next, current = current, prev, current.next\n # next_node \n\n first = head\n second = prev\n # while second.next:\n # first.next = second\n # first = first.next\n # second.next = first\n # second = second.next\n\n # while second.next:\n # first.next, first = second, first.next\n # second.next, second = first, second.next\n\n # print(f\"first: {first}\")\n # print(f\"second: {second}\")\n\n while second.next:\n temp = first.next\n first.next = second\n first = temp\n\n temp = second.next\n second.next = first\n second = temp\n \n # print(f\"head: {head}\")\n ","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def middleNode(self, head:ListNode)->ListNode:\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def reverseList(self, head:ListNode)->ListNode:\n pre = None\n cur = head\n while cur:\n nxt = cur.next\n cur.next = pre # \n pre = cur\n cur = nxt\n return pre\n def reorderList(self, head: Optional[ListNode]) -> None:\n mid = self.middleNode(head)\n head2 = self.reverseList(mid)\n while head2.next:\n nxt = head.next\n nxt2 = head2.next\n head.next = head2\n head2.next = nxt\n head = nxt\n head2 = nxt2\n","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom collections import deque\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n\n fast = slow = head\n\n while fast.next and fast.next.next:\n fast = fast.next.next\n slow = slow.next\n \n prev, current = None, slow.next\n\n while current:\n next = current.next\n current.next = prev\n prev = current\n current = next\n slow.next = None\n \n\n head1, head2 = head, prev\n while head2:\n next = head1.next\n head1.next = head2\n head1 = head2\n head2 = next\n\n\n\n\n","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n fast, slow = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n prev, curr = None, slow\n while curr:\n temp = curr.next\n curr.next = prev\n prev = curr\n curr = temp\n \n first, second = head, prev\n while second.next:\n tmp1, tmp2 = first.next, second.next\n first.next = second\n second.next = tmp1\n first = tmp1\n second = tmp2\n\n ","runtime":"44"},{"code":"class ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\nclass Solution:\n def reverse(self, head):\n if not head:\n return None\n prev = None\n curr = head\n nextNode = None\n while curr:\n nextNode = curr.next\n curr.next = prev\n prev = curr\n curr = nextNode\n return prev\n\n def merge(self, list1, list2):\n while list2:\n nextNode = list1.next\n list1.next = list2\n list1 = list2\n list2 = nextNode\n\n def reorderList(self, head):\n if not head or not head.next:\n return\n slow = head\n fast = head\n prev = head\n while fast and fast.next:\n prev = slow\n fast = fast.next.next\n slow = slow.next\n prev.next = None\n list1 = head\n list2 = self.reverse(slow)\n self.merge(list1, list2)\n ","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n leftHead = head\n slow = head\n fast = head.next\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n rightHead = slow.next\n slow.next = None\n\n prev, curr = None, rightHead\n while curr:\n temp = curr.next\n curr.next = prev\n prev = curr\n curr = temp\n \n rightHead = prev\n\n while rightHead:\n leftTemp, rightTemp = leftHead.next, rightHead.next\n\n leftHead.next = rightHead\n rightHead.next = leftTemp\n\n leftHead = leftTemp\n rightHead = rightTemp\n \n return head","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # mid\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n mid = slow\n # reverse\n prev = None\n while mid:\n tmp = mid.next\n mid.next = prev\n prev = mid\n mid = tmp\n second = prev\n # merge\n first = head\n while second.next:\n tmp = first.next\n first.next = second\n first = tmp\n\n tmp = second.next\n second.next = first\n second = tmp","runtime":"46"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Reorders the list in-place, so it becomes: L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head or not head.next:\n return\n \n # Step 1: Find the middle of the list\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n # Step 2: Reverse the second half of the list\n prev, curr = None, slow\n while curr:\n next_temp = curr.next\n curr.next = prev\n prev = curr\n curr = next_temp\n \n # Step 3: Merge the two halves\n first, second = head, prev\n while second.next:\n # Temporarily store the next pointers\n tmp1, tmp2 = first.next, second.next\n # Reorder nodes\n first.next = second\n second.next = tmp1\n # Move to the next nodes\n first = tmp1\n second = tmp2\n","runtime":"46"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom math import ceil\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n nodes_list = []\n current = head\n\n while current:\n nodes_list.append(current)\n current = current.next\n\n n = len(nodes_list)\n right = n-1\n left = 0\n for left in range(ceil(n / 2)):\n nodes_list[left].next = nodes_list[right]\n if left+1 < right:\n nodes_list[right].next = nodes_list[left + 1]\n else:\n nodes_list[right].next = None\n\n right -= 1\n \n return nodes_list[0]\n\n\n","runtime":"47"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n \n # Find the middle\n slow = head\n fast = head\n \n while fast and fast.next is not None:\n slow = slow.next\n fast = fast.next.next\n \n\n prev = None\n middle = slow\n\n # Reverse second half of the list\n while middle:\n tmp_next = middle.next\n\n middle.next = prev\n prev = middle\n middle = tmp_next\n \n # Merge second middle into the first middle, one at a time\n l1 = head\n l2 = prev\n while l2.next:\n tmp_next_1 = l1.next\n tmp_next_2 = l2.next\n\n l1.next = l2\n l2.next = tmp_next_1\n\n l1 = tmp_next_1\n l2 = tmp_next_2\n \n\n\n\n ","runtime":"47"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n slow,fast = head,head.next\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n #reverse 2nd half\n second_half = slow.next\n prev = slow.next = None\n\n while second_half:\n temp = second_half.next\n second_half.next = prev\n prev = second_half\n second_half = temp\n first,second = head,prev\n #re-ordering\n while second:\n tmp1 , tmp2 = first.next , second.next\n first.next = second\n second.next = tmp1\n first = tmp1\n second = tmp2\n \n\n\n\n ","runtime":"48"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n if fast:\n slow = slow.next\n\n prev, rev_head = None, slow\n while rev_head:\n next = rev_head.next\n rev_head.next = prev\n prev = rev_head\n rev_head = next\n\n first_half_head = head\n second_half_head = prev\n while second_half_head:\n first_half_next = first_half_head.next\n first_half_head.next = second_half_head\n first_half_head = first_half_next\n\n second_half_next = second_half_head.next\n second_half_head.next = first_half_next\n second_half_head = second_half_next\n first_half_head.next = None\n ","runtime":"48"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n\n slow = head\n fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n # reverse second half of the linked list\n\n prev, curr = None, slow\n\n while curr:\n next_node = curr.next\n curr.next = prev\n prev = curr\n curr = next_node\n \n rev_head = prev\n\n head1, head2 = head, rev_head\n\n while head2.next:\n\n node = head1.next\n head1.next = head2\n head1 = node\n\n node = head2.next\n head2.next = head1\n head2 = node\n\n \n\n ","runtime":"49"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n head_copy = head\n queue = deque()\n\n while head_copy:\n queue.append(head_copy)\n head_copy = head_copy.next\n \n head = queue.popleft()\n \n while queue:\n if len(queue) >= 2:\n l, r = queue.popleft(), queue.pop()\n head.next = r\n head = head.next\n else:\n l = queue.popleft()\n \n head.next = l\n head = head.next\n \n head.next = None \n ","runtime":"49"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n if not head or not head.next:\n return\n \n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n prev, curr = None, slow\n while curr:\n next_temp = curr.next\n curr.next = prev\n prev = curr\n curr = next_temp\n \n first, second = head, prev\n while second.next:\n temp1, temp2 = first.next, second.next\n first.next = second\n second.next = temp1\n first, second = temp1, temp2","runtime":"50"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n stack = deque()\n cur = head\n while cur:\n stack.append(cur)\n cur = cur.next\n \n cur = stack.popleft()\n counter = 0\n while stack:\n if not (counter % 2):\n cur.next = stack.pop()\n else:\n cur.next = stack.popleft()\n cur = cur.next\n counter += 1\n cur.next = None","runtime":"50"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reverseList(self, head):\n prev, curr = None, head\n while(curr):\n temp = curr.next\n curr.next = prev\n prev = curr\n curr = temp\n return prev\n\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head\n if head == None:\n return head\n while(slow.next != None and fast.next != None and fast.next.next != None):\n slow = slow.next\n fast = fast.next.next\n\n temp = slow.next\n slow.next = None\n\n l, r = head, self.reverseList(temp)\n while(l and r):\n next_l = l.next\n next_r = r.next\n l.next = r\n r.next = next_l\n l = next_l\n r = next_r\n \n\n\n return head\n\n # 1 2\n # 5 4 3\n\n\n ","runtime":"51"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n second = slow.next\n prev = slow.next = None\n while second:\n temp = second.next\n second.next = prev\n prev = second\n second = temp\n\n first, second = head, prev\n while second:\n temp1, temp2 = first.next, second.next\n first.next = second\n second.next = temp1\n first, second = temp1, temp2\n ","runtime":"51"},{"code":"class Solution:\n def reorderList(self, head: ListNode) -> None:\n def findMid(head: ListNode):\n prev = None\n slow = head\n fast = head\n\n while fast and fast.next:\n prev = slow\n slow = slow.next\n fast = fast.next.next\n prev.next = None\n\n return slow\n\n def reverse(head: ListNode) -> ListNode:\n prev = None\n curr = head\n\n while curr:\n next = curr.next\n curr.next = prev\n prev = curr\n curr = next\n\n return prev\n\n def merge(l1: ListNode, l2: ListNode) -> None:\n while l2:\n next = l1.next\n l1.next = l2\n l1 = l2\n l2 = next\n\n if not head or not head.next:\n return\n\n mid = findMid(head)\n reversed = reverse(mid)\n merge(head, reversed)","runtime":"53"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n slow = head\n fast = head.next\n \n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n second = slow.next \n prev = slow.next = None\n while second:\n temp = second.next\n second.next = prev\n prev = second\n second = temp\n\n first, second = head, prev\n while second:\n temp1, temp2 = first.next, second.next\n first.next = second\n second.next = temp1\n first , second = temp1, temp2\n\n ","runtime":"53"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # time O(n)\n # space O(1)\n slow = fast = head\n\n while fast and fast.next:\n slow, fast = slow.next, fast.next.next\n\n l2 = slow.next\n slow.next = None\n prev = None\n\n while l2:\n tmp = l2.next\n l2.next = prev\n prev = l2\n l2 = tmp\n \n l2 = prev\n l1 = head\n\n # merge l1 and l2\n while l1 and l2:\n tmp1, tmp2 = l1.next, l2.next\n l1.next = l2\n l2.next = tmp1\n l1, l2 = tmp1, tmp2\n \n return head\n","runtime":"54"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n hash={}\n idx=0\n curr=head\n while curr:\n hash[idx]=curr\n curr=curr.next\n idx +=1\n\n\n for i in range(int((idx-1)/2)):\n hash[i].next=hash[idx-1-i]\n hash[idx-1-i].next=hash[i+1]\n\n if (idx-1)%2==0:\n hash[int((idx-1)/2)].next=None\n else:\n hash[int((idx-1)/2) +1].next=None\n ","runtime":"54"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n\n #Find middle using tortoise and hare modified \n tortoise = head\n hare = head.next\n while hare and hare.next:\n tortoise = tortoise.next\n hare = hare.next.next\n \n\n #Reverse from middle \n prev = None\n second = tortoise\n while second:\n temp = second.next\n second.next = prev\n prev = second\n second = temp\n \n #Merge first half and second half\n first = head\n second = prev\n while first and second:\n temp1 = first.next\n temp2 = second.next\n first.next = second\n second.next = temp1\n first = temp1\n second = temp2","runtime":"55"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow = head\n fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n prev = None\n rev_head = slow.next\n slow.next = None\n while rev_head:\n next = rev_head.next\n rev_head.next = prev\n prev = rev_head\n rev_head = next\n\n first_half_head = head\n second_half_head = prev\n while second_half_head:\n first_half_next = first_half_head.next\n first_half_head.next = second_half_head\n first_half_head = first_half_next\n\n second_half_next = second_half_head.next\n second_half_head.next = first_half_next\n second_half_head = second_half_next\n ","runtime":"55"},{"code":"class Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n The aproach is divided in three steps:\n 1. find the middle\n 2. reverse the list from the middle to the end\n 3. have two pointer, one from the head and the other from the end,\n and start to reorder the list\n \"\"\"\n\n # Required minimum length of 3\n if head is None or head.next is None or head.next.next is None:\n return\n\n # 1. Find the middle\n slow, fast = head, head\n while fast is not None and fast.next is not None:\n fast = fast.next.next\n slow = slow.next\n\n # 2. Reverse from the middle\n current = slow\n prev = None\n while current is not None:\n next = current.next\n current.next = prev\n prev = current\n current = next\n\n # 3. Reorder the list\n right = prev\n left = head\n while right.next is not None and left.next is not None:\n next_left = left.next\n left.next = right\n left = left.next\n next_right = right.next\n left.next = next_left\n right = next_right\n left = left.next","runtime":"56"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n fast, slow = head.next, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n second = slow.next\n slow.next = prev = None\n while second:\n n = second.next\n second.next = prev\n prev = second\n second = n\n first, second = head, prev\n while first and second:\n tmp1, tmp2 = first.next, second.next\n first.next = second\n second.next = tmp1\n first = tmp1\n second = tmp2\n return head","runtime":"56"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n # get to the middle of the list and reverse the second half and merge the two parts\n slow_pt, fast_pt = head, head\n while fast_pt and fast_pt.next:\n slow_pt = slow_pt.next\n fast_pt = fast_pt.next.next\n\n \n # reverse the prev list take first half of head\n second = slow_pt.next\n dummy = slow_pt.next = None\n while second:\n dummy = ListNode(second.val, dummy)\n second = second.next\n\n\n # Merge two lists\n first, second= head, dummy\n while second:\n # keep the reset of element in tmp\n tmp1, tmp2 = first.next, second.next\n\n # add element from first and second\n first.next = second\n second.next = tmp1\n\n first, second = tmp1, tmp2\n","runtime":"57"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n mid = slow.next\n second_head = self.reverse(mid)\n slow.next = None\n first_head = head\n while second_head:\n temp1 = first_head.next\n temp2 = second_head.next\n first_head.next = second_head\n second_head.next = temp1\n first_head = temp1\n second_head = temp2\n\n\n def reverse(self, head):\n prev = None\n cur_head = head\n while cur_head:\n temp = cur_head.next\n cur_head.next = prev\n prev = cur_head\n cur_head = temp \n return prev","runtime":"57"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n dummy = ListNode(0, head)\n fast = slow = dummy\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n reverseHead = slow.next\n slow.next = None\n prev = None\n curr = reverseHead\n while curr:\n nextNode = curr.next\n curr.next = prev\n prev = curr\n curr = nextNode\n first = head\n second = prev\n while second:\n tmp1, tmp2 = first.next, second.next\n first.next = second\n second.next = tmp1\n first, second = tmp1, tmp2\n","runtime":"58"},{"code":"class Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n # find middle of list\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = (fast.next).next\n \n # reverse second half of list\n cur = slow.next\n slow.next = None\n pre = None\n while cur:\n post = cur.next\n cur.next = pre\n pre = cur\n cur = post\n\n # combine two lists\n L, R = head, pre\n while R:\n nextL, nextR = L.next, R.next\n L.next = R\n R.next = nextL\n L, R = nextL, nextR","runtime":"58"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head.next:\n return head\n slow = head\n fast = head.next\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n head2 = slow.next\n slow.next = None\n\n prev = None\n curr = head2\n\n while curr:\n temp = curr.next\n curr.next = prev\n prev = curr\n curr = temp\n \n i = head\n j = prev\n\n while i and j:\n temp = i.next\n i.next = j\n temp2 = j.next\n j.next = temp\n i = temp\n j = temp2\n\n return head","runtime":"59"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head.next\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n prev = None \n second = slow.next\n slow.next = None \n while second:\n tmp = second.next\n second.next = prev \n prev = second \n second = tmp \n while prev:\n tmp1, tmp2 = head.next, prev.next\n head.next = prev \n prev.next = tmp1\n head, prev = tmp1, tmp2","runtime":"59"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow = fast = head\n\n while fast and fast.next:\n slow, fast = slow.next, fast.next.next\n\n l2 = slow.next\n slow.next = None\n prev = None\n\n while l2:\n tmp = l2.next\n l2.next = prev\n prev = l2\n l2 = tmp\n \n l2 = prev\n l1 = head\n\n # merge l1 and l2\n while l1 and l2:\n tmp1, tmp2 = l1.next, l2.next\n l1.next = l2\n l2.next = tmp1\n l1, l2 = tmp1, tmp2\n \n return head\n","runtime":"60"},{"code":"class Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n # find middle of list\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = (fast.next).next\n \n # reverse second half of list\n cur = slow.next\n slow.next = None\n pre = None\n while cur:\n post = cur.next\n cur.next = pre\n pre = cur\n cur = post\n\n # combine two lists\n L, R = head, pre\n while R:\n nextL, nextR = L.next, R.next\n L.next = R\n R.next = nextL\n L, R = nextL, nextR","runtime":"60"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n slow, fast = head, head.next\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n second = slow.next\n prev = slow.next = None\n\n while second:\n tmp = second.next\n second.next = prev\n prev = second\n second = tmp\n\n first, second = head, prev\n while second:\n tmp1, tmp2 =first.next, second.next\n first.next = second\n second.next = tmp1\n first = tmp1\n second = tmp2\n","runtime":"61"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n history = []\n curr = head\n while curr:\n history.append(curr)\n curr = curr.next\n\n left = 0\n right = len(history) - 1\n tail = None\n while left < right:\n history[right].next = history[left].next\n history[left].next = history[right]\n tail = history[right]\n left += 1\n right -= 1\n\n if left == right:\n if tail:\n tail.next = history[left]\n tail = history[left]\n tail.next = None\n\n \n ","runtime":"61"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n start, list1 = head, head\n\n slow, fast = head, head.next\n\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n\n list2 = slow.next\n slow.next = None\n prev = None\n\n while list2:\n tempVal = list2.next\n list2.next = prev\n prev = list2 \n list2 = tempVal\n\n list2 = prev\n while list2:\n tempVal1 = list1.next\n list1.next = list2\n list1 = tempVal1\n\n tempVal2 = list2.next\n list2.next = tempVal1\n list2 = tempVal2\n \n return start\n","runtime":"62"},{"code":"class Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n # find middle of list\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = (fast.next).next\n \n # reverse second half of list\n cur = slow.next\n slow.next = None\n pre = None\n while cur:\n post = cur.next\n cur.next = pre\n pre = cur\n cur = post\n\n # combine two lists\n L, R = head, pre\n while R:\n nextL, nextR = L.next, R.next\n L.next = R\n R.next = nextL\n L, R = nextL, nextR","runtime":"62"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n count=0\n curr=head\n while curr:\n count+=1\n curr=curr.next\n mid=count//2\n if mid>=1:\n curr=head\n nxt=None\n while mid:\n if mid==1:\n nxt=curr\n curr=curr.next\n mid-=1\n nxt.next=None\n prev=None\n while curr:\n nxt=curr.next\n curr.next=prev\n prev=curr\n curr=nxt\n curr=head\n while curr:\n nxt=prev.next\n prev.next=curr.next\n curr.next=prev\n prev=nxt\n if curr.next.next is None:\n nxt=curr.next\n curr=curr.next.next\n if prev:\n nxt.next=prev\n","runtime":"63"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # find the middle nodes\n slow = head\n fast = head \n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n mid = slow \n\n # reverse the second half since middle \n prev = None\n curr = mid\n while curr:\n tmp_next = curr.next\n curr.next = prev\n prev = curr\n curr = tmp_next\n # prev is the head of reversed second half \n\n # merge them in-place \n first = head\n second = prev\n while second.next:\n first_next_tmp = first.next\n first.next = second\n first = first_next_tmp\n second_next_tmp = second.next\n second.next = first_next_tmp\n second = second_next_tmp\n","runtime":"63"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n\n slow = head\n fast = head.next\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n second = slow.next\n slow.next = None\n prev = None\n while second:\n nxt = second.next\n second.next = prev\n prev = second\n second = nxt\n\n first = head\n second = prev\n while second:\n tmp1 = first.next\n tmp2 = second.next\n first.next = second\n second.next = tmp1\n second = tmp2\n first = tmp1\n ","runtime":"64"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head or not head.next:\n return head\n # find middle to split\n dummy = ListNode(0, head)\n slow, fast = dummy, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n midpoint = slow.next\n slow.next = None\n list2 = self.reverse(midpoint)\n list1 = head\n # merge\n dummy = ListNode(0)\n current = dummy\n while list1 and list2:\n current.next = list1\n list1 = list1.next\n current = current.next\n \n current.next = list2\n list2 = list2.next\n current = current.next\n if list1:\n current.next = list1\n elif list2:\n current.next = list2\n return dummy.next\n def reverse(self, head):\n if not head or not head.next:\n return head\n prev = None\n current = head\n while current:\n next_node = current.next\n current.next = prev\n prev = current\n current = next_node\n return prev","runtime":"64"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n \n # Find the middle\n slow = head\n fast = head\n \n counter = 0\n while fast and fast.next is not None:\n slow = slow.next\n fast = fast.next.next\n counter += 1\n \n\n prev = None\n middle = slow\n\n # Reverse second half of the list\n while middle:\n tmp_next = middle.next\n\n middle.next = prev\n prev = middle\n middle = tmp_next\n \n # Merge second middle into the first middle, one at a time\n l1 = head\n l2 = prev\n while l2.next:\n tmp_next_1 = l1.next\n tmp_next_2 = l2.next\n\n l1.next = l2\n l2.next = tmp_next_1\n\n l1 = tmp_next_1\n l2 = tmp_next_2\n \n # l1.next = None\n\n\n\n ","runtime":"65"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # find the mid node\n slow = head\n fast = head\n while fast.next:\n slow = slow.next\n fast = fast.next\n if fast.next is None:\n break\n fast = fast.next \n \n # reverse links from mid to end\n prev = slow \n cur = prev.next\n prev.next = None\n while cur:\n temp = cur.next\n cur.next = prev\n prev = cur\n cur = temp\n \n right_head = prev\n left_head = head\n\n while right_head.next:\n left_next = left_head.next\n right_next = right_head.next\n \n left_head.next = right_head\n right_head.next = left_next\n \n left_head = left_next\n right_head = right_next","runtime":"65"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom math import ceil\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n nodes_list = []\n current = head\n\n while current:\n nodes_list.append(current)\n current = current.next\n\n n = len(nodes_list)\n right = n-1\n left = 0\n while left <= right:\n print(left, right)\n nodes_list[left].next = nodes_list[right]\n if left+1 < right:\n nodes_list[right].next = nodes_list[left + 1]\n else:\n nodes_list[right].next = None\n\n left += 1\n right -= 1\n \n print([node.val for node in nodes_list])\n return nodes_list[0]\n\n\n","runtime":"66"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n #first, last, second, second last?\n #idea, put nodes in a stack? first in first out\n stack = []\n curr = head\n while curr != None:\n stack.append(curr)\n curr = curr.next\n begin = True\n count = 0\n list_len = len(stack)\n curr = head\n res = ListNode\n res_iterator = res\n while count < list_len:\n if begin:\n res_iterator.next = curr\n curr = curr.next\n else:\n res_iterator.next = stack.pop()\n res_iterator = res_iterator.next\n begin = not begin\n count += 1\n res_iterator.next = None\n return res.next\n ","runtime":"66"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # find the mid-point\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n prev = None\n second = slow.next\n slow.next = None # End of the new list\n # reverse the second half of the list\n # 1 -> 2 -> 3\n # p t\n # 1 <- 2 <- 3\n while second:\n temp = second.next\n second.next = prev\n prev = second\n second = temp\n\n # merge the two lists\n first, second = head, prev\n while second:\n tmp1, tmp2 = first.next, second.next\n first.next = second\n second.next = tmp1\n first, second = tmp1, tmp2","runtime":"67"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n second = slow.next\n prev = slow.next = None\n while second:\n temp = second.next\n second.next = prev\n prev = second\n second = temp\n\n ####merging of lists\n first, second = head, prev\n while second:\n tmp1, tmp2 = first.next, second.next\n first.next = second\n second.next = tmp1\n first, second = tmp1, tmp2","runtime":"67"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n dct = {}\n n = -1\n temp = head\n \n while temp:\n n+=1\n dct[n]= temp.val\n temp=temp.next\n \n i = 0\n j= 0\n \n temp=head\n while j<n:\n j+=1\n if j%2!=0:\n temp.next = ListNode(dct[n-i])\n i+=1\n else:\n temp.next = ListNode(dct[i])\n temp =temp.next","runtime":"68"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n #find middle of lnkedlist\n #reverse later part\n #mingle them tgt\n res = head\n slow = head\n fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n prev = None\n \n \n mid = slow\n \n while mid:\n temp = mid.next\n mid.next = prev\n prev = mid\n mid = temp\n\n while prev.next:\n temp1 = head.next\n temp2 = prev.next\n head.next = prev\n prev.next = temp1\n head = temp1\n prev = temp2\n return res","runtime":"68"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n fast = second = head\n fast = fast.next\n while fast and fast.next:\n fast = fast.next.next\n second = second.next\n prev = None\n reverse = second.next\n second.next = None\n while reverse:\n temp = reverse.next\n reverse.next = prev\n prev = reverse\n reverse = temp\n second = prev\n first = head\n while second:\n first_temp = first.next\n second_temp = second.next\n first.next = second\n second.next = first_temp\n first = first_temp\n second = second_temp\n \n\n ","runtime":"69"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n \n # find the middle\n slow, fast = head, head\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n head2 = slow.next\n\n stack = []\n queue = []\n head1 = head.next\n while head2:\n stack.append(head2)\n head2 = head2.next\n\n while head1!=slow.next:\n \n queue.append(head1)\n head1 = head1.next\n if len(queue) > 0:\n queue[-1].next = None\n while len(queue)>0 or len(stack)>0:\n head.next = stack.pop(-1) if len(stack)>0 else None\n head.next.next = queue.pop(0) if len(queue)>0 else None\n head = head.next.next\n\n","runtime":"70"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom collections import deque\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n\n fast = slow = head\n\n while fast.next and fast.next.next:\n fast = fast.next.next\n slow = slow.next\n \n prev, current = None, slow.next\n\n while current:\n next = current.next\n current.next = prev\n prev = current\n current = next\n slow.next = None\n \n\n l1, l2 = head, prev\n while l1 and l2:\n next_l1 = l1.next\n next_l2 = l2.next\n\n l1.next = l2\n l1 = next_l1\n l2.next = l1\n l2 = next_l2\n\n\n\n\n","runtime":"71"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n '''\n The head is a node of value 0\n '''\n count = self.size(head)\n if(self.size(head)< 3):\n return \n shifts = (count-1)//2\n count = count-1\n lists = []\n '''get elements we are shifting'''\n curr = head.next\n prev = None\n i=0\n while(curr):\n if(i == ((count-shifts-1))):\n prev = curr\n if i >= (count-shifts):\n lists.append(curr)\n curr = curr.next\n i+=1\n prev.next = None\n lists.reverse()\n curr = head\n a = None\n i=0\n while(i < shifts):\n replace = lists[i]\n temp = curr.next\n curr.next = replace\n replace.next = temp\n curr = curr.next.next\n print(curr.val)\n i+= 1\n \n def size(self, head):\n p = head.next\n count = 1\n while(p):\n p = p.next\n count += 1\n return count","runtime":"71"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head:\n return None\n curr=head\n length=1\n while curr.next:\n curr=curr.next\n length+=1\n length=length//2 if length%2==0 else length//2+1\n curr=head\n while length>0:\n if length==1:\n temp=curr.next\n curr.next=None\n curr=temp\n else:\n curr=curr.next\n length-=1\n temp,prev=None,None\n while curr:\n temp=curr.next\n curr.next=prev\n prev=curr\n curr=temp\n curr=prev\n curr1,curr2=head,curr\n while curr2:\n temp1=curr1.next\n temp2=curr2.next\n curr1.next=curr2\n curr2.next=temp1\n curr1=temp1\n curr2=temp2","runtime":"72"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head\n while fast != None:\n slow = slow.next\n if fast != None:\n fast = fast.next\n if fast!=None:\n fast = fast.next\n low = head\n stack =[]\n queue = []\n while low!=slow:\n queue.append(low)\n low=low.next\n while slow != None:\n stack.append(slow)\n slow = slow.next\n count = 0\n ptr1 = None\n while len(queue) > 0:\n value = queue.pop(0)\n if count == 0:\n head = value\n count+=1\n if ptr1==None:\n ptr1 = value\n else:\n ptr1.next = value\n ptr1 = ptr1.next\n if len(stack)>0:\n ptr1.next = stack.pop()\n ptr1 = ptr1.next\n ptr1.next = None\n return head\n\n\n\n ","runtime":"73"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head or not head.next:\n return head\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n list1, list2 = head, slow.next\n slow.next = None\n \n #reverse list 2\n prev = None\n curr = list2\n while curr:\n tmp = curr.next\n curr.next = prev\n prev = curr\n curr = tmp\n\n list2 = prev\n #merge list1 and list2\n dummyNode = ListNode(0)\n curr = dummyNode\n i = 0\n print(list1.val, list2.val)\n while list1 and list2:\n if (i % 2) == 0:\n print(f\"list 1 {list1.val}\")\n dummyNode.next = list1\n dummyNode = dummyNode.next\n list1 = list1.next\n else:\n print(f\"list 2 {list2.val}\")\n dummyNode.next = list2\n dummyNode = dummyNode.next\n list2 = list2.next\n i += 1\n\n if list1:\n dummyNode.next = list1\n elif list2:\n dummyNode.next = list2\n\n return curr.next\n\n\n \n\n\n \n \n ","runtime":"73"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n current_node = head \n list_values = [current_node.val]\n while current_node.next is not None:\n current_node = current_node.next\n list_values.append(current_node.val)\n\n ## Check is par\n is_par = len(list_values) % 2 == 0\n\n ## Define the new list\n pointier_a = 1\n pointier_b = len(list_values) - 1\n current_node = head\n while pointier_a <= pointier_b:\n ## Get values\n value_a = list_values[pointier_a]\n value_b = list_values[pointier_b]\n\n ## Update the values\n current_node.next = ListNode(value_b)\n current_node = current_node.next\n\n if not(pointier_a == pointier_b and is_par):\n current_node.next = ListNode(value_a)\n current_node = current_node.next\n\n ## Update pointiers\n pointier_a += 1\n pointier_b -= 1","runtime":"74"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n\n if not head:\n return\n\n slow = head\n fast = head\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n prev = None\n curr = slow\n\n while curr:\n temp = curr.next\n curr.next = prev\n prev = curr\n curr = temp\n \n first = head\n second = prev\n\n while second.next:\n temp = first.next\n first.next = second\n first = temp\n\n temp = second.next\n second.next = first\n second = temp\n\n\n\n\n \n \n \n\n\n ","runtime":"74"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n # Do not return anything, modify head in-place instead.\n\n # if even, elements till (len/2 - 1) index on leftside\n # if odd, elements till (len//2 + 1 ) index on leftside\n # use double ptrs, fast one will reach end of list, track elements after mid for fast one, then add from that list in reverse order to elements till mid in \n tmp=head\n length=0\n while tmp!=None:\n tmp=tmp.next\n length+=1\n\n if length<=2: #no change required\n return\n\n if length%2==0:\n reqidx = (length/2 ) - 1\n else:\n reqidx = (length//2)\n print(\"length\",length, \"elems on left arr\",reqidx+1)\n\n\n\n i=0\n j=0\n\n slow = head\n fast = head\n\n if length%2!=0:\n j=1\n fast=head.next\n\n slowvalues = []\n fastvalues = []\n\n while fast!=None and fast.next!=None:\n # print(\"i=\",i,\" j=\",j)\n if i<=reqidx:\n slowvalues.append(slow.val)\n if j>reqidx:\n fastvalues.append(fast.val)\n if fast.next is not None and fast.next.next is None:\n fastvalues.append(fast.next.val)\n \n slow = slow.next\n i+=1\n \n if length%2!=0:\n if j==reqidx:\n fast = fast.next\n if fast.next is None:\n fastvalues.append(fast.val)\n j+=1\n continue\n\n if j>reqidx:\n fast = fast.next\n j+=1\n else:\n fast = fast.next.next\n j+=2\n \n\n if length%2!=0:\n slowvalues.append(slow.val)\n\n # print(len(slowvalues), len(fastvalues))\n print(\"slow...\",slowvalues)\n fastvalues = fastvalues[::-1]\n print(\"fast...\",fastvalues)\n\n finalvals = []\n tmp = head\n for i in range(len(slowvalues)):\n finalvals.append(slowvalues[i])\n if i>0:\n tmp.next = ListNode(val=slowvalues[i])\n tmp = tmp.next\n\n try:\n if fastvalues[i] is not None:\n finalvals.append(fastvalues[i])\n tmp.next = ListNode(val=fastvalues[i])\n tmp = tmp.next\n except IndexError:\n print(\"odd-len-so-index-error\")\n break\n \n print(\"total ... \",finalvals)\n\n\n ","runtime":"75"},{"code":"class ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\ndef printList(node):\n while node:\n print(node.val, end=\" -> \")\n node = node.next\n print(\"None\")\n\nclass Solution:\n def reorderList(self, head: ListNode) -> None:\n if not head or not head.next:\n return\n \n # printList(head)\n\n slow, fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n \n prev, curr = None, slow\n while curr:\n next_temp = curr.next\n curr.next = prev\n prev = curr\n curr = next_temp\n \n # printList(prev)\n\n first, second = head, prev\n while second.next:\n tmp1, tmp2 = first.next, second.next\n first.next = second\n second.next = tmp1\n first = tmp1\n second = tmp2\n # printList(head)\n\n # printList(head)\n","runtime":"76"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head\n while fast != None:\n slow = slow.next\n if fast != None:\n fast = fast.next\n if fast!=None:\n fast = fast.next\n low = head\n stack =[]\n queue = []\n while low!=slow:\n queue.append(low)\n low=low.next\n while slow != None:\n stack.append(slow)\n slow = slow.next\n count = 0\n ptr1 = None\n while len(queue) > 0:\n value = queue.pop(0)\n if count == 0:\n head = value\n count+=1\n if ptr1==None:\n ptr1 = value\n else:\n ptr1.next = value\n ptr1 = ptr1.next\n if len(stack)>0:\n ptr1.next = stack.pop()\n ptr1 = ptr1.next\n ptr1.next = None\n return head\n\n\n\n ","runtime":"77"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head\n while fast != None:\n slow = slow.next\n if fast != None:\n fast = fast.next\n if fast!=None:\n fast = fast.next\n low = head\n stack =[]\n queue = []\n while low!=slow:\n queue.append(low)\n low=low.next\n while slow != None:\n stack.append(slow)\n slow = slow.next\n count = 0\n ptr1 = None\n while len(queue) > 0:\n value = queue.pop(0)\n if count == 0:\n head = value\n count+=1\n if ptr1==None:\n ptr1 = value\n else:\n ptr1.next = value\n ptr1 = ptr1.next\n if len(stack)>0:\n ptr1.next = stack.pop()\n ptr1 = ptr1.next\n ptr1.next = None\n return head\n\n\n\n ","runtime":"78"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head\n while fast != None:\n slow = slow.next\n if fast != None:\n fast = fast.next\n if fast!=None:\n fast = fast.next\n low = head\n stack =[]\n queue = []\n while low!=slow:\n queue.append(low)\n low=low.next\n while slow != None:\n stack.append(slow)\n slow = slow.next\n count = 0\n ptr1 = None\n while len(queue) > 0:\n value = queue.pop(0)\n if count == 0:\n head = value\n count+=1\n if ptr1==None:\n ptr1 = value\n else:\n ptr1.next = value\n ptr1 = ptr1.next\n if len(stack)>0:\n ptr1.next = stack.pop()\n ptr1 = ptr1.next\n ptr1.next = None\n return head\n\n\n\n ","runtime":"79"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def p(self,h):\n while h:\n print(h.val)\n h=h.next\n def re(self,h):\n temp=h\n prev=None\n while temp:\n front=temp.next\n temp.next=prev\n prev=temp\n temp=front\n return prev\n \n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if head is None or head.next is None:\n return head\n slow=head\n fast=head\n\n temp=head\n\n dummy=ListNode()\n currNode=dummy\n l=None\n r=None\n\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n r=slow.next\n slow.next=None\n l=head\n\n self.p(l)\n self.p(r)\n r=self.re(r)\n pos=1\n\n while l and r:\n if pos%2==0:\n currNode.next=r\n r=r.next\n else:\n currNode.next=l\n l=l.next\n currNode=currNode.next\n pos+=1\n if l:\n currNode.next=l\n if r:\n currNode.next=r\n\n return dummy.next\n\n \n \n\n\n","runtime":"80"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n stack = []\n curr = head\n \n while curr:\n stack.append(curr)\n curr = curr.next\n\n curr = head\n \n while stack:\n curr.next = stack.pop(0)\n curr = curr.next\n\n if stack:\n curr.next = stack.pop()\n curr = curr.next\n \n curr.next = None\n \n\n\n \n ","runtime":"81"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head\n while fast != None:\n slow = slow.next\n if fast != None:\n fast = fast.next\n if fast!=None:\n fast = fast.next\n low = head\n stack =[]\n queue = []\n while low!=slow:\n queue.append(low)\n low=low.next\n while slow != None:\n stack.append(slow)\n slow = slow.next\n count = 0\n ptr1 = None\n while len(queue) > 0:\n value = queue.pop(0)\n if count == 0:\n head = value\n count+=1\n if ptr1==None:\n ptr1 = value\n else:\n ptr1.next = value\n ptr1 = ptr1.next\n if len(stack)>0:\n ptr1.next = stack.pop()\n ptr1 = ptr1.next\n ptr1.next = None\n return head","runtime":"82"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n # def reverse(self,head):\n # curr=head\n # prev,nxt=None,None\n # while(curr):\n # nxt=curr.next\n # curr.next=prev\n # prev=curr\n # curr=nxt\n # return prev\n\n def reorderList(self, head: Optional[ListNode]) -> None:\n # \"\"\"\n # Do not return anything, modify head in-place instead.\n # \"\"\"\n # if(not head or not head.next):\n # return head\n\n # newHead=head\n # temp=head.next\n # while(temp and temp.next):\n # revHead=self.reverse(temp)\n # newHead.next=revHead\n # temp=revHead.next\n # newHead=revHead\n\n if(not head or not head.next):\n return head\n\n st=[] #stack\n qu=[] #queue\n\n #find middle of LL\n s=head\n f=head\n while(f and f.next):\n s=s.next\n f=f.next.next\n mid=s\n\n #put elements till mid in queue\n temp=head\n while(temp!=mid):\n qu.append(temp)\n temp=temp.next\n\n #put rest of elements in stack\n temp=mid\n while(temp):\n st.append(temp)\n temp=temp.next\n \n #pick each element 1st from queue and then from stack\n head=qu[0]\n temp=None\n while(len(st)>0 and len(qu)>0):\n x=qu[0]\n y=st[len(st)-1]\n if(temp):\n temp.next=x\n x.next=y\n y.next=None\n st.pop(len(st)-1)\n qu.pop(0)\n temp=y\n\n while(len(st)>0):\n y=st[len(st)-1]\n if(temp):\n temp.next=y\n y.next=None\n st.pop(len(st)-1)\n temp=y\n \n while(len(qu)>0):\n x=st[0]\n if(temp):\n temp.next=x\n x.next=None\n qu.pop(0)\n temp=x\n\n\n\n\n\n\n\n ","runtime":"83"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n # Do not return anything, modify head in-place instead.\n\n # if even, elements till (len/2 - 1) index on leftside\n # if odd, elements till (len//2 + 1 ) index on leftside\n # use double ptrs, fast one will reach end of list, track elements after mid for fast one, then add from that list in reverse order to elements till mid in \n tmp=head\n length=0\n while tmp!=None:\n tmp=tmp.next\n length+=1\n\n if length<=2: #no change required\n return\n\n if length%2==0:\n reqidx = (length/2 ) - 1\n else:\n reqidx = (length//2)\n print(\"length\",length, \"elems on left arr\",reqidx+1)\n\n\n i=0\n j=0\n slow = head\n fast = head\n if length%2!=0:\n j=1\n fast=head.next\n slowvalues = []\n fastvalues = []\n while fast!=None and fast.next!=None:\n # print(\"i=\",i,\" j=\",j)\n if i<=reqidx:\n slowvalues.append(slow.val)\n if j>reqidx:\n fastvalues.append(fast.val)\n if fast.next is not None and fast.next.next is None:\n fastvalues.append(fast.next.val)\n \n slow = slow.next\n i+=1\n if length%2!=0:\n if j==reqidx:\n fast = fast.next\n if fast.next is None:\n fastvalues.append(fast.val)\n j+=1\n else:\n if j>reqidx:\n fast = fast.next\n j+=1\n else:\n fast = fast.next.next\n j+=2\n \n else:\n if j>reqidx:\n fast = fast.next\n j+=1\n else:\n fast = fast.next.next\n j+=2\n \n\n if length%2!=0:\n slowvalues.append(slow.val)\n # if len(slowvalues) + len(fastvalues)!= length:\n # fastvalues.append(fast.val)\n\n print(len(slowvalues), len(fastvalues))\n print(\"slow...\",slowvalues)\n fastvalues = fastvalues[::-1]\n print(\"fast...\",fastvalues)\n\n finalvals = []\n tmp = head\n for i in range(len(slowvalues)):\n finalvals.append(slowvalues[i])\n if i>0:\n tmp.next = ListNode(val=slowvalues[i])\n tmp = tmp.next\n\n try:\n if fastvalues[i] is not None:\n finalvals.append(fastvalues[i])\n tmp.next = ListNode(val=fastvalues[i])\n tmp = tmp.next\n except IndexError:\n print(\"odd-len-so-index-error\")\n break\n \n print(\"total ... \",finalvals)\n\n\n ","runtime":"84"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n # Do not return anything, modify head in-place instead.\n\n # if even, elements till (len/2 - 1) index on leftside\n # if odd, elements till (len//2 + 1 ) index on leftside\n # use double ptrs, fast one will reach end of list, track elements after mid for fast one, then add from that list in reverse order to elements till mid in \n tmp=head\n length=0\n while tmp!=None:\n tmp=tmp.next\n length+=1\n\n if length<=2: #no change required\n return\n\n if length%2==0:\n reqidx = (length/2 ) - 1\n else:\n reqidx = (length//2)\n print(\"length\",length, \"elems on left arr\",reqidx+1)\n\n\n i=0\n j=0\n slow = head\n fast = head\n if length%2!=0:\n j=1\n fast=head.next\n slowvalues = []\n fastvalues = []\n while fast!=None and fast.next!=None:\n # print(\"i=\",i,\" j=\",j)\n if i<=reqidx:\n slowvalues.append(slow.val)\n if j>reqidx:\n fastvalues.append(fast.val)\n if fast.next is not None and fast.next.next is None:\n fastvalues.append(fast.next.val)\n \n slow = slow.next\n i+=1\n \n if length%2!=0:\n if j==reqidx:\n fast = fast.next\n if fast.next is None:\n fastvalues.append(fast.val)\n j+=1\n continue\n # else:\n # if j>reqidx:\n # fast = fast.next\n # j+=1\n # else:\n # fast = fast.next.next\n # j+=2\n \n # else:\n # if j>reqidx:\n # fast = fast.next\n # j+=1\n # else:\n # fast = fast.next.next\n # j+=2\n if j>reqidx:\n fast = fast.next\n j+=1\n else:\n fast = fast.next.next\n j+=2\n \n\n if length%2!=0:\n slowvalues.append(slow.val)\n # if len(slowvalues) + len(fastvalues)!= length:\n # fastvalues.append(fast.val)\n\n print(len(slowvalues), len(fastvalues))\n print(\"slow...\",slowvalues)\n fastvalues = fastvalues[::-1]\n print(\"fast...\",fastvalues)\n\n finalvals = []\n tmp = head\n for i in range(len(slowvalues)):\n finalvals.append(slowvalues[i])\n if i>0:\n tmp.next = ListNode(val=slowvalues[i])\n tmp = tmp.next\n\n try:\n if fastvalues[i] is not None:\n finalvals.append(fastvalues[i])\n tmp.next = ListNode(val=fastvalues[i])\n tmp = tmp.next\n except IndexError:\n print(\"odd-len-so-index-error\")\n break\n \n print(\"total ... \",finalvals)\n\n\n ","runtime":"84"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head\n while fast != None:\n slow = slow.next\n if fast != None:\n fast = fast.next\n if fast!=None:\n fast = fast.next\n low = head\n stack =[]\n queue = []\n while low!=slow:\n queue.append(low)\n low=low.next\n while slow != None:\n stack.append(slow)\n slow = slow.next\n count = 0\n ptr1 = None\n while len(queue) > 0:\n value = queue.pop(0)\n if count == 0:\n head = value\n count+=1\n if ptr1==None:\n ptr1 = value\n else:\n ptr1.next = value\n ptr1 = ptr1.next\n if len(stack)>0:\n ptr1.next = stack.pop()\n ptr1 = ptr1.next\n ptr1.next = None\n return head\n\n\n\n ","runtime":"85"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n res = []\n curr = head\n while curr:\n res.append(curr.val)\n curr = curr.next\n \n curr = head\n i = 0\n while curr:\n if i%2 == 0:\n curr.val = res.pop(0)\n else:\n curr.val = res.pop(-1)\n curr = curr.next\n i+=1\n ","runtime":"86"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n slow, fast = head, head\n while fast != None:\n slow = slow.next\n if fast != None:\n fast = fast.next\n if fast!=None:\n fast = fast.next\n low = head\n stack =[]\n queue = []\n while low!=slow:\n queue.append(low)\n low=low.next\n while slow != None:\n stack.append(slow)\n slow = slow.next\n count = 0\n ptr1 = None\n while len(queue) > 0:\n value = queue.pop(0)\n if count == 0:\n head = value\n count+=1\n if ptr1==None:\n ptr1 = value\n else:\n ptr1.next = value\n ptr1 = ptr1.next\n if len(stack)>0:\n ptr1.next = stack.pop()\n ptr1 = ptr1.next\n ptr1.next = None\n return head","runtime":"87"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n nodeNetwork = []\n while head: #traverse till end of linked \n nodeNetwork.append(head)\n head = head.next\n l = 0\n r = len(nodeNetwork)-1\n while l < r:\n nodeNetwork[r].next = None\n nodeNetwork[l].next = nodeNetwork[r]\n print(nodeNetwork[l])\n l += 1 #increment to next\n if l >= r: \n break\n else:\n nodeNetwork[l].next = None\n nodeNetwork[r].next = nodeNetwork[l]\n r -= 1\n \n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n #insert linked list network into a list of nodes\n #using len(nodeNetwork), make connections\n #nodeNetwork[0].next = nodeNetwork[len(nodeNetwork)]\n #nodeNetwork[len(nodeNetwork)].next = nodeNetwork[1]\n #nodeNetwork[1].next = nodeNetwork[len(nodeNetwork)-1]\n #nodeNetwork[len(nodeNetwork)-1].next = nodeNetwork[2]\n #use pointers, stop when they pass each other\n ","runtime":"88"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow,fast=head,head.next\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n second=slow.next\\n slow.next=prev=None\\n while second:\\n nxt=second.next\\n second.next=prev\\n prev=second\\n second=nxt\\n first,second=head,prev\\n while second:\\n tmp1,tmp2=first.next,second.next\\n first.next=second\\n second.next=tmp1\\n first=tmp1\\n second=tmp2\\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # Get middle of list\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n # Disconnect end of l1\\n l2 = slow.next\\n slow.next = None\\n\\n # Reverse l2\\n prev = None\\n while l2:\\n temp = l2.next\\n l2.next = prev\\n prev = l2\\n l2 = temp\\n\\n # Merge lists\\n first, second = head, prev\\n while second:\\n tmp1, tmp2 = first.next, second.next\\n first.next = second\\n second.next = tmp1\\n first, second = tmp1, tmp2\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n\\n slow,fast = head,head\\n\\n # find half way mark\\n\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n curr = slow.next\\n prev = None\\n slow.next = None\\n # reverse the second portion of the list\\n while curr:\\n tmp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = tmp\\n\\n\\n first = head\\n second = prev\\n\\n # merge two lists\\n\\n while second:\\n tmp1,tmp2 = first.next, second.next\\n\\n first.next = second\\n second.next = tmp1\\n\\n first = tmp1\\n second = tmp2\\n\\n\\n return head\\n\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n second = slow.next\\n prev = slow.next = None\\n\\n while second:\\n nxt = second.next\\n second.next = prev\\n prev = second\\n second = nxt\\n \\n first, second = head, prev\\n\\n while second:\\n tmp1, tmp2 = first.next, second.next\\n first.next = second\\n second.next = tmp1\\n first, second = tmp1, tmp2\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head or not head.next:\\n return \\n \\n # Step 1: Find the middle of the linked list\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n # Step 2: Reverse the second half of the list\\n prev, curr = None, slow\\n while curr:\\n next_temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = next_temp\\n \\n # Step 3: Merge the two halves\\n first, second = head, prev\\n while second.next:\\n temp1, temp2 = first.next, second.next\\n first.next = second\\n second.next = temp1\\n first, second = temp1, temp2\\n\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n second = slow.next\\n prev = slow.next = None\\n while second:\\n temp = second.next\\n second.next = prev\\n prev = second\\n second = temp\\n\\n first, second = head, prev\\n while second:\\n temp1, temp2 = first.next, second.next\\n first.next = second\\n second.next = temp1\\n first, second = temp1, temp2\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # aliter - https://leetcode.com/problems/reorder-list/editorial/comments/1088802\\n\\n\\n #less than 2 nodes\\n if not head or not head.next:\\n return head\\n\\n #reverse second part of the list and merge 2 sorted lists\\n\\n #find mid (mid = slow)\\n fast=slow=head\\n while fast and fast.next:\\n fast=fast.next.next\\n slow=slow.next\\n\\n #reverse the 2nd part of the list\\n prev= None #prev is the start of this list\\n curr= slow\\n while curr:\\n nex = curr.next\\n curr.next=prev\\n prev=curr\\n curr=nex\\n # curr.next, prev, curr = prev, curr, curr.next\\n \\n #merge 2 sorted lists\\n p1,p2 = head, prev\\n while p2.next:\\n nex1 = p1.next\\n p1.next= p2\\n p1= nex1\\n\\n nex2=p2.next\\n p2.next=nex1\\n p2=nex2\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n \\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head:\\n return\\n ls=[]\\n temp=head\\n while temp:\\n ls.append(temp)\\n temp=temp.next\\n\\n n=len(ls)\\n prev=None\\n\\n for i in range((n+1)//2):\\n cur=ls[i]\\n last=ls[n-i-1]\\n cur.next=last\\n if prev:\\n prev.next=cur\\n prev=last\\n prev.next=None\\n \\n\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n \\n slow, fast = head, head.next\\n \\n while fast and fast.next:\\n slow, fast = slow.next, fast.next.next\\n \\n temp = slow.next\\n prev = slow.next = None\\n before = None\\n\\n while temp:\\n after = temp.next\\n temp.next = before\\n before = temp\\n temp = after\\n \\n first, second = head, before\\n\\n while second:\\n t1, t2 = first.next, second.next\\n \\n first.next = second\\n second.next = t1\\n\\n first, second = t1, t2\\n \\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head: return None\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n cur = slow.next\\n slow.next = None\\n prev = None\\n while cur:\\n nxt = cur.next\\n cur.next = prev\\n prev = cur\\n cur = nxt\\n \\n list1, list2 = head, prev\\n while list2:\\n nxt1, nxt2 = list1.next, list2.next\\n list1.next = list2\\n list2.next = nxt1\\n list1 = nxt1\\n list2 = nxt2\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head:\\n return\\n # 1, 2, 3, 4, 5, 6\\n # 1. find middle\\n slow = fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n prev, curr = None, slow\\n # 2. reverse second list\\n while curr:\\n curr.next, prev, curr = prev, curr, curr.next\\n\\n first, second = head, prev\\n #3 merge\\n while second.next:\\n first.next, first = second, first.next\\n second.next, second = first, second.next\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n import math\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n first = head; n = 0\\n while head:\\n n += 1; head = head.next\\n\\n start_idx = math.ceil(n/2 + 1)\\n i = 1; new_head = first\\n while i < start_idx - 1:\\n new_head = new_head.next\\n i += 1\\n tmp = new_head.next; new_head.next = None; new_head = tmp\\n\\n prev = None\\n while new_head:\\n tmp = new_head.next\\n new_head.next = prev\\n prev = new_head\\n new_head = tmp\\n left_head = first; right_head = prev\\n # print(left_head, right_head)\\n while left_head and right_head:\\n tmp_left = left_head.next\\n left_head.next = right_head\\n tmp_right = right_head.next\\n right_head.next = tmp_left\\n left_head = tmp_left; right_head = tmp_right\\n # print(first)\\n return prev\\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n'''\\nd->1->2->3->4\\n s\\n f\\n\\nd->1->2->3->4->5\\n s\\n f\\n\\nd->1\\n s\\n f\\n'''\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n\\n def middle(head):\\n dummy_head = ListNode()\\n dummy_head.next = head\\n slow = dummy_head\\n fast = dummy_head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def reverse(node):\\n prev = None\\n curr = node\\n while curr:\\n nxt = curr.next\\n curr.next = prev\\n prev = curr\\n curr = nxt\\n return prev\\n \\n '''\\n 1->4->2\\n\\n 1->2\\n l1\\n\\n 4\\n l2\\n '''\\n def merge(list_one, list_two):\\n while list_one and list_two:\\n next_one = list_one.next\\n next_two = list_two.next\\n list_one.next = list_two\\n list_two.next = next_one\\n list_one = next_one\\n list_two = next_two\\n \\n list_one = head\\n mid = middle(head)\\n list_two = mid.next\\n mid.next = None\\n list_two = reverse(list_two)\\n \\n return merge(list_one, list_two)\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n lst = []\\n cur = head\\n while cur is not None:\\n lst.append(cur)\\n cur = cur.next\\n l, r = 1, len(lst) - 1\\n while l < r:\\n head.next = lst[r]\\n head = head.next\\n head.next = lst[l]\\n head = head.next\\n l += 1\\n r -= 1\\n if l == r:\\n head.next = lst[l]\\n head = head.next\\n head.next = None\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\nclass Solution:\\n def reorderList(self, head: ListNode) -> None:\\n if not head:\\n return\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n prev, curr = None, slow\\n while curr:\\n next_node = curr.next\\n curr.next = prev\\n prev = curr\\n curr = next_node\\n first, second = head, prev\\n while second.next:\\n temp1, temp2 = first.next, second.next\\n first.next = second\\n second.next = temp1\\n first, second = temp1, temp2\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # print(f\\\"head:{head}\\\")\\n if not head: return\\n # First find mid-point\\n slow = head\\n fast = head\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n \\n # print(f\\\"mid point is: {slow}\\\")\\n\\n # Reverse list from mid point on wards\\n prev = None\\n current = slow\\n while current:\\n prev, current.next, current = current, prev, current.next\\n # next_node \\n\\n first = head\\n second = prev\\n # while second.next:\\n # first.next = second\\n # first = first.next\\n # second.next = first\\n # second = second.next\\n\\n # while second.next:\\n # first.next, first = second, first.next\\n # second.next, second = first, second.next\\n\\n # print(f\\\"first: {first}\\\")\\n # print(f\\\"second: {second}\\\")\\n\\n while second.next:\\n temp = first.next\\n first.next = second\\n first = temp\\n\\n temp = second.next\\n second.next = first\\n second = temp\\n \\n # print(f\\\"head: {head}\\\")\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def middleNode(self, head:ListNode)->ListNode:\\n slow = fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def reverseList(self, head:ListNode)->ListNode:\\n pre = None\\n cur = head\\n while cur:\\n nxt = cur.next\\n cur.next = pre # \\n pre = cur\\n cur = nxt\\n return pre\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n mid = self.middleNode(head)\\n head2 = self.reverseList(mid)\\n while head2.next:\\n nxt = head.next\\n nxt2 = head2.next\\n head.next = head2\\n head2.next = nxt\\n head = nxt\\n head2 = nxt2\\n\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom collections import deque\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n\\n fast = slow = head\\n\\n while fast.next and fast.next.next:\\n fast = fast.next.next\\n slow = slow.next\\n \\n prev, current = None, slow.next\\n\\n while current:\\n next = current.next\\n current.next = prev\\n prev = current\\n current = next\\n slow.next = None\\n \\n\\n head1, head2 = head, prev\\n while head2:\\n next = head1.next\\n head1.next = head2\\n head1 = head2\\n head2 = next\\n\\n\\n\\n\\n\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n fast, slow = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n prev, curr = None, slow\\n while curr:\\n temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = temp\\n \\n first, second = head, prev\\n while second.next:\\n tmp1, tmp2 = first.next, second.next\\n first.next = second\\n second.next = tmp1\\n first = tmp1\\n second = tmp2\\n\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\nclass Solution:\\n def reverse(self, head):\\n if not head:\\n return None\\n prev = None\\n curr = head\\n nextNode = None\\n while curr:\\n nextNode = curr.next\\n curr.next = prev\\n prev = curr\\n curr = nextNode\\n return prev\\n\\n def merge(self, list1, list2):\\n while list2:\\n nextNode = list1.next\\n list1.next = list2\\n list1 = list2\\n list2 = nextNode\\n\\n def reorderList(self, head):\\n if not head or not head.next:\\n return\\n slow = head\\n fast = head\\n prev = head\\n while fast and fast.next:\\n prev = slow\\n fast = fast.next.next\\n slow = slow.next\\n prev.next = None\\n list1 = head\\n list2 = self.reverse(slow)\\n self.merge(list1, list2)\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n leftHead = head\\n slow = head\\n fast = head.next\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n rightHead = slow.next\\n slow.next = None\\n\\n prev, curr = None, rightHead\\n while curr:\\n temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = temp\\n \\n rightHead = prev\\n\\n while rightHead:\\n leftTemp, rightTemp = leftHead.next, rightHead.next\\n\\n leftHead.next = rightHead\\n rightHead.next = leftTemp\\n\\n leftHead = leftTemp\\n rightHead = rightTemp\\n \\n return head\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # mid\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n mid = slow\\n # reverse\\n prev = None\\n while mid:\\n tmp = mid.next\\n mid.next = prev\\n prev = mid\\n mid = tmp\\n second = prev\\n # merge\\n first = head\\n while second.next:\\n tmp = first.next\\n first.next = second\\n first = tmp\\n\\n tmp = second.next\\n second.next = first\\n second = tmp\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Reorders the list in-place, so it becomes: L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head or not head.next:\\n return\\n \\n # Step 1: Find the middle of the list\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n # Step 2: Reverse the second half of the list\\n prev, curr = None, slow\\n while curr:\\n next_temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = next_temp\\n \\n # Step 3: Merge the two halves\\n first, second = head, prev\\n while second.next:\\n # Temporarily store the next pointers\\n tmp1, tmp2 = first.next, second.next\\n # Reorder nodes\\n first.next = second\\n second.next = tmp1\\n # Move to the next nodes\\n first = tmp1\\n second = tmp2\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom math import ceil\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n nodes_list = []\\n current = head\\n\\n while current:\\n nodes_list.append(current)\\n current = current.next\\n\\n n = len(nodes_list)\\n right = n-1\\n left = 0\\n for left in range(ceil(n / 2)):\\n nodes_list[left].next = nodes_list[right]\\n if left+1 < right:\\n nodes_list[right].next = nodes_list[left + 1]\\n else:\\n nodes_list[right].next = None\\n\\n right -= 1\\n \\n return nodes_list[0]\\n\\n\\n\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n \\n # Find the middle\\n slow = head\\n fast = head\\n \\n while fast and fast.next is not None:\\n slow = slow.next\\n fast = fast.next.next\\n \\n\\n prev = None\\n middle = slow\\n\\n # Reverse second half of the list\\n while middle:\\n tmp_next = middle.next\\n\\n middle.next = prev\\n prev = middle\\n middle = tmp_next\\n \\n # Merge second middle into the first middle, one at a time\\n l1 = head\\n l2 = prev\\n while l2.next:\\n tmp_next_1 = l1.next\\n tmp_next_2 = l2.next\\n\\n l1.next = l2\\n l2.next = tmp_next_1\\n\\n l1 = tmp_next_1\\n l2 = tmp_next_2\\n \\n\\n\\n\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n slow,fast = head,head.next\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n #reverse 2nd half\\n second_half = slow.next\\n prev = slow.next = None\\n\\n while second_half:\\n temp = second_half.next\\n second_half.next = prev\\n prev = second_half\\n second_half = temp\\n first,second = head,prev\\n #re-ordering\\n while second:\\n tmp1 , tmp2 = first.next , second.next\\n first.next = second\\n second.next = tmp1\\n first = tmp1\\n second = tmp2\\n \\n\\n\\n\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n if fast:\\n slow = slow.next\\n\\n prev, rev_head = None, slow\\n while rev_head:\\n next = rev_head.next\\n rev_head.next = prev\\n prev = rev_head\\n rev_head = next\\n\\n first_half_head = head\\n second_half_head = prev\\n while second_half_head:\\n first_half_next = first_half_head.next\\n first_half_head.next = second_half_head\\n first_half_head = first_half_next\\n\\n second_half_next = second_half_head.next\\n second_half_head.next = first_half_next\\n second_half_head = second_half_next\\n first_half_head.next = None\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n\\n slow = head\\n fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n # reverse second half of the linked list\\n\\n prev, curr = None, slow\\n\\n while curr:\\n next_node = curr.next\\n curr.next = prev\\n prev = curr\\n curr = next_node\\n \\n rev_head = prev\\n\\n head1, head2 = head, rev_head\\n\\n while head2.next:\\n\\n node = head1.next\\n head1.next = head2\\n head1 = node\\n\\n node = head2.next\\n head2.next = head1\\n head2 = node\\n\\n \\n\\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n head_copy = head\\n queue = deque()\\n\\n while head_copy:\\n queue.append(head_copy)\\n head_copy = head_copy.next\\n \\n head = queue.popleft()\\n \\n while queue:\\n if len(queue) >= 2:\\n l, r = queue.popleft(), queue.pop()\\n head.next = r\\n head = head.next\\n else:\\n l = queue.popleft()\\n \\n head.next = l\\n head = head.next\\n \\n head.next = None \\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n if not head or not head.next:\\n return\\n \\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n prev, curr = None, slow\\n while curr:\\n next_temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = next_temp\\n \\n first, second = head, prev\\n while second.next:\\n temp1, temp2 = first.next, second.next\\n first.next = second\\n second.next = temp1\\n first, second = temp1, temp2\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n stack = deque()\\n cur = head\\n while cur:\\n stack.append(cur)\\n cur = cur.next\\n \\n cur = stack.popleft()\\n counter = 0\\n while stack:\\n if not (counter % 2):\\n cur.next = stack.pop()\\n else:\\n cur.next = stack.popleft()\\n cur = cur.next\\n counter += 1\\n cur.next = None\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reverseList(self, head):\\n prev, curr = None, head\\n while(curr):\\n temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = temp\\n return prev\\n\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head\\n if head == None:\\n return head\\n while(slow.next != None and fast.next != None and fast.next.next != None):\\n slow = slow.next\\n fast = fast.next.next\\n\\n temp = slow.next\\n slow.next = None\\n\\n l, r = head, self.reverseList(temp)\\n while(l and r):\\n next_l = l.next\\n next_r = r.next\\n l.next = r\\n r.next = next_l\\n l = next_l\\n r = next_r\\n \\n\\n\\n return head\\n\\n # 1 2\\n # 5 4 3\\n\\n\\n \",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n second = slow.next\\n prev = slow.next = None\\n while second:\\n temp = second.next\\n second.next = prev\\n prev = second\\n second = temp\\n\\n first, second = head, prev\\n while second:\\n temp1, temp2 = first.next, second.next\\n first.next = second\\n second.next = temp1\\n first, second = temp1, temp2\\n \",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def reorderList(self, head: ListNode) -> None:\\n def findMid(head: ListNode):\\n prev = None\\n slow = head\\n fast = head\\n\\n while fast and fast.next:\\n prev = slow\\n slow = slow.next\\n fast = fast.next.next\\n prev.next = None\\n\\n return slow\\n\\n def reverse(head: ListNode) -> ListNode:\\n prev = None\\n curr = head\\n\\n while curr:\\n next = curr.next\\n curr.next = prev\\n prev = curr\\n curr = next\\n\\n return prev\\n\\n def merge(l1: ListNode, l2: ListNode) -> None:\\n while l2:\\n next = l1.next\\n l1.next = l2\\n l1 = l2\\n l2 = next\\n\\n if not head or not head.next:\\n return\\n\\n mid = findMid(head)\\n reversed = reverse(mid)\\n merge(head, reversed)\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n slow = head\\n fast = head.next\\n \\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n second = slow.next \\n prev = slow.next = None\\n while second:\\n temp = second.next\\n second.next = prev\\n prev = second\\n second = temp\\n\\n first, second = head, prev\\n while second:\\n temp1, temp2 = first.next, second.next\\n first.next = second\\n second.next = temp1\\n first , second = temp1, temp2\\n\\n \",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # time O(n)\\n # space O(1)\\n slow = fast = head\\n\\n while fast and fast.next:\\n slow, fast = slow.next, fast.next.next\\n\\n l2 = slow.next\\n slow.next = None\\n prev = None\\n\\n while l2:\\n tmp = l2.next\\n l2.next = prev\\n prev = l2\\n l2 = tmp\\n \\n l2 = prev\\n l1 = head\\n\\n # merge l1 and l2\\n while l1 and l2:\\n tmp1, tmp2 = l1.next, l2.next\\n l1.next = l2\\n l2.next = tmp1\\n l1, l2 = tmp1, tmp2\\n \\n return head\\n\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n hash={}\\n idx=0\\n curr=head\\n while curr:\\n hash[idx]=curr\\n curr=curr.next\\n idx +=1\\n\\n\\n for i in range(int((idx-1)/2)):\\n hash[i].next=hash[idx-1-i]\\n hash[idx-1-i].next=hash[i+1]\\n\\n if (idx-1)%2==0:\\n hash[int((idx-1)/2)].next=None\\n else:\\n hash[int((idx-1)/2) +1].next=None\\n \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n\\n #Find middle using tortoise and hare modified \\n tortoise = head\\n hare = head.next\\n while hare and hare.next:\\n tortoise = tortoise.next\\n hare = hare.next.next\\n \\n\\n #Reverse from middle \\n prev = None\\n second = tortoise\\n while second:\\n temp = second.next\\n second.next = prev\\n prev = second\\n second = temp\\n \\n #Merge first half and second half\\n first = head\\n second = prev\\n while first and second:\\n temp1 = first.next\\n temp2 = second.next\\n first.next = second\\n second.next = temp1\\n first = temp1\\n second = temp2\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow = head\\n fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n prev = None\\n rev_head = slow.next\\n slow.next = None\\n while rev_head:\\n next = rev_head.next\\n rev_head.next = prev\\n prev = rev_head\\n rev_head = next\\n\\n first_half_head = head\\n second_half_head = prev\\n while second_half_head:\\n first_half_next = first_half_head.next\\n first_half_head.next = second_half_head\\n first_half_head = first_half_next\\n\\n second_half_next = second_half_head.next\\n second_half_head.next = first_half_next\\n second_half_head = second_half_next\\n \",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n The aproach is divided in three steps:\\n 1. find the middle\\n 2. reverse the list from the middle to the end\\n 3. have two pointer, one from the head and the other from the end,\\n and start to reorder the list\\n \\\"\\\"\\\"\\n\\n # Required minimum length of 3\\n if head is None or head.next is None or head.next.next is None:\\n return\\n\\n # 1. Find the middle\\n slow, fast = head, head\\n while fast is not None and fast.next is not None:\\n fast = fast.next.next\\n slow = slow.next\\n\\n # 2. Reverse from the middle\\n current = slow\\n prev = None\\n while current is not None:\\n next = current.next\\n current.next = prev\\n prev = current\\n current = next\\n\\n # 3. Reorder the list\\n right = prev\\n left = head\\n while right.next is not None and left.next is not None:\\n next_left = left.next\\n left.next = right\\n left = left.next\\n next_right = right.next\\n left.next = next_left\\n right = next_right\\n left = left.next\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n fast, slow = head.next, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n second = slow.next\\n slow.next = prev = None\\n while second:\\n n = second.next\\n second.next = prev\\n prev = second\\n second = n\\n first, second = head, prev\\n while first and second:\\n tmp1, tmp2 = first.next, second.next\\n first.next = second\\n second.next = tmp1\\n first = tmp1\\n second = tmp2\\n return head\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n # get to the middle of the list and reverse the second half and merge the two parts\\n slow_pt, fast_pt = head, head\\n while fast_pt and fast_pt.next:\\n slow_pt = slow_pt.next\\n fast_pt = fast_pt.next.next\\n\\n \\n # reverse the prev list take first half of head\\n second = slow_pt.next\\n dummy = slow_pt.next = None\\n while second:\\n dummy = ListNode(second.val, dummy)\\n second = second.next\\n\\n\\n # Merge two lists\\n first, second= head, dummy\\n while second:\\n # keep the reset of element in tmp\\n tmp1, tmp2 = first.next, second.next\\n\\n # add element from first and second\\n first.next = second\\n second.next = tmp1\\n\\n first, second = tmp1, tmp2\\n\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n mid = slow.next\\n second_head = self.reverse(mid)\\n slow.next = None\\n first_head = head\\n while second_head:\\n temp1 = first_head.next\\n temp2 = second_head.next\\n first_head.next = second_head\\n second_head.next = temp1\\n first_head = temp1\\n second_head = temp2\\n\\n\\n def reverse(self, head):\\n prev = None\\n cur_head = head\\n while cur_head:\\n temp = cur_head.next\\n cur_head.next = prev\\n prev = cur_head\\n cur_head = temp \\n return prev\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n dummy = ListNode(0, head)\\n fast = slow = dummy\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n reverseHead = slow.next\\n slow.next = None\\n prev = None\\n curr = reverseHead\\n while curr:\\n nextNode = curr.next\\n curr.next = prev\\n prev = curr\\n curr = nextNode\\n first = head\\n second = prev\\n while second:\\n tmp1, tmp2 = first.next, second.next\\n first.next = second\\n second.next = tmp1\\n first, second = tmp1, tmp2\\n\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n # find middle of list\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = (fast.next).next\\n \\n # reverse second half of list\\n cur = slow.next\\n slow.next = None\\n pre = None\\n while cur:\\n post = cur.next\\n cur.next = pre\\n pre = cur\\n cur = post\\n\\n # combine two lists\\n L, R = head, pre\\n while R:\\n nextL, nextR = L.next, R.next\\n L.next = R\\n R.next = nextL\\n L, R = nextL, nextR\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head.next:\\n return head\\n slow = head\\n fast = head.next\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n head2 = slow.next\\n slow.next = None\\n\\n prev = None\\n curr = head2\\n\\n while curr:\\n temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = temp\\n \\n i = head\\n j = prev\\n\\n while i and j:\\n temp = i.next\\n i.next = j\\n temp2 = j.next\\n j.next = temp\\n i = temp\\n j = temp2\\n\\n return head\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n prev = None \\n second = slow.next\\n slow.next = None \\n while second:\\n tmp = second.next\\n second.next = prev \\n prev = second \\n second = tmp \\n while prev:\\n tmp1, tmp2 = head.next, prev.next\\n head.next = prev \\n prev.next = tmp1\\n head, prev = tmp1, tmp2\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow = fast = head\\n\\n while fast and fast.next:\\n slow, fast = slow.next, fast.next.next\\n\\n l2 = slow.next\\n slow.next = None\\n prev = None\\n\\n while l2:\\n tmp = l2.next\\n l2.next = prev\\n prev = l2\\n l2 = tmp\\n \\n l2 = prev\\n l1 = head\\n\\n # merge l1 and l2\\n while l1 and l2:\\n tmp1, tmp2 = l1.next, l2.next\\n l1.next = l2\\n l2.next = tmp1\\n l1, l2 = tmp1, tmp2\\n \\n return head\\n\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n # find middle of list\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = (fast.next).next\\n \\n # reverse second half of list\\n cur = slow.next\\n slow.next = None\\n pre = None\\n while cur:\\n post = cur.next\\n cur.next = pre\\n pre = cur\\n cur = post\\n\\n # combine two lists\\n L, R = head, pre\\n while R:\\n nextL, nextR = L.next, R.next\\n L.next = R\\n R.next = nextL\\n L, R = nextL, nextR\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n slow, fast = head, head.next\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n second = slow.next\\n prev = slow.next = None\\n\\n while second:\\n tmp = second.next\\n second.next = prev\\n prev = second\\n second = tmp\\n\\n first, second = head, prev\\n while second:\\n tmp1, tmp2 =first.next, second.next\\n first.next = second\\n second.next = tmp1\\n first = tmp1\\n second = tmp2\\n\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n history = []\\n curr = head\\n while curr:\\n history.append(curr)\\n curr = curr.next\\n\\n left = 0\\n right = len(history) - 1\\n tail = None\\n while left < right:\\n history[right].next = history[left].next\\n history[left].next = history[right]\\n tail = history[right]\\n left += 1\\n right -= 1\\n\\n if left == right:\\n if tail:\\n tail.next = history[left]\\n tail = history[left]\\n tail.next = None\\n\\n \\n \",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n start, list1 = head, head\\n\\n slow, fast = head, head.next\\n\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n\\n list2 = slow.next\\n slow.next = None\\n prev = None\\n\\n while list2:\\n tempVal = list2.next\\n list2.next = prev\\n prev = list2 \\n list2 = tempVal\\n\\n list2 = prev\\n while list2:\\n tempVal1 = list1.next\\n list1.next = list2\\n list1 = tempVal1\\n\\n tempVal2 = list2.next\\n list2.next = tempVal1\\n list2 = tempVal2\\n \\n return start\\n\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n # find middle of list\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = (fast.next).next\\n \\n # reverse second half of list\\n cur = slow.next\\n slow.next = None\\n pre = None\\n while cur:\\n post = cur.next\\n cur.next = pre\\n pre = cur\\n cur = post\\n\\n # combine two lists\\n L, R = head, pre\\n while R:\\n nextL, nextR = L.next, R.next\\n L.next = R\\n R.next = nextL\\n L, R = nextL, nextR\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n count=0\\n curr=head\\n while curr:\\n count+=1\\n curr=curr.next\\n mid=count//2\\n if mid>=1:\\n curr=head\\n nxt=None\\n while mid:\\n if mid==1:\\n nxt=curr\\n curr=curr.next\\n mid-=1\\n nxt.next=None\\n prev=None\\n while curr:\\n nxt=curr.next\\n curr.next=prev\\n prev=curr\\n curr=nxt\\n curr=head\\n while curr:\\n nxt=prev.next\\n prev.next=curr.next\\n curr.next=prev\\n prev=nxt\\n if curr.next.next is None:\\n nxt=curr.next\\n curr=curr.next.next\\n if prev:\\n nxt.next=prev\\n\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # find the middle nodes\\n slow = head\\n fast = head \\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n mid = slow \\n\\n # reverse the second half since middle \\n prev = None\\n curr = mid\\n while curr:\\n tmp_next = curr.next\\n curr.next = prev\\n prev = curr\\n curr = tmp_next\\n # prev is the head of reversed second half \\n\\n # merge them in-place \\n first = head\\n second = prev\\n while second.next:\\n first_next_tmp = first.next\\n first.next = second\\n first = first_next_tmp\\n second_next_tmp = second.next\\n second.next = first_next_tmp\\n second = second_next_tmp\\n\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n\\n slow = head\\n fast = head.next\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n second = slow.next\\n slow.next = None\\n prev = None\\n while second:\\n nxt = second.next\\n second.next = prev\\n prev = second\\n second = nxt\\n\\n first = head\\n second = prev\\n while second:\\n tmp1 = first.next\\n tmp2 = second.next\\n first.next = second\\n second.next = tmp1\\n second = tmp2\\n first = tmp1\\n \",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head or not head.next:\\n return head\\n # find middle to split\\n dummy = ListNode(0, head)\\n slow, fast = dummy, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n midpoint = slow.next\\n slow.next = None\\n list2 = self.reverse(midpoint)\\n list1 = head\\n # merge\\n dummy = ListNode(0)\\n current = dummy\\n while list1 and list2:\\n current.next = list1\\n list1 = list1.next\\n current = current.next\\n \\n current.next = list2\\n list2 = list2.next\\n current = current.next\\n if list1:\\n current.next = list1\\n elif list2:\\n current.next = list2\\n return dummy.next\\n def reverse(self, head):\\n if not head or not head.next:\\n return head\\n prev = None\\n current = head\\n while current:\\n next_node = current.next\\n current.next = prev\\n prev = current\\n current = next_node\\n return prev\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n \\n # Find the middle\\n slow = head\\n fast = head\\n \\n counter = 0\\n while fast and fast.next is not None:\\n slow = slow.next\\n fast = fast.next.next\\n counter += 1\\n \\n\\n prev = None\\n middle = slow\\n\\n # Reverse second half of the list\\n while middle:\\n tmp_next = middle.next\\n\\n middle.next = prev\\n prev = middle\\n middle = tmp_next\\n \\n # Merge second middle into the first middle, one at a time\\n l1 = head\\n l2 = prev\\n while l2.next:\\n tmp_next_1 = l1.next\\n tmp_next_2 = l2.next\\n\\n l1.next = l2\\n l2.next = tmp_next_1\\n\\n l1 = tmp_next_1\\n l2 = tmp_next_2\\n \\n # l1.next = None\\n\\n\\n\\n \",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # find the mid node\\n slow = head\\n fast = head\\n while fast.next:\\n slow = slow.next\\n fast = fast.next\\n if fast.next is None:\\n break\\n fast = fast.next \\n \\n # reverse links from mid to end\\n prev = slow \\n cur = prev.next\\n prev.next = None\\n while cur:\\n temp = cur.next\\n cur.next = prev\\n prev = cur\\n cur = temp\\n \\n right_head = prev\\n left_head = head\\n\\n while right_head.next:\\n left_next = left_head.next\\n right_next = right_head.next\\n \\n left_head.next = right_head\\n right_head.next = left_next\\n \\n left_head = left_next\\n right_head = right_next\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom math import ceil\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n nodes_list = []\\n current = head\\n\\n while current:\\n nodes_list.append(current)\\n current = current.next\\n\\n n = len(nodes_list)\\n right = n-1\\n left = 0\\n while left <= right:\\n print(left, right)\\n nodes_list[left].next = nodes_list[right]\\n if left+1 < right:\\n nodes_list[right].next = nodes_list[left + 1]\\n else:\\n nodes_list[right].next = None\\n\\n left += 1\\n right -= 1\\n \\n print([node.val for node in nodes_list])\\n return nodes_list[0]\\n\\n\\n\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n #first, last, second, second last?\\n #idea, put nodes in a stack? first in first out\\n stack = []\\n curr = head\\n while curr != None:\\n stack.append(curr)\\n curr = curr.next\\n begin = True\\n count = 0\\n list_len = len(stack)\\n curr = head\\n res = ListNode\\n res_iterator = res\\n while count < list_len:\\n if begin:\\n res_iterator.next = curr\\n curr = curr.next\\n else:\\n res_iterator.next = stack.pop()\\n res_iterator = res_iterator.next\\n begin = not begin\\n count += 1\\n res_iterator.next = None\\n return res.next\\n \",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # find the mid-point\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n prev = None\\n second = slow.next\\n slow.next = None # End of the new list\\n # reverse the second half of the list\\n # 1 -> 2 -> 3\\n # p t\\n # 1 <- 2 <- 3\\n while second:\\n temp = second.next\\n second.next = prev\\n prev = second\\n second = temp\\n\\n # merge the two lists\\n first, second = head, prev\\n while second:\\n tmp1, tmp2 = first.next, second.next\\n first.next = second\\n second.next = tmp1\\n first, second = tmp1, tmp2\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n second = slow.next\\n prev = slow.next = None\\n while second:\\n temp = second.next\\n second.next = prev\\n prev = second\\n second = temp\\n\\n ####merging of lists\\n first, second = head, prev\\n while second:\\n tmp1, tmp2 = first.next, second.next\\n first.next = second\\n second.next = tmp1\\n first, second = tmp1, tmp2\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n dct = {}\\n n = -1\\n temp = head\\n \\n while temp:\\n n+=1\\n dct[n]= temp.val\\n temp=temp.next\\n \\n i = 0\\n j= 0\\n \\n temp=head\\n while j<n:\\n j+=1\\n if j%2!=0:\\n temp.next = ListNode(dct[n-i])\\n i+=1\\n else:\\n temp.next = ListNode(dct[i])\\n temp =temp.next\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n #find middle of lnkedlist\\n #reverse later part\\n #mingle them tgt\\n res = head\\n slow = head\\n fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n prev = None\\n \\n \\n mid = slow\\n \\n while mid:\\n temp = mid.next\\n mid.next = prev\\n prev = mid\\n mid = temp\\n\\n while prev.next:\\n temp1 = head.next\\n temp2 = prev.next\\n head.next = prev\\n prev.next = temp1\\n head = temp1\\n prev = temp2\\n return res\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n fast = second = head\\n fast = fast.next\\n while fast and fast.next:\\n fast = fast.next.next\\n second = second.next\\n prev = None\\n reverse = second.next\\n second.next = None\\n while reverse:\\n temp = reverse.next\\n reverse.next = prev\\n prev = reverse\\n reverse = temp\\n second = prev\\n first = head\\n while second:\\n first_temp = first.next\\n second_temp = second.next\\n first.next = second\\n second.next = first_temp\\n first = first_temp\\n second = second_temp\\n \\n\\n \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n \\n # find the middle\\n slow, fast = head, head\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n head2 = slow.next\\n\\n stack = []\\n queue = []\\n head1 = head.next\\n while head2:\\n stack.append(head2)\\n head2 = head2.next\\n\\n while head1!=slow.next:\\n \\n queue.append(head1)\\n head1 = head1.next\\n if len(queue) > 0:\\n queue[-1].next = None\\n while len(queue)>0 or len(stack)>0:\\n head.next = stack.pop(-1) if len(stack)>0 else None\\n head.next.next = queue.pop(0) if len(queue)>0 else None\\n head = head.next.next\\n\\n\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom collections import deque\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n\\n fast = slow = head\\n\\n while fast.next and fast.next.next:\\n fast = fast.next.next\\n slow = slow.next\\n \\n prev, current = None, slow.next\\n\\n while current:\\n next = current.next\\n current.next = prev\\n prev = current\\n current = next\\n slow.next = None\\n \\n\\n l1, l2 = head, prev\\n while l1 and l2:\\n next_l1 = l1.next\\n next_l2 = l2.next\\n\\n l1.next = l2\\n l1 = next_l1\\n l2.next = l1\\n l2 = next_l2\\n\\n\\n\\n\\n\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n '''\\n The head is a node of value 0\\n '''\\n count = self.size(head)\\n if(self.size(head)< 3):\\n return \\n shifts = (count-1)//2\\n count = count-1\\n lists = []\\n '''get elements we are shifting'''\\n curr = head.next\\n prev = None\\n i=0\\n while(curr):\\n if(i == ((count-shifts-1))):\\n prev = curr\\n if i >= (count-shifts):\\n lists.append(curr)\\n curr = curr.next\\n i+=1\\n prev.next = None\\n lists.reverse()\\n curr = head\\n a = None\\n i=0\\n while(i < shifts):\\n replace = lists[i]\\n temp = curr.next\\n curr.next = replace\\n replace.next = temp\\n curr = curr.next.next\\n print(curr.val)\\n i+= 1\\n \\n def size(self, head):\\n p = head.next\\n count = 1\\n while(p):\\n p = p.next\\n count += 1\\n return count\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head:\\n return None\\n curr=head\\n length=1\\n while curr.next:\\n curr=curr.next\\n length+=1\\n length=length//2 if length%2==0 else length//2+1\\n curr=head\\n while length>0:\\n if length==1:\\n temp=curr.next\\n curr.next=None\\n curr=temp\\n else:\\n curr=curr.next\\n length-=1\\n temp,prev=None,None\\n while curr:\\n temp=curr.next\\n curr.next=prev\\n prev=curr\\n curr=temp\\n curr=prev\\n curr1,curr2=head,curr\\n while curr2:\\n temp1=curr1.next\\n temp2=curr2.next\\n curr1.next=curr2\\n curr2.next=temp1\\n curr1=temp1\\n curr2=temp2\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head\\n while fast != None:\\n slow = slow.next\\n if fast != None:\\n fast = fast.next\\n if fast!=None:\\n fast = fast.next\\n low = head\\n stack =[]\\n queue = []\\n while low!=slow:\\n queue.append(low)\\n low=low.next\\n while slow != None:\\n stack.append(slow)\\n slow = slow.next\\n count = 0\\n ptr1 = None\\n while len(queue) > 0:\\n value = queue.pop(0)\\n if count == 0:\\n head = value\\n count+=1\\n if ptr1==None:\\n ptr1 = value\\n else:\\n ptr1.next = value\\n ptr1 = ptr1.next\\n if len(stack)>0:\\n ptr1.next = stack.pop()\\n ptr1 = ptr1.next\\n ptr1.next = None\\n return head\\n\\n\\n\\n \",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head or not head.next:\\n return head\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n list1, list2 = head, slow.next\\n slow.next = None\\n \\n #reverse list 2\\n prev = None\\n curr = list2\\n while curr:\\n tmp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = tmp\\n\\n list2 = prev\\n #merge list1 and list2\\n dummyNode = ListNode(0)\\n curr = dummyNode\\n i = 0\\n print(list1.val, list2.val)\\n while list1 and list2:\\n if (i % 2) == 0:\\n print(f\\\"list 1 {list1.val}\\\")\\n dummyNode.next = list1\\n dummyNode = dummyNode.next\\n list1 = list1.next\\n else:\\n print(f\\\"list 2 {list2.val}\\\")\\n dummyNode.next = list2\\n dummyNode = dummyNode.next\\n list2 = list2.next\\n i += 1\\n\\n if list1:\\n dummyNode.next = list1\\n elif list2:\\n dummyNode.next = list2\\n\\n return curr.next\\n\\n\\n \\n\\n\\n \\n \\n \",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n current_node = head \\n list_values = [current_node.val]\\n while current_node.next is not None:\\n current_node = current_node.next\\n list_values.append(current_node.val)\\n\\n ## Check is par\\n is_par = len(list_values) % 2 == 0\\n\\n ## Define the new list\\n pointier_a = 1\\n pointier_b = len(list_values) - 1\\n current_node = head\\n while pointier_a <= pointier_b:\\n ## Get values\\n value_a = list_values[pointier_a]\\n value_b = list_values[pointier_b]\\n\\n ## Update the values\\n current_node.next = ListNode(value_b)\\n current_node = current_node.next\\n\\n if not(pointier_a == pointier_b and is_par):\\n current_node.next = ListNode(value_a)\\n current_node = current_node.next\\n\\n ## Update pointiers\\n pointier_a += 1\\n pointier_b -= 1\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n\\n if not head:\\n return\\n\\n slow = head\\n fast = head\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n prev = None\\n curr = slow\\n\\n while curr:\\n temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = temp\\n \\n first = head\\n second = prev\\n\\n while second.next:\\n temp = first.next\\n first.next = second\\n first = temp\\n\\n temp = second.next\\n second.next = first\\n second = temp\\n\\n\\n\\n\\n \\n \\n \\n\\n\\n \",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n # Do not return anything, modify head in-place instead.\\n\\n # if even, elements till (len/2 - 1) index on leftside\\n # if odd, elements till (len//2 + 1 ) index on leftside\\n # use double ptrs, fast one will reach end of list, track elements after mid for fast one, then add from that list in reverse order to elements till mid in \\n tmp=head\\n length=0\\n while tmp!=None:\\n tmp=tmp.next\\n length+=1\\n\\n if length<=2: #no change required\\n return\\n\\n if length%2==0:\\n reqidx = (length/2 ) - 1\\n else:\\n reqidx = (length//2)\\n print(\\\"length\\\",length, \\\"elems on left arr\\\",reqidx+1)\\n\\n\\n\\n i=0\\n j=0\\n\\n slow = head\\n fast = head\\n\\n if length%2!=0:\\n j=1\\n fast=head.next\\n\\n slowvalues = []\\n fastvalues = []\\n\\n while fast!=None and fast.next!=None:\\n # print(\\\"i=\\\",i,\\\" j=\\\",j)\\n if i<=reqidx:\\n slowvalues.append(slow.val)\\n if j>reqidx:\\n fastvalues.append(fast.val)\\n if fast.next is not None and fast.next.next is None:\\n fastvalues.append(fast.next.val)\\n \\n slow = slow.next\\n i+=1\\n \\n if length%2!=0:\\n if j==reqidx:\\n fast = fast.next\\n if fast.next is None:\\n fastvalues.append(fast.val)\\n j+=1\\n continue\\n\\n if j>reqidx:\\n fast = fast.next\\n j+=1\\n else:\\n fast = fast.next.next\\n j+=2\\n \\n\\n if length%2!=0:\\n slowvalues.append(slow.val)\\n\\n # print(len(slowvalues), len(fastvalues))\\n print(\\\"slow...\\\",slowvalues)\\n fastvalues = fastvalues[::-1]\\n print(\\\"fast...\\\",fastvalues)\\n\\n finalvals = []\\n tmp = head\\n for i in range(len(slowvalues)):\\n finalvals.append(slowvalues[i])\\n if i>0:\\n tmp.next = ListNode(val=slowvalues[i])\\n tmp = tmp.next\\n\\n try:\\n if fastvalues[i] is not None:\\n finalvals.append(fastvalues[i])\\n tmp.next = ListNode(val=fastvalues[i])\\n tmp = tmp.next\\n except IndexError:\\n print(\\\"odd-len-so-index-error\\\")\\n break\\n \\n print(\\\"total ... \\\",finalvals)\\n\\n\\n \",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\ndef printList(node):\\n while node:\\n print(node.val, end=\\\" -> \\\")\\n node = node.next\\n print(\\\"None\\\")\\n\\nclass Solution:\\n def reorderList(self, head: ListNode) -> None:\\n if not head or not head.next:\\n return\\n \\n # printList(head)\\n\\n slow, fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n \\n prev, curr = None, slow\\n while curr:\\n next_temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = next_temp\\n \\n # printList(prev)\\n\\n first, second = head, prev\\n while second.next:\\n tmp1, tmp2 = first.next, second.next\\n first.next = second\\n second.next = tmp1\\n first = tmp1\\n second = tmp2\\n # printList(head)\\n\\n # printList(head)\\n\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head\\n while fast != None:\\n slow = slow.next\\n if fast != None:\\n fast = fast.next\\n if fast!=None:\\n fast = fast.next\\n low = head\\n stack =[]\\n queue = []\\n while low!=slow:\\n queue.append(low)\\n low=low.next\\n while slow != None:\\n stack.append(slow)\\n slow = slow.next\\n count = 0\\n ptr1 = None\\n while len(queue) > 0:\\n value = queue.pop(0)\\n if count == 0:\\n head = value\\n count+=1\\n if ptr1==None:\\n ptr1 = value\\n else:\\n ptr1.next = value\\n ptr1 = ptr1.next\\n if len(stack)>0:\\n ptr1.next = stack.pop()\\n ptr1 = ptr1.next\\n ptr1.next = None\\n return head\\n\\n\\n\\n \",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head\\n while fast != None:\\n slow = slow.next\\n if fast != None:\\n fast = fast.next\\n if fast!=None:\\n fast = fast.next\\n low = head\\n stack =[]\\n queue = []\\n while low!=slow:\\n queue.append(low)\\n low=low.next\\n while slow != None:\\n stack.append(slow)\\n slow = slow.next\\n count = 0\\n ptr1 = None\\n while len(queue) > 0:\\n value = queue.pop(0)\\n if count == 0:\\n head = value\\n count+=1\\n if ptr1==None:\\n ptr1 = value\\n else:\\n ptr1.next = value\\n ptr1 = ptr1.next\\n if len(stack)>0:\\n ptr1.next = stack.pop()\\n ptr1 = ptr1.next\\n ptr1.next = None\\n return head\\n\\n\\n\\n \",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head\\n while fast != None:\\n slow = slow.next\\n if fast != None:\\n fast = fast.next\\n if fast!=None:\\n fast = fast.next\\n low = head\\n stack =[]\\n queue = []\\n while low!=slow:\\n queue.append(low)\\n low=low.next\\n while slow != None:\\n stack.append(slow)\\n slow = slow.next\\n count = 0\\n ptr1 = None\\n while len(queue) > 0:\\n value = queue.pop(0)\\n if count == 0:\\n head = value\\n count+=1\\n if ptr1==None:\\n ptr1 = value\\n else:\\n ptr1.next = value\\n ptr1 = ptr1.next\\n if len(stack)>0:\\n ptr1.next = stack.pop()\\n ptr1 = ptr1.next\\n ptr1.next = None\\n return head\\n\\n\\n\\n \",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def p(self,h):\\n while h:\\n print(h.val)\\n h=h.next\\n def re(self,h):\\n temp=h\\n prev=None\\n while temp:\\n front=temp.next\\n temp.next=prev\\n prev=temp\\n temp=front\\n return prev\\n \\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if head is None or head.next is None:\\n return head\\n slow=head\\n fast=head\\n\\n temp=head\\n\\n dummy=ListNode()\\n currNode=dummy\\n l=None\\n r=None\\n\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n r=slow.next\\n slow.next=None\\n l=head\\n\\n self.p(l)\\n self.p(r)\\n r=self.re(r)\\n pos=1\\n\\n while l and r:\\n if pos%2==0:\\n currNode.next=r\\n r=r.next\\n else:\\n currNode.next=l\\n l=l.next\\n currNode=currNode.next\\n pos+=1\\n if l:\\n currNode.next=l\\n if r:\\n currNode.next=r\\n\\n return dummy.next\\n\\n \\n \\n\\n\\n\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n stack = []\\n curr = head\\n \\n while curr:\\n stack.append(curr)\\n curr = curr.next\\n\\n curr = head\\n \\n while stack:\\n curr.next = stack.pop(0)\\n curr = curr.next\\n\\n if stack:\\n curr.next = stack.pop()\\n curr = curr.next\\n \\n curr.next = None\\n \\n\\n\\n \\n \",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head\\n while fast != None:\\n slow = slow.next\\n if fast != None:\\n fast = fast.next\\n if fast!=None:\\n fast = fast.next\\n low = head\\n stack =[]\\n queue = []\\n while low!=slow:\\n queue.append(low)\\n low=low.next\\n while slow != None:\\n stack.append(slow)\\n slow = slow.next\\n count = 0\\n ptr1 = None\\n while len(queue) > 0:\\n value = queue.pop(0)\\n if count == 0:\\n head = value\\n count+=1\\n if ptr1==None:\\n ptr1 = value\\n else:\\n ptr1.next = value\\n ptr1 = ptr1.next\\n if len(stack)>0:\\n ptr1.next = stack.pop()\\n ptr1 = ptr1.next\\n ptr1.next = None\\n return head\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n # def reverse(self,head):\\n # curr=head\\n # prev,nxt=None,None\\n # while(curr):\\n # nxt=curr.next\\n # curr.next=prev\\n # prev=curr\\n # curr=nxt\\n # return prev\\n\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n # \\\"\\\"\\\"\\n # Do not return anything, modify head in-place instead.\\n # \\\"\\\"\\\"\\n # if(not head or not head.next):\\n # return head\\n\\n # newHead=head\\n # temp=head.next\\n # while(temp and temp.next):\\n # revHead=self.reverse(temp)\\n # newHead.next=revHead\\n # temp=revHead.next\\n # newHead=revHead\\n\\n if(not head or not head.next):\\n return head\\n\\n st=[] #stack\\n qu=[] #queue\\n\\n #find middle of LL\\n s=head\\n f=head\\n while(f and f.next):\\n s=s.next\\n f=f.next.next\\n mid=s\\n\\n #put elements till mid in queue\\n temp=head\\n while(temp!=mid):\\n qu.append(temp)\\n temp=temp.next\\n\\n #put rest of elements in stack\\n temp=mid\\n while(temp):\\n st.append(temp)\\n temp=temp.next\\n \\n #pick each element 1st from queue and then from stack\\n head=qu[0]\\n temp=None\\n while(len(st)>0 and len(qu)>0):\\n x=qu[0]\\n y=st[len(st)-1]\\n if(temp):\\n temp.next=x\\n x.next=y\\n y.next=None\\n st.pop(len(st)-1)\\n qu.pop(0)\\n temp=y\\n\\n while(len(st)>0):\\n y=st[len(st)-1]\\n if(temp):\\n temp.next=y\\n y.next=None\\n st.pop(len(st)-1)\\n temp=y\\n \\n while(len(qu)>0):\\n x=st[0]\\n if(temp):\\n temp.next=x\\n x.next=None\\n qu.pop(0)\\n temp=x\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n # Do not return anything, modify head in-place instead.\\n\\n # if even, elements till (len/2 - 1) index on leftside\\n # if odd, elements till (len//2 + 1 ) index on leftside\\n # use double ptrs, fast one will reach end of list, track elements after mid for fast one, then add from that list in reverse order to elements till mid in \\n tmp=head\\n length=0\\n while tmp!=None:\\n tmp=tmp.next\\n length+=1\\n\\n if length<=2: #no change required\\n return\\n\\n if length%2==0:\\n reqidx = (length/2 ) - 1\\n else:\\n reqidx = (length//2)\\n print(\\\"length\\\",length, \\\"elems on left arr\\\",reqidx+1)\\n\\n\\n i=0\\n j=0\\n slow = head\\n fast = head\\n if length%2!=0:\\n j=1\\n fast=head.next\\n slowvalues = []\\n fastvalues = []\\n while fast!=None and fast.next!=None:\\n # print(\\\"i=\\\",i,\\\" j=\\\",j)\\n if i<=reqidx:\\n slowvalues.append(slow.val)\\n if j>reqidx:\\n fastvalues.append(fast.val)\\n if fast.next is not None and fast.next.next is None:\\n fastvalues.append(fast.next.val)\\n \\n slow = slow.next\\n i+=1\\n if length%2!=0:\\n if j==reqidx:\\n fast = fast.next\\n if fast.next is None:\\n fastvalues.append(fast.val)\\n j+=1\\n else:\\n if j>reqidx:\\n fast = fast.next\\n j+=1\\n else:\\n fast = fast.next.next\\n j+=2\\n \\n else:\\n if j>reqidx:\\n fast = fast.next\\n j+=1\\n else:\\n fast = fast.next.next\\n j+=2\\n \\n\\n if length%2!=0:\\n slowvalues.append(slow.val)\\n # if len(slowvalues) + len(fastvalues)!= length:\\n # fastvalues.append(fast.val)\\n\\n print(len(slowvalues), len(fastvalues))\\n print(\\\"slow...\\\",slowvalues)\\n fastvalues = fastvalues[::-1]\\n print(\\\"fast...\\\",fastvalues)\\n\\n finalvals = []\\n tmp = head\\n for i in range(len(slowvalues)):\\n finalvals.append(slowvalues[i])\\n if i>0:\\n tmp.next = ListNode(val=slowvalues[i])\\n tmp = tmp.next\\n\\n try:\\n if fastvalues[i] is not None:\\n finalvals.append(fastvalues[i])\\n tmp.next = ListNode(val=fastvalues[i])\\n tmp = tmp.next\\n except IndexError:\\n print(\\\"odd-len-so-index-error\\\")\\n break\\n \\n print(\\\"total ... \\\",finalvals)\\n\\n\\n \",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n # Do not return anything, modify head in-place instead.\\n\\n # if even, elements till (len/2 - 1) index on leftside\\n # if odd, elements till (len//2 + 1 ) index on leftside\\n # use double ptrs, fast one will reach end of list, track elements after mid for fast one, then add from that list in reverse order to elements till mid in \\n tmp=head\\n length=0\\n while tmp!=None:\\n tmp=tmp.next\\n length+=1\\n\\n if length<=2: #no change required\\n return\\n\\n if length%2==0:\\n reqidx = (length/2 ) - 1\\n else:\\n reqidx = (length//2)\\n print(\\\"length\\\",length, \\\"elems on left arr\\\",reqidx+1)\\n\\n\\n i=0\\n j=0\\n slow = head\\n fast = head\\n if length%2!=0:\\n j=1\\n fast=head.next\\n slowvalues = []\\n fastvalues = []\\n while fast!=None and fast.next!=None:\\n # print(\\\"i=\\\",i,\\\" j=\\\",j)\\n if i<=reqidx:\\n slowvalues.append(slow.val)\\n if j>reqidx:\\n fastvalues.append(fast.val)\\n if fast.next is not None and fast.next.next is None:\\n fastvalues.append(fast.next.val)\\n \\n slow = slow.next\\n i+=1\\n \\n if length%2!=0:\\n if j==reqidx:\\n fast = fast.next\\n if fast.next is None:\\n fastvalues.append(fast.val)\\n j+=1\\n continue\\n # else:\\n # if j>reqidx:\\n # fast = fast.next\\n # j+=1\\n # else:\\n # fast = fast.next.next\\n # j+=2\\n \\n # else:\\n # if j>reqidx:\\n # fast = fast.next\\n # j+=1\\n # else:\\n # fast = fast.next.next\\n # j+=2\\n if j>reqidx:\\n fast = fast.next\\n j+=1\\n else:\\n fast = fast.next.next\\n j+=2\\n \\n\\n if length%2!=0:\\n slowvalues.append(slow.val)\\n # if len(slowvalues) + len(fastvalues)!= length:\\n # fastvalues.append(fast.val)\\n\\n print(len(slowvalues), len(fastvalues))\\n print(\\\"slow...\\\",slowvalues)\\n fastvalues = fastvalues[::-1]\\n print(\\\"fast...\\\",fastvalues)\\n\\n finalvals = []\\n tmp = head\\n for i in range(len(slowvalues)):\\n finalvals.append(slowvalues[i])\\n if i>0:\\n tmp.next = ListNode(val=slowvalues[i])\\n tmp = tmp.next\\n\\n try:\\n if fastvalues[i] is not None:\\n finalvals.append(fastvalues[i])\\n tmp.next = ListNode(val=fastvalues[i])\\n tmp = tmp.next\\n except IndexError:\\n print(\\\"odd-len-so-index-error\\\")\\n break\\n \\n print(\\\"total ... \\\",finalvals)\\n\\n\\n \",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head\\n while fast != None:\\n slow = slow.next\\n if fast != None:\\n fast = fast.next\\n if fast!=None:\\n fast = fast.next\\n low = head\\n stack =[]\\n queue = []\\n while low!=slow:\\n queue.append(low)\\n low=low.next\\n while slow != None:\\n stack.append(slow)\\n slow = slow.next\\n count = 0\\n ptr1 = None\\n while len(queue) > 0:\\n value = queue.pop(0)\\n if count == 0:\\n head = value\\n count+=1\\n if ptr1==None:\\n ptr1 = value\\n else:\\n ptr1.next = value\\n ptr1 = ptr1.next\\n if len(stack)>0:\\n ptr1.next = stack.pop()\\n ptr1 = ptr1.next\\n ptr1.next = None\\n return head\\n\\n\\n\\n \",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n res = []\\n curr = head\\n while curr:\\n res.append(curr.val)\\n curr = curr.next\\n \\n curr = head\\n i = 0\\n while curr:\\n if i%2 == 0:\\n curr.val = res.pop(0)\\n else:\\n curr.val = res.pop(-1)\\n curr = curr.next\\n i+=1\\n \",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n slow, fast = head, head\\n while fast != None:\\n slow = slow.next\\n if fast != None:\\n fast = fast.next\\n if fast!=None:\\n fast = fast.next\\n low = head\\n stack =[]\\n queue = []\\n while low!=slow:\\n queue.append(low)\\n low=low.next\\n while slow != None:\\n stack.append(slow)\\n slow = slow.next\\n count = 0\\n ptr1 = None\\n while len(queue) > 0:\\n value = queue.pop(0)\\n if count == 0:\\n head = value\\n count+=1\\n if ptr1==None:\\n ptr1 = value\\n else:\\n ptr1.next = value\\n ptr1 = ptr1.next\\n if len(stack)>0:\\n ptr1.next = stack.pop()\\n ptr1 = ptr1.next\\n ptr1.next = None\\n return head\",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n nodeNetwork = []\\n while head: #traverse till end of linked \\n nodeNetwork.append(head)\\n head = head.next\\n l = 0\\n r = len(nodeNetwork)-1\\n while l < r:\\n nodeNetwork[r].next = None\\n nodeNetwork[l].next = nodeNetwork[r]\\n print(nodeNetwork[l])\\n l += 1 #increment to next\\n if l >= r: \\n break\\n else:\\n nodeNetwork[l].next = None\\n nodeNetwork[r].next = nodeNetwork[l]\\n r -= 1\\n \\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n #insert linked list network into a list of nodes\\n #using len(nodeNetwork), make connections\\n #nodeNetwork[0].next = nodeNetwork[len(nodeNetwork)]\\n #nodeNetwork[len(nodeNetwork)].next = nodeNetwork[1]\\n #nodeNetwork[1].next = nodeNetwork[len(nodeNetwork)-1]\\n #nodeNetwork[len(nodeNetwork)-1].next = nodeNetwork[2]\\n #use pointers, stop when they pass each other\\n \",\n \"runtime\": \"88\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":89,"string":"89"},"mm_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n current = head\n while current != None:\n print(current.val)\n pre = current\n post = current.next\n if post == None:\n break\n while post.next != None:\n pre = pre.next\n post = post.next\n pre.next = None\n post.next = current.next\n current.next = post\n current = post.next","memory":"22000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head:\n return\n node = head\n while node.next and node.next.next:\n curr = node\n next_node = node.next\n last_node=curr\n while(last_node.next.next):\n last_node=last_node.next\n temp=last_node.next\n last_node.next=None\n last_node=temp\n #print(last_node)\n node.next=last_node\n last_node.next=next_node\n node=last_node.next\n ","memory":"22200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n def r(h, d):\n if d<0: return None\n if d==0:\n h.next = None\n\n return h\n\n pointer = h\n\n for i in range(d): \n pointer = pointer.next\n \n n = r(h.next, d-2)\n\n # print(h.val if h else None,n.val if n else None,pointer.val if pointer else None)\n \n h.next = pointer\n pointer.next = n\n\n\n return h\n\n pointer = head\n length = 0\n \n while pointer:\n length += 1\n pointer = pointer.next\n\n return r(head, length-1)","memory":"22300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n c = head\n while c.next:\n # go to the end\n p1 = c.next\n prev = c\n while p1.next:\n prev = p1\n p1 = p1.next\n c_next = c.next\n c.next = p1\n if p1 is not c_next:\n p1.next = c_next\n prev.next = None\n c = c_next\n return head\n","memory":"22600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head or not head.next or not head.next.next:\n return\n p = head\n while p.next.next:\n p = p.next\n \n second = head.next\n head.next = p.next\n p.next = None\n self.reorderList(second)\n head.next.next = second","memory":"23100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n sub_tail, tail = None, head\n count = 1\n while tail.next is not None:\n count += 1\n sub_tail, tail = tail, tail.next\n if count <= 2:\n return head\n sub_head = head.next\n head.next = tail\n tail.next = sub_head\n sub_tail.next = None\n self.reorderList(sub_head)","memory":"23600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n def mid(head):\n dummy = ListNode(next = head)\n p = q = dummy\n while q and q.next:\n p = p.next\n q = q.next.next\n return p\n\n def reverse(head):\n head2 = None\n p = head\n while p:\n node = ListNode(val = p.val)\n if not head2:\n head2 = node\n else:\n node.next = head2\n head2 = node\n p = p.next\n return head2\n\n def insert_list(head, head2):\n p, q = head, head2\n while q:\n node = ListNode(\n val = q.val\n )\n node.next = p.next\n p.next = node\n p = p.next.next\n q = q.next\n\n p = mid(head)\n head2 = p.next\n p.next = None\n head2 = reverse(head2)\n insert_list(head, head2)\n ","memory":"23700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n \n ls = []\n curr = head \n while curr : \n ls.append(curr.val)\n curr = curr.next \n curr = head\n ptr = curr\n # print(curr)\n while ls : \n if ls : \n curr.val = ls.pop(0)\n if ls :\n curr.next = ListNode()\n else : \n curr.next = None\n curr = curr.next\n if ls : \n curr.val = ls.pop(-1)\n if ls :\n curr.next = ListNode()\n else : \n curr.next = None\n curr = curr.next\n # print(ptr)\n \n # print(curr, ptr,head)\n\n # pointer = head\n # i = 0\n # nodes = ls\n # print\n # while nodes:\n # if i % 2 == 0:\n # pointer.next = nodes.pop(0)\n # else:\n # pointer.next = nodes.pop()\n\n # pointer = pointer.next\n # i += 1\n # pointer.next=None\n","memory":"23800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def getOrder(self, n):\n if n == 1:\n return [0]\n order = []\n l = 0\n r = n-1\n while l < r:\n order.append(l)\n order.append(r)\n l += 1\n r -= 1\n if l == r:\n order.append(l)\n return order\n\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if head is None:\n return head\n elif head.next is None:\n return head\n \n h = head\n arr = []\n while h is not None:\n arr.append(h)\n h = h.next\n order = self.getOrder(len(arr))\n\n hh = head\n for n in order[1:]:\n hh.next = arr[n]\n hh = hh.next\n hh.next = None\n return head\n\n ","memory":"23800"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n # Do not return anything, modify head in-place instead.\n\n # if even, elements till (len/2 - 1) index on leftside\n # if odd, elements till (len//2 + 1 ) index on leftside\n # use double ptrs, fast one will reach end of list, track elements after mid for fast one, then add from that list in reverse order to elements till mid in \n tmp=head\n length=0\n while tmp!=None:\n tmp=tmp.next\n length+=1\n\n if length<=2: #no change required\n return\n\n if length%2==0:\n reqidx = (length/2 ) - 1\n else:\n reqidx = (length//2)\n print(\"length\",length, \"elems on left arr\",reqidx+1)\n\n\n i=0\n j=0\n slow = head\n fast = head\n if length%2!=0:\n j=1\n fast=head.next\n slowvalues = []\n fastvalues = []\n while fast!=None and fast.next!=None:\n # print(\"i=\",i,\" j=\",j)\n if i<=reqidx:\n slowvalues.append(slow.val)\n if j>reqidx:\n fastvalues.append(fast.val)\n if fast.next is not None and fast.next.next is None:\n fastvalues.append(fast.next.val)\n \n slow = slow.next\n i+=1\n \n if length%2!=0:\n if j==reqidx:\n fast = fast.next\n if fast.next is None:\n fastvalues.append(fast.val)\n j+=1\n continue\n # else:\n # if j>reqidx:\n # fast = fast.next\n # j+=1\n # else:\n # fast = fast.next.next\n # j+=2\n \n # else:\n # if j>reqidx:\n # fast = fast.next\n # j+=1\n # else:\n # fast = fast.next.next\n # j+=2\n if j>reqidx:\n fast = fast.next\n j+=1\n else:\n fast = fast.next.next\n j+=2\n \n\n if length%2!=0:\n slowvalues.append(slow.val)\n # if len(slowvalues) + len(fastvalues)!= length:\n # fastvalues.append(fast.val)\n\n print(len(slowvalues), len(fastvalues))\n print(\"slow...\",slowvalues)\n fastvalues = fastvalues[::-1]\n print(\"fast...\",fastvalues)\n\n finalvals = []\n tmp = head\n for i in range(len(slowvalues)):\n finalvals.append(slowvalues[i])\n if i>0:\n tmp.next = ListNode(val=slowvalues[i])\n tmp = tmp.next\n\n try:\n if fastvalues[i] is not None:\n finalvals.append(fastvalues[i])\n tmp.next = ListNode(val=fastvalues[i])\n tmp = tmp.next\n except IndexError:\n print(\"odd-len-so-index-error\")\n break\n \n print(\"total ... \",finalvals)\n\n\n ","memory":"23900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n if not head:\n return\n\n middle = head\n tail = head\n while tail and tail.next:\n middle = middle.next\n tail = tail.next.next\n \n right = self._reverse(middle.next)\n middle.next = None\n\n tail = head\n while tail.next and right:\n new_tail = tail.next\n new_right = right.next\n\n tail.next = right\n tail.next.next = new_tail\n\n tail = new_tail\n right = new_right\n\n def _reverse(self, head: ListNode) -> ListNode:\n prev = None\n curr = head\n while curr:\n temp = curr.next\n curr.next = prev\n prev = curr\n curr = temp\n return prev\n","memory":"24000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n dct = {}\n n = -1\n temp = head\n \n while temp:\n n+=1\n dct[n]= temp.val\n temp=temp.next\n \n i = 0\n j= 0\n \n temp=head\n while j<n:\n j+=1\n if j%2!=0:\n temp.next = ListNode(dct[n-i])\n i+=1\n else:\n temp.next = ListNode(dct[i])\n temp =temp.next","memory":"24100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n arr = []\n it = head\n while it:\n arr.append(it.val)\n it = it.next\n \n inx, i = [0], 1\n while len(inx) < len(arr):\n inx.append(-i)\n inx.append(i)\n i += 1\n if len(inx) > len(arr): inx.pop()\n\n it = head\n while it:\n i = inx.pop(0)\n it.val = arr[i]\n it = it.next\n\n return head\n ","memory":"24200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # maintain memory efficiency -> avoid creating new Node instances\n # iterate through whole list first and create a map with references to the node\n # that corresponds to each index\n node_map = {} # index -> node instance\n curr = head\n index = 0\n while curr is not None:\n node_map[index] = curr\n curr = curr.next\n index += 1\n # The number of edges that need to change is floor divide length of list by 2\n n = len(node_map.keys())\n edges_to_changes = n//2\n # change edges of node 0 to length num edges computed in previous comment\n for e in range(edges_to_changes):\n # 1. save node e's next pointer\n old = node_map[e].next\n # 2. change node e's next pointer to node n-e\n node_map[e].next = node_map[n - e - 1]\n # 3. change node n-e's next pointer to the saved next pointer in step 1\n node_map[n - e - 1].next = old\n # change last e + 1 next pointer to None\n node_map[edges_to_changes].next = None\n\n return node_map[0]","memory":"24300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head.next:\n return head\n slow = head\n fast = head.next\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n head2 = slow.next\n slow.next = None\n\n prev = None\n curr = head2\n\n while curr:\n temp = curr.next\n curr.next = prev\n prev = curr\n curr = temp\n \n i = head\n j = prev\n\n while i and j:\n temp = i.next\n i.next = j\n temp2 = j.next\n j.next = temp\n i = temp\n j = temp2\n\n return head","memory":"24400"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if head.next == None:\n head = head\n elif head.next.next == None:\n head = head\n else:\n avant_dernier = head\n while avant_dernier.next.next != None:\n avant_dernier = avant_dernier.next\n avant_dernier.next.next = head.next\n head.next = None\n head.next = avant_dernier.next\n avant_dernier.next = None\n self.reorderList(head.next.next)\n\n \n ","memory":"24400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # time O(n)\n # space O(1)\n slow = fast = head\n\n while fast and fast.next:\n slow, fast = slow.next, fast.next.next\n\n l2 = slow.next\n slow.next = None\n prev = None\n\n while l2:\n tmp = l2.next\n l2.next = prev\n prev = l2\n l2 = tmp\n \n l2 = prev\n l1 = head\n\n # merge l1 and l2\n while l1 and l2:\n tmp1, tmp2 = l1.next, l2.next\n l1.next = l2\n l2.next = tmp1\n l1, l2 = tmp1, tmp2\n \n return head\n","memory":"24500"},{"code":"class Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n The aproach is divided in three steps:\n 1. find the middle\n 2. reverse the list from the middle to the end\n 3. have two pointer, one from the head and the other from the end,\n and start to reorder the list\n \"\"\"\n\n # Required minimum length of 3\n if head is None or head.next is None or head.next.next is None:\n return\n\n # 1. Find the middle\n slow, fast = head, head\n while fast is not None and fast.next is not None:\n fast = fast.next.next\n slow = slow.next\n\n # 2. Reverse from the middle\n current = slow\n prev = None\n while current is not None:\n next = current.next\n current.next = prev\n prev = current\n current = next\n\n # 3. Reorder the list\n right = prev\n left = head\n while right.next is not None and left.next is not None:\n next_left = left.next\n left.next = right\n left = left.next\n next_right = right.next\n left.next = next_left\n right = next_right\n left = left.next","memory":"24500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n if not head:\n return\n \n # Step 1: Find the middle of the list\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n # Step 2: Reverse the second half of the list\n prev = None\n while slow:\n temp = slow.next\n slow.next = prev\n prev = slow\n slow = temp\n \n # Step 3: Merge the two halves\n second = prev\n first = head\n while second:\n temp1 = first.next\n temp2 = second.next\n first.next = second\n second.next = temp1\n first = temp1\n second = temp2\n # Important: Ensure the last node points to None to avoid cycle\n if first:\n first.next = None\n","memory":"24600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n slow , fast = head, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n second = slow.next\n prev = slow.next = None\n while second:\n tmp = second.next\n second.next = prev\n prev = second\n second = tmp\n first,sec = head, prev\n while first and sec:\n tmp1, tmp2 = first.next, sec.next\n first.next = sec\n sec.next = tmp1\n first,sec = tmp1, tmp2\n ","memory":"24600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n \"\"\"Idea: reverse second half then merge with first half\n \"\"\"\n # reverse second half\n # find middle element\n slow = fast = head\n while fast and fast.next:\n slow, fast = slow.next, fast.next.next\n\n prev, curr = None, slow\n while curr:\n prev, curr.next, curr = curr, prev, curr.next\n \n # merge the two\n dummy = ListNode(0, head)\n p1, p2 = head, prev\n while p2.next:\n p1.next, p1 = p2, p1.next\n p2.next, p2 = p1, p2.next\n\n return dummy.next\n\n \n ","memory":"24700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n # Initialize pointers\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n # Reverse second\n second = slow.next\n slow.next = None\n prev = None\n while second:\n tmp = second.next\n second.next = prev\n prev = second\n second = tmp\n \n # Merge both lists\n first, second = head, prev\n while second:\n tmp1, tmp2 = first.next, second.next\n first.next = second\n second.next = tmp1\n first, second = tmp1, tmp2","memory":"24700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n hash={}\n idx=0\n curr=head\n while curr:\n hash[idx]=curr\n curr=curr.next\n idx +=1\n\n\n for i in range(int((idx-1)/2)):\n hash[i].next=hash[idx-1-i]\n hash[idx-1-i].next=hash[i+1]\n\n if (idx-1)%2==0:\n hash[int((idx-1)/2)].next=None\n else:\n hash[int((idx-1)/2) +1].next=None\n ","memory":"24800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom collections import deque\nclass Solution:\n def reorderList(self, head: Optional[ListNode]) -> None:\n\n queue = deque()\n current = head\n while current:\n queue.append(current)\n current = current.next\n \n new_head = ListNode(0)\n current = new_head\n left = True\n while queue:\n next = None\n if left:\n next = queue.popleft()\n left = False\n else:\n next = queue.pop()\n left = True\n next.next = None\n current.next = next\n current = current.next\n return new_head.next\n\n","memory":"24800"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n current = head\\n while current != None:\\n print(current.val)\\n pre = current\\n post = current.next\\n if post == None:\\n break\\n while post.next != None:\\n pre = pre.next\\n post = post.next\\n pre.next = None\\n post.next = current.next\\n current.next = post\\n current = post.next\",\n \"memory\": \"22000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head:\\n return\\n node = head\\n while node.next and node.next.next:\\n curr = node\\n next_node = node.next\\n last_node=curr\\n while(last_node.next.next):\\n last_node=last_node.next\\n temp=last_node.next\\n last_node.next=None\\n last_node=temp\\n #print(last_node)\\n node.next=last_node\\n last_node.next=next_node\\n node=last_node.next\\n \",\n \"memory\": \"22200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n def r(h, d):\\n if d<0: return None\\n if d==0:\\n h.next = None\\n\\n return h\\n\\n pointer = h\\n\\n for i in range(d): \\n pointer = pointer.next\\n \\n n = r(h.next, d-2)\\n\\n # print(h.val if h else None,n.val if n else None,pointer.val if pointer else None)\\n \\n h.next = pointer\\n pointer.next = n\\n\\n\\n return h\\n\\n pointer = head\\n length = 0\\n \\n while pointer:\\n length += 1\\n pointer = pointer.next\\n\\n return r(head, length-1)\",\n \"memory\": \"22300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n c = head\\n while c.next:\\n # go to the end\\n p1 = c.next\\n prev = c\\n while p1.next:\\n prev = p1\\n p1 = p1.next\\n c_next = c.next\\n c.next = p1\\n if p1 is not c_next:\\n p1.next = c_next\\n prev.next = None\\n c = c_next\\n return head\\n\",\n \"memory\": \"22600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head or not head.next or not head.next.next:\\n return\\n p = head\\n while p.next.next:\\n p = p.next\\n \\n second = head.next\\n head.next = p.next\\n p.next = None\\n self.reorderList(second)\\n head.next.next = second\",\n \"memory\": \"23100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n sub_tail, tail = None, head\\n count = 1\\n while tail.next is not None:\\n count += 1\\n sub_tail, tail = tail, tail.next\\n if count <= 2:\\n return head\\n sub_head = head.next\\n head.next = tail\\n tail.next = sub_head\\n sub_tail.next = None\\n self.reorderList(sub_head)\",\n \"memory\": \"23600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n def mid(head):\\n dummy = ListNode(next = head)\\n p = q = dummy\\n while q and q.next:\\n p = p.next\\n q = q.next.next\\n return p\\n\\n def reverse(head):\\n head2 = None\\n p = head\\n while p:\\n node = ListNode(val = p.val)\\n if not head2:\\n head2 = node\\n else:\\n node.next = head2\\n head2 = node\\n p = p.next\\n return head2\\n\\n def insert_list(head, head2):\\n p, q = head, head2\\n while q:\\n node = ListNode(\\n val = q.val\\n )\\n node.next = p.next\\n p.next = node\\n p = p.next.next\\n q = q.next\\n\\n p = mid(head)\\n head2 = p.next\\n p.next = None\\n head2 = reverse(head2)\\n insert_list(head, head2)\\n \",\n \"memory\": \"23700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n \\n ls = []\\n curr = head \\n while curr : \\n ls.append(curr.val)\\n curr = curr.next \\n curr = head\\n ptr = curr\\n # print(curr)\\n while ls : \\n if ls : \\n curr.val = ls.pop(0)\\n if ls :\\n curr.next = ListNode()\\n else : \\n curr.next = None\\n curr = curr.next\\n if ls : \\n curr.val = ls.pop(-1)\\n if ls :\\n curr.next = ListNode()\\n else : \\n curr.next = None\\n curr = curr.next\\n # print(ptr)\\n \\n # print(curr, ptr,head)\\n\\n # pointer = head\\n # i = 0\\n # nodes = ls\\n # print\\n # while nodes:\\n # if i % 2 == 0:\\n # pointer.next = nodes.pop(0)\\n # else:\\n # pointer.next = nodes.pop()\\n\\n # pointer = pointer.next\\n # i += 1\\n # pointer.next=None\\n\",\n \"memory\": \"23800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def getOrder(self, n):\\n if n == 1:\\n return [0]\\n order = []\\n l = 0\\n r = n-1\\n while l < r:\\n order.append(l)\\n order.append(r)\\n l += 1\\n r -= 1\\n if l == r:\\n order.append(l)\\n return order\\n\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if head is None:\\n return head\\n elif head.next is None:\\n return head\\n \\n h = head\\n arr = []\\n while h is not None:\\n arr.append(h)\\n h = h.next\\n order = self.getOrder(len(arr))\\n\\n hh = head\\n for n in order[1:]:\\n hh.next = arr[n]\\n hh = hh.next\\n hh.next = None\\n return head\\n\\n \",\n \"memory\": \"23800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n # Do not return anything, modify head in-place instead.\\n\\n # if even, elements till (len/2 - 1) index on leftside\\n # if odd, elements till (len//2 + 1 ) index on leftside\\n # use double ptrs, fast one will reach end of list, track elements after mid for fast one, then add from that list in reverse order to elements till mid in \\n tmp=head\\n length=0\\n while tmp!=None:\\n tmp=tmp.next\\n length+=1\\n\\n if length<=2: #no change required\\n return\\n\\n if length%2==0:\\n reqidx = (length/2 ) - 1\\n else:\\n reqidx = (length//2)\\n print(\\\"length\\\",length, \\\"elems on left arr\\\",reqidx+1)\\n\\n\\n i=0\\n j=0\\n slow = head\\n fast = head\\n if length%2!=0:\\n j=1\\n fast=head.next\\n slowvalues = []\\n fastvalues = []\\n while fast!=None and fast.next!=None:\\n # print(\\\"i=\\\",i,\\\" j=\\\",j)\\n if i<=reqidx:\\n slowvalues.append(slow.val)\\n if j>reqidx:\\n fastvalues.append(fast.val)\\n if fast.next is not None and fast.next.next is None:\\n fastvalues.append(fast.next.val)\\n \\n slow = slow.next\\n i+=1\\n \\n if length%2!=0:\\n if j==reqidx:\\n fast = fast.next\\n if fast.next is None:\\n fastvalues.append(fast.val)\\n j+=1\\n continue\\n # else:\\n # if j>reqidx:\\n # fast = fast.next\\n # j+=1\\n # else:\\n # fast = fast.next.next\\n # j+=2\\n \\n # else:\\n # if j>reqidx:\\n # fast = fast.next\\n # j+=1\\n # else:\\n # fast = fast.next.next\\n # j+=2\\n if j>reqidx:\\n fast = fast.next\\n j+=1\\n else:\\n fast = fast.next.next\\n j+=2\\n \\n\\n if length%2!=0:\\n slowvalues.append(slow.val)\\n # if len(slowvalues) + len(fastvalues)!= length:\\n # fastvalues.append(fast.val)\\n\\n print(len(slowvalues), len(fastvalues))\\n print(\\\"slow...\\\",slowvalues)\\n fastvalues = fastvalues[::-1]\\n print(\\\"fast...\\\",fastvalues)\\n\\n finalvals = []\\n tmp = head\\n for i in range(len(slowvalues)):\\n finalvals.append(slowvalues[i])\\n if i>0:\\n tmp.next = ListNode(val=slowvalues[i])\\n tmp = tmp.next\\n\\n try:\\n if fastvalues[i] is not None:\\n finalvals.append(fastvalues[i])\\n tmp.next = ListNode(val=fastvalues[i])\\n tmp = tmp.next\\n except IndexError:\\n print(\\\"odd-len-so-index-error\\\")\\n break\\n \\n print(\\\"total ... \\\",finalvals)\\n\\n\\n \",\n \"memory\": \"23900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n if not head:\\n return\\n\\n middle = head\\n tail = head\\n while tail and tail.next:\\n middle = middle.next\\n tail = tail.next.next\\n \\n right = self._reverse(middle.next)\\n middle.next = None\\n\\n tail = head\\n while tail.next and right:\\n new_tail = tail.next\\n new_right = right.next\\n\\n tail.next = right\\n tail.next.next = new_tail\\n\\n tail = new_tail\\n right = new_right\\n\\n def _reverse(self, head: ListNode) -> ListNode:\\n prev = None\\n curr = head\\n while curr:\\n temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = temp\\n return prev\\n\",\n \"memory\": \"24000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n dct = {}\\n n = -1\\n temp = head\\n \\n while temp:\\n n+=1\\n dct[n]= temp.val\\n temp=temp.next\\n \\n i = 0\\n j= 0\\n \\n temp=head\\n while j<n:\\n j+=1\\n if j%2!=0:\\n temp.next = ListNode(dct[n-i])\\n i+=1\\n else:\\n temp.next = ListNode(dct[i])\\n temp =temp.next\",\n \"memory\": \"24100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n arr = []\\n it = head\\n while it:\\n arr.append(it.val)\\n it = it.next\\n \\n inx, i = [0], 1\\n while len(inx) < len(arr):\\n inx.append(-i)\\n inx.append(i)\\n i += 1\\n if len(inx) > len(arr): inx.pop()\\n\\n it = head\\n while it:\\n i = inx.pop(0)\\n it.val = arr[i]\\n it = it.next\\n\\n return head\\n \",\n \"memory\": \"24200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # maintain memory efficiency -> avoid creating new Node instances\\n # iterate through whole list first and create a map with references to the node\\n # that corresponds to each index\\n node_map = {} # index -> node instance\\n curr = head\\n index = 0\\n while curr is not None:\\n node_map[index] = curr\\n curr = curr.next\\n index += 1\\n # The number of edges that need to change is floor divide length of list by 2\\n n = len(node_map.keys())\\n edges_to_changes = n//2\\n # change edges of node 0 to length num edges computed in previous comment\\n for e in range(edges_to_changes):\\n # 1. save node e's next pointer\\n old = node_map[e].next\\n # 2. change node e's next pointer to node n-e\\n node_map[e].next = node_map[n - e - 1]\\n # 3. change node n-e's next pointer to the saved next pointer in step 1\\n node_map[n - e - 1].next = old\\n # change last e + 1 next pointer to None\\n node_map[edges_to_changes].next = None\\n\\n return node_map[0]\",\n \"memory\": \"24300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head.next:\\n return head\\n slow = head\\n fast = head.next\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n head2 = slow.next\\n slow.next = None\\n\\n prev = None\\n curr = head2\\n\\n while curr:\\n temp = curr.next\\n curr.next = prev\\n prev = curr\\n curr = temp\\n \\n i = head\\n j = prev\\n\\n while i and j:\\n temp = i.next\\n i.next = j\\n temp2 = j.next\\n j.next = temp\\n i = temp\\n j = temp2\\n\\n return head\",\n \"memory\": \"24400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if head.next == None:\\n head = head\\n elif head.next.next == None:\\n head = head\\n else:\\n avant_dernier = head\\n while avant_dernier.next.next != None:\\n avant_dernier = avant_dernier.next\\n avant_dernier.next.next = head.next\\n head.next = None\\n head.next = avant_dernier.next\\n avant_dernier.next = None\\n self.reorderList(head.next.next)\\n\\n \\n \",\n \"memory\": \"24400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # time O(n)\\n # space O(1)\\n slow = fast = head\\n\\n while fast and fast.next:\\n slow, fast = slow.next, fast.next.next\\n\\n l2 = slow.next\\n slow.next = None\\n prev = None\\n\\n while l2:\\n tmp = l2.next\\n l2.next = prev\\n prev = l2\\n l2 = tmp\\n \\n l2 = prev\\n l1 = head\\n\\n # merge l1 and l2\\n while l1 and l2:\\n tmp1, tmp2 = l1.next, l2.next\\n l1.next = l2\\n l2.next = tmp1\\n l1, l2 = tmp1, tmp2\\n \\n return head\\n\",\n \"memory\": \"24500\"\n },\n {\n \"code\": \"class Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n The aproach is divided in three steps:\\n 1. find the middle\\n 2. reverse the list from the middle to the end\\n 3. have two pointer, one from the head and the other from the end,\\n and start to reorder the list\\n \\\"\\\"\\\"\\n\\n # Required minimum length of 3\\n if head is None or head.next is None or head.next.next is None:\\n return\\n\\n # 1. Find the middle\\n slow, fast = head, head\\n while fast is not None and fast.next is not None:\\n fast = fast.next.next\\n slow = slow.next\\n\\n # 2. Reverse from the middle\\n current = slow\\n prev = None\\n while current is not None:\\n next = current.next\\n current.next = prev\\n prev = current\\n current = next\\n\\n # 3. Reorder the list\\n right = prev\\n left = head\\n while right.next is not None and left.next is not None:\\n next_left = left.next\\n left.next = right\\n left = left.next\\n next_right = right.next\\n left.next = next_left\\n right = next_right\\n left = left.next\",\n \"memory\": \"24500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n if not head:\\n return\\n \\n # Step 1: Find the middle of the list\\n slow = fast = head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n # Step 2: Reverse the second half of the list\\n prev = None\\n while slow:\\n temp = slow.next\\n slow.next = prev\\n prev = slow\\n slow = temp\\n \\n # Step 3: Merge the two halves\\n second = prev\\n first = head\\n while second:\\n temp1 = first.next\\n temp2 = second.next\\n first.next = second\\n second.next = temp1\\n first = temp1\\n second = temp2\\n # Important: Ensure the last node points to None to avoid cycle\\n if first:\\n first.next = None\\n\",\n \"memory\": \"24600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n slow , fast = head, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n second = slow.next\\n prev = slow.next = None\\n while second:\\n tmp = second.next\\n second.next = prev\\n prev = second\\n second = tmp\\n first,sec = head, prev\\n while first and sec:\\n tmp1, tmp2 = first.next, sec.next\\n first.next = sec\\n sec.next = tmp1\\n first,sec = tmp1, tmp2\\n \",\n \"memory\": \"24600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"Idea: reverse second half then merge with first half\\n \\\"\\\"\\\"\\n # reverse second half\\n # find middle element\\n slow = fast = head\\n while fast and fast.next:\\n slow, fast = slow.next, fast.next.next\\n\\n prev, curr = None, slow\\n while curr:\\n prev, curr.next, curr = curr, prev, curr.next\\n \\n # merge the two\\n dummy = ListNode(0, head)\\n p1, p2 = head, prev\\n while p2.next:\\n p1.next, p1 = p2, p1.next\\n p2.next, p2 = p1, p2.next\\n\\n return dummy.next\\n\\n \\n \",\n \"memory\": \"24700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n # Initialize pointers\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n # Reverse second\\n second = slow.next\\n slow.next = None\\n prev = None\\n while second:\\n tmp = second.next\\n second.next = prev\\n prev = second\\n second = tmp\\n \\n # Merge both lists\\n first, second = head, prev\\n while second:\\n tmp1, tmp2 = first.next, second.next\\n first.next = second\\n second.next = tmp1\\n first, second = tmp1, tmp2\",\n \"memory\": \"24700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify head in-place instead.\\n \\\"\\\"\\\"\\n hash={}\\n idx=0\\n curr=head\\n while curr:\\n hash[idx]=curr\\n curr=curr.next\\n idx +=1\\n\\n\\n for i in range(int((idx-1)/2)):\\n hash[i].next=hash[idx-1-i]\\n hash[idx-1-i].next=hash[i+1]\\n\\n if (idx-1)%2==0:\\n hash[int((idx-1)/2)].next=None\\n else:\\n hash[int((idx-1)/2) +1].next=None\\n \",\n \"memory\": \"24800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom collections import deque\\nclass Solution:\\n def reorderList(self, head: Optional[ListNode]) -> None:\\n\\n queue = deque()\\n current = head\\n while current:\\n queue.append(current)\\n current = current.next\\n \\n new_head = ListNode(0)\\n current = new_head\\n left = True\\n while queue:\\n next = None\\n if left:\\n next = queue.popleft()\\n left = False\\n else:\\n next = queue.pop()\\n left = True\\n next.next = None\\n current.next = next\\n current = current.next\\n return new_head.next\\n\\n\",\n \"memory\": \"24800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":24,"string":"24"}}},{"rowIdx":48,"cells":{"question_id":{"kind":"number","value":144,"string":"144"},"name":{"kind":"string","value":"binary-tree-preorder-traversal"},"content":{"kind":"string","value":"<p>Given the <code>root</code> of a binary tree, return <em>the preorder traversal of its nodes' values</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">root = [1,null,2,3]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[1,2,3]</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png\" style=\"width: 200px; height: 264px;\" /></p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">root = [1,2,3,4,5,null,8,null,null,6,7,9]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[1,2,4,5,6,7,3,8,9]</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/08/29/tree_2.png\" style=\"width: 350px; height: 286px;\" /></p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">root = []</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[]</span></p>\n</div>\n\n<p><strong class=\"example\">Example 4:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">root = [1]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[1]</span></p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>\n\t<li><code>-100 <= Node.val <= 100</code></li>\n</ul>\n\n<p> </p>\n<p><strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</p>\n"},"acRate":{"kind":"number","value":70.82184271728046,"string":"70.821843"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["stack","tree","depth-first-search","binary-tree"],"string":"[\n \"stack\",\n \"tree\",\n \"depth-first-search\",\n \"binary-tree\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"11\", 0.0071], [\"12\", 0.0071], [\"15\", 0.0214], [\"16\", 0.0286], [\"17\", 0.0214], [\"18\", 0.0715], [\"19\", 0.1429], [\"20\", 0.1287], [\"21\", 0.2573], [\"22\", 0.6361], [\"23\", 0.6933], [\"24\", 0.7505], [\"25\", 0.922], [\"26\", 2.3158], [\"27\", 2.0728], [\"28\", 2.0513], [\"29\", 3.3236], [\"30\", 6.1897], [\"31\", 4.6601], [\"32\", 4.0526], [\"33\", 7.0259], [\"34\", 9.7706], [\"35\", 6.3684], [\"36\", 5.3249], [\"37\", 8.5841], [\"38\", 8.8557], [\"39\", 6.0324], [\"40\", 4.2885], [\"41\", 4.9389], [\"42\", 4.0955]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15800\", 0.0071], [\"15900\", 0.0071], [\"16100\", 0.0143], [\"16200\", 0.2573], [\"16300\", 4.8388], [\"16400\", 26.2169], [\"16500\", 49.296]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n stack = [root]\n result=[]\n while stack:\n node=stack.pop()\n result.append(node.val)\n if node.right:\n stack.append(node.right)\n if node.left:\n stack.append(node.left)\n return result\n","runtime":"11"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n self.pre_helper(root,res)\n return res\n \n def pre_helper(self,root,res):\n if not root:\n return\n res.append(root.val)\n self.pre_helper(root.left,res)\n self.pre_helper(root.right,res)","runtime":"12"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res=[]\n def pT(node):\n if node is None:\n return []\n res.append(node.val)\n pT(node.left)\n pT(node.right)\n \n pT(root)\n return res","runtime":"15"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n\n def preorderHelper(node):\n if node == None:\n return\n # Root Left Right\n res.append(node.val)\n preorderHelper(node.left)\n preorderHelper(node.right)\n \n preorderHelper(root)\n\n return res\n","runtime":"16"},{"code":"# Definition for a binary tree node.\nclass TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\nclass Solution:\n def __init__(self):\n self.arr=[]\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if root==None:\n return\n \n self.arr.append(root.val)\n self.preorderTraversal(root.left)\n self.preorderTraversal(root.right)\n return self.arr\n\n \n ","runtime":"16"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n\n def dfs(node, res):\n if not node:\n return\n \n res.append(node.val)\n dfs(node.left, res)\n dfs(node.right, res)\n dfs(root, res)\n return res","runtime":"17"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if root is None:\n return []\n # Preorder: root -> left -> right\n return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)","runtime":"18"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]: \n ans = []\n def preorderHelper(root):\n if root is None:\n return ans\n \n ans.append(root.val)\n preorderHelper(root.left)\n preorderHelper(root.right)\n \n preorderHelper(root)\n return ans","runtime":"19"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def __init__(self):\n self.result = []\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return root\n stack = []\n stack.append(root)\n res = []\n \n while stack:\n tmp = stack.pop()\n res.append(tmp.val)\n if tmp.right != None:\n stack.append(tmp.right)\n if tmp.left != None:\n stack.append(tmp.left)\n return res","runtime":"20"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nfrom collections import deque\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n # res = list()\n # def preorder(root):\n # if root==None:\n # return\n # res.append(root.val)\n # preorder(root.left)\n # preorder(root.right)\n # preorder(root)\n # return res\n\n res = list()\n st = deque()\n if root == None:\n return res\n st.append(root)\n while len(st) != 0:\n element = st.pop()\n res.append(element.val)\n if element.right != None:\n st.append(element.right)\n if element.left != None:\n st.append(element.left)\n return res","runtime":"20"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def pre(node):\n if node:\n res.append(node.val)\n pre(node.left)\n pre(node.right)\n else:\n return\n res = []\n pre(root)\n return res","runtime":"21"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\nclass LeetCode:\n\n \n\n def P144(self, root):\n\n \n\n result = []\n\n \n\n def dfs(node):\n\n \n\n if not node:\n\n return\n\n \n\n \n\n # Visit root\n\n result.append(node.val) \n\n \n\n # Visit left subtree\n\n dfs(node.left)\n\n \n\n \n\n # Visit right subtree\n\n dfs(node.right)\n\n \n\n dfs(root)\n\n return result \nclass Solution(LeetCode):\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n return self.P144(root)\n ","runtime":"22"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n \n if root is None:\n return []\n\n res = []\n res.append(root.val)\n res += self.preorderTraversal(root.left)\n res += self.preorderTraversal(root.right)\n\n return res ","runtime":"22"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n preorder=[]\n curr=root\n while curr is not None:\n if curr.left is None:\n preorder.append(curr.val)\n curr=curr.right\n else:\n prev=curr.left\n while prev.right and prev.right!=curr:\n prev=prev.right\n if prev.right is None:\n prev.right=curr\n preorder.append(curr.val)\n curr=curr.left\n else:\n prev.right=None\n \n curr=curr.right\n return preorder","runtime":"23"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n\n def helper(root):\n if not root:\n return res\n \n res.append(root.val)\n helper(root.left)\n helper(root.right)\n helper(root)\n return res\n ","runtime":"23"},{"code":"# Definition for a binary tree node.\nclass TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n l=[]\n def traverse(node):\n if node:\n l.append(node.val)\n traverse(node.left)\n traverse(node.right)\n \n traverse(root)\n \n return l","runtime":"24"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def __init__(self):\n self.arr=[]\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if root is not None:\n self.arr.append(root.val)\n self.preorderTraversal(root.left)\n self.preorderTraversal(root.right)\n return self.arr\n ","runtime":"24"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n l=[]\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n self.l=[]\n def pre(root):\n if root:\n self.l.append(root.val)\n\n pre(root.left)\n pre(root.right)\n pre(root)\n return self.l","runtime":"25"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n # preorder: root->left->right\n res = []\n def dfs(node):\n if not node:\n return\n res.append(node.val)\n dfs(node.left)\n dfs(node.right)\n dfs(root)\n return res\n ","runtime":"26"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n\n def traverse(node):\n if not node:\n return\n \n res.append(node.val)\n traverse(node.left)\n traverse(node.right)\n \n traverse(root)\n\n return res","runtime":"26"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n arry=[]\n def dfs(node):\n if node is None:\n return None\n arry.append(node.val)\n return dfs(node.left) or dfs(node.right)\n dfs(root)\n return arry\n ","runtime":"27"},{"code":"# Time complexity: we visit each node exactly once, thus the time complexity is O(N), where N is the number of nodes, i.e. the size of the tree.\n\n# Space complexity: depending on the tree structure, we could keep up to the entire tree, therefore, the space complexity is O(N).\n\n# Iterative\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n result = []\n stack = [root]\n while stack:\n node = stack.pop()\n result.append(node.val)\n\n if node.right:\n stack.append(node.right)\n if node.left:\n stack.append(node.left)\n return result\n\n \n \n ","runtime":"27"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n lis = []\n if root is None:\n return\n def preorder(root):\n if root is None:\n return\n lis.append(root.val)\n preorder(root.left)\n preorder(root.right)\n preorder(root)\n return lis","runtime":"28"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode], arr = []) -> List[int]:\n # current = root\n # if current is None:\n # return arr\n # arr.append(current.val)\n # self.preorderTraversal(current.left, arr)\n # self.preorderTraversal(current.right, arr)\n ans = []\n st = [root]\n\n while st:\n temp = st.pop()\n if temp:\n ans.append(temp.val)\n st.append(temp.right) # 2nd element to be popped\n st.append(temp.left) # 1st element to be popped\n \n return ans","runtime":"28"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def helper(self, root, result):\n if not root:\n return\n result.append(root.val)\n if root.left:\n self.helper(root.left, result)\n if root.right:\n self.helper(root.right, result)\n \n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n self.helper(root, result)\n return result\n\n\n\n","runtime":"29"},{"code":"class Solution:\n def preorderTraversal(self, root: TreeNode | None) -> list[int]:\n ans = []\n\n def preorder(root: TreeNode | None) -> None:\n if not root:\n return\n\n ans.append(root.val)\n preorder(root.left)\n preorder(root.right)\n\n preorder(root)\n return ans","runtime":"29"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def dfs(root):\n if root is None:\n return\n ans.append(root.val)\n dfs(root.left)\n dfs(root.right)\n\n ans = []\n dfs(root)\n return ans\n ","runtime":"30"},{"code":"class Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def dfs(root):\n if root is None:\n return\n ans.append(root.val)\n dfs(root.left)\n dfs(root.right)\n\n ans = []\n dfs(root)\n return ans\n","runtime":"30"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n stack=[]\n cur=root\n res=[]\n while stack or cur:\n while cur:\n stack.append(cur.right)\n res.append(cur.val)\n cur=cur.left\n cur=stack.pop()\n return res\n ","runtime":"31"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\ndef solve(root, ans):\n if root is None:\n return\n\n ans.append(root.val)\n solve(root.left,ans)\n solve(root.right,ans)\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n order = []\n stack = [root]\n while stack:\n node = stack.pop()\n order.append(node.val)\n if node.right:\n stack.append(node.right)\n if node.left:\n stack.append(node.left)\n\n return order","runtime":"31"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\n\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n\n output: List[int] = []\n\n # process this node\n output.append(root.val)\n\n # go left\n output += self.preorderTraversal(root.left)\n\n # go right\n output += self.preorderTraversal(root.right)\n\n return output","runtime":"32"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n # preorder: root, left subtree, right subtree\n # M1: recursive\n ans = list()\n def dfs(root):\n if root is None:\n return\n ans.append(root.val)\n dfs(root.left)\n dfs(root.right)\n dfs(root)\n return ans\n","runtime":"32"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\n\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n \n # Recursive implementation of the pre-order:\n \n def dfs(node, arr):\n if not node:\n return arr\n arr.append(node.val)\n arr = dfs(node.left, arr)\n arr = dfs(node.right, arr)\n return arr\n \n # Iterative implementation\n if not root:\n return []\n\n stack = []\n stack.append(root)\n res = []\n while len(stack) > 0:\n node = stack.pop()\n res.append(node.val)\n if node.right is not None:\n stack.append(node.right)\n if node.left is not None:\n stack.append(node.left)\n \n return res\n \n ","runtime":"33"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def dfs(root):\n if root is None:\n return\n ans.append(root.val)\n dfs(root.left)\n dfs(root.right)\n\n ans = []\n dfs(root)\n return ans","runtime":"33"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\n\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n \n # Recursive implementation of the pre-order:\n def dfs(node, arr):\n if not node:\n return arr\n arr.append(node.val)\n arr = dfs(node.left, arr)\n arr = dfs(node.right, arr)\n return arr\n \n return dfs(root, [])\n \n ","runtime":"34"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\n\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n output_list: List[int] = []\n\n def recursive_preorder(root: TreeNode | None) -> None:\n if not root:\n return\n\n # process this node\n output_list.append(root.val)\n\n # go left\n recursive_preorder(root.left)\n\n # go right\n recursive_preorder(root.right)\n\n recursive_preorder(root)\n\n return output_list","runtime":"34"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\ndef solve(root, ans):\n if root is None:\n return\n\n ans.append(root.val)\n solve(root.left,ans)\n solve(root.right,ans)\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n ans = []\n solve(root,ans)\n return ans","runtime":"35"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n s = [root]\n ans = []\n while s:\n n = s[-1]\n s.remove(n)\n ans.append(n.val)\n if n.right: s.append(n.right)\n if n.left: s.append(n.left)\n return ans\n ","runtime":"35"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res=[]\n def traverse(node):\n if node is not None:\n 'visit root'\n res.append(node.val) \n 'traverse left subtree'\n traverse(node.left)\n 'traverse right subtree'\n traverse(node.right)\n traverse(root)\n return res\n\n\n'''\nIn binary tree traversal, the way nodes are visited differs based on the type of traversal. Here are the three main types:\n\n1. **Inorder Traversal**:\n - **Order**: Left subtree, Root, Right subtree.\n - **Description**: This traversal visits the left child first, then the root node, and finally the right child. In a binary search tree, this results in visiting the nodes in ascending order.\n\n2. **Preorder Traversal**:\n - **Order**: Root, Left subtree, Right subtree.\n - **Description**: This traversal visits the root node first, followed by the left child, and then the right child. It’s useful for creating a copy of the tree or for prefix expression notation.\n\n3. **Postorder Traversal**:\n - **Order**: Left subtree, Right subtree, Root.\n - **Description**: This traversal visits the left child first, then the right child, and finally the root node. It’s often used for deleting a tree or for postfix expression notation.\n\n### Summary of Orders:\n- **Inorder**: Left → Root → Right\n- **Preorder**: Root → Left → Right\n- **Postorder**: Left → Right → Root\n\nEach traversal serves different purposes depending on the requirements of the algorithm or operation being performed on the tree.\n'''","runtime":"36"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res=[]\n def traverse(node):\n if node is not None:\n # preorder: \\U0001f9b7↙️↘️\n res.append(node.val)\n traverse(node.left)\n traverse(node.right)\n traverse(root)\n return res","runtime":"37"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res=[]\n def preorder(node):\n if not node:\n return \n res.append(node.val)\n preorder(node.left)\n preorder(node.right)\n preorder(root)\n return res","runtime":"37"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root :\n return []\n queue=[root]\n output=[]\n while queue:\n node=queue.pop(0)\n output.append(node.val)\n if node is not None:\n if node.right is not None:\n queue.insert(0,node.right)\n if node.left is not None:\n queue.insert(0,node.left)\n\n return output","runtime":"38"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n\n if not root:\n return []\n\n res = []\n \n def traversal(root):\n if root:\n res.append(root.val)\n if root.left:\n traversal(root.left)\n if root.right:\n traversal(root.right)\n \n traversal(root)\n return res\n\n\n\n ","runtime":"38"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if root is None:\n return []\n stack=[]\n stack.append(root)\n ans=[]\n while stack:\n node=stack.pop()\n ans.append(node.val)\n if node.right is not None:\n stack.append(node.right)\n if node.left is not None:\n stack.append(node.left)\n return ans\n\n ","runtime":"39"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n def helper(node):\n if not node:\n return node\n result.append(node.val)\n\n helper(node.left)\n helper(node.right)\n\n helper(root)\n return result\n\n \n\n\n ","runtime":"39"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n stack = [root]\n ans = []\n\n while stack:\n out = stack.pop()\n if out:\n ans.append(out.val)\n stack.append(out.right)\n stack.append(out.left)\n \n return ans","runtime":"40"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n def dfs(currentNode,res):\n if not currentNode:\n return\n res.append(currentNode.val)\n dfs(currentNode.left,res)\n dfs(currentNode.right,res)\n dfs(root,res)\n return res","runtime":"40"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n def dfs(root):\n if not root:\n return\n \n res.append(root.val)\n dfs(root.left)\n dfs(root.right)\n return\n dfs(root)\n return res\n \n ","runtime":"41"},{"code":"class Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def dfs(root):\n if root is None:\n return\n ans.append(root.val)\n dfs(root.left)\n dfs(root.right)\n\n ans = []\n dfs(root)\n return ans\n","runtime":"41"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n def preorder_bis(self, root, L):\n if root:\n L.append(root.val)\n preorder_bis(self, root.left, L)\n preorder_bis(self, root.right, L)\n return L\n\n return preorder_bis(self, root, res)\n","runtime":"42"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n\n stack = [root]\n res = []\n\n while stack:\n cur = stack.pop()\n res.append(cur.val)\n\n if cur.right:\n stack.append(cur.right)\n \n if cur.left:\n stack.append(cur.left)\n \n return res","runtime":"42"}],"string":"[\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n stack = [root]\\n result=[]\\n while stack:\\n node=stack.pop()\\n result.append(node.val)\\n if node.right:\\n stack.append(node.right)\\n if node.left:\\n stack.append(node.left)\\n return result\\n\",\n \"runtime\": \"11\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n self.pre_helper(root,res)\\n return res\\n \\n def pre_helper(self,root,res):\\n if not root:\\n return\\n res.append(root.val)\\n self.pre_helper(root.left,res)\\n self.pre_helper(root.right,res)\",\n \"runtime\": \"12\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res=[]\\n def pT(node):\\n if node is None:\\n return []\\n res.append(node.val)\\n pT(node.left)\\n pT(node.right)\\n \\n pT(root)\\n return res\",\n \"runtime\": \"15\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n\\n def preorderHelper(node):\\n if node == None:\\n return\\n # Root Left Right\\n res.append(node.val)\\n preorderHelper(node.left)\\n preorderHelper(node.right)\\n \\n preorderHelper(root)\\n\\n return res\\n\",\n \"runtime\": \"16\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\nclass TreeNode:\\n def __init__(self, val=0, left=None, right=None):\\n self.val = val\\n self.left = left\\n self.right = right\\nclass Solution:\\n def __init__(self):\\n self.arr=[]\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if root==None:\\n return\\n \\n self.arr.append(root.val)\\n self.preorderTraversal(root.left)\\n self.preorderTraversal(root.right)\\n return self.arr\\n\\n \\n \",\n \"runtime\": \"16\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n\\n def dfs(node, res):\\n if not node:\\n return\\n \\n res.append(node.val)\\n dfs(node.left, res)\\n dfs(node.right, res)\\n dfs(root, res)\\n return res\",\n \"runtime\": \"17\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if root is None:\\n return []\\n # Preorder: root -> left -> right\\n return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]: \\n ans = []\\n def preorderHelper(root):\\n if root is None:\\n return ans\\n \\n ans.append(root.val)\\n preorderHelper(root.left)\\n preorderHelper(root.right)\\n \\n preorderHelper(root)\\n return ans\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def __init__(self):\\n self.result = []\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return root\\n stack = []\\n stack.append(root)\\n res = []\\n \\n while stack:\\n tmp = stack.pop()\\n res.append(tmp.val)\\n if tmp.right != None:\\n stack.append(tmp.right)\\n if tmp.left != None:\\n stack.append(tmp.left)\\n return res\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nfrom collections import deque\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n # res = list()\\n # def preorder(root):\\n # if root==None:\\n # return\\n # res.append(root.val)\\n # preorder(root.left)\\n # preorder(root.right)\\n # preorder(root)\\n # return res\\n\\n res = list()\\n st = deque()\\n if root == None:\\n return res\\n st.append(root)\\n while len(st) != 0:\\n element = st.pop()\\n res.append(element.val)\\n if element.right != None:\\n st.append(element.right)\\n if element.left != None:\\n st.append(element.left)\\n return res\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def pre(node):\\n if node:\\n res.append(node.val)\\n pre(node.left)\\n pre(node.right)\\n else:\\n return\\n res = []\\n pre(root)\\n return res\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\nclass LeetCode:\\n\\n \\n\\n def P144(self, root):\\n\\n \\n\\n result = []\\n\\n \\n\\n def dfs(node):\\n\\n \\n\\n if not node:\\n\\n return\\n\\n \\n\\n \\n\\n # Visit root\\n\\n result.append(node.val) \\n\\n \\n\\n # Visit left subtree\\n\\n dfs(node.left)\\n\\n \\n\\n \\n\\n # Visit right subtree\\n\\n dfs(node.right)\\n\\n \\n\\n dfs(root)\\n\\n return result \\nclass Solution(LeetCode):\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n return self.P144(root)\\n \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n \\n if root is None:\\n return []\\n\\n res = []\\n res.append(root.val)\\n res += self.preorderTraversal(root.left)\\n res += self.preorderTraversal(root.right)\\n\\n return res \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n preorder=[]\\n curr=root\\n while curr is not None:\\n if curr.left is None:\\n preorder.append(curr.val)\\n curr=curr.right\\n else:\\n prev=curr.left\\n while prev.right and prev.right!=curr:\\n prev=prev.right\\n if prev.right is None:\\n prev.right=curr\\n preorder.append(curr.val)\\n curr=curr.left\\n else:\\n prev.right=None\\n \\n curr=curr.right\\n return preorder\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n\\n def helper(root):\\n if not root:\\n return res\\n \\n res.append(root.val)\\n helper(root.left)\\n helper(root.right)\\n helper(root)\\n return res\\n \",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\nclass TreeNode:\\n def __init__(self, val=0, left=None, right=None):\\n self.val = val\\n self.left = left\\n self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n l=[]\\n def traverse(node):\\n if node:\\n l.append(node.val)\\n traverse(node.left)\\n traverse(node.right)\\n \\n traverse(root)\\n \\n return l\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def __init__(self):\\n self.arr=[]\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if root is not None:\\n self.arr.append(root.val)\\n self.preorderTraversal(root.left)\\n self.preorderTraversal(root.right)\\n return self.arr\\n \",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n l=[]\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n self.l=[]\\n def pre(root):\\n if root:\\n self.l.append(root.val)\\n\\n pre(root.left)\\n pre(root.right)\\n pre(root)\\n return self.l\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n # preorder: root->left->right\\n res = []\\n def dfs(node):\\n if not node:\\n return\\n res.append(node.val)\\n dfs(node.left)\\n dfs(node.right)\\n dfs(root)\\n return res\\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n\\n def traverse(node):\\n if not node:\\n return\\n \\n res.append(node.val)\\n traverse(node.left)\\n traverse(node.right)\\n \\n traverse(root)\\n\\n return res\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n arry=[]\\n def dfs(node):\\n if node is None:\\n return None\\n arry.append(node.val)\\n return dfs(node.left) or dfs(node.right)\\n dfs(root)\\n return arry\\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Time complexity: we visit each node exactly once, thus the time complexity is O(N), where N is the number of nodes, i.e. the size of the tree.\\n\\n# Space complexity: depending on the tree structure, we could keep up to the entire tree, therefore, the space complexity is O(N).\\n\\n# Iterative\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n result = []\\n stack = [root]\\n while stack:\\n node = stack.pop()\\n result.append(node.val)\\n\\n if node.right:\\n stack.append(node.right)\\n if node.left:\\n stack.append(node.left)\\n return result\\n\\n \\n \\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n lis = []\\n if root is None:\\n return\\n def preorder(root):\\n if root is None:\\n return\\n lis.append(root.val)\\n preorder(root.left)\\n preorder(root.right)\\n preorder(root)\\n return lis\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode], arr = []) -> List[int]:\\n # current = root\\n # if current is None:\\n # return arr\\n # arr.append(current.val)\\n # self.preorderTraversal(current.left, arr)\\n # self.preorderTraversal(current.right, arr)\\n ans = []\\n st = [root]\\n\\n while st:\\n temp = st.pop()\\n if temp:\\n ans.append(temp.val)\\n st.append(temp.right) # 2nd element to be popped\\n st.append(temp.left) # 1st element to be popped\\n \\n return ans\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def helper(self, root, result):\\n if not root:\\n return\\n result.append(root.val)\\n if root.left:\\n self.helper(root.left, result)\\n if root.right:\\n self.helper(root.right, result)\\n \\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n self.helper(root, result)\\n return result\\n\\n\\n\\n\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def preorderTraversal(self, root: TreeNode | None) -> list[int]:\\n ans = []\\n\\n def preorder(root: TreeNode | None) -> None:\\n if not root:\\n return\\n\\n ans.append(root.val)\\n preorder(root.left)\\n preorder(root.right)\\n\\n preorder(root)\\n return ans\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def dfs(root):\\n if root is None:\\n return\\n ans.append(root.val)\\n dfs(root.left)\\n dfs(root.right)\\n\\n ans = []\\n dfs(root)\\n return ans\\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def dfs(root):\\n if root is None:\\n return\\n ans.append(root.val)\\n dfs(root.left)\\n dfs(root.right)\\n\\n ans = []\\n dfs(root)\\n return ans\\n\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n stack=[]\\n cur=root\\n res=[]\\n while stack or cur:\\n while cur:\\n stack.append(cur.right)\\n res.append(cur.val)\\n cur=cur.left\\n cur=stack.pop()\\n return res\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\ndef solve(root, ans):\\n if root is None:\\n return\\n\\n ans.append(root.val)\\n solve(root.left,ans)\\n solve(root.right,ans)\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n order = []\\n stack = [root]\\n while stack:\\n node = stack.pop()\\n order.append(node.val)\\n if node.right:\\n stack.append(node.right)\\n if node.left:\\n stack.append(node.left)\\n\\n return order\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\n\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n\\n output: List[int] = []\\n\\n # process this node\\n output.append(root.val)\\n\\n # go left\\n output += self.preorderTraversal(root.left)\\n\\n # go right\\n output += self.preorderTraversal(root.right)\\n\\n return output\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n # preorder: root, left subtree, right subtree\\n # M1: recursive\\n ans = list()\\n def dfs(root):\\n if root is None:\\n return\\n ans.append(root.val)\\n dfs(root.left)\\n dfs(root.right)\\n dfs(root)\\n return ans\\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\n\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n \\n # Recursive implementation of the pre-order:\\n \\n def dfs(node, arr):\\n if not node:\\n return arr\\n arr.append(node.val)\\n arr = dfs(node.left, arr)\\n arr = dfs(node.right, arr)\\n return arr\\n \\n # Iterative implementation\\n if not root:\\n return []\\n\\n stack = []\\n stack.append(root)\\n res = []\\n while len(stack) > 0:\\n node = stack.pop()\\n res.append(node.val)\\n if node.right is not None:\\n stack.append(node.right)\\n if node.left is not None:\\n stack.append(node.left)\\n \\n return res\\n \\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def dfs(root):\\n if root is None:\\n return\\n ans.append(root.val)\\n dfs(root.left)\\n dfs(root.right)\\n\\n ans = []\\n dfs(root)\\n return ans\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\n\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n \\n # Recursive implementation of the pre-order:\\n def dfs(node, arr):\\n if not node:\\n return arr\\n arr.append(node.val)\\n arr = dfs(node.left, arr)\\n arr = dfs(node.right, arr)\\n return arr\\n \\n return dfs(root, [])\\n \\n \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\n\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n output_list: List[int] = []\\n\\n def recursive_preorder(root: TreeNode | None) -> None:\\n if not root:\\n return\\n\\n # process this node\\n output_list.append(root.val)\\n\\n # go left\\n recursive_preorder(root.left)\\n\\n # go right\\n recursive_preorder(root.right)\\n\\n recursive_preorder(root)\\n\\n return output_list\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\ndef solve(root, ans):\\n if root is None:\\n return\\n\\n ans.append(root.val)\\n solve(root.left,ans)\\n solve(root.right,ans)\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n ans = []\\n solve(root,ans)\\n return ans\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n s = [root]\\n ans = []\\n while s:\\n n = s[-1]\\n s.remove(n)\\n ans.append(n.val)\\n if n.right: s.append(n.right)\\n if n.left: s.append(n.left)\\n return ans\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res=[]\\n def traverse(node):\\n if node is not None:\\n 'visit root'\\n res.append(node.val) \\n 'traverse left subtree'\\n traverse(node.left)\\n 'traverse right subtree'\\n traverse(node.right)\\n traverse(root)\\n return res\\n\\n\\n'''\\nIn binary tree traversal, the way nodes are visited differs based on the type of traversal. Here are the three main types:\\n\\n1. **Inorder Traversal**:\\n - **Order**: Left subtree, Root, Right subtree.\\n - **Description**: This traversal visits the left child first, then the root node, and finally the right child. In a binary search tree, this results in visiting the nodes in ascending order.\\n\\n2. **Preorder Traversal**:\\n - **Order**: Root, Left subtree, Right subtree.\\n - **Description**: This traversal visits the root node first, followed by the left child, and then the right child. It’s useful for creating a copy of the tree or for prefix expression notation.\\n\\n3. **Postorder Traversal**:\\n - **Order**: Left subtree, Right subtree, Root.\\n - **Description**: This traversal visits the left child first, then the right child, and finally the root node. It’s often used for deleting a tree or for postfix expression notation.\\n\\n### Summary of Orders:\\n- **Inorder**: Left → Root → Right\\n- **Preorder**: Root → Left → Right\\n- **Postorder**: Left → Right → Root\\n\\nEach traversal serves different purposes depending on the requirements of the algorithm or operation being performed on the tree.\\n'''\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res=[]\\n def traverse(node):\\n if node is not None:\\n # preorder: \\\\U0001f9b7↙️↘️\\n res.append(node.val)\\n traverse(node.left)\\n traverse(node.right)\\n traverse(root)\\n return res\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res=[]\\n def preorder(node):\\n if not node:\\n return \\n res.append(node.val)\\n preorder(node.left)\\n preorder(node.right)\\n preorder(root)\\n return res\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root :\\n return []\\n queue=[root]\\n output=[]\\n while queue:\\n node=queue.pop(0)\\n output.append(node.val)\\n if node is not None:\\n if node.right is not None:\\n queue.insert(0,node.right)\\n if node.left is not None:\\n queue.insert(0,node.left)\\n\\n return output\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n\\n if not root:\\n return []\\n\\n res = []\\n \\n def traversal(root):\\n if root:\\n res.append(root.val)\\n if root.left:\\n traversal(root.left)\\n if root.right:\\n traversal(root.right)\\n \\n traversal(root)\\n return res\\n\\n\\n\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if root is None:\\n return []\\n stack=[]\\n stack.append(root)\\n ans=[]\\n while stack:\\n node=stack.pop()\\n ans.append(node.val)\\n if node.right is not None:\\n stack.append(node.right)\\n if node.left is not None:\\n stack.append(node.left)\\n return ans\\n\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n def helper(node):\\n if not node:\\n return node\\n result.append(node.val)\\n\\n helper(node.left)\\n helper(node.right)\\n\\n helper(root)\\n return result\\n\\n \\n\\n\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n stack = [root]\\n ans = []\\n\\n while stack:\\n out = stack.pop()\\n if out:\\n ans.append(out.val)\\n stack.append(out.right)\\n stack.append(out.left)\\n \\n return ans\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n def dfs(currentNode,res):\\n if not currentNode:\\n return\\n res.append(currentNode.val)\\n dfs(currentNode.left,res)\\n dfs(currentNode.right,res)\\n dfs(root,res)\\n return res\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n def dfs(root):\\n if not root:\\n return\\n \\n res.append(root.val)\\n dfs(root.left)\\n dfs(root.right)\\n return\\n dfs(root)\\n return res\\n \\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def dfs(root):\\n if root is None:\\n return\\n ans.append(root.val)\\n dfs(root.left)\\n dfs(root.right)\\n\\n ans = []\\n dfs(root)\\n return ans\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n def preorder_bis(self, root, L):\\n if root:\\n L.append(root.val)\\n preorder_bis(self, root.left, L)\\n preorder_bis(self, root.right, L)\\n return L\\n\\n return preorder_bis(self, root, res)\\n\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n\\n stack = [root]\\n res = []\\n\\n while stack:\\n cur = stack.pop()\\n res.append(cur.val)\\n\\n if cur.right:\\n stack.append(cur.right)\\n \\n if cur.left:\\n stack.append(cur.left)\\n \\n return res\",\n \"runtime\": \"42\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":51,"string":"51"},"mm_list":{"kind":"list like","value":[{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n \n def preOrder(node, result):\n if node:\n result.append(node.val)\n preOrder(node.left, result)\n preOrder(node.right, result)\n \n result = []\n preOrder(root, result)\n return result","memory":"15800"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return\n result = []\n stack = [root]\n while stack:\n cur = stack.pop()\n result.append(cur.val)\n if cur.right:\n stack.append(cur.right)\n if cur.left:\n stack.append(cur.left)\n return result","memory":"15900"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n if not(root.left or root.right):\n return [root.val]\n output = []\n next_node = [root]\n while len(next_node) != 0:\n current = next_node.pop(0)\n output.append(current.val)\n if current.right:\n next_node.insert(0, current.right)\n if current.left:\n next_node.insert(0, current.left)\n return output\n","memory":"16100"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n stack = []\n while root or stack:\n if root:\n result.append(root.val)\n stack.append(root)\n root = root.left\n else:\n root = stack.pop()\n root = root.right\n return result","memory":"16200"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n nums = []\n def rec(root, nums):\n if root is None:\n return\n nums.append(root.val)\n if root.left is not None:\n rec(root.left, nums)\n if root.right is not None:\n rec(root.right, nums)\n \n return nums\n\n return rec(root, nums)\n","memory":"16300"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if root is None:\n return []\n stack=[]\n stack.append(root)\n ans=[]\n while stack:\n node=stack.pop()\n ans.append(node.val)\n if node.right is not None:\n stack.append(node.right)\n if node.left is not None:\n stack.append(node.left)\n return ans\n\n ","memory":"16300"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n def helper(node):\n if not node:\n return node\n result.append(node.val)\n\n helper(node.left)\n helper(node.right)\n\n helper(root)\n return result\n\n \n\n\n ","memory":"16400"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n arr = []\n curr = root\n while curr != None:\n if curr.left is None:\n arr.append(curr.val)\n curr = curr.right\n else:\n prev = curr.left\n while prev.right and prev.right != curr:\n prev = prev.right\n if prev.right is None:\n prev.right = curr\n arr.append(curr.val)\n curr = curr.left\n else:\n prev.right = None\n curr = curr.right\n return arr","memory":"16400"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\nclass Solution:\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n\n stack = [root]\n res = []\n\n while stack:\n node = stack.pop()\n res.append(node.val)\n\n if node.right:\n stack.append(node.right)\n if node.left:\n stack.append(node.left)\n\n return res","memory":"16500"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def traverse(self, root, result):\n if not root:\n return result\n\n result.append(root.val)\n self.traverse(root.left, result)\n self.traverse(root.right, result)\n \n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n self.traverse(root, result)\n return result\n ","memory":"16500"}],"string":"[\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n \\n def preOrder(node, result):\\n if node:\\n result.append(node.val)\\n preOrder(node.left, result)\\n preOrder(node.right, result)\\n \\n result = []\\n preOrder(root, result)\\n return result\",\n \"memory\": \"15800\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return\\n result = []\\n stack = [root]\\n while stack:\\n cur = stack.pop()\\n result.append(cur.val)\\n if cur.right:\\n stack.append(cur.right)\\n if cur.left:\\n stack.append(cur.left)\\n return result\",\n \"memory\": \"15900\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n if not(root.left or root.right):\\n return [root.val]\\n output = []\\n next_node = [root]\\n while len(next_node) != 0:\\n current = next_node.pop(0)\\n output.append(current.val)\\n if current.right:\\n next_node.insert(0, current.right)\\n if current.left:\\n next_node.insert(0, current.left)\\n return output\\n\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n stack = []\\n while root or stack:\\n if root:\\n result.append(root.val)\\n stack.append(root)\\n root = root.left\\n else:\\n root = stack.pop()\\n root = root.right\\n return result\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n nums = []\\n def rec(root, nums):\\n if root is None:\\n return\\n nums.append(root.val)\\n if root.left is not None:\\n rec(root.left, nums)\\n if root.right is not None:\\n rec(root.right, nums)\\n \\n return nums\\n\\n return rec(root, nums)\\n\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if root is None:\\n return []\\n stack=[]\\n stack.append(root)\\n ans=[]\\n while stack:\\n node=stack.pop()\\n ans.append(node.val)\\n if node.right is not None:\\n stack.append(node.right)\\n if node.left is not None:\\n stack.append(node.left)\\n return ans\\n\\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n def helper(node):\\n if not node:\\n return node\\n result.append(node.val)\\n\\n helper(node.left)\\n helper(node.right)\\n\\n helper(root)\\n return result\\n\\n \\n\\n\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n arr = []\\n curr = root\\n while curr != None:\\n if curr.left is None:\\n arr.append(curr.val)\\n curr = curr.right\\n else:\\n prev = curr.left\\n while prev.right and prev.right != curr:\\n prev = prev.right\\n if prev.right is None:\\n prev.right = curr\\n arr.append(curr.val)\\n curr = curr.left\\n else:\\n prev.right = None\\n curr = curr.right\\n return arr\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\nclass Solution:\\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n\\n stack = [root]\\n res = []\\n\\n while stack:\\n node = stack.pop()\\n res.append(node.val)\\n\\n if node.right:\\n stack.append(node.right)\\n if node.left:\\n stack.append(node.left)\\n\\n return res\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def traverse(self, root, result):\\n if not root:\\n return result\\n\\n result.append(root.val)\\n self.traverse(root.left, result)\\n self.traverse(root.right, result)\\n \\n def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n self.traverse(root, result)\\n return result\\n \",\n \"memory\": \"16500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":10,"string":"10"}}},{"rowIdx":49,"cells":{"question_id":{"kind":"number","value":145,"string":"145"},"name":{"kind":"string","value":"binary-tree-postorder-traversal"},"content":{"kind":"string","value":"<p>Given the <code>root</code> of a binary tree, return <em>the postorder traversal of its nodes' values</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">root = [1,null,2,3]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[3,2,1]</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png\" style=\"width: 200px; height: 264px;\" /></p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">root = [1,2,3,4,5,null,8,null,null,6,7,9]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[4,6,7,5,2,9,8,3,1]</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/08/29/tree_2.png\" style=\"width: 350px; height: 286px;\" /></p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">root = []</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[]</span></p>\n</div>\n\n<p><strong class=\"example\">Example 4:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">root = [1]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[1]</span></p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of the nodes in the tree is in the range <code>[0, 100]</code>.</li>\n\t<li><code>-100 <= Node.val <= 100</code></li>\n</ul>\n\n<p> </p>\n<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?"},"acRate":{"kind":"number","value":73.43801444509738,"string":"73.438014"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["stack","tree","depth-first-search","binary-tree"],"string":"[\n \"stack\",\n \"tree\",\n \"depth-first-search\",\n \"binary-tree\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"7\", 0.003], [\"12\", 0.0089], [\"14\", 0.0089], [\"15\", 0.0238], [\"16\", 0.0356], [\"17\", 0.0208], [\"18\", 0.0831], [\"19\", 0.2138], [\"20\", 0.1573], [\"21\", 0.1484], [\"22\", 0.6502], [\"23\", 0.6056], [\"24\", 0.8461], [\"25\", 0.9322], [\"26\", 2.5413], [\"27\", 1.8228], [\"28\", 2.3691], [\"29\", 3.3221], [\"30\", 6.1929], [\"31\", 4.2453], [\"32\", 4.3522], [\"33\", 6.6233], [\"34\", 9.8385], [\"35\", 6.0741], [\"36\", 5.6911], [\"37\", 8.8677], [\"38\", 8.939], [\"39\", 5.6822], [\"40\", 4.2157], [\"41\", 5.0558], [\"42\", 3.8386]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15900\", 0.003], [\"16000\", 0.003], [\"16100\", 0.0327], [\"16200\", 0.2108], [\"16300\", 4.2038], [\"16400\", 25.5077], [\"16500\", 49.4181]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n order = []\n stack = [root]\n while stack:\n node = stack.pop()\n order.append(node.val)\n if node.left:\n stack.append(node.left)\n if node.right:\n stack.append(node.right)\n\n return order[::-1]\n\n \n","runtime":"7"},{"code":"\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n def pot(root):\n if root:\n pot(root.left)\n pot(root.right)\n res.append(root.val)\n pot(root)\n return res","runtime":"12"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n ans = []\n def postorder(node):\n if not node:\n return\n postorder(node.left)\n postorder(node.right)\n ans.append(node.val)\n postorder(root)\n return ans","runtime":"12"},{"code":"class Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n self.ans=[]\n self.Traversal(root)\n return self.ans\n\n def Traversal(self,root):\n if root is None:\n return\n self.Traversal(root.left)\n self.Traversal(root.right)\n self.ans.append(root.val)\n \n ","runtime":"14"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n def dfs(node):\n if not node:\n return \n dfs(node.left)\n dfs(node.right)\n res.append(node.val)\n dfs(root)\n return res\n ","runtime":"15"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n results = []\n def dfs(root):\n if root is None:\n return\n if root.left: dfs(root.left)\n if root.right: dfs(root.right)\n results.append(root.val)\n dfs(root)\n return results","runtime":"16"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n val = []\n\n def dfs(node):\n if not node:\n return None\n dfs(node.left)\n dfs(node.right)\n val.append(node.val)\n dfs(root)\n return val","runtime":"17"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n stack, value = [root], [False]\n res = []\n\n while stack:\n n, v = stack.pop(), value.pop()\n if n:\n if v:\n res.append(n.val)\n else:\n stack.append(n)\n value.append(True)\n stack.append(n.right)\n value.append(False)\n stack.append(n.left)\n value.append(False)\n \n return res","runtime":"18"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n postorder = []\n\n def dfs(node):\n if node is None: return\n dfs(node.left)\n dfs(node.right)\n postorder.append(node.val)\n \n dfs(root)\n return postorder","runtime":"19"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorder(self,root,ans):\n if root==None:\n return \n self.postorder(root.left,ans)\n self.postorder(root.right,ans)\n ans.append(root.val) \n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n ans = []\n self.postorder(root,ans)\n return ans","runtime":"20"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if root is None: return []\n else:\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]\n ","runtime":"20"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n '''\n #postorder: left,right,root\n res = []\n if root:\n res += self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]\n return res\n '''\n # iterative\n # use stack, left right root, modifed preorder results\n # push item to the stack in the way if root, left, right \n # ele at res in the order of root right left, reverse it will be left right root \n if not root:\n return []\n stack = [root]\n res = []\n while stack:\n cur = stack.pop()\n res.append(cur.val)\n if cur.left:\n stack.append(cur.left)\n if cur.right:\n stack.append(cur.right)\n return res[::-1]\n \n \n ","runtime":"21"},{"code":"from typing import List, Optional\n\nclass TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\n\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def postorder(node: Optional[TreeNode]) -> List[int]:\n if node is None:\n return []\n # Recursively traverse left and right subtrees, then visit the root\n return postorder(node.left) + postorder(node.right) + [node.val]\n \n return postorder(root)\n","runtime":"22"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n stack = []\n curr = root\n while curr or stack:\n if curr:\n stack.append(curr)\n res.append(curr.val)\n curr = curr.right\n else:\n p = stack.pop()\n curr = p.left\n res.reverse()\n return res","runtime":"22"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n\n ans = []\n def helper(node):\n if not node: return\n helper(node.left)\n helper(node.right)\n ans.append(node.val)\n\n helper(root)\n return ans\n ","runtime":"23"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n# class Solution:\n# def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n# res = []\n# self.traverse(root, res)\n# return res\n \n# def traverse(self, root, res):\n# if root is None:\n# return\n# self.traverse(root.left, res)\n# self.traverse(root.right, res)\n# res.append(root.val)\n\n# class Solution:\n# def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n# res = []\n# if root is None:\n# return res\n# res.extend(self.postorderTraversal(root.left))\n# res.extend(self.postorderTraversal(root.right))\n# res.append(root.val)\n# return res\n\n# class Solution:\n# def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n# res = []\n# stack = []\n# # 保存前一个访问的节点，用于确定当前节点的右子树是否访问完毕\n# prev = None \n# # 根节点或栈不为空\n# while root or stack: \n# while root:\n# # 将当前树的根节点入栈\n# stack.append(root) \n# # 继续访问左子树，找到最左侧节点\n# root = root.left \n \n# # 遍历到最左侧，当前节点无左子树时，将最左侧节点弹出\n# cur = stack.pop() \n\n# # 若当前节点无右子树或者右子树访问完毕\n# if not cur.right or cur.right == prev:\n# # 访问该节点\n# res.append(cur.val)\n# # 记录前一节点\n# prev = cur \n# # 将当前根节点标记为空 \n# root = None \n# else:\n# # 右子树尚未访问完毕，将当前节点重新压回栈中\n# stack.append(cur) \n# # 继续访问右子树\n# root = cur.right \n \n# return res\n\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n if not root:\n return []\n stack = [root]\n while stack:\n cur = stack.pop()\n # 中结点先处理\n res.append(cur.val)\n # 左孩子先入栈\n if cur.left:\n stack.append(cur.left)\n # 右孩子后入栈\n if cur.right:\n stack.append(cur.right)\n # 将最终的数组翻转\n return res[::-1]\n ","runtime":"23"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n def aux_dfs(node, result):\n if node.left:\n aux_dfs(node.left, result)\n if node.right:\n aux_dfs(node.right, result)\n result.append(node.val)\n \n result = []\n aux_dfs(root, result)\n return result\n","runtime":"24"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n visit = [False] \n stack = [root]\n res = [] \n \n while stack: \n curr, visited = stack.pop(), visit.pop() \n if curr:\n if visited: \n res.append(curr.val)\n else:\n stack.append(curr)\n visit.append(True)\n\n stack.append(curr.right)\n visit.append(False)\n stack.append(curr.left)\n visit.append(False)\n return res \n \n \n \n \n ","runtime":"24"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n \n ret = []\n\n left_list = self.postorderTraversal(root.left)\n right_list = self.postorderTraversal(root.right)\n\n return left_list + right_list + [root.val]\n ","runtime":"25"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def post(root, arr):\n if root:\n post(root.left, arr)\n post(root.right, arr)\n arr.append(root.val)\n arr = []\n post(root, arr)\n return arr","runtime":"26"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n traversal_stack = []\n current_node = root\n\n while current_node or traversal_stack:\n if current_node:\n result.append(current_node.val)\n traversal_stack.append(current_node)\n current_node = current_node.right\n else:\n current_node = traversal_stack.pop()\n current_node = current_node.left\n \n result.reverse()\n return result","runtime":"26"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n ans=[]\n def pot(root):\n if root is not None:\n pot(root.left)\n pot(root.right)\n ans.append(root.val)\n return ans\n return pot(root)\n\n\n ","runtime":"27"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n\n def prenode(node):\n if node is None:\n return\n prenode(node.left)\n prenode(node.right)\n result.append(node.val)\n \n prenode(root)\n return result","runtime":"27"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n\n def dfs(root, result):\n if root == None:\n return\n dfs(root.left, result)\n dfs(root.right, result)\n result.append(root.val)\n \n dfs(root, result)\n\n return result","runtime":"28"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n ans = []\n\n # def DFS(root):\n # nonlocal ans\n # if not root:\n # return\n \n # DFS(root.left)\n # DFS(root.right)\n # ans.append(root.val)\n\n # DFS(root)\n stack = []\n res = []\n currNode = root\n while stack or currNode:\n if currNode:\n res.append(currNode.val)\n stack.append(currNode)\n currNode = currNode.right\n else:\n currNode = stack.pop()\n currNode = currNode.left\n \n res.reverse()\n return res\n \n \n \n\n\n return ans\n\n\n \n \n ","runtime":"28"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n res = []\n\n def dfs(root):\n if not root:\n return\n \n res.append(root.val)\n\n dfs(root.right)\n dfs(root.left)\n\n dfs(root)\n return res[::-1]","runtime":"29"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n stack = []\n res = []\n stack.append(root)\n while(stack):\n node = stack.pop()\n if node is None:\n continue\n res.append(node.val)\n stack.append(node.left)\n stack.append(node.right)\n res.reverse()\n return res","runtime":"29"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n num = []\n def f(root):\n if root == None:\n return num\n f(root.left)\n f(root.right)\n num.append(root.val)\n return num\n return f(root)\n\n\n \n\n","runtime":"30"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def dfs(root):\n if root is None:\n return\n dfs(root.left)\n dfs(root.right)\n ans.append(root.val)\n\n ans = []\n dfs(root)\n return ans","runtime":"30"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n return self.postorderTraversal(root.left)+self.postorderTraversal(root.right)+[root.val]","runtime":"31"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n stack=[root]\n res=[]\n visit=[False]\n while stack:\n cur,v=stack.pop(),visit.pop()\n if cur:\n if v:\n res.append(cur.val)\n else:\n stack.append(cur)\n visit.append(True)\n stack.append(cur.right)\n visit.append(False)\n stack.append(cur.left)\n visit.append(False)\n return res\n","runtime":"31"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def dfs(root):\n if root is None:\n return\n dfs(root.left)\n dfs(root.right)\n ans.append(root.val)\n\n ans = []\n dfs(root)\n return ans","runtime":"32"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def postOrder(l, root):\n if root is not None:\n postOrder(l, root.left)\n postOrder(l, root.right)\n l.append(root.val)\n return l\n return postOrder([], root) ","runtime":"32"},{"code":"# Definition for a binary tree node.\nclass TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\n\nclass Solution:\n def postorderTraversal(self, root: TreeNode) -> List[int]:\n def recurse(node):\n if not node:\n return []\n return recurse(node.left) + recurse(node.right) + [node.val]\n \n return recurse(root)\n\n\nfrom typing import List, Optional\n\n# Definition for a binary tree node.\nclass TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\n\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n \n stack, output = [root], []\n \n while stack:\n node = stack.pop()\n output.append(node.val)\n if node.left:\n stack.append(node.left)\n if node.right:\n stack.append(node.right)\n \n return output[::-1] # reverse the output list to get the correct postorder traversal","runtime":"33"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n if root == None:\n return res\n if root.left != None:\n res.extend(self.postorderTraversal(root.left)) \n if root.right != None:\n res.extend(self.postorderTraversal(root.right))\n res.append(root.val)\n return res","runtime":"33"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n ans = []\n\n def dfs(root):\n if root:\n dfs(root.left)\n dfs(root.right)\n ans.append(root.val)\n \n dfs(root)\n \n return ans","runtime":"34"},{"code":"class Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n def dfs(root):\n if root is None:\n return\n dfs(root.left)\n dfs(root.right)\n ans.append(root.val)\n\n ans = []\n dfs(root)\n return ans","runtime":"34"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root: return []\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]","runtime":"36"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\ndef postorder(root, arr):\n if not root:\n return\n \n postorder(root.left, arr)\n postorder(root.right, arr)\n arr.append(root.val)\n\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n ans = []\n postorder(root, ans)\n return ans\n","runtime":"36"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n\n def traversal(node):\n if node is None:\n return\n\n traversal(node.left)\n\n traversal(node.right)\n\n result.append(node.val)\n\n traversal(root)\n\n return result","runtime":"37"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n ans = []\n\n def postorder(node):\n if node:\n if node.left:\n postorder(node.left)\n if node.right:\n postorder(node.right)\n ans.append(node.val)\n \n postorder(root)\n return ans","runtime":"37"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n num=[]\n def f(root):\n if root==None:return num\n f(root.left)\n f(root.right)\n num.append(root.val)\n return num\n return f(root)","runtime":"38"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n results = []\n def traverse(current_node):\n if current_node.left is not None:\n traverse(current_node.left)\n if current_node.right is not None:\n traverse(current_node.right)\n if current_node:\n results.append(current_node.val)\n\n if root is not None:\n traverse(root)\n return results\n return []\n ","runtime":"38"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n ans = []\n stack = [root]\n while stack:\n node = stack.pop()\n ans.append(node.val)\n\n if node.left:\n stack.append(node.left)\n if node.right:\n stack.append(node.right)\n return ans[::-1]\n ","runtime":"39"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n stack=[]\n visited=set()\n curr=root\n res=[]\n while curr or stack:\n if curr:\n stack.append(curr)\n curr=curr.left\n if not curr:\n if stack[-1] not in visited:\n visited.add(stack[-1])\n curr=stack[-1].right\n else:\n res.append(stack.pop().val)\n curr=None\n return res\n\n\n ","runtime":"39"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val] if root else []\n ","runtime":"40"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]","runtime":"40"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if root is None:\n return []\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]","runtime":"41"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n \n stack, res = [], [] \n last_visited = None\n\n while stack or root:\n if root:\n stack.append(root)\n root = root.left\n else:\n peek_node = stack[-1]\n if peek_node.right and last_visited != peek_node.right:\n root = peek_node.right\n else:\n stack.pop()\n res.append(peek_node.val)\n last_visited = peek_node\n return res\n\n\n # if not root:\n # return []\n \n # stack = []\n # result = []\n # last_visited = None\n \n # while stack or root:\n # if root:\n # stack.append(root)\n # root = root.left\n # else:\n # peek_node = stack[-1]\n # if peek_node.right and last_visited != peek_node.right:\n # root = peek_node.right\n # else:\n # stack.pop()\n # result.append(peek_node.val)\n # last_visited = peek_node\n \n # return result\n","runtime":"41"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n \n # Recursive Solution\n def dfs(node, arr):\n if not node:\n return arr\n arr = dfs(node.left, arr)\n arr = dfs(node.right, arr)\n arr.append(node.val)\n return arr\n \n # Iterative Solution\n if not root:\n return []\n s1 = []\n s2 = []\n s1.append(root)\n while s1:\n node = s1.pop()\n s2.append(node)\n if node.left:\n s1.append(node.left)\n if node.right:\n s1.append(node.right)\n res = []\n while s2:\n node = s2.pop()\n res.append(node.val)\n return res","runtime":"42"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nfrom collections import deque\n\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n values=deque([root])\n out=[]\n while len(values)!=0:\n last=values.pop()\n if type(last)==type(1):\n out.append(last)\n else:\n values.append(last.val)\n if last.right:\n values.append(last.right)\n if last.left:\n values.append(last.left)\n return out","runtime":"42"}],"string":"[\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n order = []\\n stack = [root]\\n while stack:\\n node = stack.pop()\\n order.append(node.val)\\n if node.left:\\n stack.append(node.left)\\n if node.right:\\n stack.append(node.right)\\n\\n return order[::-1]\\n\\n \\n\",\n \"runtime\": \"7\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n def pot(root):\\n if root:\\n pot(root.left)\\n pot(root.right)\\n res.append(root.val)\\n pot(root)\\n return res\",\n \"runtime\": \"12\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n ans = []\\n def postorder(node):\\n if not node:\\n return\\n postorder(node.left)\\n postorder(node.right)\\n ans.append(node.val)\\n postorder(root)\\n return ans\",\n \"runtime\": \"12\"\n },\n {\n \"code\": \"class Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n self.ans=[]\\n self.Traversal(root)\\n return self.ans\\n\\n def Traversal(self,root):\\n if root is None:\\n return\\n self.Traversal(root.left)\\n self.Traversal(root.right)\\n self.ans.append(root.val)\\n \\n \",\n \"runtime\": \"14\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n def dfs(node):\\n if not node:\\n return \\n dfs(node.left)\\n dfs(node.right)\\n res.append(node.val)\\n dfs(root)\\n return res\\n \",\n \"runtime\": \"15\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n results = []\\n def dfs(root):\\n if root is None:\\n return\\n if root.left: dfs(root.left)\\n if root.right: dfs(root.right)\\n results.append(root.val)\\n dfs(root)\\n return results\",\n \"runtime\": \"16\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n val = []\\n\\n def dfs(node):\\n if not node:\\n return None\\n dfs(node.left)\\n dfs(node.right)\\n val.append(node.val)\\n dfs(root)\\n return val\",\n \"runtime\": \"17\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n stack, value = [root], [False]\\n res = []\\n\\n while stack:\\n n, v = stack.pop(), value.pop()\\n if n:\\n if v:\\n res.append(n.val)\\n else:\\n stack.append(n)\\n value.append(True)\\n stack.append(n.right)\\n value.append(False)\\n stack.append(n.left)\\n value.append(False)\\n \\n return res\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n postorder = []\\n\\n def dfs(node):\\n if node is None: return\\n dfs(node.left)\\n dfs(node.right)\\n postorder.append(node.val)\\n \\n dfs(root)\\n return postorder\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorder(self,root,ans):\\n if root==None:\\n return \\n self.postorder(root.left,ans)\\n self.postorder(root.right,ans)\\n ans.append(root.val) \\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n ans = []\\n self.postorder(root,ans)\\n return ans\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if root is None: return []\\n else:\\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]\\n \",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n '''\\n #postorder: left,right,root\\n res = []\\n if root:\\n res += self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]\\n return res\\n '''\\n # iterative\\n # use stack, left right root, modifed preorder results\\n # push item to the stack in the way if root, left, right \\n # ele at res in the order of root right left, reverse it will be left right root \\n if not root:\\n return []\\n stack = [root]\\n res = []\\n while stack:\\n cur = stack.pop()\\n res.append(cur.val)\\n if cur.left:\\n stack.append(cur.left)\\n if cur.right:\\n stack.append(cur.right)\\n return res[::-1]\\n \\n \\n \",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"from typing import List, Optional\\n\\nclass TreeNode:\\n def __init__(self, val=0, left=None, right=None):\\n self.val = val\\n self.left = left\\n self.right = right\\n\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def postorder(node: Optional[TreeNode]) -> List[int]:\\n if node is None:\\n return []\\n # Recursively traverse left and right subtrees, then visit the root\\n return postorder(node.left) + postorder(node.right) + [node.val]\\n \\n return postorder(root)\\n\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n stack = []\\n curr = root\\n while curr or stack:\\n if curr:\\n stack.append(curr)\\n res.append(curr.val)\\n curr = curr.right\\n else:\\n p = stack.pop()\\n curr = p.left\\n res.reverse()\\n return res\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n\\n ans = []\\n def helper(node):\\n if not node: return\\n helper(node.left)\\n helper(node.right)\\n ans.append(node.val)\\n\\n helper(root)\\n return ans\\n \",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n# class Solution:\\n# def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n# res = []\\n# self.traverse(root, res)\\n# return res\\n \\n# def traverse(self, root, res):\\n# if root is None:\\n# return\\n# self.traverse(root.left, res)\\n# self.traverse(root.right, res)\\n# res.append(root.val)\\n\\n# class Solution:\\n# def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n# res = []\\n# if root is None:\\n# return res\\n# res.extend(self.postorderTraversal(root.left))\\n# res.extend(self.postorderTraversal(root.right))\\n# res.append(root.val)\\n# return res\\n\\n# class Solution:\\n# def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n# res = []\\n# stack = []\\n# # 保存前一个访问的节点，用于确定当前节点的右子树是否访问完毕\\n# prev = None \\n# # 根节点或栈不为空\\n# while root or stack: \\n# while root:\\n# # 将当前树的根节点入栈\\n# stack.append(root) \\n# # 继续访问左子树，找到最左侧节点\\n# root = root.left \\n \\n# # 遍历到最左侧，当前节点无左子树时，将最左侧节点弹出\\n# cur = stack.pop() \\n\\n# # 若当前节点无右子树或者右子树访问完毕\\n# if not cur.right or cur.right == prev:\\n# # 访问该节点\\n# res.append(cur.val)\\n# # 记录前一节点\\n# prev = cur \\n# # 将当前根节点标记为空 \\n# root = None \\n# else:\\n# # 右子树尚未访问完毕，将当前节点重新压回栈中\\n# stack.append(cur) \\n# # 继续访问右子树\\n# root = cur.right \\n \\n# return res\\n\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n if not root:\\n return []\\n stack = [root]\\n while stack:\\n cur = stack.pop()\\n # 中结点先处理\\n res.append(cur.val)\\n # 左孩子先入栈\\n if cur.left:\\n stack.append(cur.left)\\n # 右孩子后入栈\\n if cur.right:\\n stack.append(cur.right)\\n # 将最终的数组翻转\\n return res[::-1]\\n \",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n def aux_dfs(node, result):\\n if node.left:\\n aux_dfs(node.left, result)\\n if node.right:\\n aux_dfs(node.right, result)\\n result.append(node.val)\\n \\n result = []\\n aux_dfs(root, result)\\n return result\\n\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n visit = [False] \\n stack = [root]\\n res = [] \\n \\n while stack: \\n curr, visited = stack.pop(), visit.pop() \\n if curr:\\n if visited: \\n res.append(curr.val)\\n else:\\n stack.append(curr)\\n visit.append(True)\\n\\n stack.append(curr.right)\\n visit.append(False)\\n stack.append(curr.left)\\n visit.append(False)\\n return res \\n \\n \\n \\n \\n \",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n \\n ret = []\\n\\n left_list = self.postorderTraversal(root.left)\\n right_list = self.postorderTraversal(root.right)\\n\\n return left_list + right_list + [root.val]\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def post(root, arr):\\n if root:\\n post(root.left, arr)\\n post(root.right, arr)\\n arr.append(root.val)\\n arr = []\\n post(root, arr)\\n return arr\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n traversal_stack = []\\n current_node = root\\n\\n while current_node or traversal_stack:\\n if current_node:\\n result.append(current_node.val)\\n traversal_stack.append(current_node)\\n current_node = current_node.right\\n else:\\n current_node = traversal_stack.pop()\\n current_node = current_node.left\\n \\n result.reverse()\\n return result\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n ans=[]\\n def pot(root):\\n if root is not None:\\n pot(root.left)\\n pot(root.right)\\n ans.append(root.val)\\n return ans\\n return pot(root)\\n\\n\\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n\\n def prenode(node):\\n if node is None:\\n return\\n prenode(node.left)\\n prenode(node.right)\\n result.append(node.val)\\n \\n prenode(root)\\n return result\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n\\n def dfs(root, result):\\n if root == None:\\n return\\n dfs(root.left, result)\\n dfs(root.right, result)\\n result.append(root.val)\\n \\n dfs(root, result)\\n\\n return result\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n ans = []\\n\\n # def DFS(root):\\n # nonlocal ans\\n # if not root:\\n # return\\n \\n # DFS(root.left)\\n # DFS(root.right)\\n # ans.append(root.val)\\n\\n # DFS(root)\\n stack = []\\n res = []\\n currNode = root\\n while stack or currNode:\\n if currNode:\\n res.append(currNode.val)\\n stack.append(currNode)\\n currNode = currNode.right\\n else:\\n currNode = stack.pop()\\n currNode = currNode.left\\n \\n res.reverse()\\n return res\\n \\n \\n \\n\\n\\n return ans\\n\\n\\n \\n \\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n res = []\\n\\n def dfs(root):\\n if not root:\\n return\\n \\n res.append(root.val)\\n\\n dfs(root.right)\\n dfs(root.left)\\n\\n dfs(root)\\n return res[::-1]\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n stack = []\\n res = []\\n stack.append(root)\\n while(stack):\\n node = stack.pop()\\n if node is None:\\n continue\\n res.append(node.val)\\n stack.append(node.left)\\n stack.append(node.right)\\n res.reverse()\\n return res\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n num = []\\n def f(root):\\n if root == None:\\n return num\\n f(root.left)\\n f(root.right)\\n num.append(root.val)\\n return num\\n return f(root)\\n\\n\\n \\n\\n\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def dfs(root):\\n if root is None:\\n return\\n dfs(root.left)\\n dfs(root.right)\\n ans.append(root.val)\\n\\n ans = []\\n dfs(root)\\n return ans\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n return self.postorderTraversal(root.left)+self.postorderTraversal(root.right)+[root.val]\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n stack=[root]\\n res=[]\\n visit=[False]\\n while stack:\\n cur,v=stack.pop(),visit.pop()\\n if cur:\\n if v:\\n res.append(cur.val)\\n else:\\n stack.append(cur)\\n visit.append(True)\\n stack.append(cur.right)\\n visit.append(False)\\n stack.append(cur.left)\\n visit.append(False)\\n return res\\n\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def dfs(root):\\n if root is None:\\n return\\n dfs(root.left)\\n dfs(root.right)\\n ans.append(root.val)\\n\\n ans = []\\n dfs(root)\\n return ans\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def postOrder(l, root):\\n if root is not None:\\n postOrder(l, root.left)\\n postOrder(l, root.right)\\n l.append(root.val)\\n return l\\n return postOrder([], root) \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\nclass TreeNode:\\n def __init__(self, val=0, left=None, right=None):\\n self.val = val\\n self.left = left\\n self.right = right\\n\\nclass Solution:\\n def postorderTraversal(self, root: TreeNode) -> List[int]:\\n def recurse(node):\\n if not node:\\n return []\\n return recurse(node.left) + recurse(node.right) + [node.val]\\n \\n return recurse(root)\\n\\n\\nfrom typing import List, Optional\\n\\n# Definition for a binary tree node.\\nclass TreeNode:\\n def __init__(self, val=0, left=None, right=None):\\n self.val = val\\n self.left = left\\n self.right = right\\n\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n \\n stack, output = [root], []\\n \\n while stack:\\n node = stack.pop()\\n output.append(node.val)\\n if node.left:\\n stack.append(node.left)\\n if node.right:\\n stack.append(node.right)\\n \\n return output[::-1] # reverse the output list to get the correct postorder traversal\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n if root == None:\\n return res\\n if root.left != None:\\n res.extend(self.postorderTraversal(root.left)) \\n if root.right != None:\\n res.extend(self.postorderTraversal(root.right))\\n res.append(root.val)\\n return res\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n ans = []\\n\\n def dfs(root):\\n if root:\\n dfs(root.left)\\n dfs(root.right)\\n ans.append(root.val)\\n \\n dfs(root)\\n \\n return ans\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n def dfs(root):\\n if root is None:\\n return\\n dfs(root.left)\\n dfs(root.right)\\n ans.append(root.val)\\n\\n ans = []\\n dfs(root)\\n return ans\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root: return []\\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\ndef postorder(root, arr):\\n if not root:\\n return\\n \\n postorder(root.left, arr)\\n postorder(root.right, arr)\\n arr.append(root.val)\\n\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n ans = []\\n postorder(root, ans)\\n return ans\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n\\n def traversal(node):\\n if node is None:\\n return\\n\\n traversal(node.left)\\n\\n traversal(node.right)\\n\\n result.append(node.val)\\n\\n traversal(root)\\n\\n return result\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n ans = []\\n\\n def postorder(node):\\n if node:\\n if node.left:\\n postorder(node.left)\\n if node.right:\\n postorder(node.right)\\n ans.append(node.val)\\n \\n postorder(root)\\n return ans\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n num=[]\\n def f(root):\\n if root==None:return num\\n f(root.left)\\n f(root.right)\\n num.append(root.val)\\n return num\\n return f(root)\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n results = []\\n def traverse(current_node):\\n if current_node.left is not None:\\n traverse(current_node.left)\\n if current_node.right is not None:\\n traverse(current_node.right)\\n if current_node:\\n results.append(current_node.val)\\n\\n if root is not None:\\n traverse(root)\\n return results\\n return []\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n ans = []\\n stack = [root]\\n while stack:\\n node = stack.pop()\\n ans.append(node.val)\\n\\n if node.left:\\n stack.append(node.left)\\n if node.right:\\n stack.append(node.right)\\n return ans[::-1]\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n stack=[]\\n visited=set()\\n curr=root\\n res=[]\\n while curr or stack:\\n if curr:\\n stack.append(curr)\\n curr=curr.left\\n if not curr:\\n if stack[-1] not in visited:\\n visited.add(stack[-1])\\n curr=stack[-1].right\\n else:\\n res.append(stack.pop().val)\\n curr=None\\n return res\\n\\n\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n\\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val] if root else []\\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if root is None:\\n return []\\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n \\n stack, res = [], [] \\n last_visited = None\\n\\n while stack or root:\\n if root:\\n stack.append(root)\\n root = root.left\\n else:\\n peek_node = stack[-1]\\n if peek_node.right and last_visited != peek_node.right:\\n root = peek_node.right\\n else:\\n stack.pop()\\n res.append(peek_node.val)\\n last_visited = peek_node\\n return res\\n\\n\\n # if not root:\\n # return []\\n \\n # stack = []\\n # result = []\\n # last_visited = None\\n \\n # while stack or root:\\n # if root:\\n # stack.append(root)\\n # root = root.left\\n # else:\\n # peek_node = stack[-1]\\n # if peek_node.right and last_visited != peek_node.right:\\n # root = peek_node.right\\n # else:\\n # stack.pop()\\n # result.append(peek_node.val)\\n # last_visited = peek_node\\n \\n # return result\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n \\n # Recursive Solution\\n def dfs(node, arr):\\n if not node:\\n return arr\\n arr = dfs(node.left, arr)\\n arr = dfs(node.right, arr)\\n arr.append(node.val)\\n return arr\\n \\n # Iterative Solution\\n if not root:\\n return []\\n s1 = []\\n s2 = []\\n s1.append(root)\\n while s1:\\n node = s1.pop()\\n s2.append(node)\\n if node.left:\\n s1.append(node.left)\\n if node.right:\\n s1.append(node.right)\\n res = []\\n while s2:\\n node = s2.pop()\\n res.append(node.val)\\n return res\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nfrom collections import deque\\n\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n values=deque([root])\\n out=[]\\n while len(values)!=0:\\n last=values.pop()\\n if type(last)==type(1):\\n out.append(last)\\n else:\\n values.append(last.val)\\n if last.right:\\n values.append(last.right)\\n if last.left:\\n values.append(last.left)\\n return out\",\n \"runtime\": \"42\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":51,"string":"51"},"mm_list":{"kind":"list like","value":[{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n\n def postorder(root):\n if root is None:\n return\n\n postorder(root.left) #treating the left nodes as a complete tree\n postorder(root.right) \n result.append(root.val) \n\n postorder(root)\n\n return result ","memory":"15900"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n result = []\n def preorder(root):\n if root is not None:\n preorder(root.left)\n preorder(root.right)\n result.append(root.val)\n preorder(root)\n return result","memory":"16000"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\n# post order traversal: Left Right Root\n# 4 6 7 5 2 9 8 3 1\n# pre order traversal: Root Right Left\n# 1 3 8 9 2 5 7 6 4\n\n# postorder can be implemented as preorder traversal but by visiting right child first and then left child\n# pre order traversal: Root Left Right but for this scenario we can traverse as Root Right Left\n\nclass Solution:\n\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if root == None:\n return []\n stack = [root]\n result = []\n\n while stack : \n node = stack.pop()\n result.append(node.val)\n\n if node.left:\n stack.append(node.left)\n\n if node.right:\n stack.append(node.right)\n\n return result[::-1]\n \n ","memory":"16100"},{"code":"# use recursive dfs\n# but try iterative traversal using stack(s): use a stack to insert nodes in reverse of post-order. while \n# stack is not empty, keep popping from top of stack. if top has been expanded, add to result. else, \n# expand the node and insert in reverse post-order. for each item, track if it has been expanded\n\n# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n stack = list()\n result = list()\n stack.append((root, False))\n while stack:\n node, expanded = stack.pop()\n if not node: continue\n if expanded:\n result.append(node.val)\n else:\n stack.append((node, True))\n stack.append((node.right, False))\n stack.append((node.left, False))\n return result\n\n\n # def postOrder(node):\n # if not node: return []\n # result = []\n # if node.left: result.extend(postOrder(node.left))\n # if node.right: result.extend(postOrder(node.right))\n # result.append(node.val)\n # return result\n\n # return postOrder(root)\n","memory":"16200"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if root is None:\n return []\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]","memory":"16300"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res=[]\n def traverse(node):\n if node is not None:\n # ↙↘醴\n traverse(node.left)\n traverse(node.right)\n res.append(node.val)\n traverse(root)\n return res\n","memory":"16300"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n stack = []\n \n if not root:\n return res\n \n stack.append(root)\n while stack:\n curr = stack.pop()\n res.append(curr.val)\n if curr.left:\n stack.append(curr.left)\n if curr.right:\n stack.append(curr.right)\n \n res.reverse()\n return res\n \n \n \n \n \n \n \n \n \n ","memory":"16400"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if root == None:\n return []\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]\n ","memory":"16400"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n def pot(root):\n if root:\n pot(root.left)\n pot(root.right)\n res.append(root.val)\n pot(root)\n return res","memory":"16500"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def recursive_helper(self, node, res):\n if node.left: self.recursive_helper(node.left, res)\n if node.right: self.recursive_helper(node.right, res)\n \n res.append(node.val)\n\n return res\n\n # Time: O(n), where n => number of nodes in BT\n # Space: O(h), where h => height of BT\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\n if not root: return []\n return self.recursive_helper(root, [])\n","memory":"16500"}],"string":"[\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n\\n def postorder(root):\\n if root is None:\\n return\\n\\n postorder(root.left) #treating the left nodes as a complete tree\\n postorder(root.right) \\n result.append(root.val) \\n\\n postorder(root)\\n\\n return result \",\n \"memory\": \"15900\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n result = []\\n def preorder(root):\\n if root is not None:\\n preorder(root.left)\\n preorder(root.right)\\n result.append(root.val)\\n preorder(root)\\n return result\",\n \"memory\": \"16000\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\n\\n# post order traversal: Left Right Root\\n# 4 6 7 5 2 9 8 3 1\\n# pre order traversal: Root Right Left\\n# 1 3 8 9 2 5 7 6 4\\n\\n# postorder can be implemented as preorder traversal but by visiting right child first and then left child\\n# pre order traversal: Root Left Right but for this scenario we can traverse as Root Right Left\\n\\nclass Solution:\\n\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if root == None:\\n return []\\n stack = [root]\\n result = []\\n\\n while stack : \\n node = stack.pop()\\n result.append(node.val)\\n\\n if node.left:\\n stack.append(node.left)\\n\\n if node.right:\\n stack.append(node.right)\\n\\n return result[::-1]\\n \\n \",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"# use recursive dfs\\n# but try iterative traversal using stack(s): use a stack to insert nodes in reverse of post-order. while \\n# stack is not empty, keep popping from top of stack. if top has been expanded, add to result. else, \\n# expand the node and insert in reverse post-order. for each item, track if it has been expanded\\n\\n# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n stack = list()\\n result = list()\\n stack.append((root, False))\\n while stack:\\n node, expanded = stack.pop()\\n if not node: continue\\n if expanded:\\n result.append(node.val)\\n else:\\n stack.append((node, True))\\n stack.append((node.right, False))\\n stack.append((node.left, False))\\n return result\\n\\n\\n # def postOrder(node):\\n # if not node: return []\\n # result = []\\n # if node.left: result.extend(postOrder(node.left))\\n # if node.right: result.extend(postOrder(node.right))\\n # result.append(node.val)\\n # return result\\n\\n # return postOrder(root)\\n\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if root is None:\\n return []\\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res=[]\\n def traverse(node):\\n if node is not None:\\n # ↙↘醴\\n traverse(node.left)\\n traverse(node.right)\\n res.append(node.val)\\n traverse(root)\\n return res\\n\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n stack = []\\n \\n if not root:\\n return res\\n \\n stack.append(root)\\n while stack:\\n curr = stack.pop()\\n res.append(curr.val)\\n if curr.left:\\n stack.append(curr.left)\\n if curr.right:\\n stack.append(curr.right)\\n \\n res.reverse()\\n return res\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if root == None:\\n return []\\n return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n def pot(root):\\n if root:\\n pot(root.left)\\n pot(root.right)\\n res.append(root.val)\\n pot(root)\\n return res\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def recursive_helper(self, node, res):\\n if node.left: self.recursive_helper(node.left, res)\\n if node.right: self.recursive_helper(node.right, res)\\n \\n res.append(node.val)\\n\\n return res\\n\\n # Time: O(n), where n => number of nodes in BT\\n # Space: O(h), where h => height of BT\\n def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:\\n if not root: return []\\n return self.recursive_helper(root, [])\\n\",\n \"memory\": \"16500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":10,"string":"10"}}},{"rowIdx":50,"cells":{"question_id":{"kind":"number","value":146,"string":"146"},"name":{"kind":"string","value":"lru-cache"},"content":{"kind":"string","value":"<p>Design a data structure that follows the constraints of a <strong><a href=\"https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU\" target=\"_blank\">Least Recently Used (LRU) cache</a></strong>.</p>\n\n<p>Implement the <code>LRUCache</code> class:</p>\n\n<ul>\n\t<li><code>LRUCache(int capacity)</code> Initialize the LRU cache with <strong>positive</strong> size <code>capacity</code>.</li>\n\t<li><code>int get(int key)</code> Return the value of the <code>key</code> if the key exists, otherwise return <code>-1</code>.</li>\n\t<li><code>void put(int key, int value)</code> Update the value of the <code>key</code> if the <code>key</code> exists. Otherwise, add the <code>key-value</code> pair to the cache. If the number of keys exceeds the <code>capacity</code> from this operation, <strong>evict</strong> the least recently used key.</li>\n</ul>\n\n<p>The functions <code>get</code> and <code>put</code> must each run in <code>O(1)</code> average time complexity.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input</strong>\n["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]\n[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]\n<strong>Output</strong>\n[null, null, null, 1, null, -1, null, -1, 3, 4]\n\n<strong>Explanation</strong>\nLRUCache lRUCache = new LRUCache(2);\nlRUCache.put(1, 1); // cache is {1=1}\nlRUCache.put(2, 2); // cache is {1=1, 2=2}\nlRUCache.get(1); // return 1\nlRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3}\nlRUCache.get(2); // returns -1 (not found)\nlRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}\nlRUCache.get(1); // return -1 (not found)\nlRUCache.get(3); // return 3\nlRUCache.get(4); // return 4\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= capacity <= 3000</code></li>\n\t<li><code>0 <= key <= 10<sup>4</sup></code></li>\n\t<li><code>0 <= value <= 10<sup>5</sup></code></li>\n\t<li>At most <code>2 * 10<sup>5</sup></code> calls will be made to <code>get</code> and <code>put</code>.</li>\n</ul>\n"},"acRate":{"kind":"number","value":43.2566850010241,"string":"43.256685"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["hash-table","linked-list","design","doubly-linked-list"],"string":"[\n \"hash-table\",\n \"linked-list\",\n \"design\",\n \"doubly-linked-list\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"157\", 0.0164], [\"181\", 0.0041], [\"204\", 0.0041], [\"228\", 0.0041], [\"252\", 0.0164], [\"275\", 0.0041], [\"299\", 0.0164], [\"322\", 0.0123], [\"346\", 0.0164], [\"370\", 0.0041], [\"393\", 0.0082], [\"417\", 0.0287], [\"440\", 0.0123], [\"464\", 0.0287], [\"488\", 0.15200000000000002], [\"511\", 7.1828], [\"535\", 13.179399999999998], [\"558\", 21.725799999999996], [\"582\", 31.155299999999997], [\"605\", 12.037500000000001], [\"629\", 2.8090999999999995], [\"653\", 0.8257], [\"676\", 0.43069999999999997], [\"700\", 0.23370000000000007], [\"723\", 0.164], [\"747\", 0.18040000000000006], [\"771\", 0.0615], [\"794\", 0.0574], [\"818\", 0.0574], [\"841\", 0.0369], [\"865\", 0.0246], [\"889\", 0.0082], [\"912\", 0.0328], [\"936\", 0.0205], [\"959\", 0.0164], [\"983\", 0.0533], [\"1006\", 0.2706], [\"1030\", 0.2543], [\"1054\", 0.07380000000000002], [\"1077\", 0.041], [\"1101\", 0.012300000000000002], [\"1124\", 0.0041], [\"1148\", 0.0041], [\"1172\", 0.0082], [\"1195\", 0.0041], [\"1219\", 0.0041], [\"1242\", 0.0082], [\"1266\", 0.0041], [\"1289\", 0.0041], [\"1313\", 0.0123], [\"1337\", 0.0041], [\"1360\", 0.0041], [\"1384\", 0.0041], [\"1407\", 0.0041], [\"1431\", 0.0041], [\"1455\", 0.0041], [\"1478\", 0.0041], [\"1502\", 0.0041], [\"1525\", 0.0082], [\"1549\", 0.0082], [\"1573\", 0.012300000000000002], [\"1596\", 0.0041], [\"1620\", 0.0041], [\"1643\", 0.0041], [\"1667\", 0.0041], [\"1690\", 0.0041], [\"1714\", 0.0164], [\"1738\", 0.0164], [\"1761\", 0.0164], [\"1785\", 0.09840000000000002], [\"1808\", 0.22140000000000004], [\"1832\", 0.5334999999999999], [\"1856\", 0.4923], [\"1879\", 0.41819999999999996], [\"1903\", 0.26239999999999997], [\"1926\", 0.17220000000000005], [\"1950\", 0.18450000000000003], [\"1974\", 0.22960000000000003], [\"1997\", 0.41019999999999995], [\"2021\", 0.513]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"68800\", 0.0082], [\"68900\", 0.0041], [\"73600\", 0.0041], [\"74100\", 0.0041], [\"74800\", 0.0041], [\"74900\", 0.0041], [\"75100\", 0.0041], [\"75300\", 0.0123], [\"75400\", 0.0082], [\"75500\", 0.0082], [\"75600\", 0.0041], [\"75700\", 0.0164], [\"75800\", 0.0123], [\"76000\", 0.0534], [\"76100\", 0.0945], [\"76200\", 0.1889], [\"76300\", 0.4641], [\"76400\", 0.1848], [\"76500\", 0.3819], [\"76600\", 0.69], [\"76700\", 0.2711], [\"76800\", 0.23], [\"76900\", 0.3368], [\"77000\", 0.5503], [\"77100\", 0.6325], [\"77200\", 0.8296], [\"77300\", 0.7926], [\"77400\", 1.6428], [\"77500\", 1.6264], [\"77600\", 1.3717], [\"77700\", 2.6983], [\"77800\", 3.8975], [\"77900\", 3.109], [\"78000\", 6.6984], [\"78100\", 8.2385], [\"78200\", 16.2923], [\"78300\", 9.0599], [\"78400\", 5.4417], [\"78500\", 7.7498], [\"78600\", 2.4642], [\"78700\", 0.423], [\"78800\", 0.616], [\"78900\", 1.5647], [\"79000\", 0.9487], [\"79100\", 0.7639], [\"79200\", 4.2137]]}"},"rt_list":{"kind":"list like","value":[{"code":"def lc(operations, params):\n cache = OrderedDict()\n result = []\n capacity = None\n for i, op in enumerate(operations):\n if op == \"LRUCache\":\n capacity = params[i][0]\n result.append(None)\n elif op == \"put\":\n key, value = params[i]\n if key in cache:\n cache.move_to_end(key)\n cache[key] = value\n if len(cache) > capacity:\n cache.popitem(last=False)\n result.append(None)\n elif op == \"get\":\n key = params[i][0]\n if key in cache:\n cache.move_to_end(key)\n result.append(cache[key])\n else:\n result.append(-1) \n return result\n\nwith open(\"user.out\",\"w\") as sys.stdout:\n print(*(str(lc(*h)).replace('None','null').replace(' ','') for h in zip(*[map(loads,stdin)]*2)),sep='\\n')\nexit(0)","runtime":"157"},{"code":"def lc(operations, params):\n cache = OrderedDict()\n result = []\n capacity = None\n for i, op in enumerate(operations):\n if op == \"LRUCache\":\n capacity = params[i][0]\n result.append(None)\n elif op == \"put\":\n key, value = params[i]\n if key in cache:\n cache.move_to_end(key)\n cache[key] = value\n if len(cache) > capacity:\n cache.popitem(last=False)\n result.append(None)\n elif op == \"get\":\n key = params[i][0]\n if key in cache:\n cache.move_to_end(key)\n result.append(cache[key])\n else:\n result.append(-1) \n return result\n\nwith open(\"user.out\",\"w\") as sys.stdout:\n print(*(str(lc(*h)).replace('None','null').replace(' ','') for h in zip(*[map(loads,stdin)]*2)),sep='\\n')\nexit(0)","runtime":"157"},{"code":"from collections import OrderedDict\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.dict: OrderedDict[int, int] = OrderedDict()\n \n\n def get(self, key: int) -> int:\n if key in self.dict:\n self.dict.move_to_end(key)\n return self.dict[key]\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.dict:\n self.dict[key] = value\n self.dict.move_to_end(key)\n else:\n if len(self.dict) == self.capacity:\n self.dict.popitem(last=False)\n self.dict[key] = value\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"181"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.data = OrderedDict()\n def get(self, key: int) -> int:\n if key in self.data:\n self.data.move_to_end(key)\n return self.data.get(key, -1)\n \n def put(self, key: int, value: int) -> None:\n self.data[key] = value\n self.data.move_to_end(key)\n if len(self.data) > self.capacity:\n self.data.popitem(last=False)\n \n \n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"204"},{"code":"from collections import deque, OrderedDict\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = OrderedDict() \n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n \n # 접근한 항목을 가장 최근에 사용된 위치로 이동\n self.cache.move_to_end(key)\n return self.cache[key]\n \n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.move_to_end(key)\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n \n self.cache[key] = value\n \n \n\n\nlRUCache = LRUCache(2)\nlRUCache.put(1, 1); # cache is {1=1}\nlRUCache.put(2, 2); # cache is {1=1, 2=2}\nlRUCache.get(1); # return 1\nlRUCache.put(3, 3); # LRU key was 2, evicts key 2, cache is {1=1, 3=3}\nlRUCache.get(2); # returns -1 (not found)\nlRUCache.put(4, 4); # LRU key was 1, evicts key 1, cache is {4=4, 3=3}\nlRUCache.get(1); # return -1 (not found)\nlRUCache.get(3); # return 3\nlRUCache.get(4); # return 4","runtime":"228"},{"code":"from collections import OrderedDict\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = OrderedDict()\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n else:\n # Move the accessed key to the end to mark it as recently used\n self.cache.move_to_end(key)\n return self.cache[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n # Update the value and mark as recently used\n self.cache.move_to_end(key)\n self.cache[key] = value\n if len(self.cache) > self.capacity:\n # Remove the first item from the OrderedDict (the least recently used item)\n self.cache.popitem(last=False)","runtime":"252"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = OrderedDict()\n \n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.cache.move_to_end(key)\n return self.cache[key]\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if not key in self.cache:\n if len(self.cache) == self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n self.cache.move_to_end(key)\n return None\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"275"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = OrderedDict()\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.cache.move_to_end(key)\n return self.cache[key]\n else:\n return -1\n \n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.move_to_end(key)\n self.cache[key] = value\n else:\n self.cache[key] = value\n self.cache.move_to_end(key)\n if len(self.cache) > self.capacity:\n self.cache.popitem(last=False)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"299"},{"code":"from collections import OrderedDict\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.dic = OrderedDict()\n \n def get(self, key: int) -> int:\n if key in self.dic:\n self.dic.move_to_end(key)\n return self.dic[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.dic:\n self.dic.pop(key)\n elif len(self.dic) >= self.capacity:\n self.dic.popitem(last=False)\n self.dic[key] = value\n \n","runtime":"322"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = collections.OrderedDict()\n \n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n self.cache.move_to_end(key)\n return self.cache[key]\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.move_to_end(key)\n self.cache[key] = value\n if len(self.cache) > self.capacity:\n self.cache.popitem(False)\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"346"},{"code":"from collections import OrderedDict\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self._capacity = capacity\n self._lru_cache = OrderedDict()\n \n\n def get(self, key: int) -> int:\n result = -1\n if key in self._lru_cache:\n result = self._lru_cache[key]\n self._lru_cache.move_to_end(key)\n return result\n \n\n def put(self, key: int, value: int) -> None:\n self._lru_cache[key] = value\n self._lru_cache.move_to_end(key)\n\n if len(self._lru_cache) > self._capacity:\n self._lru_cache.popitem(last=False)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"370"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.lru = OrderedDict()\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key not in self.lru:\n return -1\n\n self.lru.move_to_end(key)\n\n return self.lru[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.lru or len(self.lru) < self.capacity:\n self.lru[key] = value\n self.lru.move_to_end(key)\n else:\n self.lru.popitem(last=False)\n self.lru[key] = value\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"393"},{"code":"import collections\nclass LRUCache:\n def __init__(self, capacity):\n self.capacity = capacity\n self.dic = collections.OrderedDict()\n \n def get(self, key: int) -> int:\n if key not in self.dic:\n return -1\n self.dic.move_to_end(key)\n return self.dic[key]\n \n def put(self, key: int, value: int) -> None:\n if key in self.dic:\n self.dic.move_to_end(key)\n self.dic[key] = value\n if len(self.dic) > self.capacity:\n self.dic.popitem(False)\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"417"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.d = OrderedDict()\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key not in self.d:\n return -1\n \n self.d.move_to_end(key)\n return self.d[key]\n\n \n def put(self, key: int, value: int) -> None:\n if key in self.d:\n self.d[key] = value\n self.d.move_to_end(key)\n \n else:\n if len(self.d) >= self.capacity:\n self.d.popitem(last = False)\n self.d[key] = value\n \n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"440"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n \"\"\"\n Initialize the LRU cache with a positive capacity.\n \n :param capacity: The maximum number of items the cache can hold.\n \"\"\"\n self.data = OrderedDict() # OrderedDict maintains the order of keys based on access\n self.cap = capacity # Maximum capacity of the cache\n\n def get(self, key: int) -> int:\n \"\"\"\n Get the value of the key if the key exists in the cache; otherwise return -1.\n \n :param key: The key of the entry to be fetched.\n :return: The value associated with the key, or -1 if the key does not exist.\n \"\"\"\n if key in self.data:\n # Move the accessed key to the end to mark it as recently used\n self.data.move_to_end(key)\n return self.data[key]\n return -1\n\n def put(self, key: int, value: int) -> None:\n \"\"\"\n Update the value of the key if the key exists in the cache. Otherwise, add the key-value pair to the cache.\n If the cache reaches its capacity, remove the least recently used entry.\n \n :param key: The key of the entry to be added or updated.\n :param value: The value to be associated with the key.\n \"\"\"\n # Insert or update the key-value pair and mark the key as recently used\n self.data[key] = value\n self.data.move_to_end(key)\n # Remove the least recently used entry if the cache exceeds capacity\n if len(self.data) > self.cap:\n self.data.popitem(last=False) # Remove the first (least recently used) item\n\n# Time Complexity:\n# - get(key): O(1) - The get operation is performed in constant time because accessing and updating the position of an entry in an OrderedDict is O(1).\n# - put(key, value): O(1) - The put operation is also performed in constant time. The removal of the least recently used entry is also O(1) due to the efficient handling of OrderedDict.\n\n# Space Complexity:\n# - O(capacity) - The space complexity is O(capacity) because the OrderedDict stores up to `capacity` entries.\n# - The space used by the OrderedDict is directly proportional to the number of entries it holds, which is at most `capacity`.\n\n# Idea Behind This Solution:\n# - The LRU cache uses an `OrderedDict` to maintain the order of access, which supports the Least Recently Used (LRU) eviction policy.\n# - By using an `OrderedDict`, the cache efficiently keeps track of the order in which keys are accessed, making it easy to remove the least recently used entry when the cache reaches its capacity.\n\n# Algorithm Steps:\n# 1. **Initialization:** \n# - Create an instance of `OrderedDict` to store cache entries and maintain their access order.\n# - Set the maximum capacity of the cache.\n\n# 2. **Get Operation (`get` method):**\n# - Check if the key exists in the cache.\n# - If it exists, move the key to the end of the `OrderedDict` to mark it as recently used and return its value.\n# - If it does not exist, return -1.\n\n# 3. **Put Operation (`put` method):**\n# - Insert or update the key-value pair in the cache.\n# - Move the key to the end to mark it as recently used.\n# - If the size of the cache exceeds the capacity, remove the oldest entry (the first item in the `OrderedDict`) to make space for the new entry.","runtime":"464"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache=OrderedDict()\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n \n self.cache.move_to_end(key)\n return self.cache[key]\n\n def put(self, key: int, value: int) -> None:\n self.cache[key]=value\n self.cache.move_to_end(key)\n if (len(self.cache) > self.capacity ):\n self.cache.popitem(last=False)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"488"},{"code":"class LRUCache:\n from collections import OrderedDict\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = OrderedDict()\n \n \n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n else:\n self.cache.move_to_end(key)\n return self.cache[key]\n \n \n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.move_to_end(key)\n self.cache[key] = value\n if len(self.cache) > self.capacity:\n self.cache.popitem(False)\n \n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"488"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.od = OrderedDict()\n self.max_length = capacity\n self.length = 0 \n\n def get(self, key: int) -> int:\n if key not in self.od:\n return -1\n self.od.move_to_end(key)\n return self.od[key] \n\n def put(self, key: int, value: int) -> None:\n if key in self.od:\n self.od[key] = value\n self.od.move_to_end(key, last=True)\n elif self.length < self.max_length:\n self.length += 1\n self.od[key] = value\n else:\n self.od.popitem(last=False)\n self.od[key] = value \n \n\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"511"},{"code":"from collections import OrderedDict\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = OrderedDict()\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n\n self.cache.move_to_end(key)\n \n return self.cache[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache[key] = value\n self.cache.move_to_end(key)\n else:\n if len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n\n self.cache[key] = value\n \n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"511"},{"code":"from collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = OrderedDict()\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n self.cache.move_to_end(key, last = True)\n return self.cache[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.move_to_end(key, last = True)\n self.cache[key] = value\n return\n \n self.cache[key] = value\n if len(self.cache) > self.capacity:\n self.cache.popitem(last = False)\n return\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"535"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = OrderedDict()\n \n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n self.cache.move_to_end(key)\n return self.cache[key]\n \n\n def put(self, key: int, value: int) -> None:\n self.cache[key] = value\n self.cache.move_to_end(key)\n if len(self.cache) > self.capacity:\n self.cache.popitem(last=False)\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"535"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n \n\n def get(self, key: int) -> int:\n # maintain order\n if key in self.cache:\n self.cache[key] = self.cache.pop(key)\n return self.cache[key]\n \n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.pop(key)\n\n self.cache[key] = value\n\n if len(self.cache) > self.capacity:\n self.cache.pop(next(iter(self.cache)))\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"558"},{"code":"class Node:\n def __init__(self, key: int, value: int):\n self.key = key\n self.value = value\n self.prev = None\n self.next = None\n\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {} # Map key to node\n \n # Dummy head and tail to avoid edge case checks\n self.head = Node(0, 0)\n self.tail = Node(0, 0)\n self.head.next = self.tail\n self.tail.prev = self.head\n\n # Helper function to remove a node from the linked list\n def _remove(self, node: Node):\n prev_node = node.prev\n next_node = node.next\n prev_node.next = next_node\n next_node.prev = prev_node\n\n # Helper function to add a node right after the head (most recently used position)\n def _add(self, node: Node):\n node.next = self.head.next\n node.prev = self.head\n self.head.next.prev = node\n self.head.next = node\n\n # Move a node to the front (most recently used)\n def _move_to_front(self, node: Node):\n self._remove(node)\n self._add(node)\n\n # Get the value (will always move the accessed node to the front)\n def get(self, key: int) -> int:\n if key in self.cache:\n node = self.cache[key]\n self._move_to_front(node) # Move the accessed node to the front\n return node.value\n return -1 # Return -1 if the key is not found\n\n # Add or update the value for the given key\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n # Update the existing node and move it to the front\n node = self.cache[key]\n node.value = value\n self._move_to_front(node)\n else:\n # Add a new node\n if len(self.cache) >= self.capacity:\n # Remove the least recently used (which is at the tail's previous node)\n lru = self.tail.prev\n self._remove(lru)\n del self.cache[lru.key] # Remove from hashmap\n\n # Create a new node and add it to the front\n new_node = Node(key, value)\n self.cache[key] = new_node\n self._add(new_node)\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"558"},{"code":"class Node:\n def __init__(self, key: int, value: int):\n # Doubly Linked List (DLL)\n self.key: int = key\n self.value: int = value\n self.prev: Node | None = None\n self.next: Node | None = None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.head = Node(-1, -1)\n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.hash_map: dict[int, Node] = {}\n self.capacity: int = capacity\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n def get(self, key: int) -> int:\n node = self.hash_map.get(key)\n if not node:\n return -1\n # Move the node to the tail (most recently used)\n if node != self.tail.prev: # Optimization: move only if not already the most recent\n self.remove(node)\n self.add(node)\n return node.value\n\n def add(self, node) -> None:\n self.tail.prev.next = node\n node.prev = self.tail.prev \n node.next = self.tail\n self.tail.prev = node\n\n def put(self, key: int, value: int) -> None:\n if key in self.hash_map:\n node = self.hash_map[key] \n node.value = value\n self.remove(node)\n else:\n node = Node(key, value) \n self.hash_map[key] = node\n\n self.add(node)\n\n if len(self.hash_map) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.hash_map[node_to_delete.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"582"},{"code":"class Node:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.next = None\n self.prev = None\n\nclass DoublyLinkedList:\n def __init__(self):\n self.left = None # Most recently used (MRU)\n self.right = None # Least recently used (LRU)\n self.size = 0\n\n def get_size(self):\n return self.size\n\n def get_right(self):\n return self.right\n\n def insert_front(self, node):\n \"\"\" Insert a node at the front (MRU side). \"\"\"\n if self.left is None:\n self.left = node\n self.right = node\n else:\n node.next = self.left\n self.left.prev = node\n self.left = node\n self.size += 1\n\n def delete(self, node):\n \"\"\" Remove a node from the list. \"\"\"\n if node == self.left == self.right:\n self.left = None\n self.right = None\n elif node == self.left:\n second = self.left.next\n if second:\n second.prev = None\n self.left = second\n elif node == self.right:\n second_last = self.right.prev\n if second_last:\n second_last.next = None\n self.right = second_last\n else:\n prev_node = node.prev\n next_node = node.next\n prev_node.next = next_node\n next_node.prev = prev_node\n \n self.size -= 1\n\n def move_to_front(self, node):\n \"\"\" Move an existing node to the front (MRU). \"\"\"\n if node == self.left:\n return # It's already at the front\n self.delete(node)\n self.insert_front(node)\n \n def view(self):\n \"\"\" Helper method to print the list (optional, for debugging). \"\"\"\n cur = self.left\n while cur:\n print(f\"({cur.key}: {cur.val})\", end=\" -> \")\n cur = cur.next\n print()\n\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.dll = DoublyLinkedList()\n\n def get(self, key: int) -> int:\n if key in self.cache:\n node = self.cache[key]\n self.dll.move_to_front(node) # Move accessed node to the front\n return node.val\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n node = self.cache[key]\n node.val = value # Update the value if key exists\n self.dll.move_to_front(node) # Move node to the front\n else:\n new_node = Node(key, value)\n self.cache[key] = new_node\n self.dll.insert_front(new_node)\n if self.dll.get_size() > self.capacity:\n lru = self.dll.get_right()\n self.dll.delete(lru)\n del self.cache[lru.key]\n\n\n# Example usage:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key, value)\n","runtime":"582"},{"code":"class Node:\n def __init__(self, key: int, value: int):\n # DDL\n self.key, self.value, self.prev, self.next = key, value, None, None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.head = Node(-1, -1)\n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.hash_map = {}\n self.capacity = capacity\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n def get(self, key: int) -> int:\n if not key in self.hash_map:\n return -1 \n node = self.hash_map[key]\n self.remove(node)\n self.add(node)\n return node.value\n\n def add(self, node):\n previous_end = self.tail.prev\n previous_end.next = node\n node.prev = previous_end\n node.next = self.tail\n self.tail.prev = node\n\n def put(self, key: int, value: int) -> None:\n if key in self.hash_map:\n self.remove(self.hash_map[key])\n\n node = Node(key, value) \n self.hash_map[key] = node\n self.add(node)\n\n if len(self.hash_map) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.hash_map[node_to_delete.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"605"},{"code":"class Node:\n def __init__(self, key: int, value: int):\n # Doubly Linked List (DLL)\n self.key: int = key\n self.value: int = value\n self.prev: Node | None = None\n self.next: Node | None = None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.head = Node(-1, -1)\n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.hash_map: dict[int, Node] = {}\n self.capacity: int = capacity\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n def get(self, key: int) -> int:\n if not key in self.hash_map:\n return -1 \n node = self.hash_map[key]\n # Move the node to the tail (most recently used)\n if node != self.tail.prev: # Optimization: move only if not already the most recent\n self.remove(node)\n self.add(node)\n return node.value\n\n def add(self, node) -> None:\n self.tail.prev.next = node\n node.prev = self.tail.prev \n node.next = self.tail\n self.tail.prev = node\n\n def put(self, key: int, value: int) -> None:\n if key in self.hash_map:\n self.remove(self.hash_map[key])\n\n node = Node(key, value) \n self.hash_map[key] = node\n self.add(node)\n\n if len(self.hash_map) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.hash_map[node_to_delete.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"605"},{"code":"class DLL:\n def __init__(self,key=None,value=None):\n self.key = key\n self.val = value\n self.next = None\n self.prev = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.head = DLL()\n self.tail = DLL()\n self.head.next = self.tail\n self.tail.prev = self.head\n self.size = 0\n self.capacity = capacity\n self.hmap = {}\n\n def get(self, key: int) -> int:\n if key in self.hmap:\n value = self.hmap[key].val\n self.remove_node(key)\n self.add_node(key,value)\n return self.hmap[key].val\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.hmap:\n self.remove_node(key)\n self.add_node(key,value)\n else:\n if self.size == self.capacity:\n self.remove_from_tail()\n self.add_node(key, value)\n\n def add_node(self,key,value):\n new_node = DLL(key=key, value=value)\n tmp = self.head.next\n tmp.prev = new_node\n self.head.next = new_node\n new_node.prev =self.head\n new_node.next = tmp\n self.hmap[key] = new_node\n self.size+=1\n return\n \n def remove_node(self,key):\n node = self.hmap[key]\n prev = node.prev\n next = node.next\n\n prev.next = next\n next.prev = prev\n self.size-=1\n del self.hmap[key]\n\n def remove_from_tail(self):\n key = self.tail.prev.key\n self.remove_node(key)\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"629"},{"code":"class Node:\n def __init__(self, key: int, value: int):\n # Doubly Linked List (DLL)\n self.key: int = key\n self.value: int = value\n self.prev: Node | None = None\n self.next: Node | None = None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.head = Node(-1, -1)\n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.hash_map: dict[int, Node] = {}\n self.capacity: int = capacity\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n def get(self, key: int) -> int:\n if not key in self.hash_map:\n return -1 \n node = self.hash_map[key]\n # Move the node to the tail (most recently used)\n if node != self.tail.prev: # Optimization: move only if not already the most recent\n self.remove(node)\n self.add(node)\n return node.value\n\n def add(self, node) -> None:\n self.tail.prev.next = node\n node.prev = self.tail.prev \n node.next = self.tail\n self.tail.prev = node\n\n def put(self, key: int, value: int) -> None:\n if key in self.hash_map:\n self.remove(self.hash_map[key])\n\n node = Node(key, value) \n self.hash_map[key] = node\n self.add(node)\n\n if len(self.hash_map) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.hash_map[node_to_delete.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"629"},{"code":"class Node:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.prev = None\n self.next = None\n\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = dict()\n self.capacity = capacity\n self.count = 0\n self.head = None\n self.tail = None\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n elif self.count == 1 or self.cache[key] == self.head:\n return self.cache[key].val\n\n node = self.cache[key]\n self._remove(node)\n self._add(node)\n return self.head.val\n\n def put(self, key: int, val: int) -> None:\n node = Node(key, val)\n if not self.head:\n self._add(node)\n else:\n if key in self.cache:\n self._remove(self.cache[key])\n self._add(node)\n\n if self.count > self.capacity:\n self._remove(self.tail)\n \n def _remove(self, node):\n self.count -= 1\n if node == self.head:\n self.head = node.next\n if node == self.tail:\n self.tail = node.prev\n if node.prev:\n node.prev.next = node.next\n if node.next:\n node.next.prev = node.prev\n self.cache.pop(node.key)\n \n def _add(self, node):\n self.count += 1\n node.prev = None\n node.next = self.head\n if self.head:\n self.head.prev = node\n self.head = node\n if not self.tail:\n self.tail = node\n self.cache[node.key] = node\n","runtime":"653"},{"code":"import threading\nclass Node:\n def __init__(self, key, value):\n self.key = key\n self.value = value\n self.prev = None\n self.next = None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.head = Node(0, 0)\n self.tail = Node(0, 0)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.lock = threading.Lock() # Lock for thread-safe operations\n \n def _add_node(self, node):\n node.prev = self.head\n node.next = self.head.next\n self.head.next.prev = node\n self.head.next = node\n \n def _remove_node(self, node):\n prev = node.prev\n next = node.next\n prev.next = next\n next.prev = prev\n \n def _move_to_head(self, node):\n self._remove_node(node)\n self._add_node(node)\n \n def _pop_tail(self):\n res = self.tail.prev\n self._remove_node(res)\n return res\n\n def get(self, key: int) -> int:\n with self.lock:\n node = self.cache.get(key, None)\n if not node:\n return -1\n self._move_to_head(node)\n return node.value\n\n def put(self, key: int, value: int) -> None:\n with self.lock:\n node = self.cache.get(key)\n if not node:\n newNode = Node(key, value)\n self.cache[key] = newNode\n self._add_node(newNode)\n \n if len(self.cache) > self.capacity:\n tail = self._pop_tail()\n del self.cache[tail.key]\n else:\n node.value = value\n self._move_to_head(node)\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"653"},{"code":"class Node:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.prev = None\n self.next = None\n\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = dict()\n self.capacity = capacity\n self.count = 0\n self.head = None\n self.tail = None\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n elif self.count == 1 or self.cache[key] == self.head:\n return self.cache[key].val\n\n node = self.cache[key]\n self._remove(node)\n self._add(node)\n return self.head.val\n\n def put(self, key: int, val: int) -> None:\n node = Node(key, val)\n if not self.head:\n self._add(node)\n else:\n if key in self.cache:\n self._remove(self.cache[key])\n self._add(node)\n\n if self.count > self.capacity:\n self._remove(self.tail)\n \n def _remove(self, node):\n self.count -= 1\n if node == self.head:\n self.head = node.next\n if node == self.tail:\n self.tail = node.prev\n if node.prev:\n node.prev.next = node.next\n if node.next:\n node.next.prev = node.prev\n self.cache.pop(node.key)\n \n def _add(self, node):\n self.count += 1\n node.prev = None\n node.next = self.head\n if self.head:\n self.head.prev = node\n self.head = node\n if not self.tail:\n self.tail = node\n self.cache[node.key] = node\n","runtime":"676"},{"code":"class Node:\n def __init__(self, key: int, value: int, next = None, prev = None):\n self.value = value\n self.key = key\n self.next = next\n self.prev = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.length = 0\n self.cache = {}\n self.head = None\n self.tail = None\n\n def get(self, key: int) -> int:\n if key in self.cache:\n temp = self.cache[key]\n if self.length == 1 or self.tail == temp:\n print(self.head)\n return temp.value\n if temp == self.head:\n self.head = temp.next\n if temp.prev:\n temp.prev.next = temp.next\n if temp.next:\n temp.next.prev = temp.prev\n temp.next = None\n temp.prev = self.tail\n self.tail.next = temp\n self.tail = temp\n print(self.head)\n return temp.value\n else:\n print(self.head)\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n temp = self.cache[key]\n temp.value = value\n self.get(key)\n return\n if self.length == self.capacity:\n del self.cache[self.head.key]\n temp = self.head\n if self.head.next:\n self.head = self.head.next\n self.head.prev = None\n temp.key = key\n temp.value = value\n temp.next = None\n temp.prev = self.tail\n self.tail.next = temp\n self.tail = temp\n self.cache[key] = temp\n \n else:\n temp = Node(value = value, key = key)\n self.cache[key] = temp\n if self.length == 0:\n self.head = temp\n self.tail = temp\n else:\n temp.prev = self.tail\n self.tail.next = temp\n self.tail = temp\n self.length += 1\n\n print(self.head)\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"676"},{"code":"class ListNode:\n def __init__(self, key=None, val=None, prev=None, next=None):\n self.key = key\n self.val = val\n self.prev = prev\n self.next = next\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.front, self.back = ListNode(), ListNode()\n self.front.next = self.back\n self.back.prev = self.front\n self.cache = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n \n val = self.cache[key].val\n self._remove(key)\n self._insert(key, val)\n return val\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self._remove(key)\n \n self._insert(key, value)\n print(key, len(self.cache))\n if len(self.cache) > self.capacity:\n lru_key = self.back.prev.key\n print('lru_key', lru_key)\n self._remove(lru_key)\n \n def _insert(self, key, val):\n # insert both node and cache entries\n insertNode = ListNode(key, val, None, None)\n\n prevNode, nextNode = self.front, self.front.next\n prevNode.next = insertNode\n insertNode.prev = prevNode\n insertNode.next = nextNode\n nextNode.prev = insertNode\n\n self.cache[key] = insertNode\n \n def _remove(self, key):\n # remove both node and cache entries\n keyNode = self.cache[key]\n\n prevNode, nextNode = keyNode.prev, keyNode.next\n prevNode.next = nextNode\n nextNode.prev = prevNode\n\n del self.cache[key]\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"700"},{"code":"class OrderedMap:\n class Node:\n def __init__(self, key, val, nex, prev):\n self.key = key\n self.val = val\n self.next = nex\n self.prev = prev\n \n def __repr__(self):\n return \"(\" + str(self.key) + \": \" + str(self.val) + \")\"\n\n def __init__(self):\n self.size = 0\n self.sentinel = self.Node(None, None, None, None)\n self.sentinel.next = self.sentinel\n self.sentinel.prev = self.sentinel\n self.key_to_node = {}\n\n def add_first(self, key, val):\n if key in self.key_to_node:\n self.key_to_node[key].val = val\n else:\n new_node = self.Node(key, val, self.sentinel.next, self.sentinel)\n self.sentinel.next.prev = new_node\n self.sentinel.next = new_node\n self.size += 1\n self.key_to_node[key] = new_node\n\n def getNode(self, key):\n if not key in self.key_to_node:\n return None\n return self.key_to_node[key]\n\n def get(self, key):\n val = self.getNode(key).val\n return val if not val is None else -1\n\n def contains_key(self, key):\n return key in self.key_to_node\n\n def move_to_front(self, key):\n print(self.key_to_node[key])\n node = self.getNode(key)\n node.prev.next = node.next\n node.next.prev = node. prev\n\n node.prev = self.sentinel\n node.next = self.sentinel.next\n\n self.sentinel.next = node\n node.next.prev = node\n\n def remove_last(self):\n #print(self.sentinel.prev)\n del self.key_to_node[self.sentinel.prev.key]\n self.sentinel.prev = self.sentinel.prev.prev\n self.sentinel.prev.next = self.sentinel\n self.size -= 1\n \n\nclass LRUCache: \n\n # capacity > 0\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.items = OrderedMap()\n\n def get(self, key: int) -> int:\n if not self.items.contains_key(key):\n return -1\n self.items.move_to_front(key)\n return self.items.get(key)\n\n def put(self, key: int, value: int) -> None:\n if self.items.contains_key(key):\n self.items.move_to_front(key)\n if self.items.size == self.capacity and not self.items.contains_key(key):\n self.items.remove_last()\n self.items.add_first(key, value)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"700"},{"code":"class LRUCache:\n\n lruCache = {}\n capacity = 0\n startNode = None\n lastNode = None\n \n class MyListNode(object):\n \n def __init__(self, key, value):\n self.key = key\n self.value = value\n self.nextPtr = None\n self.prevPtr = None\n \n \n def getVal(self):\n return self.value\n \n def getKey(self):\n return self.key\n \n def putVal(self, val):\n self.value = val\n \n \n \n def __init__(self, capacity: int):\n \n # Need to keep track of time\n # when a key was last used\n \n # Need to keep track of keys and values\n \n #self.lruCache = {}\n self.capacity = capacity\n #self.cacheQueue = deque([])\n self.lruCache = {}\n self.startNode = None\n self.lastNode = None\n \n # Create Start and Head Node of the Linked list\n \n self.startNode = LRUCache.MyListNode(0,sys.maxsize)\n self.lastNode = LRUCache.MyListNode(0,sys.maxsize)\n self.startNode.nextPtr = self.lastNode\n self.lastNode.prevPtr = self.startNode\n \n \n def addNodeEnd(self, node):\n \n # Add to the end of the list\n prevNode = self.lastNode.prevPtr\n prevNode.nextPtr = node\n node.prevPtr = prevNode\n node.nextPtr = self.lastNode\n self.lastNode.prevPtr = node\n \n \n \n def delNode(self, node):\n \n prevNode = node.prevPtr\n nextNode = node.nextPtr\n prevNode.nextPtr = nextNode\n nextNode.prevPtr = prevNode\n \n \n def movetoEndNode(self, node):\n \n self.delNode(node)\n self.addNodeEnd(node)\n \n \n def log(self, s, logEnabled):\n if logEnabled:\n print(s)\n \n def get(self, key: int) -> int:\n \n logEnabled = True\n #self.log(f\"Content in dict:{self.lruCache}\", logEnabled)\n \n if key in self.lruCache:\n # Push the key in a queue\n getNode = self.lruCache[key]\n retVal = getNode.getVal()\n #retVal = getNode.value\n self.movetoEndNode(getNode)\n self.log(f\"Returning:value:{retVal}\", logEnabled)\n return retVal\n else:\n self.log(f\"key:{key} not found!\", logEnabled)\n return -1\n \n \n\n def put(self, key: int, value: int) -> None:\n \n logEnabled = True\n \n if self.capacity == 0 and key not in self.lruCache:\n # Time to evict\n # deque the queue for the key to evict\n self.log(f\"Capacity:{self.capacity}, key:{key}, val:{value}, Evicting\", logEnabled)\n sNode = self.startNode.nextPtr\n if sNode.getVal() == sys.maxsize:\n self.log(f\"Nothing in the list, not possible\", logEnabled)\n \n self.log(f\"key to delete:{sNode.getKey()}\", logEnabled)\n self.delNode(sNode)\n self.lruCache.pop(sNode.getKey())\n # Node deleted, capacity has to be incremented\n self.capacity += 1\n \n newNode = LRUCache.MyListNode(key,value)\n self.lruCache[key] = newNode\n self.addNodeEnd(newNode)\n # Node added, capacity has to be decremented\n self.capacity -= 1\n else:\n self.log(f\"Capacity:{self.capacity}, Putting, key:{key}, val:{value}\", logEnabled)\n \n if key in self.lruCache:\n # Move the node to the end of the list\n updateNode = self.lruCache[key]\n updateNode.putVal(value)\n self.movetoEndNode(updateNode)\n else:\n lruNode = LRUCache.MyListNode(key,value)\n self.lruCache[key] = lruNode\n self.addNodeEnd(lruNode)\n self.capacity -= 1\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"747"},{"code":"class LRUCache:\n\n class ListNode:\n def __init__(self, key, val, prev=None, next=None):\n self.prev = prev\n self.next = next\n self.key = key\n self.val = val\n \n def __init__(self, capacity: int):\n self.mapping = {}\n self.capacity = capacity\n self.head = self.ListNode(-1, -1)\n self.tail = self.ListNode(-1, -1) \n self.head.next = self.tail\n self.tail.prev = self.head\n \n def addNode(self, node):\n print(f\"adding node {node.key}, {node.val}\")\n node.next = self.head.next\n node.next.prev = node\n self.head.next = node\n node.prev = self.head\n self.mapping[node.key] = node\n # self.printList()\n \n def deleteNode(self, node):\n print(f\"deleting node {node.key}, {node.val}\")\n node.prev.next = node.next\n node.next.prev = node.prev\n del self.mapping[node.key]\n # self.printList()\n \n def printList(self):\n curr = self.head\n res = []\n while curr:\n res.append(f\"({curr.key}, {curr.val})\")\n curr = curr.next\n print(\",\".join(res))\n\n def get(self, key: int) -> int:\n if key not in self.mapping:\n return -1\n \n node = self.mapping[key]\n self.deleteNode(node)\n self.addNode(node)\n return node.val\n\n def put(self, key: int, value: int) -> None:\n if key not in self.mapping:\n node = self.ListNode(key, value)\n self.addNode(node)\n if len(self.mapping) > self.capacity:\n self.deleteNode(self.tail.prev)\n \n else:\n node = self.mapping[key]\n node.val = value\n self.deleteNode(node)\n self.addNode(node)\n\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"747"},{"code":"class LRUCache:\n class Node:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.next = None\n self.prev = None\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.head = self.Node(-1, -1)\n self.tail = self.Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.m = {}\n\n def get(self, key: int) -> int:\n #print(\"get node key = \", key)\n if key in self.m:\n value = self.m[key].val\n self.put(key, value) \n return value \n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n #print(\"put node key, value = \", key, value)\n #print(\"what is value =\", value)\n if key in self.m:\n self.deleteNode(key)\n self.addNode(key, value)\n #print(\"i am asa here, len(self.m) = \", len(self.m))\n #print(\"self.capacity =\", self.capacity)\n if len(self.m) > self.capacity:\n print(\"i am here\")\n self.deleteNode(self.tail.prev.key)\n \n def addNode(self, key, val):\n print(\"addNode, key, val=\", key, val)\n node = self.Node(key, val)\n temp = self.head.next\n self.head.next = node\n temp.prev = node\n node.prev = self.head\n node.next = temp\n self.m[key] = node\n \n \n\n def deleteNode(self, key):\n node = self.m[key]\n node.prev.next = node.next\n node.next.prev = node.prev\n #self.addNode(key, value)\n self.m.pop(key)\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"771"},{"code":"class Node:\n def __init__(self, key, val: int, prev=None, next=None):\n self.key = key\n self.val = val\n self.next = next\n self.prev = prev\n\nclass LRUCache:\n \n def __init__(self, capacity: int):\n self.capacity = capacity\n self.storage = {}\n\n self.head = Node(None, 0, None, None)\n self.tail = Node(None, 0, None, None)\n self.head.next = self.tail\n self.tail.prev = self.head\n def delete(self, key):\n node = self.storage[key]\n #delete\n node.prev.next = node.next\n node.next.prev = node.prev\n node.prev, node.next= None, None\n pass\n def add(self, key, value):\n node = Node(key, value)\n prev = self.tail.prev\n next = self.tail\n\n prev.next = node\n next.prev = node\n \n node.prev = prev\n node.next = next\n \n\n self.storage[key] = node\n\n\n def get(self, key: int) -> int:\n if key in self.storage:\n self.delete(key)\n\n node = self.storage[key]\n self.add(node.key, node.val)\n\n return self.storage[key].val\n \n return -1\n \n\n def put(self, key: int, value: int) -> None:\n print()\n print('set')\n if key in self.storage:\n print('exists already')\n self.delete(key)\n self.add(key, value)\n else: #it does not exist\n if len(self.storage) < self.capacity:\n print('doesnt exist, but theres room')\n self.add(key, value)\n else:\n print('out of room...')\n LRU = self.head.next\n LRU.next.prev = LRU.prev\n LRU.prev.next = LRU.next\n del self.storage[LRU.key]\n \n self.add(key, value)\n\n print('set ' , self.head.next.key, self.tail.prev.key)\n \n\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"771"},{"code":"class Node:\n def __init__(self,val,key=None):\n self.val=val\n self.key=key\n self.prev=None\n self.next=None \nclass LRUCache:\n def __init__(self, capacity: int):\n self.cap = 0\n self.mx = capacity\n self.map = dict()\n self.head = Node(-1)\n self.tail = Node(-1)\n self.head.next = self.tail\n self.tail.prev = self.head\n print(self.head.val)\n def get(self, key: int) -> int:\n if key not in self.map:\n return -1\n res=self.map[key]\n self.delete(res)\n self.insert(self.head,res)\n return res.val\n def insert(self,head,node):\n if self.cap>=self.mx:\n lru = self.tail.prev\n self.delete(lru)\n del self.map[lru.key]\n self.cap+=1\n tmp=self.head.next\n self.head.next=node\n node.next=tmp\n node.prev=self.head\n tmp.prev=node\n def delete(self,node):\n print(self.tail.prev.val,\"hi\")\n self.cap-=1\n prev_node = node.prev\n next_node = node.next\n prev_node.next = next_node\n next_node.prev = prev_node\n print(self.tail.prev.val,\"hi\")\n\n\n\n def put(self, key: int, value: int) -> None:\n p=Node(value,key)\n if key in self.map:\n self.delete(self.map[key])\n self.map[key]=p\n self.insert(self.head,p)\n # print(self.head.next.val,self.map)\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"794"},{"code":"class LRUCache:\n #\n # (None)<->(1)<->(2)<->(3)<->\n # *\n #\n def __init__(self, capacity: int):\n self.head = ListNode(None, None)\n self.tail = ListNode(None, None)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.capacity = capacity\n self.table = {}\n\n def get(self, key: int) -> int:\n if key in self.table:\n self.put(key, self.table[key].val)\n return self.table[key].val\n else:\n return -1\n def put(self, key: int, value: int) -> None:\n if key in self.table:\n self.remove(self.table[key])\n elif self.capacity == 0:\n self.remove(self.tail.prev)\n node = ListNode(key, value)\n first_node = self.head.next\n self.head.next = node\n node.next = first_node\n first_node.prev = node\n node.prev = self.head\n self.table[key] = node\n self.capacity -= 1\n\n \n def remove(self, node):\n prev_node = node.prev\n next_node = node.next\n key = node.key\n prev_node.next = next_node\n next_node.prev = prev_node\n self.table.pop(key)\n self.capacity += 1\n\n \n \n \n \nclass ListNode:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.next = None\n self.prev = None\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"794"},{"code":"class Node:\n def __init__(self, key, value):\n self.key = key\n self.value = value\n self.prev = None\n self.next = None\n\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.node_dict = {}\n self.head = Node(-1, -1)\n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.capacity = capacity\n \n\n def get(self, key: int) -> int:\n # print(f'key to get: {key}')\n # print(f'self.node_dict: {self.node_dict}')\n # print()\n\n print('get')\n print(key)\n print()\n if key not in self.node_dict:\n return -1\n else:\n node = self.node_dict[key]\n self.remove(key)\n self.add(node)\n return node.value\n \n\n def put(self, key: int, value: int) -> None:\n print('put')\n print(key, value)\n print()\n node = Node(key, value)\n if key in self.node_dict:\n self.remove(key)\n self.add(node)\n \n if len(self.node_dict) > self.capacity:\n # print(f\"len(self.node_dict): {len(self.node_dict)}\")\n # print(f\"self.capacity: {self.capacity}\")\n lru_node = self.head.next\n # print(lru_node.key)\n # print(lru_node.value)\n # print()\n self.remove(lru_node.key)\n \n def remove(self, key):\n node = self.node_dict[key]\n prev_node = node.prev\n next_node = node.next\n prev_node.next = next_node\n next_node.prev = prev_node\n\n # print(self.node_dict)\n self.node_dict.pop(node.key, None)\n # print(self.node_dict)\n # print()\n \n def add(self, node):\n prev_node = self.tail.prev\n node.prev = prev_node\n node.next = self.tail\n prev_node.next = node\n self.tail.prev = node\n self.node_dict[node.key] = node\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"818"},{"code":"class ListNode:\n def __init__(self, val=0, prev=None, next=None):\n self.val = val\n self.prev = prev\n self.next = next\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.dict = {-1:-1}\n self.head = None\n self.tail = None\n self.capacity = capacity\n self.cnt = 0\n\n def _bring_node_to_front(self, node):\n if not node.next:\n return\n prev = node.prev\n nxt = node.next\n if prev:\n prev.next = nxt\n else:\n self.head = nxt\n\n\n if nxt:\n nxt.prev = prev\n self.tail.next = node\n node.prev = self.tail\n self.tail = node\n node.next = None\n \n if not self.head:\n self.head = self.tail\n\n def get(self, key: int) -> int:\n print(f'get {key}')\n \n if key not in self.dict:\n return -1\n else:\n data = self.dict[key]\n val = data['val']\n node = data['node']\n self._bring_node_to_front(node)\n print(self.head.val if self.head else 'head null')\n print(self.tail.val if self.tail else 'tail null')\n return val\n\n def put(self, key: int, value: int) -> None:\n print(f'put {key}, {value}')\n print(self.head.val if self.head else 'head null')\n print(self.tail.val if self.tail else 'tail null')\n if key not in self.dict:\n if self.cnt == self.capacity:\n lru_key = self.head.val\n self.head = self.head.next\n if self.head:\n self.head.prev = None\n del self.dict[lru_key]\n print(f'del {lru_key}')\n else:\n self.cnt += 1\n\n node = ListNode(val=key)\n self.dict[key] = {\n 'val': value,\n 'node': node\n }\n if not self.head:\n self.head = node\n self.tail = node\n else:\n self.tail.next = node\n node.prev = self.tail\n self.tail = node\n else:\n self.dict[key]['val'] = value\n node = self.dict[key]['node']\n self._bring_node_to_front(node)\n \n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"818"},{"code":"from sortedcontainers import SortedDict\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.dict = {}\n self.timestamps = SortedDict()\n self.timestamp = 0\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n self.timestamp += 1\n # print (self.dict, self.timestamp, self.timestamps, key)\n \n if key not in self.dict: return -1\n val, old_timestamp = self.dict[key]\n del self.timestamps[old_timestamp]\n self.timestamps[self.timestamp] = key\n self.dict[key] = (val, self.timestamp)\n return val\n\n\n def put(self, key: int, value: int) -> None:\n self.timestamp += 1\n # print (self.dict, self.timestamp, self.timestamps, key, value)\n\n if key not in self.dict:\n self.dict[key] = (value, self.timestamp)\n self.timestamps[self.timestamp] = key\n while len(self.timestamps) > self.capacity:\n evict_ts = self.timestamps.keys()[0]\n evict_key = self.timestamps[evict_ts]\n del self.timestamps[evict_ts]\n del self.dict[evict_key]\n else:\n val, old_timestamp = self.dict[key]\n del self.timestamps[old_timestamp]\n self.timestamps[self.timestamp] = key\n self.dict[key] = (value, self.timestamp)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"841"},{"code":"class DoubleLinkedListNode:\n def __init__(self, k, v, n=None, p=None):\n self.v = v\n self.k = k\n self.next = n\n self.prev = p\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.size = 0\n self.head = DoubleLinkedListNode(-1, -1)\n self.tail = DoubleLinkedListNode(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.map = dict()\n\n def append(self, node):\n prev_tail = self.tail.prev\n \n self.tail.prev = node\n prev_tail.next = node\n\n node.prev = prev_tail\n node.next = self.tail\n \n self.size += 1\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n node.next = None\n node.prev = None\n\n self.size -= 1\n\n def get(self, key: int) -> int:\n if key not in self.map:\n return -1\n\n node = self.map[key]\n self.remove(node)\n self.append(node)\n\n return node.v\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.map:\n node = self.map[key]\n node.v = value\n self.remove(node)\n else:\n node = DoubleLinkedListNode(key, value)\n self.map[key] = node\n\n self.append(node)\n\n # ptr = self.head.next\n # l = []\n # while ptr != self.tail and len(l) < 10:\n # l.append(ptr.v)\n # ptr = ptr.next\n\n # print(l, self.size)\n\n while len(self.map) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.map[node_to_delete.k]\n\n ptr = self.head.next\n l = []\n while ptr != self.tail and len(l) < 10:\n l.append(ptr.v)\n ptr = ptr.next\n\n print(l, self.size)\n \n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"841"},{"code":"class ListNode:\n def __init__(self, val=(0, 0)):\n self.val = val\n self.next = None\n self. prev = None\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cur_size = 0\n self.head = ListNode()\n self.key_node = dict()\n self.capacity = capacity\n self.tail = None\n\n def get(self, key: int) -> int:\n if key in self.key_node:\n key, val = self.key_node[key].val\n self.remove(key)\n self.append(key, val)\n return val\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.key_node:\n self.remove(key)\n self.append(key, value)\n def append(self, key, val):\n print('append', key, val)\n if key in self.key_node:\n raise Exception('key in key_node') \n node = ListNode((key, val))\n self.key_node[key] = node\n if self.tail:\n self.tail.next = node\n node.prev = self.tail\n self.tail = node\n else:\n self.tail = node\n node.prev = self.head\n self.head.next = node\n self.cur_size += 1\n print(self.head.next.val)\n if self.cur_size > self.capacity:\n self.remove(self.head.next.val[0])\n\n\n def remove(self, key):\n node = self.key_node[key]\n prev = node.prev\n nxt = node.next\n if nxt is None:\n self.tail = prev\n prev.next = nxt\n if nxt:\n nxt.prev = prev\n \n del self.key_node[key]\n self.cur_size -= 1\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"865"},{"code":"class LinkedList:\n def __init__(self, key = None, value = None, next = None, prev = None):\n self.key = key\n self.value = value\n self.next = next\n self.prev = prev\n\nclass LRUCache:\n '''\n LRU: 1) head <--> tail\n head <-> (1) <-> tail\n '''\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.LRU_size = 0\n self.LRU_map = {}\n self.LRU_head = LinkedList()\n self.LRU_tail = LinkedList()\n self.LRU_head.next = self.LRU_tail\n self.LRU_tail.prev = self.LRU_head\n\n def __evict_LRU(self) -> None:\n # remove least-recently used from LRU datastructure\n lru_node = self.LRU_tail.prev\n print(f\"Evicting LRU: {lru_node.value}\")\n prev = lru_node.prev\n next = self.LRU_tail\n\n prev.next = next\n next.prev = prev\n\n del self.LRU_map[lru_node.key]\n self.LRU_size -= 1\n\n def __make_MRU(self, key: int, value: int) -> None:\n original_MRU = self.LRU_head.next\n node = LinkedList(key=key, value=value, prev=self.LRU_head, next=original_MRU)\n print(f\"Making MRU: {value}\")\n self.LRU_head.next = node\n original_MRU.prev = node\n self.LRU_map[key] = node\n self.LRU_size += 1\n\n def __evict_some_RU(self, key: int) -> None:\n if key not in self.LRU_map:\n raise ValueError()\n \n node = self.LRU_map[key]\n print(f\"Evicting some RU: {node.value}\")\n # pop off D.L.L.\n prev = node.prev\n next = node.next\n prev.next = next\n next.prev = prev\n\n self.LRU_size -= 1\n\n\n def get(self, key: int) -> int:\n print(f\"Getting key: {key}\")\n # get corresponding value if exists\n if not key in self.LRU_map:\n return -1\n\n node = self.LRU_map[key]\n value = node.value\n self.__evict_some_RU(key)\n self.__make_MRU(key, value)\n return value\n\n def put(self, key: int, value: int) -> None:\n # update or create value at corresponding key\n # update key to be most-recently used\n # 1) if create, easy just add to LRU datastructure\n # 2) if update, pop key from LRU datastructure and add\n # FYI need to check capacity\n print(f\"Putting key, value: {key}, {value}\")\n if key in self.LRU_map:\n self.__evict_some_RU(key)\n elif self.LRU_size == self.capacity:\n lru_key = self.__evict_LRU()\n\n self.__make_MRU(key, value)\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"865"},{"code":"class Node:\n def __init__(self, key, val: int, prev=None, next=None):\n self.key = key\n self.val = val\n self.next = next\n self.prev = prev\n\nclass LRUCache:\n \n def __init__(self, capacity: int):\n self.capacity = capacity\n self.storage = {}\n\n self.head = Node(None, 0, None, None)\n self.tail = Node(None, 0, None, None)\n self.head.next = self.tail\n self.tail.prev = self.head\n def delete(self, key):\n node = self.storage[key]\n #delete\n node.prev.next = node.next\n node.next.prev = node.prev\n node.prev, node.next= None, None\n pass\n def add(self, key, value):\n node = Node(key, value)\n node.prev = self.tail.prev\n node.next = self.tail\n\n node.prev.next = node \n self.tail.prev = node\n\n\n self.storage[key] = node\n\n\n def get(self, key: int) -> int:\n print()\n print('getting...')\n if key in self.storage:\n if self.tail.prev.key == key:\n return self.tail.prev.val\n print('get' , self.head.next.key, self.tail.prev.key)\n self.delete(key)\n node = self.storage[key]\n self.add(node.key, node.val)\n\n #print('get', self.head.next.val, self.tail.val)\n print('get after: ' , self.head.next.key, self.tail.prev.key)\n return self.storage[key].val\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n print()\n print('set')\n if key in self.storage:\n print('exists already')\n self.delete(key)\n self.add(key, value)\n else: #it does not exist\n if len(self.storage) < self.capacity:\n print('doesnt exist, but theres room')\n self.add(key, value)\n else:\n #remove LRU\n \n #add new node\n print('out of room...')\n\n #if self.capacity==1:\n # del self.storage[self.tail.prev.key]\n #else:\n #delete LRU, or left.\n LRU = self.head.next\n # self.head.next = LRU.next\n LRU.next.prev = LRU.prev\n LRU.prev.next = LRU.next\n #self.delete(self.head.next.key)\n del self.storage[LRU.key]\n \n self.add(key, value)\n\n print('set ' , self.head.next.key, self.tail.prev.key)\n \n\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"889"},{"code":"from collections import deque, defaultdict\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.dict_aux = {}\n self.queue = deque()\n self.aux_cap = defaultdict(int)\n\n def get(self, key: int) -> int:\n if key in self.dict_aux:\n self.aux_cap[key] += 1\n self.queue.append(key)\n return self.dict_aux.get(key, -1)\n\n def put(self, key: int, value: int) -> None:\n if key in self.dict_aux:\n self.aux_cap[key] += 1\n self.dict_aux[key] = value\n self.queue.append(key)\n return\n \n if len(self.queue) == (self.capacity + sum(self.aux_cap.values())):\n old_key = self.queue.popleft()\n while old_key in self.aux_cap:\n aux = self.aux_cap.get(old_key)\n if aux == 1:\n del(self.aux_cap[old_key])\n else:\n self.aux_cap[old_key] -= 1\n old_key = self.queue.popleft()\n\n del(self.dict_aux[old_key])\n self.queue.append(key)\n self.dict_aux[key] = value\n\n\n\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"889"},{"code":"class Node:\n def __init__(self, key, val: int, prev=None, next=None):\n self.key = key\n self.val = val\n self.next = next\n self.prev = prev\n\nclass LRUCache:\n \n def __init__(self, capacity: int):\n self.capacity = capacity\n self.storage = {}\n\n self.head = Node(None, 0, None, None)\n self.tail = Node(None, 0, None, None)\n self.head.next = self.tail\n self.tail.prev = self.head\n def delete(self, key):\n node = self.storage[key]\n #delete\n node.prev.next = node.next\n node.next.prev = node.prev\n node.prev, node.next= None, None\n pass\n def add(self, key, value):\n node = Node(key, value)\n node.prev = self.tail.prev\n node.next = self.tail\n\n node.prev.next = node \n self.tail.prev = node\n\n\n self.storage[key] = node\n\n\n def get(self, key: int) -> int:\n print()\n print('getting...')\n if key in self.storage:\n if self.tail.prev.key == key:\n return self.tail.prev.val\n print('get' , self.head.next.key, self.tail.prev.key)\n self.delete(key)\n node = self.storage[key]\n self.add(node.key, node.val)\n\n #print('get', self.head.next.val, self.tail.val)\n print('get after: ' , self.head.next.key, self.tail.prev.key)\n return self.storage[key].val\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n print()\n print('set')\n if key in self.storage:\n print('exists already')\n self.delete(key)\n self.add(key, value)\n else: #it does not exist\n if len(self.storage) < self.capacity:\n print('doesnt exist, but theres room')\n self.add(key, value)\n else:\n #remove LRU\n \n #add new node\n print('out of room...')\n\n if self.capacity==1:\n del self.storage[self.tail.prev.key]\n else:\n #delete LRU, or left.\n LRU = self.head.next\n # self.head.next = LRU.next\n LRU.next.prev = LRU.prev\n LRU.prev.next = LRU.next\n #self.delete(self.head.next.key)\n del self.storage[LRU.key]\n \n self.add(key, value)\n\n print('set ' , self.head.next.key, self.tail.prev.key)\n \n\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"912"},{"code":"class DoubleLinkedListNode:\n def __init__(self, k, v):\n self.k = k\n self.v = v\n self.prev = None\n self.next = None\n def __repr__(self):\n return f'k={self.k}, v={self.v}'\n\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.tail = None\n self.head = None\n self.size = 0\n self.capacity = capacity\n self.cache = {}\n\n def get(self, key: int) -> int:\n k = self.cache.get(key, None)\n print(f\"get {key}\")\n if k:\n self.move_to_front(k)\n return k.v\n return -1\n\n def move_to_front(self, node):\n print(f\"moving {node} to front\")\n if node == self.head:\n pass\n else:\n if node == self.tail:\n self.tail = node.prev\n if node.prev:\n node.prev.next = node.next\n if node.next:\n node.next.prev = node.prev\n node.next = self.head\n if self.head:\n self.head.prev = node\n self.head = node\n print(f\"new head is {self.head}\")\n print(f\"new tail is {self.tail}\")\n\n\n def put(self, key: int, value: int) -> None:\n print(f'put {key}')\n exists = self.cache.get(key, None)\n if exists:\n exists.v = value\n self.move_to_front(exists)\n return\n\n if self.size == self.capacity:\n if not self.tail:\n print(f'h=[{self.head}], size={self.size}')\n raise ValueError\n del self.cache[self.tail.k]\n self.tail = self.tail.prev\n self.size -= 1\n\n node = DoubleLinkedListNode(key, value)\n if self.size == 0:\n self.tail = node\n else:\n self.head.prev = node\n node.next = self.head\n\n self.size += 1\n self.head = node\n self.cache[key] = node\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"912"},{"code":"class Node:\n def __init__(self, val):\n self.val = val\n self.next = None\n self.prev = None\n\nclass DLL:\n def __init__(self):\n self.size = 0\n self.head = None\n self.tail = None\n\n def appendleft(self, node):\n node.next = self.head\n if self.head:\n self.head.prev = node\n self.head = node\n if self.size == 0:\n self.tail = node\n self.size += 1\n\n def remove(self, node):\n if node == self.head:\n self.head = self.head.next\n if self.head:\n self.head.prev = None\n else:\n if node.prev:\n node.prev.next = node.next\n if node.next:\n node.next.prev = node.prev\n \n if node == self.tail:\n if self.tail:\n self.tail = self.tail.prev\n self.size -= 1\n\n def pop(self):\n node = self.tail\n self.tail = self.tail.prev\n if self.tail:\n self.tail.next = None\n self.size -= 1\n return node\n \nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.H = {}\n self.dll = DLL()\n self.capacity = capacity\n \n def get(self, key: int) -> int:\n if key not in self.H:\n print(\"get missing\", key, -1, (self.dll.size, self.capacity))\n return -1\n node = self.H[key]\n self.dll.remove(node)\n self.dll.appendleft(node)\n print(\"get\", key, node.val, (self.dll.size, self.capacity))\n return node.val[1]\n\n def put(self, key: int, value: int) -> None:\n node = Node((key, value))\n if key in self.H:\n self.dll.remove(self.H[key])\n \n self.dll.appendleft(node)\n print(\"Adding\", key, (self.dll.size, self.capacity))\n if self.dll.size > self.capacity:\n tmp = self.dll.pop()\n print(\"Removing\", tmp.val[0], (self.dll.size, self.capacity))\n self.H.pop(tmp.val[0])\n print(\"Removed\", tmp.val[0], (self.dll.size, self.capacity))\n\n self.H[key] = node\n\n \n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"936"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.d = {}\n self.l_head = Node(None, None)\n self.l_tail = Node(None, None)\n self.l_head.next=self.l_tail\n self.l_tail.next = None\n self.l_head.prev = None\n self.l_tail.prev = self.l_head\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key not in self.d:\n return -1\n\n node = self.d[key]\n #self.evict(node)\n node.prev.next = node.next\n node.next.prev = node.prev\n self.move_to_end(node)\n return node.val\n \n def move_to_end(self, node):\n node.next = self.l_tail\n node.prev = self.l_tail.prev\n self.l_tail.prev.next = node\n self.l_tail.prev = node\n\n def put(self, key: int, value: int) -> None:\n print (\"op : put \" , key, value, \"head \" , self.l_head.next.key, self.l_head.next.val)\n\n if key in self.d:\n node = self.d[key]\n node.val = value\n node.prev.next = node.next\n node.next.prev = node.prev\n print (\"put update\" , node.key , node.val)\n self.move_to_end(node)\n print (\"op_post : put \" , key, value, \"head \" , self.l_head.next.key, self.l_head.next.val)\n return\n\n if len(self.d) == self.capacity:\n print (\"put new with evict\" , key , value)\n self.evict(self.l_head.next)\n\n \n node = Node(key, value)\n self.d[key] = node\n self.move_to_end(node)\n print (\"op_post : put \" , key, value, \"head \" , self.l_head.next.key, self.l_head.next.val)\n\n def evict(self, node):\n print (\"evict \", node.key , node.val)\n node.prev.next = node.next\n node.next.prev = node.prev\n del self.d[node.key]\n \n\nclass Node:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.prev = None\n self.next = None\n \n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"936"},{"code":"class Node:\n def __init__(self, key, value, next_node, prev_node):\n self.key = key\n self.value = value\n self.next = next_node\n self.prev = prev_node\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.numb_ele = 0\n self.cache = dict()\n self.begin = None\n self.end = None\n self.recent = list()\n\n def get(self, key: int) -> int:\n print(\"get: \", key)\n ret = self.cache.get(key, -1)\n if ret != -1:\n # print(ret.key, ret.value)\n prev_node = ret.prev\n next_node = ret.next\n print(prev_node, next_node)\n \n if prev_node != None:\n prev_node.next = next_node\n if next_node != None:\n next_node.prev = prev_node\n else:\n self.end = prev_node\n self.begin.prev = ret\n ret.next = self.begin\n ret.prev = None\n self.begin = ret\n \n return ret.value\n return ret\n\n def put(self, key: int, value: int) -> None:\n print(\"put: \", key, value)\n \n if self.get(key) != -1:\n self.cache[key].value = value\n else:\n new_node = Node(key=key, value=value, next_node=self.begin, prev_node=None)\n # print(\"else: \", self.begin, self.end)\n self.cache[key] = new_node\n \n self.numb_ele += 1\n if self.numb_ele == 1:\n self.end = new_node\n else:\n self.begin.prev = new_node\n print(\"put, begin\", self.begin.key, self.begin.prev)\n self.begin = new_node\n if self.numb_ele > self.capacity:\n end_node = self.end\n new_end = end_node.prev\n new_end.next = None\n self.cache.pop(self.end.key, None)\n self.end = new_end\n self.numb_ele -= 1\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"959"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.ts = 0\n self.capacity = capacity\n self.history = []\n\n def get(self, key: int) -> int:\n if not key in self.cache:\n return -1\n\n val, ts = self.cache[key]\n self.ts += 1\n self.cache[key] = [val, self.ts]\n self.history.append([key, self.ts])\n return val\n\n def put(self, key: int, value: int) -> None:\n self.ts += 1\n self.cache[key] = [value, self.ts]\n self.history.append([key, self.ts])\n self.evict()\n\n def evict(self):\n if len(self.cache) <= self.capacity:\n return\n\n n = 0\n for key, ts in self.history:\n if len(self.cache) <= self.capacity:\n break\n v, t = self.cache[key]\n if t == ts:\n del self.cache[key]\n n += 1\n\n self.history = self.history[n:]\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"959"},{"code":"'''class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache=[]\n self.cap=capacity\n self.dicti=dict()\n \n\n def get(self, key: int) -> int:\n if key in self.dicti:\n #print(self.cache)\n self.cache.remove(key)\n self.cache.append(key)\n return self.dicti[key]\n else:\n return -1\n\n\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.dicti:\n self.dicti[key]=value\n self.cache.remove(key)\n self.cache.append(key)\n\n else:\n if len(self.cache)<self.cap:\n \n self.cache.append(key)\n self.dicti[key]=value\n else:\n p=self.cache.pop(0)\n self.cache.append(key)\n self.dicti[key]=value\n self.dicti.pop(p)\n'''\nclass LRUCache:\n def __init__(self, capacity):\n self.dict = {}\n self.freeSpace = capacity\n\n\n def get(self, key):\n if key not in self.dict:\n return -1\n\n self.dict[key] = self.dict.pop(key)\n\n return self.dict[key]\n\n\n def put(self, key, value):\n if key in self.dict:\n self.dict.pop(key)\n else:\n if self.freeSpace:\n self.freeSpace -= 1\n else:\n first=list(self.dict.keys())[0]\n #self.dict.pop(next(iter(self.dict)))\n self.dict.pop(first)\n\n self.dict[key] = value\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"983"},{"code":"class Node:\n def __init__(self, val=0, key=0, next=None, prev=None):\n self.next = next\n self.prev = prev\n self.val = val\n self.key = key\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.cap = capacity\n self.cache = {}\n self.lru = Node()\n self.mru = Node()\n self.mru.prev = self.lru\n self.lru.next = self.mru\n\n def insert(self, new_node):\n n = self.mru.prev\n new_node.next = self.mru\n new_node.prev = n\n self.mru.prev = new_node\n n.next = new_node\n\n def remove(self, cur_node):\n n1 = cur_node.prev\n n2 = cur_node.next\n n1.next = n2\n n2.prev = n1\n\n def get(self, key: int) -> int:\n # print(self.lru.next.key, self.lru.next.val )\n if key in self.cache:\n self.remove(self.cache[key])\n self.insert(self.cache[key])\n return self.cache[key].val\n else:\n return -1\n \n def put(self, key: int, value: int) -> None:\n print(f'before put {key},{value}:', \n 'mr:', self.mru.prev.key,self.mru.prev.val, \n 'lr:', self.lru.next.key,self.lru.next.val)\n if len(self.cache) < self.cap:\n if key not in self.cache:\n new_node = Node(value, key)\n self.cache[key] = new_node\n else:\n self.remove(self.cache[key])\n self.cache[key].val = value \n else:\n if key not in self.cache:\n to_del_node = self.lru.next\n print('to_del_node', to_del_node.key, to_del_node.val)\n del self.cache[to_del_node.key]\n self.remove(to_del_node)\n\n new_node = Node(value, key)\n self.cache[key] = new_node\n else:\n self.remove(self.cache[key])\n self.cache[key].val = value\n\n self.insert(self.cache[key])\n print(f'after put {key},{value}:', \n 'mr:', self.mru.prev.key,self.mru.prev.val, \n 'lr:', self.lru.next.key,self.lru.next.val)\n print()\n \n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"983"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cap = capacity\n self.store = {}\n\n def get(self, key: int) -> int:\n val = self.store.get(key, -1)\n if val != -1:\n del self.store[key]\n self.store[key] = val\n return val\n\n def put(self, key: int, value: int) -> None:\n if self.store.get(key):\n del self.store[key]\n self.store[key] = value\n else:\n if len(self.store) == self.cap:\n del self.store[list(self.store.keys())[0]]\n self.store[key] = value\n else:\n self.store[key] = value\n # print(self.store)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1006"},{"code":"class DLL:\n def __init__(self, key = 0, left = None, right = None):\n self.key = key\n self.left = left\n self.right = right\n \n\n\nclass LRUCache:\n def print_ptr(self, ptr):\n ans = []\n max_size = 10\n while ptr is not None and max_size:\n ans.append(ptr.key)\n ptr = ptr.right\n max_size -= 1\n print(ans)\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.size = 0\n\n self.cache = {}\n self.act_map = {}\n\n self.head = DLL() \n self.end = self.head\n \n def delink_ptr(self, ptr):\n if ptr is None:\n return \n _left = ptr.left\n _right = ptr.right\n if _right:\n _left.right , _right.left = _right, _left\n else:\n _left.right= None\n self.end = _left\n return ptr\n\n def update_ptr(self, ptr):\n if ptr is None:\n return \n \n if ptr == self.end:\n return\n\n ptr = self.delink_ptr(ptr)\n self.end.right = ptr\n ptr.left = self.end \n ptr.right = None \n self.end = ptr\n\n\n def get(self, key: int) -> int:\n print(\"\\n\\n\")\n print(f\"get: {key}\")\n if self.cache.get(key, None):\n ptr = self.cache.get(key, None)\n self.update_ptr(ptr)\n (self.print_ptr(self.head))\n return self.act_map[key] \n return -1 \n\n\n\n def put(self, key: int, value: int) -> None:\n print(\"\\n\\n\")\n print(f\"put: {key}\")\n\n if self.cache.get(key, None):\n ptr = self.cache.get(key, None)\n self.update_ptr(ptr)\n \n else:\n if self.size == self.capacity:\n ptr = self.delink_ptr(self.head.right)\n self.cache[ptr.key] = None\n else:\n self.size += 1\n\n ptr = DLL(key, self.end, None)\n self.cache[key], self.end.right, self.end = ptr, ptr, ptr\n \n # print(f\"put: {key}\")\n (self.print_ptr(self.head))\n self.act_map[key] = value \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1006"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cap = capacity\n self.store = {}\n\n def get(self, key: int) -> int:\n val = self.store.get(key, -1)\n if val != -1:\n del self.store[key]\n self.store[key] = val\n return val\n\n def put(self, key: int, value: int) -> None:\n if self.store.get(key):\n del self.store[key]\n self.store[key] = value\n else:\n if len(self.store) == self.cap:\n del self.store[list(self.store.keys())[0]]\n self.store[key] = value\n else:\n self.store[key] = value\n # print(self.store)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1030"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cap = capacity\n self.cache_map = {}\n \n\n def get(self, key: int) -> int:\n if key in self.cache_map:\n val = self.cache_map[key]\n del self.cache_map[key]\n self.cache_map[key] = val\n return val\n else:\n return -1\n \n def put(self, key: int, value: int) -> None:\n if key in self.cache_map:\n del self.cache_map[key]\n self.cache_map[key] = value\n else:\n if len(self.cache_map) < self.cap:\n self.cache_map[key] = value\n else:\n del self.cache_map[list(self.cache_map)[0]]\n self.cache_map[key] = value\n\n\n\n \n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1030"},{"code":"class LRUCache:\n from collections import OrderedDict\n def __init__(self, capacity: int):\n self.capacity=capacity\n self.cache=DefaultDict()\n\n def makeRecent(self, key):\n value=self.cache[key]\n del self.cache[key]\n self.cache[key]=value\n\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.makeRecent(key)\n return self.cache[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.makeRecent(key)\n self.cache[key]=value\n else:\n if len(self.cache)>=self.capacity:\n oldest_key=list(self.cache)[0]\n del self.cache[oldest_key]\n\n self.cache[key]=value\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1054"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.holder = {}\n self.maxhold = capacity\n\n def get(self, key: int) -> int:\n if key not in self.holder:\n return -1\n val = self.holder[key]\n self.holder.pop(key)\n self.holder[key]=val\n return val\n\n#[_2_:_2_,_1_:_1_]\n\n def put(self, key: int, value: int) -> None:\n if key in self.holder.keys():\n self.holder.pop(key)\n self.holder[key] = value #added at the end saying it is most recently used\n else:\n if len(self.holder)>=self.maxhold:#remove in front (least recently used) and add at last\n removekeys = list(self.holder.keys()) #must make .keys to list (cause its just for viewing)\n removekeys = removekeys[0]\n self.holder.pop(removekeys) \n self.holder[key]=value\n\n else:#add in the last \n self.holder[key]=value\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)\n\n","runtime":"1054"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n\n def get(self, key: int) -> int:\n if key in self.cache.keys():\n temp = [ key , self.cache[key] ]\n del self.cache[key]\n self.cache[key] = temp[1]\n return self.cache[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache.keys():\n del self.cache[key]\n self.cache[key] = value\n elif len(self.cache) >= self.capacity:\n del self.cache[list(self.cache)[0]]\n self.cache[key] = value\n else:\n self.cache[key] = value\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1077"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.map = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if self.map.get(key) is not None:\n val = self.map[key]\n del(self.map[key]) \n self.map[key] = val\n return val\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if not self.map.get(key):\n if len(self.map.keys()) == self.capacity:\n i = list(self.map.keys())[0]\n del(self.map[i])\n else:\n del(self.map[key])\n \n self.map[key] = value\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1077"},{"code":"\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.hmap = {}\n self.count = 0\n self.lru = {}\n self.age = 0\n self.age_to_key = {}\n\n def get(self, key: int) -> int:\n if key in self.hmap:\n self.age += 1\n self.lru.pop(key)\n self.lru[key] = self.age\n self.age_to_key[self.age] = key\n return self.hmap.get(key)\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if self.count < self.capacity and key not in self.hmap:\n self.hmap[key] = value\n self.count += 1\n self.age += 1\n self.lru[key] = self.age\n self.age_to_key[self.age] = key\n elif key in self.hmap:\n self.hmap[key] = value\n self.age += 1\n self.lru.pop(key)\n self.lru[key] = self.age\n self.age_to_key[self.age] = key\n elif self.count >= self.capacity:\n least = float('inf')\n remove_key = None\n keys = list(self.lru.keys())\n remove_key = keys[0]\n self.age += 1\n self.lru.pop(remove_key)\n self.hmap.pop(remove_key)\n self.hmap[key] = value\n self.lru[key] = self.age\n \n \n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1101"},{"code":"\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.hmap = {}\n self.count = 0\n self.lru = {}\n self.age = 0\n self.age_to_key = {}\n\n def get(self, key: int) -> int:\n if key in self.hmap:\n self.age += 1\n self.lru.pop(key)\n self.lru[key] = self.age\n self.age_to_key[self.age] = key\n return self.hmap.get(key)\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if self.count < self.capacity and key not in self.hmap:\n self.hmap[key] = value\n self.count += 1\n self.age += 1\n self.lru[key] = self.age\n self.age_to_key[self.age] = key\n elif key in self.hmap:\n self.hmap[key] = value\n self.age += 1\n self.lru.pop(key)\n self.lru[key] = self.age\n self.age_to_key[self.age] = key\n elif self.count >= self.capacity:\n least = float('inf')\n remove_key = None\n keys = list(self.lru.keys())\n remove_key = keys[0]\n self.age += 1\n self.lru.pop(remove_key)\n self.hmap.pop(remove_key)\n self.hmap[key] = value\n self.lru[key] = self.age\n \n \n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1101"},{"code":"\nclass LRUCache:\n # built by 2 data structure: doubly LL & HashMap\n\n #self.dict[key]: This retrieves the value associated with the key key from the dictionary self.dict.\n #self.dict.key(): This calls a method named key() that belongs to the object self.dict.\n def __init__(self, capacity: int):\n # self.capacity = capacity\n # self.dict = {}\n self.capacity = capacity\n self.dict = {}\n\n def get(self, key: int) -> int:\n # if key in self.dict.keys():\n # value = self.dict[key]\n # del self.dict[key]\n # self.dict[key] = value\n # return value\n # else:\n # return -1\n if key in self.dict.keys():\n val = self.dict[key]\n del self.dict[key]\n self.dict[key] = val\n return val\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n # if key in self.dict.keys():\n # del self.dict[key]\n # self.dict[key] = value\n # else:\n # if len(self.dict) < self.capacity:\n # self.dict[key] = value\n # else:\n # del self.dict[list(self.dict)[0]]\n # self.dict[key] = value \n if key in self.dict.keys():\n del self.dict[key]\n self.dict[key] = value\n else:\n if len(self.dict) < self.capacity:\n self.dict[key] = value\n else:\n del self.dict[list(self.dict)[0]]\n \n self.dict[key] = value \n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)\n","runtime":"1124"},{"code":"class Node:\n def __init__(self, val, prev=None, next_=None):\n self.val = val\n self.prev = prev\n self.next = next_\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.__size = capacity\n self.__map = {}\n self.initialise()\n\n \n def initialise(self):\n self.head = Node(-1)\n self.tail = Node(-1)\n self.head.next = self.tail\n self.tail.prev = self.head\n \n\n def get(self, key: int) -> int:\n if key in self.__map:\n self.update_lru(key)\n return self.__map[key].val\n else:\n return -1\n \n def put(self, key: int, value: int) -> None:\n if key in self.__map:\n self.__map[key].val = value\n self.update_lru(key)\n else:\n if len(self.__map) >= self.__size:\n self.delete_node()\n self.__map[key] = Node(value)\n self.append_node(key)\n \n def append_node(self, key):\n node = self.__map[key]\n\n node.next = self.head.next\n node.prev = self.head\n self.head.next.prev = node\n self.head.next = node\n\n def delete_node(self):\n node = self.tail.prev\n\n self.tail.prev = node.prev\n node.prev.next = self.tail\n\n for i, j in self.__map.items():\n if j == node:\n del self.__map[i]\n break\n\n def update_lru(self, key):\n node = self.__map[key]\n node.prev.next = node.next\n node.next.prev = node.prev\n\n self.head.next.prev = node\n node.next = self.head.next\n node.prev = self.head\n self.head.next = node\n\n\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1148"},{"code":"class Node :\n def __init__(self, val = None ):\n self.next = None\n self.prev = None\n self.val = val\n \nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.hashmap = {}\n self.head = Node()\n self.tail = Node()\n self.head.next = self.tail\n self.tail.prev = self.head\n self.count = 0\n\n # when inserting we can insert at head\n # pop from tail\n # so tail will have the most recently used\n\n def remove(self, node) :\n next_node = node.next\n prev_node = node.prev\n\n prev_node.next = next_node\n next_node.prev = prev_node\n\n self.insert_at_head(node)\n\n def insert_at_head(self, node) :\n # Now insert at head\n next_node_head = self.head.next\n self.head.next = node\n node.next = next_node_head\n node.prev = self.head\n next_node_head.prev = node\n \n def get(self, key: int) -> int:\n if key in self.hashmap :\n # Pop from linked list\n self.remove(self.hashmap[key])\n return self.hashmap[key].val\n else :\n return -1 \n \n def put(self, key: int, value: int) -> None:\n if self.head.next :\n print(self.head.next.val)\n # So that would be ,\n if key in self.hashmap : # For Updating the value only\n # The node exists, so updating the value\n self.hashmap[key].val = value\n self.remove(self.hashmap[key])\n else :\n new_node = Node(value)\n self.hashmap[key] = new_node\n if self.count < self.capacity : \n # We insert at head position\n # Now put it at the head\n self.insert_at_head(new_node)\n self.count += 1\n else :\n # If its greater than capacity, then we need to remove from tail\n prev_node = self.tail.prev.prev # This is the LRU\n prev_node_removed = self.tail.prev\n prev_node.next = self.tail\n self.tail.prev = prev_node\n # Remove this node from hashmap as well\n\n for k, v in self.hashmap.items() :\n if v == prev_node_removed :\n del self.hashmap[k]\n break\n \n # now we can insert the node at the head\n self.insert_at_head(new_node)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1172"},{"code":"from bisect import insort\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.consequence = 0\n self.cache_list = []\n self.key_cache_vect = []\n self.consequence_cache_vect = []\n\n def binary_search(self, vect, key):\n left, right = 0, len(vect) - 1\n while left <= right:\n mid = left + (right - left) // 2\n if vect[mid][0] == key:\n return mid\n elif vect[mid][0] < key:\n left = mid + 1\n else:\n right = mid - 1\n return None\n\n def get(self, key: int) -> int:\n # check if key exists\n key_cache_ind = self.binary_search(self.key_cache_vect, key)\n if key_cache_ind is not None:\n # update consequence_cache_vect\n cache_ind = self.key_cache_vect[key_cache_ind][1]\n old_consequence = self.cache_list[cache_ind]['consequence']\n consequence_cache_ind = self.binary_search(self.consequence_cache_vect, old_consequence)\n\n insort(self.consequence_cache_vect, [self.consequence, cache_ind])\n self.consequence_cache_vect.pop(consequence_cache_ind)\n #self.consequence_cache_vect[consequence_cache_ind][0] = self.consequence\n #self.consequence_cache_vect.sort()\n\n\n # update cache_list\n self.cache_list[cache_ind]['consequence'] = self.consequence\n self.consequence += 1\n # get the value\n return self.cache_list[cache_ind]['value']\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n # check if key exists\n key_cache_ind = self.binary_search(self.key_cache_vect, key)\n if key_cache_ind is not None:\n # update consequence_cache_vect\n cache_ind = self.key_cache_vect[key_cache_ind][1]\n old_consequence = self.cache_list[cache_ind]['consequence']\n consequence_cache_ind = self.binary_search(self.consequence_cache_vect, old_consequence)\n\n insort(self.consequence_cache_vect, [self.consequence, cache_ind])\n self.consequence_cache_vect.pop(consequence_cache_ind)\n #self.consequence_cache_vect[consequence_cache_ind][0] = self.consequence\n #self.consequence_cache_vect.sort()\n \n \n # update cache value\n self.cache_list[cache_ind]['value'] = value\n self.cache_list[cache_ind]['consequence'] = self.consequence\n self.consequence += 1\n return None\n cache_Len = len(self.cache_list)\n new_cache = {'key': key, 'value': value, 'consequence': self.consequence}\n if cache_Len < self.capacity:\n # put new cache\n self.cache_list.append(new_cache)\n \n insort(self.key_cache_vect, [key, cache_Len])\n #self.key_cache_vect.append([key, cache_Len])\n #self.key_cache_vect.sort()\n\n insort(self.consequence_cache_vect, [self.consequence, cache_Len])\n #self.consequence_cache_vect.append([self.consequence, cache_Len])\n #self.consequence_cache_vect.sort()\n self.consequence += 1\n else:\n # evict by new cache\n # update consequence_cache_vect\n ind = self.consequence_cache_vect[0][1]\n \n insort(self.consequence_cache_vect, [self.consequence, ind])\n #self.consequence_cache_vect.append([self.consequence, ind])\n #self.consequence_cache_vect.sort()\n self.consequence_cache_vect.pop(0)\n \n # update cache_list\n old_key = self.cache_list[ind]['key']\n self.cache_list[ind] = new_cache\n self.consequence += 1\n # update key_cache_vect\n key_cache_ind = self.binary_search(self.key_cache_vect, old_key)\n self.key_cache_vect.pop(key_cache_ind)\n insort(self.key_cache_vect, [key, ind])\n #self.key_cache_vect.append([key, ind])\n #self.key_cache_vect.sort()\n return None\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)\n","runtime":"1195"},{"code":"from typing import Dict, List\n'''\n 10s : 1\n 20s : 1\n 30s: 2\n 40s: 1 \n 50s : 3\n\n 1 : 10s, 20s,40s\n 2: 30s\n\n 30s : 2\n 40s: 1\n\n'''\nfrom collections import OrderedDict\nfrom datetime import datetime\n\ni = 0\ndef get_i():\n global i\n i+=1\n return i\n\nclass CacheValue:\n last_timestamp: int\n value: int\n \n def __init__(self, v: int):\n self.value = v\n self.last_timestamp = get_i()\n\nclass LRUCache:\n caches: dict[int, CacheValue]\n hisotry : OrderedDict\n size : int \n \n \n def __init__(self, capacity: int):\n self.size = capacity\n self.caches = {}\n self.history = {}\n \n def get(self, key: int) -> int:\n if key in self.caches:\n self.update_history(key)\n #self.show(f'get {key}')\n return self.caches[key].value\n else:\n #self.show(f'get {key}')\n return -1\n \n def put(self, key: int, value: int) -> None:\n #print(f\"size: {self.size}\")\n if key in self.caches:\n self.caches[key].value = value \n self.update_history(key) \n #self.show(f'put({key}, {value})')\n return\n\n if len(self.caches)==self.size:\n # sort hisotry\n ordered_timestamp = sorted(self.history.keys())\n least_used_timestamp = ordered_timestamp[0]\n least_used_key = self.history[least_used_timestamp]\n \n del self.caches[least_used_key] \n del self.history[least_used_timestamp] \n \n self.caches[key] = CacheValue(value) \n self.add_history(key) \n #self.show(f'put({key}, {value})')\n \n def add_history(self, key:int) ->None:\n cached_value = self.caches[key]\n self.history[cached_value.last_timestamp] = key\n \n def update_history(self, key:int) ->None:\n # delete old timestamp history\n cached_value = self.caches[key]\n old_timestamp = cached_value.last_timestamp\n del self.history[old_timestamp]\n \n # update timestamp in caches and history dict\n \n new_timestamp = get_i()\n \n cached_value.last_timestamp = new_timestamp\n self.history[new_timestamp] = key\n \n def show(self, action) -> None:\n print(f\"----{action}\")\n print('history')\n print(self.history)\n print('caches')\n #print(self.caches)\n for k, v in self.caches.items():\n print(f\"cache: key-{k} value-{v.value} timestamp-{v.last_timestamp}\")\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1219"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.max_size = capacity\n\n def get(self, key: int) -> int:\n if key in self.cache:\n tmp = self.cache.pop(key)\n self.cache[key] = tmp\n return self.cache[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n prev_size = len(self.cache)\n self.cache[key] = value\n if prev_size == len(self.cache):\n tmp = self.cache.pop(key)\n self.cache[key] = tmp\n if len(self.cache) > self.max_size:\n keys = list(self.cache.keys())\n self.cache.pop(list(self.cache.keys())[0])\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1242"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.young = 0\n self.capacity = capacity \n self.hashmap_of_dict_priority = {}\n self.hashmap_of_dict_age = {}\n self.hashmap_of_dict_val = {}\n \n\n def get(self, key: int) -> int:\n #print(self.hashmap_of_dict_val)\n if key in self.hashmap_of_dict_val:\n self.hashmap_of_dict_priority[self.young] = key\n age = self.hashmap_of_dict_age[key]\n self.hashmap_of_dict_age[key] = self.young\n del self.hashmap_of_dict_priority[age]\n self.young +=1\n return self.hashmap_of_dict_val[key]\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n #print(self.hashmap_of_dict_val)\n if key in self.hashmap_of_dict_val:\n self.hashmap_of_dict_priority[self.young] = key\n age = self.hashmap_of_dict_age[key]\n self.hashmap_of_dict_age[key] = self.young\n del self.hashmap_of_dict_priority[age]\n self.hashmap_of_dict_val[key] = value\n self.young +=1\n return \n\n if len(self.hashmap_of_dict_val) == self.capacity:\n del_key_priority = min(self.hashmap_of_dict_priority)\n del_key = self.hashmap_of_dict_priority[del_key_priority]\n del self.hashmap_of_dict_val[del_key]\n del self.hashmap_of_dict_priority[del_key_priority]\n del self.hashmap_of_dict_age[del_key]\n self.hashmap_of_dict_val[key] = value\n self.hashmap_of_dict_priority[self.young] = key\n self.hashmap_of_dict_age[key] = self.young\n self.young +=1\n\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1266"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cap = capacity\n self.time = 0\n self.time_to_key = {} # time:key\n self.key_to_time = {} # key:time\n self.key_to_val = {} # key:value\n\n def get(self, key: int) -> int:\n if key not in self.key_to_val:\n return -1\n prev_time = self.key_to_time[key]\n self.key_to_time[key] = self.time\n del self.time_to_key[prev_time]\n self.time_to_key[self.time] = key\n self.time += 1\n return self.key_to_val[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.key_to_val:\n self.key_to_val[key] = value\n prev_time = self.key_to_time[key]\n del self.time_to_key[prev_time]\n self.time_to_key[self.time] = key\n self.key_to_time[key] = self.time\n else:\n if len(self.key_to_val) == self.cap:\n min_time = min(self.time_to_key)\n min_key = self.time_to_key[min_time]\n del self.time_to_key[min_time]\n del self.key_to_time[min_key]\n del self.key_to_val[min_key]\n self.time_to_key[self.time] = key\n self.key_to_time[key] = self.time\n self.key_to_val[key] = value\n self.time += 1\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1289"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.size = capacity\n self.map_key_rec = {} # To record when the key was last used\n self.map_rec_key = {} # To map recency counts to keys\n self.map_key_value = {} # To store key-value pairs\n self.count = 0 # Instance variable to track recency\n\n def get(self, key: int) -> int:\n if key in self.map_key_rec:\n self.count += 1\n rec_count = self.map_key_rec[key]\n del self.map_rec_key[rec_count] # Remove old recency\n self.map_key_rec[key] = self.count\n self.map_rec_key[self.count] = key # Update with new recency\n return self.map_key_value[key]\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.map_key_rec:\n # Update the value and recency if key already exists\n rec_count = self.map_key_rec[key]\n del self.map_rec_key[rec_count] # Remove old recency\n elif len(self.map_key_value) >= self.size:\n # Evict the least recently used key\n oldest_recency = min(self.map_rec_key.keys())\n lru_key = self.map_rec_key[oldest_recency]\n del self.map_key_value[lru_key]\n del self.map_key_rec[lru_key]\n del self.map_rec_key[oldest_recency]\n \n # Insert the new key-value pair\n self.map_key_value[key] = value\n self.count += 1\n self.map_key_rec[key] = self.count\n self.map_rec_key[self.count] = key\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1313"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.young = 0\n self.capacity = capacity \n self.hashmap_of_dict_priority = {}\n self.hashmap_of_dict_age = {}\n self.hashmap_of_dict_val = {}\n \n\n def get(self, key: int) -> int:\n #print(self.hashmap_of_dict_val)\n if key in self.hashmap_of_dict_val:\n self.hashmap_of_dict_priority[self.young] = key\n age = self.hashmap_of_dict_age[key]\n self.hashmap_of_dict_age[key] = self.young\n del self.hashmap_of_dict_priority[age]\n self.young +=1\n return self.hashmap_of_dict_val[key]\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n #print(self.hashmap_of_dict_val)\n if key in self.hashmap_of_dict_val:\n self.hashmap_of_dict_priority[self.young] = key\n age = self.hashmap_of_dict_age[key]\n self.hashmap_of_dict_age[key] = self.young\n del self.hashmap_of_dict_priority[age]\n self.hashmap_of_dict_val[key] = value\n self.young +=1\n return \n\n if len(self.hashmap_of_dict_val) == self.capacity:\n del_key_priority = min(self.hashmap_of_dict_priority)\n del_key = self.hashmap_of_dict_priority[del_key_priority]\n del self.hashmap_of_dict_val[del_key]\n del self.hashmap_of_dict_priority[del_key_priority]\n del self.hashmap_of_dict_age[del_key]\n self.hashmap_of_dict_val[key] = value\n self.hashmap_of_dict_priority[self.young] = key\n self.hashmap_of_dict_age[key] = self.young\n self.young +=1\n\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1337"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.keyCount = 0\n self.capacity = capacity\n self.use = {}\n self.step = 100\n self.minKey = None\n \n\n def get(self, key: int) -> int:\n self.step += 1\n if key in self.cache:\n lastUse, val = self.cache[key]\n del self.use[lastUse]\n self.use[self.step] = key\n self.cache[key] = (self.step, val)\n if self.minKey == lastUse:\n self.minKey = min(self.use.keys())\n \n return val\n else:\n return -1\n\n \n\n def put(self, key: int, value: int) -> None:\n self.step += 1\n if key in self.cache:\n lastUse, _ = self.cache[key]\n del self.use[lastUse]\n self.use[self.step] = key\n self.cache[key] = (self.step, value)\n\n if self.minKey == lastUse:\n self.minKey = min(self.use.keys())\n elif self.keyCount < self.capacity:\n self.cache[key] = (self.step, value)\n self.use[self.step] = key\n self.keyCount += 1\n if self.minKey is None:\n self.minKey = self.step\n else:\n ejectedKey = self.use[self.minKey]\n del self.use[self.minKey]\n if ejectedKey in self.cache:\n del self.cache[ejectedKey]\n self.cache[key] = (self.step, value)\n self.use[self.step] = key\n self.minKey = min(self.use.keys())\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1360"},{"code":"class LRUCache:\n\n class Node:\n def __init__(self, val):\n self.val = val\n self.prev = None\n self.next = None\n\n def __init__(self, capacity: int):\n self.keys_to_nodes = {}\n self.sentinel = self.Node(0)\n self.sentinel.prev = self.sentinel\n self.sentinel.next = self.sentinel\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key not in self.keys_to_nodes:\n return -1\n self.remove(self.keys_to_nodes[key])\n self.add(self.keys_to_nodes[key])\n return self.keys_to_nodes[key].val\n\n def put(self, key: int, value: int) -> None:\n if key in self.keys_to_nodes:\n new_node = self.Node(value)\n self.remove(self.keys_to_nodes[key])\n self.keys_to_nodes[key] = new_node\n self.add(new_node)\n elif self.capacity > 0:\n new_node = self.Node(value)\n self.keys_to_nodes[key] = new_node\n self.add(new_node)\n self.capacity -= 1\n else:\n # print(f\"REMOVING {self.sentinel.prev.val}\")\n last_node = self.sentinel.prev\n bad_key = None\n for val in self.keys_to_nodes.keys():\n if self.keys_to_nodes[val] == last_node:\n bad_key = val\n break\n del self.keys_to_nodes[bad_key]\n self.remove(last_node)\n new_node = self.Node(value)\n self.keys_to_nodes[key] = new_node\n self.add(new_node)\n\n def add(self, value) -> None:\n temp = self.sentinel.next \n self.sentinel.next = value\n value.next = temp\n value.prev = self.sentinel\n value.next.prev = value\n # print(f\"ADDED {value.val}\")\n # print(self.sentinel.prev.val, self.sentinel.next.val)\n\n def remove(self, value) -> None:\n value.prev.next = value.next\n value.next.prev = value.prev\n # print(f\"REMOVED {value.val}\")\n # print(self.sentinel.prev, self.sentinel.next)\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1384"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cap = capacity\n self.time = 0\n self.time_to_key = {} # time:key\n self.key_to_time = {} # key:time\n self.key_to_val = {} # key:value\n\n def get(self, key: int) -> int:\n if key not in self.key_to_val:\n return -1\n prev_time = self.key_to_time[key]\n self.key_to_time[key] = self.time\n del self.time_to_key[prev_time]\n self.time_to_key[self.time] = key\n self.time += 1\n return self.key_to_val[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.key_to_val:\n self.key_to_val[key] = value\n prev_time = self.key_to_time[key]\n del self.time_to_key[prev_time]\n self.time_to_key[self.time] = key\n self.key_to_time[key] = self.time\n else:\n if len(self.key_to_val) == self.cap:\n min_time = min(self.time_to_key)\n min_key = self.time_to_key[min_time]\n del self.time_to_key[min_time]\n del self.key_to_time[min_key]\n del self.key_to_val[min_key]\n self.time_to_key[self.time] = key\n self.key_to_time[key] = self.time\n self.key_to_val[key] = value\n self.time += 1\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1407"},{"code":"class LRUCache:\n cache = {}\n lru = {}\n capacity = 0\n count = 0\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.lru = {}\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.lru.pop(self.cache[key][1])\n value = self.cache[key][0]\n self.cache[key] = (value, self.count)\n self.lru[self.count] = key\n self.count += 1\n return self.cache[key][0]\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key not in self.cache and len(self.cache) >= self.capacity:\n minimum = min(self.lru)\n self.cache.pop(self.lru[minimum])\n self.lru.pop(minimum)\n # self.lru.pop(self.cache[key][1])\n if key in self.cache:\n self.lru.pop(self.cache[key][1])\n self.cache[key] = (value, self.count)\n self.lru[self.count] = key\n self.count += 1\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1431"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.lru = {}\n self.count = 0\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.lru.pop(self.cache[key][1])\n value = self.cache[key][0]\n self.cache[key] = (value, self.count)\n self.lru[self.count] = key\n self.count += 1\n return self.cache[key][0]\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key not in self.cache and len(self.cache) >= self.capacity:\n minimum = min(self.lru)\n self.cache.pop(self.lru[minimum])\n self.lru.pop(minimum)\n # self.lru.pop(self.cache[key][1])\n if key in self.cache:\n self.lru.pop(self.cache[key][1])\n self.cache[key] = (value, self.count)\n self.lru[self.count] = key\n self.count += 1\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1455"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.size = capacity\n self.map_key_rec = {} \n self.map_rec_key = {} \n self.map_key_value = {} \n self.count = 0 \n\n def get(self, key: int) -> int:\n if key in self.map_key_rec:\n self.count += 1\n rec_count = self.map_key_rec[key]\n del self.map_rec_key[rec_count] \n self.map_key_rec[key] = self.count\n self.map_rec_key[self.count] = key \n return self.map_key_value[key]\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.map_key_rec:\n \n rec_count = self.map_key_rec[key]\n del self.map_rec_key[rec_count] \n elif len(self.map_key_value) >= self.size:\n \n oldest_recency = min(self.map_rec_key.keys())\n lru_key = self.map_rec_key[oldest_recency]\n del self.map_key_value[lru_key]\n del self.map_key_rec[lru_key]\n del self.map_rec_key[oldest_recency]\n \n \n self.map_key_value[key] = value\n self.count += 1\n self.map_key_rec[key] = self.count\n self.map_rec_key[self.count] = key\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1478"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.young = 0\n self.capacity = capacity \n self.hashmap_of_dict_priority = {}\n self.hashmap_of_dict_age = {}\n self.hashmap_of_dict_val = {}\n \n\n def get(self, key: int) -> int:\n #print(self.hashmap_of_dict_val)\n if key in self.hashmap_of_dict_val:\n self.hashmap_of_dict_priority[self.young] = key\n age = self.hashmap_of_dict_age[key]\n self.hashmap_of_dict_age[key] = self.young\n del self.hashmap_of_dict_priority[age]\n self.young +=1\n return self.hashmap_of_dict_val[key]\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n #print(self.hashmap_of_dict_val)\n if key in self.hashmap_of_dict_val:\n self.hashmap_of_dict_priority[self.young] = key\n age = self.hashmap_of_dict_age[key]\n self.hashmap_of_dict_age[key] = self.young\n del self.hashmap_of_dict_priority[age]\n self.hashmap_of_dict_val[key] = value\n self.young +=1\n return \n\n if len(self.hashmap_of_dict_val) == self.capacity:\n del_key_priority = min(self.hashmap_of_dict_priority)\n del_key = self.hashmap_of_dict_priority[del_key_priority]\n del self.hashmap_of_dict_val[del_key]\n del self.hashmap_of_dict_priority[del_key_priority]\n del self.hashmap_of_dict_age[del_key]\n self.hashmap_of_dict_val[key] = value\n self.hashmap_of_dict_priority[self.young] = key\n self.hashmap_of_dict_age[key] = self.young\n self.young +=1\n\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1502"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key in self.cache:\n val = self.cache[key]\n del self.cache[key]\n self.cache[key] = val\n return val\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key not in self.cache:\n self.cache[key] = value\n if len(list(self.cache)) > self.capacity:\n del self.cache[list(self.cache.keys())[0]]\n else:\n del self.cache[key]\n self.cache[key] = value\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1525"},{"code":"#\n#\n# {2: ListNode(2), 1: ListNode(1), 3: ListNode(3)}\n# \n# [1, 2,3 ] \n# \n# None 1 <-> 2 <-> 3 get(2) ListNode(2).next() = 3, prev = 1, connect 1.next = 2.next take the #tail.next=2.next\n# \n\nclass ListNode:\n def __init__(self,key = 0, val = 0):\n self.key = key\n self.val = val\n self.next = None\n self.prev = None\n\n#\n#\n# cache {1: 1, 1: 2}\n# linkedList = 1 <=> 2 \n# everytime I put an item in the cache, append to the end of the linked List\n# \n# function -> adds item to the end of the linkedList\n# function -> deletes item from the linkedList\n\n \nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = dict()\n self.headNode = ListNode(-1, -1)\n self.tailNode = self.headNode\n self.currentCap = 0\n self.capacity = capacity\n \n def deleteFromLinkedList(self, currNode):\n prevElement = currNode.prev\n nextElement = currNode.next\n \n prevElement.next = nextElement\n if(nextElement == None):\n self.tailNode = prevElement\n else:\n nextElement.prev = prevElement\n \n def appendNodeToEnd(self, currNode):\n self.tailNode.next = currNode\n currNode.prev = self.tailNode\n self.tailNode = self.tailNode.next\n currNode.next = None\n \n def get(self, key: int) -> int:\n if(key in self.cache):\n currentNode = self.cache[key]\n self.deleteFromLinkedList(currentNode)\n self.appendNodeToEnd(currentNode)\n return currentNode.val\n else: \n return -1 \n \n\n def put(self, key: int, value: int) -> None:\n newNode = ListNode(key, value)\n if(key in self.cache):\n # delete from linkedList\n self.deleteFromLinkedList(self.cache[key])\n \n # make a new node and replace it in cache\n self.cache[key] = newNode\n \n # append the new node to the end of the LL\n self.appendNodeToEnd(newNode)\n \n else:\n if(self.currentCap != self.capacity):\n self.currentCap +=1\n else: \n toBeDeleted = self.headNode.next\n tempHead = self.headNode \n \n while(tempHead):\n tempHead = tempHead.next \n self.deleteFromLinkedList(toBeDeleted)\n del self.cache[toBeDeleted.key]\n \n \n self.cache[key] = newNode\n self.appendNodeToEnd(newNode)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1549"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.lru_dict = {}\n self.capacity = capacity\n \n\n def get(self, key: int) -> int:\n if key in self.lru_dict:\n value = self.lru_dict[key]\n del self.lru_dict[key]\n self.lru_dict[key] = value\n return value\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.lru_dict:\n del self.lru_dict[key]\n self.lru_dict[key] = value\n else:\n self.lru_dict[key] = value\n if len(list(self.lru_dict.keys())) > self.capacity:\n first_key = list(self.lru_dict.keys())[0]\n del self.lru_dict[first_key]\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1549"},{"code":"class LRUCache:\n cache = {}\n lru = {}\n capacity = 0\n count = 0\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.lru = {}\n\n def get(self, key: int) -> int:\n # print(\"get\")\n # print(self.cache)\n # print(self.lru)\n if key in self.cache:\n self.lru.pop(self.cache[key][1])\n value = self.cache[key][0]\n self.cache[key] = (value, self.count)\n self.lru[self.count] = key\n self.count += 1\n return self.cache[key][0]\n return -1\n\n def put(self, key: int, value: int) -> None:\n # print(\"put\")\n if key not in self.cache and len(self.cache) >= self.capacity:\n minimum = min(self.lru)\n self.cache.pop(self.lru[minimum])\n self.lru.pop(minimum)\n # self.lru.pop(self.cache[key][1])\n if key in self.cache:\n self.lru.pop(self.cache[key][1])\n self.cache[key] = (value, self.count)\n self.lru[self.count] = key\n self.count += 1\n # print(self.cache)\n # print(self.lru)\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1573"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key in self.cache:\n val = self.cache[key]\n del self.cache[key]\n self.cache[key] = val\n return val\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key not in self.cache:\n self.cache[key] = value\n if len(list(self.cache)) > self.capacity:\n del self.cache[list(self.cache)[0]]\n else:\n del self.cache[key]\n self.cache[key] = value\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1573"},{"code":"class LinkedListNode:\n def __init__(self, key: int, value: int):\n self.key = key\n self.value = value\n self.next = None\n self.prev = None\n\n def __repr__(self):\n return self.__str__()\n \n def __str__(self):\n return f\"key={self.key} value={self.value}\"\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.nodes = {}\n self.list = None\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n # print(\"get\", key)\n if key in self.nodes:\n node = self.nodes[key]\n value = node.value\n self._move_to_head(node)\n # self._print()\n return value\n return -1\n\n def put(self, key: int, value: int) -> None:\n # print(\"put\", key, value)\n if key in self.nodes:\n node = self.nodes[key]\n node.value = value\n self._move_to_head(node)\n else:\n if self.capacity == 1 and len(self.nodes) == self.capacity:\n del self.nodes[self.list.key]\n self.list = None\n elif len(self.nodes) == self.capacity:\n curr = self.list\n while curr.next is not None:\n curr = curr.next\n # curr is now the tail\n curr.prev.next = None\n curr.prev = None\n del self.nodes[curr.key]\n node = LinkedListNode(key, value)\n self.nodes[key] = node\n self._move_to_head(node)\n # self._print()\n \n\n def _move_to_head(self, node: LinkedListNode):\n # print(\"move to head\", node)\n if self.list == node:\n return\n\n if node.prev:\n node.prev.next = node.next\n if node.next:\n node.next.prev = node.prev\n\n if self.list is not None:\n self.list.prev = node\n node.next = self.list\n node.prev = None\n self.list = node\n\n def _print(self):\n print(\"nodes\", self.nodes)\n curr = self.list\n while curr is not None:\n print(\"node\", curr)\n curr = curr.next\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1596"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity=capacity\n self.map={}\n self.counts={}\n self.history=[]\n\n def get(self, key: int) -> int:\n if key in self.map:\n self.counts[key]+=1\n self.history+=[key]\n return self.map[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if len(self.map)==self.capacity and key not in self.map:\n while self.counts[self.history[0]]!=1:\n self.counts[self.history[0]]-=1\n self.history=self.history[1:]\n\n # remove value from LRU cache\n self.counts.pop(self.history[0])\n self.map.pop(self.history[0])\n self.history=self.history[1:]\n \n self.map[key]=value\n self.counts[key]=self.counts[key]+1 if key in self.counts else 1\n self.history+=[key]\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1620"},{"code":"class LRUCache:\n class Node:\n def __init__(self, key, val=0, nxt=None, prev=None):\n self.key = key\n self.val = val\n self.next = nxt\n self.prev = prev\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.m = {}\n self.head = None\n\n\n def get(self, key: int) -> int:\n if key in self.m:\n node = self.m[key]\n prev = node.prev\n nxt = node.next\n if not prev:\n return self.m[key].val\n prev.next = nxt\n if nxt:\n nxt.prev = prev\n\n node.prev = None\n node.next = self.head\n self.head.prev = node\n self.head = node\n\n return self.m[key].val\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.m:\n node = self.m[key]\n node.val = value\n\n pre = node.prev\n nxt = node.next\n if not pre:\n return\n pre.next = nxt\n if nxt:\n nxt.prev = pre\n\n node.prev = None\n node.next = self.head\n self.head.prev = node\n self.head = node\n else:\n self.m[key] = self.Node(key, value, self.head)\n if self.head:\n self.head.prev = self.m[key]\n self.head = self.m[key]\n\n if self.capacity == 0:\n temp = self.head\n while temp.next:\n temp = temp.next\n t = temp.prev\n t.next = None\n self.m.pop(temp.key)\n del temp\n else:\n self.capacity -= 1\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1643"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.queue = []\n self.map = {}\n self.occurences = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n value = self.map.get(key, -1) \n if value >= 0:\n # we found it in the map and need to put it to front of queue\n self.capacity += 1\n self.queue.append(key)\n self.occurences[key] += 1\n return value\n \n def put(self, key: int, value: int) -> None:\n if self.occurences.get(key, 0) > 0:\n # if already in cache we don't want to\n # remove anything\n self.capacity += 1\n \n if len(self.queue) == self.capacity:\n valueToRemove = self.queue[0]\n while self.occurences.get(valueToRemove, 0) > 1:\n # there are multiple copies so we need to keep removing \n # until we find one that only has one copy\n self.occurences[valueToRemove] -= 1\n self.capacity -= 1\n self.queue = self.queue[1:]\n valueToRemove = self.queue[0]\n self.queue = self.queue[1:]\n self.occurences[valueToRemove] = 0\n self.map[valueToRemove] = -1\n self.occurences[key] = self.occurences.get(key, 0) + 1\n self.queue.append(key)\n self.map[key] = value\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1667"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key in self.cache:\n val = self.cache[key]\n del self.cache[key]\n self.cache[key] = val\n return val\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key not in self.cache:\n self.cache[key] = value\n if len(list(self.cache.values())) > self.capacity:\n del self.cache[list(self.cache.keys())[0]]\n else:\n del self.cache[key]\n self.cache[key] = value\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1690"},{"code":"#\n#\n# {2: ListNode(2), 1: ListNode(1), 3: ListNode(3)}\n# \n# [1, 2,3 ] \n# \n# None 1 <-> 2 <-> 3 get(2) ListNode(2).next() = 3, prev = 1, connect 1.next = 2.next take the #tail.next=2.next\n# \n\nclass ListNode:\n def __init__(self,key = 0, val = 0):\n self.key = key\n self.val = val\n self.next = None\n self.prev = None\n\n#\n#\n# cache {1: 1, 1: 2}\n# linkedList = 1 <=> 2 \n# everytime I put an item in the cache, append to the end of the linked List\n# \n# function -> adds item to the end of the linkedList\n# function -> deletes item from the linkedList\n\n \nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = dict()\n self.headNode = ListNode(-1, -1)\n self.tailNode = self.headNode\n self.currentCap = 0\n self.capacity = capacity\n \n def deleteFromLinkedList(self, currNode):\n prevElement = currNode.prev\n nextElement = currNode.next\n \n prevElement.next = nextElement\n if(nextElement == None):\n self.tailNode = prevElement\n else:\n nextElement.prev = prevElement\n \n def appendNodeToEnd(self, currNode):\n self.tailNode.next = currNode\n currNode.prev = self.tailNode\n self.tailNode = self.tailNode.next\n currNode.next = None\n \n def get(self, key: int) -> int:\n if(key in self.cache):\n currentNode = self.cache[key]\n self.deleteFromLinkedList(currentNode)\n self.appendNodeToEnd(currentNode)\n return currentNode.val\n else: \n return -1 \n \n\n def put(self, key: int, value: int) -> None:\n newNode = ListNode(key, value)\n if(key in self.cache):\n # delete from linkedList\n self.deleteFromLinkedList(self.cache[key])\n \n # make a new node and replace it in cache\n self.cache[key] = newNode\n \n # append the new node to the end of the LL\n self.appendNodeToEnd(newNode)\n \n else:\n if(self.currentCap != self.capacity):\n self.currentCap +=1\n else: \n toBeDeleted = self.headNode.next\n tempHead = self.headNode \n \n while(tempHead):\n tempHead = tempHead.next \n self.deleteFromLinkedList(toBeDeleted)\n del self.cache[toBeDeleted.key]\n \n \n self.cache[key] = newNode\n self.appendNodeToEnd(newNode)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1714"},{"code":"import heapq\n\n\nclass LRUCache:\n class Node:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.prev = None\n self.next = None\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.size = 0\n self.queue = None\n self.map = dict()\n\n def get(self, key: int) -> int:\n if key not in self.map:\n return -1\n\n node = self.map[key]\n self.to_front(node)\n\n return node.val\n\n def to_front(self, node):\n if node == self.queue:\n return\n\n prev = node.prev\n next_ = node.next\n\n prev.next = next_\n if next_ is not None:\n next_.prev = prev\n\n node.prev = None\n node.next = self.queue\n self.queue.prev = node\n self.queue = node\n\n def insert_front(self, node):\n node.next = self.queue\n if self.queue is not None:\n self.queue.prev = node\n self.queue = node\n def put(self, key: int, value: int) -> None:\n\n if key in self.map:\n node = self.map[key]\n node.val = value\n self.to_front(node)\n else:\n node = LRUCache.Node(key, value)\n self.map[key] = node\n self.insert_front(node)\n self.size += 1\n\n if self.size > self.capacity:\n self.evict()\n\n def evict(self) -> None:\n current = self.queue\n while current.next is not None:\n current = current.next\n\n current.prev.next = None\n\n del self.map[current.key]\n\n self.size -= 1\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)\n","runtime":"1738"},{"code":"class LRUCache:\n class Node:\n def __init__(self, key, val=0, nxt=None, prev=None):\n self.key = key\n self.val = val\n self.next = nxt\n self.prev = prev\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.m = {}\n self.head = None\n\n\n def get(self, key: int) -> int:\n if key in self.m:\n node = self.m[key]\n prev = node.prev\n nxt = node.next\n if not prev:\n return self.m[key].val\n prev.next = nxt\n if nxt:\n nxt.prev = prev\n\n node.prev = None\n node.next = self.head\n self.head.prev = node\n self.head = node\n\n return self.m[key].val\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.m:\n node = self.m[key]\n node.val = value\n\n pre = node.prev\n nxt = node.next\n if not pre:\n return\n pre.next = nxt\n if nxt:\n nxt.prev = pre\n\n node.prev = None\n node.next = self.head\n self.head.prev = node\n self.head = node\n else:\n self.m[key] = self.Node(key, value, self.head)\n if self.head:\n self.head.prev = self.m[key]\n self.head = self.m[key]\n\n if self.capacity == 0:\n temp = self.head\n while temp.next:\n temp = temp.next\n t = temp.prev\n t.next = None\n self.m.pop(temp.key)\n del temp\n else:\n self.capacity -= 1\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1738"},{"code":"class LRUCache:\n class Node:\n def __init__(self, key, val=0, nxt=None, prev=None):\n self.key = key\n self.val = val\n self.next = nxt\n self.prev = prev\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.m = {}\n self.head = None\n\n\n def get(self, key: int) -> int:\n if key in self.m:\n node = self.m[key]\n prev = node.prev\n nxt = node.next\n if not prev:\n return self.m[key].val\n prev.next = nxt\n if nxt:\n nxt.prev = prev\n\n node.prev = None\n node.next = self.head\n self.head.prev = node\n self.head = node\n\n return self.m[key].val\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.m:\n node = self.m[key]\n node.val = value\n\n pre = node.prev\n nxt = node.next\n if not pre:\n return\n pre.next = nxt\n if nxt:\n nxt.prev = pre\n\n node.prev = None\n node.next = self.head\n self.head.prev = node\n self.head = node\n else:\n self.m[key] = self.Node(key, value, self.head)\n if self.head:\n self.head.prev = self.m[key]\n self.head = self.m[key]\n\n if self.capacity == 0:\n temp = self.head\n while temp.next:\n temp = temp.next\n t = temp.prev\n t.next = None\n self.m.pop(temp.key)\n del temp\n else:\n self.capacity -= 1\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1761"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.data = {\n\n }\n self.used_key = []\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n value = self.data.get(key, None)\n if value is None:\n return -1\n else:\n self.used_key.remove(key)\n self.used_key.append(key)\n return value\n \n def put(self, key: int, value: int) -> None:\n if key in self.data.keys():\n self.data[key] = value\n self.used_key.remove(key)\n self.used_key.append(key)\n return\n if len(self.data.keys()) == self.capacity and len(self.used_key) > 0:\n lru_key = self.used_key[0]\n self.used_key.remove(lru_key)\n del self.data[lru_key]\n\n self.data[key] = value\n self.used_key.append(key)\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1761"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.order = []\n\n def get(self, key: int) -> int:\n \n if key in self.cache:\n self.order.remove(key)\n self.order.append(key)\n return self.cache[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n\n self.order.append(key)\n if key in self.cache:\n self.order.remove(key)\n self.cache[key]= value\n else:\n\n if len(self.cache)==self.capacity:\n self.cache.pop(self.order.pop(0))\n self.cache[key]= value\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1785"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.map = {}\n self.array = []\n def get(self, key: int) -> int:\n if key in self.map:\n self.array.remove(key)\n self.array.append(key)\n return self.map[key]\n return -1\n def put(self, key: int, value: int) -> None:\n if key in self.map:\n # If the key exists, update its value and move it to the most recently used\n self.map[key] = value\n self.array.remove(key)\n self.array.append(key)\n else:\n if len(self.map) >= self.capacity:\n # Evict the least recently used key (first in the array)\n lru_key = self.array.pop(0)\n del self.map[lru_key]\n # Add the new key-value pair\n self.map[key] = value\n self.array.append(key)\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1785"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.memory = {} \n self.capacity = capacity \n self.lrutracker = [] \n\n def get(self, key: int) -> int:\n if key not in self.memory:\n return -1\n \n self.lrutracker.remove(key)\n self.lrutracker.append(key)\n return self.memory[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.memory:\n self.lrutracker.remove(key)\n elif len(self.memory) >= self.capacity:\n lru = self.lrutracker.pop(0)\n del self.memory[lru]\n self.memory[key] = value\n self.lrutracker.append(key)\n \n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1808"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n if capacity > 0:\n self.capacity = capacity\n self.cache = {} # overall cache\n self.cache_order = [] # used key order\n \n def get(self, key: int) -> int:\n if key in self.cache:\n # move key to the recently used (end) of list\n self.cache_order.remove(key) \n self.cache_order.append(key)\n return self.cache[key]\n\n else: return -1\n \n def put(self, key: int, value: int) -> None:\n if key in self.cache: \n self.cache[key] = value\n self.cache_order.remove(key) \n self.cache_order.append(key)\n else:\n if len(self.cache_order) >= self.capacity:\n lru_key = self.cache_order[0]\n del self.cache[lru_key]\n self.cache_order.remove(lru_key) \n \n self.cache[key] = value\n self.cache_order.append(key) \n\n \n \n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1808"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.bank = []\n self.size = 0\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.bank.remove(key)\n self.bank.append(key)\n return self.cache[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache[key] = value\n self.bank.remove(key)\n self.bank.append(key)\n elif self.size < self.capacity:\n self.size += 1\n self.cache[key] = value\n self.bank.append(key)\n else:\n cur = self.bank.pop(0)\n del self.cache[cur]\n self.cache[key] = value\n self.bank.append(key)\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1832"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.size = capacity\n self.cache = {}\n self.order = []\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.order.remove(key)\n self.order.append(key)\n return self.cache[key]\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache[key] = value\n self.order.remove(key)\n self.order.append(key)\n else:\n if len(self.cache) >= self.size:\n x = self.order.pop(0)\n self.cache.pop(x)\n self.cache[key]=value\n self.order.append(key)\n \n\n\n# class Node:\n# def __init__(self, key = -1, val = -1):\n# self.key = key\n# self.val = val\n# self.prev = None\n# self.next = None\n\n# class DLL:\n# def __init__(self):\n# self.dummy_start = Node()\n# self.dummy_end = Node()\n# self.dummy_start.next = self.dummy_end\n# self.dummy_end.prev = self.dummy_start\n\n# def appendleft(self, node) -> Node:\n# left, right = self.dummy_start, self.dummy_start.next\n# node.next = right\n# right.prev = node\n# left.next = node\n# node.prev = left\n \n# return node\n\n# def remove(self, node) -> Node:\n# left, right = node.prev, node.next\n# left.next = right\n# right.prev = left\n \n# return node\n\n# def move_to_start(self, node):\n# return self.appendleft(self.remove(node))\n\n# def pop(self):\n# return self.remove(self.dummy_end.prev)\n \n# def peek(self):\n# return self.dummy_end.prev.val\n\n# class LRUCache:\n# def __init__(self, capacity: int):\n# self.capacity = capacity\n# self.cache = dict()\n# self.dll = DLL()\n\n# def get(self, key: int) -> int:\n# if key not in self.cache: return -1\n \n# node = self.cache[key]\n# self.dll.move_to_start(node)\n \n# return node.val\n\n# def put(self, key: int, value: int) -> None:\n# if key in self.cache:\n# node = self.dll.remove(self.cache[key])\n# node.val = value\n# else:\n# node = Node(key, value)\n# self.cache[key] = node\n \n# self.dll.appendleft(node)\n \n# if len(self.cache) > self.capacity:\n# self.cache.pop(self.dll.pop().key)\n\n# class Node():\n# def __init__(self, value, next):\n# self.value = value\n# self.next = next\n\n\n# class LRUCache:\n\n# def __init__(self, capacity: int):\n# self.capacity = capacity\n# self.cache = {}\n# self.left = None\n# self.right = None\n# self.count = 0\n \n# def put(self, key: int, value: int) -> None:\n# if key in self.cache:\n# prev, node = self.cache[key]\n# if prev is None:\n# self.left = self.left.next\n# self.cache[self.node.val] = [None, self.left]\n# else:\n# prev.next = prev.next.next\n \n# self.right.next = Node(value)\n# self.right = self.right.next\n# if len(self.cache)<capacity:\n# if self.left is None and self.right is None:\n# self.left = self.right = Node(value)\n# self.cache[key] = [None, self.right]\n# else:\n# self.right.next = Node(value)\n# self.cache[key] = [self.right, self.right.next]\n\n# self.right = self.right.next\n\n# if len(self.cache)==self.capacity:\n# self.left = self.left.next\n# self.right.next = Node(value)\n# self.right = self.right.next\n\n\n\n# else:\n\n# class LRUCache:\n\n# def __init__(self, capacity: int):\n\n# self.capacity = capacity\n# self.k_to_v_i= {}\n# self.i_to_k = {}\n# self.idx = -1\n\n# def get(self, key: int) -> int:\n# if key in self.k_to_v_i:\n# self.put(key, self.k_to_v_i[key][0])\n# return self.k_to_v_i[key][0]\n# return -1\n\n\n# def put(self, key: int, value: int) -> None:\n# self.idx+=1\n# if len(self.k_to_v_i) == self.capacity:\n# if key not in self.k_to_v_i:\n# # Delete the pair\n \n# idx_to_remove = self.idx - self.capacity\n# k_to_remove = self.i_to_k.pop(idx_to_remove)\n# del self.k_to_v_i[k_to_remove]\n \n# else:\n# idx_to_update = self.k_to_v_i[key][1] - 1\n# while idx_to_update in self.i_to_k:\n# key_to_update = self.i_to_k[idx_to_update]\n# self.k_to_v_i[key_to_update][1]+=1\n\n# del self.i_to_k[idx_to_update]\n# self.i_to_k[idx_to_update+1] = key_to_update\n# idx_to_update-=1\n\n# # Add the pair\n# self.k_to_v_i[key] = [value, self.idx]\n# self.i_to_k[self.idx] = key\n\n\n\n \n\n\n# # Your LRUCache object will be instantiated and called as such:\n# # obj = LRUCache(capacity)\n# # param_1 = obj.get(key)\n# # obj.put(key,value)","runtime":"1832"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity \n self.lru = [] \n self.mp = {} \n\n def get(self, key: int) -> int:\n if key in self.mp:\n self.lru.remove(key)\n self.lru.append(key)\n return self.mp[key] \n else:\n return -1 \n\n def put(self, key: int, value: int) -> None:\n if key in self.mp:\n self.mp[key] = value\n self.lru.remove(key) \n else:\n if len(self.mp) >= self.capacity:\n \n lru_key = self.lru.pop(0) \n del self.mp[lru_key] \n\n\n self.mp[key] = value\n\n\n self.lru.append(key)\n","runtime":"1856"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.LRUtag = []\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.LRUtag.remove(key)\n self.LRUtag.append(key)\n return self.cache.get(key)\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n # need smt to keep track of the least recently used key\n # print(\"put\", key)\n if key in self.cache:\n # If the key already exists, update its value and mark it as most recently used\n self.cache[key] = value\n self.LRUtag.remove(key) # Remove from its current position\n self.LRUtag.append(key) # Add to the end to mark as most recently used\n else:\n # If the cache is full, remove the least recently used key (first key in LRUtag)\n if len(self.cache) >= self.capacity:\n least_recently_used = self.LRUtag.pop(0) # Evict the first (least recently used)\n del self.cache[least_recently_used]\n\n # Add the new key-value pair\n self.cache[key] = value\n self.LRUtag.append(key) # Mark the new key as most recently used\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)\n","runtime":"1856"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.used = []\n self.size = capacity \n self.capacity = 0\n self.map = {}\n\n def get(self, key: int) -> int:\n if key in self.map:\n self.used.remove(key)\n self.used.append(key)\n return self.map[key]\n else:\n return -1\n \n def put(self, key: int, value: int) -> None:\n if key in self.map:\n self.map[key] = value\n self.used.remove(key)\n self.used.append(key)\n else:\n if self.capacity + 1 > self.size:\n #check first value in LRU array\n val = self.used[0]\n self.used.remove(val)\n del self.map[val]\n self.used.append(key)\n self.map[key] = value \n else:\n self.capacity +=1\n self.map[key] = value \n self.used.append(key)\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1879"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.order = []\n\n def get(self, key: int) -> int:\n if key in self.cache:\n # Update the order list by moving the accessed key to the end\n self.order.remove(key)\n self.order.append(key)\n return self.cache[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.order.remove(key)\n elif len(self.cache) >= self.capacity:\n lru_key = self.order.pop(0)\n del self.cache[lru_key]\n \n self.cache[key] = value\n self.order.append(key)\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1879"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.keys = capacity\n self.stack =[]\n self.hmap= {}\n \n\n def get(self, key: int) -> int:\n if key in self.hmap:\n self.stack.remove(key)\n self.stack.append(key)\n return self.hmap[key]\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.hmap:\n self.stack.remove(key)\n self.stack.append(key)\n \n elif len(self.hmap) < self.keys:\n self.stack.append(key) \n else:\n evict = self.stack[0]\n self.stack.remove(evict)\n self.stack.append(key)\n # print(\"bf def\", self.hmap)\n del self.hmap[evict]\n # print(\"af def\", self.hmap)\n self.hmap[key] = value\n return \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1903"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.d=dict()\n self.stack=[]\n self.capacity=capacity\n\n def get(self, key: int) -> int:\n if key in self.d.keys():\n self.stack.remove(key)\n self.stack.append(key)\n return self.d[key]\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.d.keys():\n self.d[key]=value\n self.stack.remove(key)\n self.stack.append(key)\n \n elif len(self.d.keys())>=self.capacity:\n k=self.stack[0]\n self.d.pop(k)\n self.stack.pop(0)\n self.d[key]=value\n self.stack.append(key)\n else:\n self.d[key]=value\n self.stack.append(key)\n \n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1903"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.dic = dict()\n self.lst = []\n def get(self, key: int) -> int:\n if self.dic.get(key) != None:\n self.lst += [self.lst.pop(self.lst.index(key))]\n return self.dic.get(key)\n return -1\n def put(self, key: int, value: int) -> None:\n if self.dic.get(key) != None:\n self.lst += [self.lst.pop(self.lst.index(key))]\n else:\n if len(self.lst) == self.capacity:\n del self.dic[self.lst.pop(0)]\n self.lst += [key]\n self.dic[key] = value\n","runtime":"1926"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.lru_q = []\n self.mp = {}\n self.capacity = capacity\n self.curr = 0\n \n\n def get(self, key: int) -> int:\n if key in self.mp:\n self.lru_q.remove(key)\n self.lru_q.append(key)\n return self.mp[key]\n return -1\n\n \n\n def put(self, key: int, value: int) -> None:\n if self.curr < self.capacity and key not in self.mp:\n self.mp[key] = value\n self.curr += 1\n self.lru_q.append(key)\n if key in self.mp:\n self.mp[key] = value\n self.lru_q.remove(key)\n self.lru_q.append(key)\n\n else:\n while self.curr >= self.capacity:\n evict = self.lru_q.pop(0)\n self.mp.pop(evict)\n self.curr -= 1\n self.mp[key] = value\n self.curr += 1\n self.lru_q.append(key)\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1926"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.store = dict()\n self.capacity = capacity\n self.priority = collections.deque([])\n\n def get(self, key: int) -> int:\n if key not in self.store:\n return -1\n\n self.priority.remove(key)\n self.priority.append(key)\n\n return self.store[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.store:\n self.priority.remove(key)\n\n if len(self.priority) == self.capacity:\n evicted = self.priority.popleft()\n del self.store[evicted]\n\n self.store[key] = value\n self.priority.append(key)\n \n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1950"},{"code":"import collections\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.LRU=collections.deque()\n self.LRUD={}\n self.cap=capacity\n \n\n def get(self, key: int) -> int:\n if key in self.LRUD:\n self.LRU.remove(key)\n self.LRU.append(key)\n return self.LRUD[key]\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if self.cap>len(self.LRU) and key not in self.LRUD:\n self.LRUD[key]=value\n self.LRU.append(key)\n elif key in self.LRUD:\n self.LRUD[key]=value\n self.LRU.remove(key)\n self.LRU.append(key)\n else:\n k1=self.LRU[0]\n self.LRU.popleft()\n del self.LRUD[k1]\n self.LRUD[key]=value\n self.LRU.append(key)\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1950"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.s=deque()\n self.d={}\n self.c=capacity\n def get(self, key: int) -> int:\n if key in self.d:\n self.s.remove(key)\n self.s.appendleft(key)\n return self.d[key]\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.d:\n self.d[key]=value\n\n self.s.remove(key)\n self.s.appendleft(key)\n else:\n if len(self.s)>=self.c:\n v=self.s.pop()\n if v in self.d:\n del self.d[v]\n\n self.d[key] = value\n self.s.appendleft(key)\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1974"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.keys = collections.defaultdict(int)\n self.q = deque()\n self.capacity = capacity\n \n\n def get(self, key: int) -> int:\n if key in self.keys:\n self.q.remove(key)\n self.q.append(key)\n return self.keys[key]\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.keys:\n ## Rearranging\n self.q.remove(key)\n self.q.append(key)\n else:\n self.q.append(key)\n if len(self.q) > self.capacity:\n LRUKey = self.q.popleft()\n del self.keys[LRUKey]\n self.keys[key] = value\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1974"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.cap = capacity\n self.lru = {}\n self.least = deque()\n\n def get(self, key: int) -> int:\n if key not in self.lru:\n return -1\n else:\n self.least.remove(key)\n self.least.insert(0, key)\n\n return self.lru[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.lru:\n self.least.remove(key)\n\n elif len(self.lru) >= self.cap:\n least = self.least.pop()\n self.lru.pop(least)\n \n\n self.least.insert(0, key)\n self.lru[key] = value\n \n\n \n\n \n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1997"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = []\n self.dict = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key in self.dict:\n self.cache.pop(self.cache.index(key))\n self.cache.append(key)\n return self.dict[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.dict:\n self.cache.pop(self.cache.index(key))\n self.cache.append(key)\n self.dict[key] = value\n if len(self.cache) > self.capacity:\n del self.dict[self.cache[0]]\n self.cache = self.cache[1:]\n \n\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"1997"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.limit = capacity\n self.cache = {}\n self.capacity = deque()\n \n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.capacity.remove(key)\n self.capacity.append(key)\n return self.cache[key]\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache[key] = value\n self.capacity.remove(key)\n self.capacity.append(key)\n else:\n if len(self.cache) >= self.limit:\n lru = self.capacity.popleft()\n del self.cache[lru]\n self.cache[key] = value\n self.capacity.append(key)\n \n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"2021"},{"code":"from collections import deque,defaultdict\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity=capacity\n self.cache=defaultdict(int)\n self.lru=deque()\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n self.lru.remove(key)\n self.lru.appendleft(key)\n return self.cache[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.lru.remove(key)\n elif len(self.cache) >= self.capacity:\n lru=self.lru.pop()\n self.cache.pop(lru)\n self.lru.appendleft(key)\n self.cache[key]=value\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","runtime":"2021"}],"string":"[\n {\n \"code\": \"def lc(operations, params):\\n cache = OrderedDict()\\n result = []\\n capacity = None\\n for i, op in enumerate(operations):\\n if op == \\\"LRUCache\\\":\\n capacity = params[i][0]\\n result.append(None)\\n elif op == \\\"put\\\":\\n key, value = params[i]\\n if key in cache:\\n cache.move_to_end(key)\\n cache[key] = value\\n if len(cache) > capacity:\\n cache.popitem(last=False)\\n result.append(None)\\n elif op == \\\"get\\\":\\n key = params[i][0]\\n if key in cache:\\n cache.move_to_end(key)\\n result.append(cache[key])\\n else:\\n result.append(-1) \\n return result\\n\\nwith open(\\\"user.out\\\",\\\"w\\\") as sys.stdout:\\n print(*(str(lc(*h)).replace('None','null').replace(' ','') for h in zip(*[map(loads,stdin)]*2)),sep='\\\\n')\\nexit(0)\",\n \"runtime\": \"157\"\n },\n {\n \"code\": \"def lc(operations, params):\\n cache = OrderedDict()\\n result = []\\n capacity = None\\n for i, op in enumerate(operations):\\n if op == \\\"LRUCache\\\":\\n capacity = params[i][0]\\n result.append(None)\\n elif op == \\\"put\\\":\\n key, value = params[i]\\n if key in cache:\\n cache.move_to_end(key)\\n cache[key] = value\\n if len(cache) > capacity:\\n cache.popitem(last=False)\\n result.append(None)\\n elif op == \\\"get\\\":\\n key = params[i][0]\\n if key in cache:\\n cache.move_to_end(key)\\n result.append(cache[key])\\n else:\\n result.append(-1) \\n return result\\n\\nwith open(\\\"user.out\\\",\\\"w\\\") as sys.stdout:\\n print(*(str(lc(*h)).replace('None','null').replace(' ','') for h in zip(*[map(loads,stdin)]*2)),sep='\\\\n')\\nexit(0)\",\n \"runtime\": \"157\"\n },\n {\n \"code\": \"from collections import OrderedDict\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.dict: OrderedDict[int, int] = OrderedDict()\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.dict:\\n self.dict.move_to_end(key)\\n return self.dict[key]\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.dict:\\n self.dict[key] = value\\n self.dict.move_to_end(key)\\n else:\\n if len(self.dict) == self.capacity:\\n self.dict.popitem(last=False)\\n self.dict[key] = value\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"181\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.data = OrderedDict()\\n def get(self, key: int) -> int:\\n if key in self.data:\\n self.data.move_to_end(key)\\n return self.data.get(key, -1)\\n \\n def put(self, key: int, value: int) -> None:\\n self.data[key] = value\\n self.data.move_to_end(key)\\n if len(self.data) > self.capacity:\\n self.data.popitem(last=False)\\n \\n \\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"204\"\n },\n {\n \"code\": \"from collections import deque, OrderedDict\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = OrderedDict() \\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n \\n # 접근한 항목을 가장 최근에 사용된 위치로 이동\\n self.cache.move_to_end(key)\\n return self.cache[key]\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.move_to_end(key)\\n elif len(self.cache) >= self.capacity:\\n self.cache.popitem(last=False)\\n \\n self.cache[key] = value\\n \\n \\n\\n\\nlRUCache = LRUCache(2)\\nlRUCache.put(1, 1); # cache is {1=1}\\nlRUCache.put(2, 2); # cache is {1=1, 2=2}\\nlRUCache.get(1); # return 1\\nlRUCache.put(3, 3); # LRU key was 2, evicts key 2, cache is {1=1, 3=3}\\nlRUCache.get(2); # returns -1 (not found)\\nlRUCache.put(4, 4); # LRU key was 1, evicts key 1, cache is {4=4, 3=3}\\nlRUCache.get(1); # return -1 (not found)\\nlRUCache.get(3); # return 3\\nlRUCache.get(4); # return 4\",\n \"runtime\": \"228\"\n },\n {\n \"code\": \"from collections import OrderedDict\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = OrderedDict()\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n else:\\n # Move the accessed key to the end to mark it as recently used\\n self.cache.move_to_end(key)\\n return self.cache[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n # Update the value and mark as recently used\\n self.cache.move_to_end(key)\\n self.cache[key] = value\\n if len(self.cache) > self.capacity:\\n # Remove the first item from the OrderedDict (the least recently used item)\\n self.cache.popitem(last=False)\",\n \"runtime\": \"252\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = OrderedDict()\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.cache.move_to_end(key)\\n return self.cache[key]\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if not key in self.cache:\\n if len(self.cache) == self.capacity:\\n self.cache.popitem(last=False)\\n self.cache[key] = value\\n self.cache.move_to_end(key)\\n return None\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"275\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = OrderedDict()\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.cache.move_to_end(key)\\n return self.cache[key]\\n else:\\n return -1\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.move_to_end(key)\\n self.cache[key] = value\\n else:\\n self.cache[key] = value\\n self.cache.move_to_end(key)\\n if len(self.cache) > self.capacity:\\n self.cache.popitem(last=False)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"299\"\n },\n {\n \"code\": \"from collections import OrderedDict\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.dic = OrderedDict()\\n \\n def get(self, key: int) -> int:\\n if key in self.dic:\\n self.dic.move_to_end(key)\\n return self.dic[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.dic:\\n self.dic.pop(key)\\n elif len(self.dic) >= self.capacity:\\n self.dic.popitem(last=False)\\n self.dic[key] = value\\n \\n\",\n \"runtime\": \"322\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = collections.OrderedDict()\\n \\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n self.cache.move_to_end(key)\\n return self.cache[key]\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.move_to_end(key)\\n self.cache[key] = value\\n if len(self.cache) > self.capacity:\\n self.cache.popitem(False)\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"346\"\n },\n {\n \"code\": \"from collections import OrderedDict\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self._capacity = capacity\\n self._lru_cache = OrderedDict()\\n \\n\\n def get(self, key: int) -> int:\\n result = -1\\n if key in self._lru_cache:\\n result = self._lru_cache[key]\\n self._lru_cache.move_to_end(key)\\n return result\\n \\n\\n def put(self, key: int, value: int) -> None:\\n self._lru_cache[key] = value\\n self._lru_cache.move_to_end(key)\\n\\n if len(self._lru_cache) > self._capacity:\\n self._lru_cache.popitem(last=False)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"370\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.lru = OrderedDict()\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key not in self.lru:\\n return -1\\n\\n self.lru.move_to_end(key)\\n\\n return self.lru[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.lru or len(self.lru) < self.capacity:\\n self.lru[key] = value\\n self.lru.move_to_end(key)\\n else:\\n self.lru.popitem(last=False)\\n self.lru[key] = value\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"393\"\n },\n {\n \"code\": \"import collections\\nclass LRUCache:\\n def __init__(self, capacity):\\n self.capacity = capacity\\n self.dic = collections.OrderedDict()\\n \\n def get(self, key: int) -> int:\\n if key not in self.dic:\\n return -1\\n self.dic.move_to_end(key)\\n return self.dic[key]\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.dic:\\n self.dic.move_to_end(key)\\n self.dic[key] = value\\n if len(self.dic) > self.capacity:\\n self.dic.popitem(False)\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"417\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.d = OrderedDict()\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key not in self.d:\\n return -1\\n \\n self.d.move_to_end(key)\\n return self.d[key]\\n\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.d:\\n self.d[key] = value\\n self.d.move_to_end(key)\\n \\n else:\\n if len(self.d) >= self.capacity:\\n self.d.popitem(last = False)\\n self.d[key] = value\\n \\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"440\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n \\\"\\\"\\\"\\n Initialize the LRU cache with a positive capacity.\\n \\n :param capacity: The maximum number of items the cache can hold.\\n \\\"\\\"\\\"\\n self.data = OrderedDict() # OrderedDict maintains the order of keys based on access\\n self.cap = capacity # Maximum capacity of the cache\\n\\n def get(self, key: int) -> int:\\n \\\"\\\"\\\"\\n Get the value of the key if the key exists in the cache; otherwise return -1.\\n \\n :param key: The key of the entry to be fetched.\\n :return: The value associated with the key, or -1 if the key does not exist.\\n \\\"\\\"\\\"\\n if key in self.data:\\n # Move the accessed key to the end to mark it as recently used\\n self.data.move_to_end(key)\\n return self.data[key]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n \\\"\\\"\\\"\\n Update the value of the key if the key exists in the cache. Otherwise, add the key-value pair to the cache.\\n If the cache reaches its capacity, remove the least recently used entry.\\n \\n :param key: The key of the entry to be added or updated.\\n :param value: The value to be associated with the key.\\n \\\"\\\"\\\"\\n # Insert or update the key-value pair and mark the key as recently used\\n self.data[key] = value\\n self.data.move_to_end(key)\\n # Remove the least recently used entry if the cache exceeds capacity\\n if len(self.data) > self.cap:\\n self.data.popitem(last=False) # Remove the first (least recently used) item\\n\\n# Time Complexity:\\n# - get(key): O(1) - The get operation is performed in constant time because accessing and updating the position of an entry in an OrderedDict is O(1).\\n# - put(key, value): O(1) - The put operation is also performed in constant time. The removal of the least recently used entry is also O(1) due to the efficient handling of OrderedDict.\\n\\n# Space Complexity:\\n# - O(capacity) - The space complexity is O(capacity) because the OrderedDict stores up to `capacity` entries.\\n# - The space used by the OrderedDict is directly proportional to the number of entries it holds, which is at most `capacity`.\\n\\n# Idea Behind This Solution:\\n# - The LRU cache uses an `OrderedDict` to maintain the order of access, which supports the Least Recently Used (LRU) eviction policy.\\n# - By using an `OrderedDict`, the cache efficiently keeps track of the order in which keys are accessed, making it easy to remove the least recently used entry when the cache reaches its capacity.\\n\\n# Algorithm Steps:\\n# 1. **Initialization:** \\n# - Create an instance of `OrderedDict` to store cache entries and maintain their access order.\\n# - Set the maximum capacity of the cache.\\n\\n# 2. **Get Operation (`get` method):**\\n# - Check if the key exists in the cache.\\n# - If it exists, move the key to the end of the `OrderedDict` to mark it as recently used and return its value.\\n# - If it does not exist, return -1.\\n\\n# 3. **Put Operation (`put` method):**\\n# - Insert or update the key-value pair in the cache.\\n# - Move the key to the end to mark it as recently used.\\n# - If the size of the cache exceeds the capacity, remove the oldest entry (the first item in the `OrderedDict`) to make space for the new entry.\",\n \"runtime\": \"464\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache=OrderedDict()\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n \\n self.cache.move_to_end(key)\\n return self.cache[key]\\n\\n def put(self, key: int, value: int) -> None:\\n self.cache[key]=value\\n self.cache.move_to_end(key)\\n if (len(self.cache) > self.capacity ):\\n self.cache.popitem(last=False)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"488\"\n },\n {\n \"code\": \"class LRUCache:\\n from collections import OrderedDict\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = OrderedDict()\\n \\n \\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n else:\\n self.cache.move_to_end(key)\\n return self.cache[key]\\n \\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.move_to_end(key)\\n self.cache[key] = value\\n if len(self.cache) > self.capacity:\\n self.cache.popitem(False)\\n \\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"488\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.od = OrderedDict()\\n self.max_length = capacity\\n self.length = 0 \\n\\n def get(self, key: int) -> int:\\n if key not in self.od:\\n return -1\\n self.od.move_to_end(key)\\n return self.od[key] \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.od:\\n self.od[key] = value\\n self.od.move_to_end(key, last=True)\\n elif self.length < self.max_length:\\n self.length += 1\\n self.od[key] = value\\n else:\\n self.od.popitem(last=False)\\n self.od[key] = value \\n \\n\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"511\"\n },\n {\n \"code\": \"from collections import OrderedDict\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = OrderedDict()\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n\\n self.cache.move_to_end(key)\\n \\n return self.cache[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache[key] = value\\n self.cache.move_to_end(key)\\n else:\\n if len(self.cache) >= self.capacity:\\n self.cache.popitem(last=False)\\n\\n self.cache[key] = value\\n \\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"511\"\n },\n {\n \"code\": \"from collections import OrderedDict\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = OrderedDict()\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n self.cache.move_to_end(key, last = True)\\n return self.cache[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.move_to_end(key, last = True)\\n self.cache[key] = value\\n return\\n \\n self.cache[key] = value\\n if len(self.cache) > self.capacity:\\n self.cache.popitem(last = False)\\n return\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"535\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = OrderedDict()\\n \\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n self.cache.move_to_end(key)\\n return self.cache[key]\\n \\n\\n def put(self, key: int, value: int) -> None:\\n self.cache[key] = value\\n self.cache.move_to_end(key)\\n if len(self.cache) > self.capacity:\\n self.cache.popitem(last=False)\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"535\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n \\n\\n def get(self, key: int) -> int:\\n # maintain order\\n if key in self.cache:\\n self.cache[key] = self.cache.pop(key)\\n return self.cache[key]\\n \\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.pop(key)\\n\\n self.cache[key] = value\\n\\n if len(self.cache) > self.capacity:\\n self.cache.pop(next(iter(self.cache)))\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"558\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int):\\n self.key = key\\n self.value = value\\n self.prev = None\\n self.next = None\\n\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {} # Map key to node\\n \\n # Dummy head and tail to avoid edge case checks\\n self.head = Node(0, 0)\\n self.tail = Node(0, 0)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n\\n # Helper function to remove a node from the linked list\\n def _remove(self, node: Node):\\n prev_node = node.prev\\n next_node = node.next\\n prev_node.next = next_node\\n next_node.prev = prev_node\\n\\n # Helper function to add a node right after the head (most recently used position)\\n def _add(self, node: Node):\\n node.next = self.head.next\\n node.prev = self.head\\n self.head.next.prev = node\\n self.head.next = node\\n\\n # Move a node to the front (most recently used)\\n def _move_to_front(self, node: Node):\\n self._remove(node)\\n self._add(node)\\n\\n # Get the value (will always move the accessed node to the front)\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n node = self.cache[key]\\n self._move_to_front(node) # Move the accessed node to the front\\n return node.value\\n return -1 # Return -1 if the key is not found\\n\\n # Add or update the value for the given key\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n # Update the existing node and move it to the front\\n node = self.cache[key]\\n node.value = value\\n self._move_to_front(node)\\n else:\\n # Add a new node\\n if len(self.cache) >= self.capacity:\\n # Remove the least recently used (which is at the tail's previous node)\\n lru = self.tail.prev\\n self._remove(lru)\\n del self.cache[lru.key] # Remove from hashmap\\n\\n # Create a new node and add it to the front\\n new_node = Node(key, value)\\n self.cache[key] = new_node\\n self._add(new_node)\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"558\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int):\\n # Doubly Linked List (DLL)\\n self.key: int = key\\n self.value: int = value\\n self.prev: Node | None = None\\n self.next: Node | None = None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.head = Node(-1, -1)\\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.hash_map: dict[int, Node] = {}\\n self.capacity: int = capacity\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n def get(self, key: int) -> int:\\n node = self.hash_map.get(key)\\n if not node:\\n return -1\\n # Move the node to the tail (most recently used)\\n if node != self.tail.prev: # Optimization: move only if not already the most recent\\n self.remove(node)\\n self.add(node)\\n return node.value\\n\\n def add(self, node) -> None:\\n self.tail.prev.next = node\\n node.prev = self.tail.prev \\n node.next = self.tail\\n self.tail.prev = node\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hash_map:\\n node = self.hash_map[key] \\n node.value = value\\n self.remove(node)\\n else:\\n node = Node(key, value) \\n self.hash_map[key] = node\\n\\n self.add(node)\\n\\n if len(self.hash_map) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.hash_map[node_to_delete.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"582\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.next = None\\n self.prev = None\\n\\nclass DoublyLinkedList:\\n def __init__(self):\\n self.left = None # Most recently used (MRU)\\n self.right = None # Least recently used (LRU)\\n self.size = 0\\n\\n def get_size(self):\\n return self.size\\n\\n def get_right(self):\\n return self.right\\n\\n def insert_front(self, node):\\n \\\"\\\"\\\" Insert a node at the front (MRU side). \\\"\\\"\\\"\\n if self.left is None:\\n self.left = node\\n self.right = node\\n else:\\n node.next = self.left\\n self.left.prev = node\\n self.left = node\\n self.size += 1\\n\\n def delete(self, node):\\n \\\"\\\"\\\" Remove a node from the list. \\\"\\\"\\\"\\n if node == self.left == self.right:\\n self.left = None\\n self.right = None\\n elif node == self.left:\\n second = self.left.next\\n if second:\\n second.prev = None\\n self.left = second\\n elif node == self.right:\\n second_last = self.right.prev\\n if second_last:\\n second_last.next = None\\n self.right = second_last\\n else:\\n prev_node = node.prev\\n next_node = node.next\\n prev_node.next = next_node\\n next_node.prev = prev_node\\n \\n self.size -= 1\\n\\n def move_to_front(self, node):\\n \\\"\\\"\\\" Move an existing node to the front (MRU). \\\"\\\"\\\"\\n if node == self.left:\\n return # It's already at the front\\n self.delete(node)\\n self.insert_front(node)\\n \\n def view(self):\\n \\\"\\\"\\\" Helper method to print the list (optional, for debugging). \\\"\\\"\\\"\\n cur = self.left\\n while cur:\\n print(f\\\"({cur.key}: {cur.val})\\\", end=\\\" -> \\\")\\n cur = cur.next\\n print()\\n\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.dll = DoublyLinkedList()\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n node = self.cache[key]\\n self.dll.move_to_front(node) # Move accessed node to the front\\n return node.val\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n node = self.cache[key]\\n node.val = value # Update the value if key exists\\n self.dll.move_to_front(node) # Move node to the front\\n else:\\n new_node = Node(key, value)\\n self.cache[key] = new_node\\n self.dll.insert_front(new_node)\\n if self.dll.get_size() > self.capacity:\\n lru = self.dll.get_right()\\n self.dll.delete(lru)\\n del self.cache[lru.key]\\n\\n\\n# Example usage:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key, value)\\n\",\n \"runtime\": \"582\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int):\\n # DDL\\n self.key, self.value, self.prev, self.next = key, value, None, None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.head = Node(-1, -1)\\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.hash_map = {}\\n self.capacity = capacity\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n def get(self, key: int) -> int:\\n if not key in self.hash_map:\\n return -1 \\n node = self.hash_map[key]\\n self.remove(node)\\n self.add(node)\\n return node.value\\n\\n def add(self, node):\\n previous_end = self.tail.prev\\n previous_end.next = node\\n node.prev = previous_end\\n node.next = self.tail\\n self.tail.prev = node\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hash_map:\\n self.remove(self.hash_map[key])\\n\\n node = Node(key, value) \\n self.hash_map[key] = node\\n self.add(node)\\n\\n if len(self.hash_map) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.hash_map[node_to_delete.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"605\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int):\\n # Doubly Linked List (DLL)\\n self.key: int = key\\n self.value: int = value\\n self.prev: Node | None = None\\n self.next: Node | None = None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.head = Node(-1, -1)\\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.hash_map: dict[int, Node] = {}\\n self.capacity: int = capacity\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n def get(self, key: int) -> int:\\n if not key in self.hash_map:\\n return -1 \\n node = self.hash_map[key]\\n # Move the node to the tail (most recently used)\\n if node != self.tail.prev: # Optimization: move only if not already the most recent\\n self.remove(node)\\n self.add(node)\\n return node.value\\n\\n def add(self, node) -> None:\\n self.tail.prev.next = node\\n node.prev = self.tail.prev \\n node.next = self.tail\\n self.tail.prev = node\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hash_map:\\n self.remove(self.hash_map[key])\\n\\n node = Node(key, value) \\n self.hash_map[key] = node\\n self.add(node)\\n\\n if len(self.hash_map) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.hash_map[node_to_delete.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"605\"\n },\n {\n \"code\": \"class DLL:\\n def __init__(self,key=None,value=None):\\n self.key = key\\n self.val = value\\n self.next = None\\n self.prev = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.head = DLL()\\n self.tail = DLL()\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.size = 0\\n self.capacity = capacity\\n self.hmap = {}\\n\\n def get(self, key: int) -> int:\\n if key in self.hmap:\\n value = self.hmap[key].val\\n self.remove_node(key)\\n self.add_node(key,value)\\n return self.hmap[key].val\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hmap:\\n self.remove_node(key)\\n self.add_node(key,value)\\n else:\\n if self.size == self.capacity:\\n self.remove_from_tail()\\n self.add_node(key, value)\\n\\n def add_node(self,key,value):\\n new_node = DLL(key=key, value=value)\\n tmp = self.head.next\\n tmp.prev = new_node\\n self.head.next = new_node\\n new_node.prev =self.head\\n new_node.next = tmp\\n self.hmap[key] = new_node\\n self.size+=1\\n return\\n \\n def remove_node(self,key):\\n node = self.hmap[key]\\n prev = node.prev\\n next = node.next\\n\\n prev.next = next\\n next.prev = prev\\n self.size-=1\\n del self.hmap[key]\\n\\n def remove_from_tail(self):\\n key = self.tail.prev.key\\n self.remove_node(key)\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"629\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int):\\n # Doubly Linked List (DLL)\\n self.key: int = key\\n self.value: int = value\\n self.prev: Node | None = None\\n self.next: Node | None = None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.head = Node(-1, -1)\\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.hash_map: dict[int, Node] = {}\\n self.capacity: int = capacity\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n def get(self, key: int) -> int:\\n if not key in self.hash_map:\\n return -1 \\n node = self.hash_map[key]\\n # Move the node to the tail (most recently used)\\n if node != self.tail.prev: # Optimization: move only if not already the most recent\\n self.remove(node)\\n self.add(node)\\n return node.value\\n\\n def add(self, node) -> None:\\n self.tail.prev.next = node\\n node.prev = self.tail.prev \\n node.next = self.tail\\n self.tail.prev = node\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hash_map:\\n self.remove(self.hash_map[key])\\n\\n node = Node(key, value) \\n self.hash_map[key] = node\\n self.add(node)\\n\\n if len(self.hash_map) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.hash_map[node_to_delete.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"629\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.prev = None\\n self.next = None\\n\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = dict()\\n self.capacity = capacity\\n self.count = 0\\n self.head = None\\n self.tail = None\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n elif self.count == 1 or self.cache[key] == self.head:\\n return self.cache[key].val\\n\\n node = self.cache[key]\\n self._remove(node)\\n self._add(node)\\n return self.head.val\\n\\n def put(self, key: int, val: int) -> None:\\n node = Node(key, val)\\n if not self.head:\\n self._add(node)\\n else:\\n if key in self.cache:\\n self._remove(self.cache[key])\\n self._add(node)\\n\\n if self.count > self.capacity:\\n self._remove(self.tail)\\n \\n def _remove(self, node):\\n self.count -= 1\\n if node == self.head:\\n self.head = node.next\\n if node == self.tail:\\n self.tail = node.prev\\n if node.prev:\\n node.prev.next = node.next\\n if node.next:\\n node.next.prev = node.prev\\n self.cache.pop(node.key)\\n \\n def _add(self, node):\\n self.count += 1\\n node.prev = None\\n node.next = self.head\\n if self.head:\\n self.head.prev = node\\n self.head = node\\n if not self.tail:\\n self.tail = node\\n self.cache[node.key] = node\\n\",\n \"runtime\": \"653\"\n },\n {\n \"code\": \"import threading\\nclass Node:\\n def __init__(self, key, value):\\n self.key = key\\n self.value = value\\n self.prev = None\\n self.next = None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.head = Node(0, 0)\\n self.tail = Node(0, 0)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.lock = threading.Lock() # Lock for thread-safe operations\\n \\n def _add_node(self, node):\\n node.prev = self.head\\n node.next = self.head.next\\n self.head.next.prev = node\\n self.head.next = node\\n \\n def _remove_node(self, node):\\n prev = node.prev\\n next = node.next\\n prev.next = next\\n next.prev = prev\\n \\n def _move_to_head(self, node):\\n self._remove_node(node)\\n self._add_node(node)\\n \\n def _pop_tail(self):\\n res = self.tail.prev\\n self._remove_node(res)\\n return res\\n\\n def get(self, key: int) -> int:\\n with self.lock:\\n node = self.cache.get(key, None)\\n if not node:\\n return -1\\n self._move_to_head(node)\\n return node.value\\n\\n def put(self, key: int, value: int) -> None:\\n with self.lock:\\n node = self.cache.get(key)\\n if not node:\\n newNode = Node(key, value)\\n self.cache[key] = newNode\\n self._add_node(newNode)\\n \\n if len(self.cache) > self.capacity:\\n tail = self._pop_tail()\\n del self.cache[tail.key]\\n else:\\n node.value = value\\n self._move_to_head(node)\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"653\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.prev = None\\n self.next = None\\n\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = dict()\\n self.capacity = capacity\\n self.count = 0\\n self.head = None\\n self.tail = None\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n elif self.count == 1 or self.cache[key] == self.head:\\n return self.cache[key].val\\n\\n node = self.cache[key]\\n self._remove(node)\\n self._add(node)\\n return self.head.val\\n\\n def put(self, key: int, val: int) -> None:\\n node = Node(key, val)\\n if not self.head:\\n self._add(node)\\n else:\\n if key in self.cache:\\n self._remove(self.cache[key])\\n self._add(node)\\n\\n if self.count > self.capacity:\\n self._remove(self.tail)\\n \\n def _remove(self, node):\\n self.count -= 1\\n if node == self.head:\\n self.head = node.next\\n if node == self.tail:\\n self.tail = node.prev\\n if node.prev:\\n node.prev.next = node.next\\n if node.next:\\n node.next.prev = node.prev\\n self.cache.pop(node.key)\\n \\n def _add(self, node):\\n self.count += 1\\n node.prev = None\\n node.next = self.head\\n if self.head:\\n self.head.prev = node\\n self.head = node\\n if not self.tail:\\n self.tail = node\\n self.cache[node.key] = node\\n\",\n \"runtime\": \"676\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int, next = None, prev = None):\\n self.value = value\\n self.key = key\\n self.next = next\\n self.prev = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.length = 0\\n self.cache = {}\\n self.head = None\\n self.tail = None\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n temp = self.cache[key]\\n if self.length == 1 or self.tail == temp:\\n print(self.head)\\n return temp.value\\n if temp == self.head:\\n self.head = temp.next\\n if temp.prev:\\n temp.prev.next = temp.next\\n if temp.next:\\n temp.next.prev = temp.prev\\n temp.next = None\\n temp.prev = self.tail\\n self.tail.next = temp\\n self.tail = temp\\n print(self.head)\\n return temp.value\\n else:\\n print(self.head)\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n temp = self.cache[key]\\n temp.value = value\\n self.get(key)\\n return\\n if self.length == self.capacity:\\n del self.cache[self.head.key]\\n temp = self.head\\n if self.head.next:\\n self.head = self.head.next\\n self.head.prev = None\\n temp.key = key\\n temp.value = value\\n temp.next = None\\n temp.prev = self.tail\\n self.tail.next = temp\\n self.tail = temp\\n self.cache[key] = temp\\n \\n else:\\n temp = Node(value = value, key = key)\\n self.cache[key] = temp\\n if self.length == 0:\\n self.head = temp\\n self.tail = temp\\n else:\\n temp.prev = self.tail\\n self.tail.next = temp\\n self.tail = temp\\n self.length += 1\\n\\n print(self.head)\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"676\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, key=None, val=None, prev=None, next=None):\\n self.key = key\\n self.val = val\\n self.prev = prev\\n self.next = next\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.front, self.back = ListNode(), ListNode()\\n self.front.next = self.back\\n self.back.prev = self.front\\n self.cache = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n \\n val = self.cache[key].val\\n self._remove(key)\\n self._insert(key, val)\\n return val\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self._remove(key)\\n \\n self._insert(key, value)\\n print(key, len(self.cache))\\n if len(self.cache) > self.capacity:\\n lru_key = self.back.prev.key\\n print('lru_key', lru_key)\\n self._remove(lru_key)\\n \\n def _insert(self, key, val):\\n # insert both node and cache entries\\n insertNode = ListNode(key, val, None, None)\\n\\n prevNode, nextNode = self.front, self.front.next\\n prevNode.next = insertNode\\n insertNode.prev = prevNode\\n insertNode.next = nextNode\\n nextNode.prev = insertNode\\n\\n self.cache[key] = insertNode\\n \\n def _remove(self, key):\\n # remove both node and cache entries\\n keyNode = self.cache[key]\\n\\n prevNode, nextNode = keyNode.prev, keyNode.next\\n prevNode.next = nextNode\\n nextNode.prev = prevNode\\n\\n del self.cache[key]\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"700\"\n },\n {\n \"code\": \"class OrderedMap:\\n class Node:\\n def __init__(self, key, val, nex, prev):\\n self.key = key\\n self.val = val\\n self.next = nex\\n self.prev = prev\\n \\n def __repr__(self):\\n return \\\"(\\\" + str(self.key) + \\\": \\\" + str(self.val) + \\\")\\\"\\n\\n def __init__(self):\\n self.size = 0\\n self.sentinel = self.Node(None, None, None, None)\\n self.sentinel.next = self.sentinel\\n self.sentinel.prev = self.sentinel\\n self.key_to_node = {}\\n\\n def add_first(self, key, val):\\n if key in self.key_to_node:\\n self.key_to_node[key].val = val\\n else:\\n new_node = self.Node(key, val, self.sentinel.next, self.sentinel)\\n self.sentinel.next.prev = new_node\\n self.sentinel.next = new_node\\n self.size += 1\\n self.key_to_node[key] = new_node\\n\\n def getNode(self, key):\\n if not key in self.key_to_node:\\n return None\\n return self.key_to_node[key]\\n\\n def get(self, key):\\n val = self.getNode(key).val\\n return val if not val is None else -1\\n\\n def contains_key(self, key):\\n return key in self.key_to_node\\n\\n def move_to_front(self, key):\\n print(self.key_to_node[key])\\n node = self.getNode(key)\\n node.prev.next = node.next\\n node.next.prev = node. prev\\n\\n node.prev = self.sentinel\\n node.next = self.sentinel.next\\n\\n self.sentinel.next = node\\n node.next.prev = node\\n\\n def remove_last(self):\\n #print(self.sentinel.prev)\\n del self.key_to_node[self.sentinel.prev.key]\\n self.sentinel.prev = self.sentinel.prev.prev\\n self.sentinel.prev.next = self.sentinel\\n self.size -= 1\\n \\n\\nclass LRUCache: \\n\\n # capacity > 0\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.items = OrderedMap()\\n\\n def get(self, key: int) -> int:\\n if not self.items.contains_key(key):\\n return -1\\n self.items.move_to_front(key)\\n return self.items.get(key)\\n\\n def put(self, key: int, value: int) -> None:\\n if self.items.contains_key(key):\\n self.items.move_to_front(key)\\n if self.items.size == self.capacity and not self.items.contains_key(key):\\n self.items.remove_last()\\n self.items.add_first(key, value)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"700\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n lruCache = {}\\n capacity = 0\\n startNode = None\\n lastNode = None\\n \\n class MyListNode(object):\\n \\n def __init__(self, key, value):\\n self.key = key\\n self.value = value\\n self.nextPtr = None\\n self.prevPtr = None\\n \\n \\n def getVal(self):\\n return self.value\\n \\n def getKey(self):\\n return self.key\\n \\n def putVal(self, val):\\n self.value = val\\n \\n \\n \\n def __init__(self, capacity: int):\\n \\n # Need to keep track of time\\n # when a key was last used\\n \\n # Need to keep track of keys and values\\n \\n #self.lruCache = {}\\n self.capacity = capacity\\n #self.cacheQueue = deque([])\\n self.lruCache = {}\\n self.startNode = None\\n self.lastNode = None\\n \\n # Create Start and Head Node of the Linked list\\n \\n self.startNode = LRUCache.MyListNode(0,sys.maxsize)\\n self.lastNode = LRUCache.MyListNode(0,sys.maxsize)\\n self.startNode.nextPtr = self.lastNode\\n self.lastNode.prevPtr = self.startNode\\n \\n \\n def addNodeEnd(self, node):\\n \\n # Add to the end of the list\\n prevNode = self.lastNode.prevPtr\\n prevNode.nextPtr = node\\n node.prevPtr = prevNode\\n node.nextPtr = self.lastNode\\n self.lastNode.prevPtr = node\\n \\n \\n \\n def delNode(self, node):\\n \\n prevNode = node.prevPtr\\n nextNode = node.nextPtr\\n prevNode.nextPtr = nextNode\\n nextNode.prevPtr = prevNode\\n \\n \\n def movetoEndNode(self, node):\\n \\n self.delNode(node)\\n self.addNodeEnd(node)\\n \\n \\n def log(self, s, logEnabled):\\n if logEnabled:\\n print(s)\\n \\n def get(self, key: int) -> int:\\n \\n logEnabled = True\\n #self.log(f\\\"Content in dict:{self.lruCache}\\\", logEnabled)\\n \\n if key in self.lruCache:\\n # Push the key in a queue\\n getNode = self.lruCache[key]\\n retVal = getNode.getVal()\\n #retVal = getNode.value\\n self.movetoEndNode(getNode)\\n self.log(f\\\"Returning:value:{retVal}\\\", logEnabled)\\n return retVal\\n else:\\n self.log(f\\\"key:{key} not found!\\\", logEnabled)\\n return -1\\n \\n \\n\\n def put(self, key: int, value: int) -> None:\\n \\n logEnabled = True\\n \\n if self.capacity == 0 and key not in self.lruCache:\\n # Time to evict\\n # deque the queue for the key to evict\\n self.log(f\\\"Capacity:{self.capacity}, key:{key}, val:{value}, Evicting\\\", logEnabled)\\n sNode = self.startNode.nextPtr\\n if sNode.getVal() == sys.maxsize:\\n self.log(f\\\"Nothing in the list, not possible\\\", logEnabled)\\n \\n self.log(f\\\"key to delete:{sNode.getKey()}\\\", logEnabled)\\n self.delNode(sNode)\\n self.lruCache.pop(sNode.getKey())\\n # Node deleted, capacity has to be incremented\\n self.capacity += 1\\n \\n newNode = LRUCache.MyListNode(key,value)\\n self.lruCache[key] = newNode\\n self.addNodeEnd(newNode)\\n # Node added, capacity has to be decremented\\n self.capacity -= 1\\n else:\\n self.log(f\\\"Capacity:{self.capacity}, Putting, key:{key}, val:{value}\\\", logEnabled)\\n \\n if key in self.lruCache:\\n # Move the node to the end of the list\\n updateNode = self.lruCache[key]\\n updateNode.putVal(value)\\n self.movetoEndNode(updateNode)\\n else:\\n lruNode = LRUCache.MyListNode(key,value)\\n self.lruCache[key] = lruNode\\n self.addNodeEnd(lruNode)\\n self.capacity -= 1\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"747\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n class ListNode:\\n def __init__(self, key, val, prev=None, next=None):\\n self.prev = prev\\n self.next = next\\n self.key = key\\n self.val = val\\n \\n def __init__(self, capacity: int):\\n self.mapping = {}\\n self.capacity = capacity\\n self.head = self.ListNode(-1, -1)\\n self.tail = self.ListNode(-1, -1) \\n self.head.next = self.tail\\n self.tail.prev = self.head\\n \\n def addNode(self, node):\\n print(f\\\"adding node {node.key}, {node.val}\\\")\\n node.next = self.head.next\\n node.next.prev = node\\n self.head.next = node\\n node.prev = self.head\\n self.mapping[node.key] = node\\n # self.printList()\\n \\n def deleteNode(self, node):\\n print(f\\\"deleting node {node.key}, {node.val}\\\")\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n del self.mapping[node.key]\\n # self.printList()\\n \\n def printList(self):\\n curr = self.head\\n res = []\\n while curr:\\n res.append(f\\\"({curr.key}, {curr.val})\\\")\\n curr = curr.next\\n print(\\\",\\\".join(res))\\n\\n def get(self, key: int) -> int:\\n if key not in self.mapping:\\n return -1\\n \\n node = self.mapping[key]\\n self.deleteNode(node)\\n self.addNode(node)\\n return node.val\\n\\n def put(self, key: int, value: int) -> None:\\n if key not in self.mapping:\\n node = self.ListNode(key, value)\\n self.addNode(node)\\n if len(self.mapping) > self.capacity:\\n self.deleteNode(self.tail.prev)\\n \\n else:\\n node = self.mapping[key]\\n node.val = value\\n self.deleteNode(node)\\n self.addNode(node)\\n\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"747\"\n },\n {\n \"code\": \"class LRUCache:\\n class Node:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.next = None\\n self.prev = None\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.head = self.Node(-1, -1)\\n self.tail = self.Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.m = {}\\n\\n def get(self, key: int) -> int:\\n #print(\\\"get node key = \\\", key)\\n if key in self.m:\\n value = self.m[key].val\\n self.put(key, value) \\n return value \\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n #print(\\\"put node key, value = \\\", key, value)\\n #print(\\\"what is value =\\\", value)\\n if key in self.m:\\n self.deleteNode(key)\\n self.addNode(key, value)\\n #print(\\\"i am asa here, len(self.m) = \\\", len(self.m))\\n #print(\\\"self.capacity =\\\", self.capacity)\\n if len(self.m) > self.capacity:\\n print(\\\"i am here\\\")\\n self.deleteNode(self.tail.prev.key)\\n \\n def addNode(self, key, val):\\n print(\\\"addNode, key, val=\\\", key, val)\\n node = self.Node(key, val)\\n temp = self.head.next\\n self.head.next = node\\n temp.prev = node\\n node.prev = self.head\\n node.next = temp\\n self.m[key] = node\\n \\n \\n\\n def deleteNode(self, key):\\n node = self.m[key]\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n #self.addNode(key, value)\\n self.m.pop(key)\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"771\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val: int, prev=None, next=None):\\n self.key = key\\n self.val = val\\n self.next = next\\n self.prev = prev\\n\\nclass LRUCache:\\n \\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.storage = {}\\n\\n self.head = Node(None, 0, None, None)\\n self.tail = Node(None, 0, None, None)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n def delete(self, key):\\n node = self.storage[key]\\n #delete\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n node.prev, node.next= None, None\\n pass\\n def add(self, key, value):\\n node = Node(key, value)\\n prev = self.tail.prev\\n next = self.tail\\n\\n prev.next = node\\n next.prev = node\\n \\n node.prev = prev\\n node.next = next\\n \\n\\n self.storage[key] = node\\n\\n\\n def get(self, key: int) -> int:\\n if key in self.storage:\\n self.delete(key)\\n\\n node = self.storage[key]\\n self.add(node.key, node.val)\\n\\n return self.storage[key].val\\n \\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n print()\\n print('set')\\n if key in self.storage:\\n print('exists already')\\n self.delete(key)\\n self.add(key, value)\\n else: #it does not exist\\n if len(self.storage) < self.capacity:\\n print('doesnt exist, but theres room')\\n self.add(key, value)\\n else:\\n print('out of room...')\\n LRU = self.head.next\\n LRU.next.prev = LRU.prev\\n LRU.prev.next = LRU.next\\n del self.storage[LRU.key]\\n \\n self.add(key, value)\\n\\n print('set ' , self.head.next.key, self.tail.prev.key)\\n \\n\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"771\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self,val,key=None):\\n self.val=val\\n self.key=key\\n self.prev=None\\n self.next=None \\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.cap = 0\\n self.mx = capacity\\n self.map = dict()\\n self.head = Node(-1)\\n self.tail = Node(-1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n print(self.head.val)\\n def get(self, key: int) -> int:\\n if key not in self.map:\\n return -1\\n res=self.map[key]\\n self.delete(res)\\n self.insert(self.head,res)\\n return res.val\\n def insert(self,head,node):\\n if self.cap>=self.mx:\\n lru = self.tail.prev\\n self.delete(lru)\\n del self.map[lru.key]\\n self.cap+=1\\n tmp=self.head.next\\n self.head.next=node\\n node.next=tmp\\n node.prev=self.head\\n tmp.prev=node\\n def delete(self,node):\\n print(self.tail.prev.val,\\\"hi\\\")\\n self.cap-=1\\n prev_node = node.prev\\n next_node = node.next\\n prev_node.next = next_node\\n next_node.prev = prev_node\\n print(self.tail.prev.val,\\\"hi\\\")\\n\\n\\n\\n def put(self, key: int, value: int) -> None:\\n p=Node(value,key)\\n if key in self.map:\\n self.delete(self.map[key])\\n self.map[key]=p\\n self.insert(self.head,p)\\n # print(self.head.next.val,self.map)\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"794\"\n },\n {\n \"code\": \"class LRUCache:\\n #\\n # (None)<->(1)<->(2)<->(3)<->\\n # *\\n #\\n def __init__(self, capacity: int):\\n self.head = ListNode(None, None)\\n self.tail = ListNode(None, None)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.capacity = capacity\\n self.table = {}\\n\\n def get(self, key: int) -> int:\\n if key in self.table:\\n self.put(key, self.table[key].val)\\n return self.table[key].val\\n else:\\n return -1\\n def put(self, key: int, value: int) -> None:\\n if key in self.table:\\n self.remove(self.table[key])\\n elif self.capacity == 0:\\n self.remove(self.tail.prev)\\n node = ListNode(key, value)\\n first_node = self.head.next\\n self.head.next = node\\n node.next = first_node\\n first_node.prev = node\\n node.prev = self.head\\n self.table[key] = node\\n self.capacity -= 1\\n\\n \\n def remove(self, node):\\n prev_node = node.prev\\n next_node = node.next\\n key = node.key\\n prev_node.next = next_node\\n next_node.prev = prev_node\\n self.table.pop(key)\\n self.capacity += 1\\n\\n \\n \\n \\n \\nclass ListNode:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.next = None\\n self.prev = None\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"794\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, value):\\n self.key = key\\n self.value = value\\n self.prev = None\\n self.next = None\\n\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.node_dict = {}\\n self.head = Node(-1, -1)\\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.capacity = capacity\\n \\n\\n def get(self, key: int) -> int:\\n # print(f'key to get: {key}')\\n # print(f'self.node_dict: {self.node_dict}')\\n # print()\\n\\n print('get')\\n print(key)\\n print()\\n if key not in self.node_dict:\\n return -1\\n else:\\n node = self.node_dict[key]\\n self.remove(key)\\n self.add(node)\\n return node.value\\n \\n\\n def put(self, key: int, value: int) -> None:\\n print('put')\\n print(key, value)\\n print()\\n node = Node(key, value)\\n if key in self.node_dict:\\n self.remove(key)\\n self.add(node)\\n \\n if len(self.node_dict) > self.capacity:\\n # print(f\\\"len(self.node_dict): {len(self.node_dict)}\\\")\\n # print(f\\\"self.capacity: {self.capacity}\\\")\\n lru_node = self.head.next\\n # print(lru_node.key)\\n # print(lru_node.value)\\n # print()\\n self.remove(lru_node.key)\\n \\n def remove(self, key):\\n node = self.node_dict[key]\\n prev_node = node.prev\\n next_node = node.next\\n prev_node.next = next_node\\n next_node.prev = prev_node\\n\\n # print(self.node_dict)\\n self.node_dict.pop(node.key, None)\\n # print(self.node_dict)\\n # print()\\n \\n def add(self, node):\\n prev_node = self.tail.prev\\n node.prev = prev_node\\n node.next = self.tail\\n prev_node.next = node\\n self.tail.prev = node\\n self.node_dict[node.key] = node\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"818\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, prev=None, next=None):\\n self.val = val\\n self.prev = prev\\n self.next = next\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.dict = {-1:-1}\\n self.head = None\\n self.tail = None\\n self.capacity = capacity\\n self.cnt = 0\\n\\n def _bring_node_to_front(self, node):\\n if not node.next:\\n return\\n prev = node.prev\\n nxt = node.next\\n if prev:\\n prev.next = nxt\\n else:\\n self.head = nxt\\n\\n\\n if nxt:\\n nxt.prev = prev\\n self.tail.next = node\\n node.prev = self.tail\\n self.tail = node\\n node.next = None\\n \\n if not self.head:\\n self.head = self.tail\\n\\n def get(self, key: int) -> int:\\n print(f'get {key}')\\n \\n if key not in self.dict:\\n return -1\\n else:\\n data = self.dict[key]\\n val = data['val']\\n node = data['node']\\n self._bring_node_to_front(node)\\n print(self.head.val if self.head else 'head null')\\n print(self.tail.val if self.tail else 'tail null')\\n return val\\n\\n def put(self, key: int, value: int) -> None:\\n print(f'put {key}, {value}')\\n print(self.head.val if self.head else 'head null')\\n print(self.tail.val if self.tail else 'tail null')\\n if key not in self.dict:\\n if self.cnt == self.capacity:\\n lru_key = self.head.val\\n self.head = self.head.next\\n if self.head:\\n self.head.prev = None\\n del self.dict[lru_key]\\n print(f'del {lru_key}')\\n else:\\n self.cnt += 1\\n\\n node = ListNode(val=key)\\n self.dict[key] = {\\n 'val': value,\\n 'node': node\\n }\\n if not self.head:\\n self.head = node\\n self.tail = node\\n else:\\n self.tail.next = node\\n node.prev = self.tail\\n self.tail = node\\n else:\\n self.dict[key]['val'] = value\\n node = self.dict[key]['node']\\n self._bring_node_to_front(node)\\n \\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"818\"\n },\n {\n \"code\": \"from sortedcontainers import SortedDict\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.dict = {}\\n self.timestamps = SortedDict()\\n self.timestamp = 0\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n self.timestamp += 1\\n # print (self.dict, self.timestamp, self.timestamps, key)\\n \\n if key not in self.dict: return -1\\n val, old_timestamp = self.dict[key]\\n del self.timestamps[old_timestamp]\\n self.timestamps[self.timestamp] = key\\n self.dict[key] = (val, self.timestamp)\\n return val\\n\\n\\n def put(self, key: int, value: int) -> None:\\n self.timestamp += 1\\n # print (self.dict, self.timestamp, self.timestamps, key, value)\\n\\n if key not in self.dict:\\n self.dict[key] = (value, self.timestamp)\\n self.timestamps[self.timestamp] = key\\n while len(self.timestamps) > self.capacity:\\n evict_ts = self.timestamps.keys()[0]\\n evict_key = self.timestamps[evict_ts]\\n del self.timestamps[evict_ts]\\n del self.dict[evict_key]\\n else:\\n val, old_timestamp = self.dict[key]\\n del self.timestamps[old_timestamp]\\n self.timestamps[self.timestamp] = key\\n self.dict[key] = (value, self.timestamp)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"841\"\n },\n {\n \"code\": \"class DoubleLinkedListNode:\\n def __init__(self, k, v, n=None, p=None):\\n self.v = v\\n self.k = k\\n self.next = n\\n self.prev = p\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.size = 0\\n self.head = DoubleLinkedListNode(-1, -1)\\n self.tail = DoubleLinkedListNode(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.map = dict()\\n\\n def append(self, node):\\n prev_tail = self.tail.prev\\n \\n self.tail.prev = node\\n prev_tail.next = node\\n\\n node.prev = prev_tail\\n node.next = self.tail\\n \\n self.size += 1\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n node.next = None\\n node.prev = None\\n\\n self.size -= 1\\n\\n def get(self, key: int) -> int:\\n if key not in self.map:\\n return -1\\n\\n node = self.map[key]\\n self.remove(node)\\n self.append(node)\\n\\n return node.v\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.map:\\n node = self.map[key]\\n node.v = value\\n self.remove(node)\\n else:\\n node = DoubleLinkedListNode(key, value)\\n self.map[key] = node\\n\\n self.append(node)\\n\\n # ptr = self.head.next\\n # l = []\\n # while ptr != self.tail and len(l) < 10:\\n # l.append(ptr.v)\\n # ptr = ptr.next\\n\\n # print(l, self.size)\\n\\n while len(self.map) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.map[node_to_delete.k]\\n\\n ptr = self.head.next\\n l = []\\n while ptr != self.tail and len(l) < 10:\\n l.append(ptr.v)\\n ptr = ptr.next\\n\\n print(l, self.size)\\n \\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"841\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=(0, 0)):\\n self.val = val\\n self.next = None\\n self. prev = None\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cur_size = 0\\n self.head = ListNode()\\n self.key_node = dict()\\n self.capacity = capacity\\n self.tail = None\\n\\n def get(self, key: int) -> int:\\n if key in self.key_node:\\n key, val = self.key_node[key].val\\n self.remove(key)\\n self.append(key, val)\\n return val\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.key_node:\\n self.remove(key)\\n self.append(key, value)\\n def append(self, key, val):\\n print('append', key, val)\\n if key in self.key_node:\\n raise Exception('key in key_node') \\n node = ListNode((key, val))\\n self.key_node[key] = node\\n if self.tail:\\n self.tail.next = node\\n node.prev = self.tail\\n self.tail = node\\n else:\\n self.tail = node\\n node.prev = self.head\\n self.head.next = node\\n self.cur_size += 1\\n print(self.head.next.val)\\n if self.cur_size > self.capacity:\\n self.remove(self.head.next.val[0])\\n\\n\\n def remove(self, key):\\n node = self.key_node[key]\\n prev = node.prev\\n nxt = node.next\\n if nxt is None:\\n self.tail = prev\\n prev.next = nxt\\n if nxt:\\n nxt.prev = prev\\n \\n del self.key_node[key]\\n self.cur_size -= 1\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"865\"\n },\n {\n \"code\": \"class LinkedList:\\n def __init__(self, key = None, value = None, next = None, prev = None):\\n self.key = key\\n self.value = value\\n self.next = next\\n self.prev = prev\\n\\nclass LRUCache:\\n '''\\n LRU: 1) head <--> tail\\n head <-> (1) <-> tail\\n '''\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.LRU_size = 0\\n self.LRU_map = {}\\n self.LRU_head = LinkedList()\\n self.LRU_tail = LinkedList()\\n self.LRU_head.next = self.LRU_tail\\n self.LRU_tail.prev = self.LRU_head\\n\\n def __evict_LRU(self) -> None:\\n # remove least-recently used from LRU datastructure\\n lru_node = self.LRU_tail.prev\\n print(f\\\"Evicting LRU: {lru_node.value}\\\")\\n prev = lru_node.prev\\n next = self.LRU_tail\\n\\n prev.next = next\\n next.prev = prev\\n\\n del self.LRU_map[lru_node.key]\\n self.LRU_size -= 1\\n\\n def __make_MRU(self, key: int, value: int) -> None:\\n original_MRU = self.LRU_head.next\\n node = LinkedList(key=key, value=value, prev=self.LRU_head, next=original_MRU)\\n print(f\\\"Making MRU: {value}\\\")\\n self.LRU_head.next = node\\n original_MRU.prev = node\\n self.LRU_map[key] = node\\n self.LRU_size += 1\\n\\n def __evict_some_RU(self, key: int) -> None:\\n if key not in self.LRU_map:\\n raise ValueError()\\n \\n node = self.LRU_map[key]\\n print(f\\\"Evicting some RU: {node.value}\\\")\\n # pop off D.L.L.\\n prev = node.prev\\n next = node.next\\n prev.next = next\\n next.prev = prev\\n\\n self.LRU_size -= 1\\n\\n\\n def get(self, key: int) -> int:\\n print(f\\\"Getting key: {key}\\\")\\n # get corresponding value if exists\\n if not key in self.LRU_map:\\n return -1\\n\\n node = self.LRU_map[key]\\n value = node.value\\n self.__evict_some_RU(key)\\n self.__make_MRU(key, value)\\n return value\\n\\n def put(self, key: int, value: int) -> None:\\n # update or create value at corresponding key\\n # update key to be most-recently used\\n # 1) if create, easy just add to LRU datastructure\\n # 2) if update, pop key from LRU datastructure and add\\n # FYI need to check capacity\\n print(f\\\"Putting key, value: {key}, {value}\\\")\\n if key in self.LRU_map:\\n self.__evict_some_RU(key)\\n elif self.LRU_size == self.capacity:\\n lru_key = self.__evict_LRU()\\n\\n self.__make_MRU(key, value)\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"865\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val: int, prev=None, next=None):\\n self.key = key\\n self.val = val\\n self.next = next\\n self.prev = prev\\n\\nclass LRUCache:\\n \\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.storage = {}\\n\\n self.head = Node(None, 0, None, None)\\n self.tail = Node(None, 0, None, None)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n def delete(self, key):\\n node = self.storage[key]\\n #delete\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n node.prev, node.next= None, None\\n pass\\n def add(self, key, value):\\n node = Node(key, value)\\n node.prev = self.tail.prev\\n node.next = self.tail\\n\\n node.prev.next = node \\n self.tail.prev = node\\n\\n\\n self.storage[key] = node\\n\\n\\n def get(self, key: int) -> int:\\n print()\\n print('getting...')\\n if key in self.storage:\\n if self.tail.prev.key == key:\\n return self.tail.prev.val\\n print('get' , self.head.next.key, self.tail.prev.key)\\n self.delete(key)\\n node = self.storage[key]\\n self.add(node.key, node.val)\\n\\n #print('get', self.head.next.val, self.tail.val)\\n print('get after: ' , self.head.next.key, self.tail.prev.key)\\n return self.storage[key].val\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n print()\\n print('set')\\n if key in self.storage:\\n print('exists already')\\n self.delete(key)\\n self.add(key, value)\\n else: #it does not exist\\n if len(self.storage) < self.capacity:\\n print('doesnt exist, but theres room')\\n self.add(key, value)\\n else:\\n #remove LRU\\n \\n #add new node\\n print('out of room...')\\n\\n #if self.capacity==1:\\n # del self.storage[self.tail.prev.key]\\n #else:\\n #delete LRU, or left.\\n LRU = self.head.next\\n # self.head.next = LRU.next\\n LRU.next.prev = LRU.prev\\n LRU.prev.next = LRU.next\\n #self.delete(self.head.next.key)\\n del self.storage[LRU.key]\\n \\n self.add(key, value)\\n\\n print('set ' , self.head.next.key, self.tail.prev.key)\\n \\n\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"889\"\n },\n {\n \"code\": \"from collections import deque, defaultdict\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.dict_aux = {}\\n self.queue = deque()\\n self.aux_cap = defaultdict(int)\\n\\n def get(self, key: int) -> int:\\n if key in self.dict_aux:\\n self.aux_cap[key] += 1\\n self.queue.append(key)\\n return self.dict_aux.get(key, -1)\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.dict_aux:\\n self.aux_cap[key] += 1\\n self.dict_aux[key] = value\\n self.queue.append(key)\\n return\\n \\n if len(self.queue) == (self.capacity + sum(self.aux_cap.values())):\\n old_key = self.queue.popleft()\\n while old_key in self.aux_cap:\\n aux = self.aux_cap.get(old_key)\\n if aux == 1:\\n del(self.aux_cap[old_key])\\n else:\\n self.aux_cap[old_key] -= 1\\n old_key = self.queue.popleft()\\n\\n del(self.dict_aux[old_key])\\n self.queue.append(key)\\n self.dict_aux[key] = value\\n\\n\\n\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"889\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val: int, prev=None, next=None):\\n self.key = key\\n self.val = val\\n self.next = next\\n self.prev = prev\\n\\nclass LRUCache:\\n \\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.storage = {}\\n\\n self.head = Node(None, 0, None, None)\\n self.tail = Node(None, 0, None, None)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n def delete(self, key):\\n node = self.storage[key]\\n #delete\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n node.prev, node.next= None, None\\n pass\\n def add(self, key, value):\\n node = Node(key, value)\\n node.prev = self.tail.prev\\n node.next = self.tail\\n\\n node.prev.next = node \\n self.tail.prev = node\\n\\n\\n self.storage[key] = node\\n\\n\\n def get(self, key: int) -> int:\\n print()\\n print('getting...')\\n if key in self.storage:\\n if self.tail.prev.key == key:\\n return self.tail.prev.val\\n print('get' , self.head.next.key, self.tail.prev.key)\\n self.delete(key)\\n node = self.storage[key]\\n self.add(node.key, node.val)\\n\\n #print('get', self.head.next.val, self.tail.val)\\n print('get after: ' , self.head.next.key, self.tail.prev.key)\\n return self.storage[key].val\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n print()\\n print('set')\\n if key in self.storage:\\n print('exists already')\\n self.delete(key)\\n self.add(key, value)\\n else: #it does not exist\\n if len(self.storage) < self.capacity:\\n print('doesnt exist, but theres room')\\n self.add(key, value)\\n else:\\n #remove LRU\\n \\n #add new node\\n print('out of room...')\\n\\n if self.capacity==1:\\n del self.storage[self.tail.prev.key]\\n else:\\n #delete LRU, or left.\\n LRU = self.head.next\\n # self.head.next = LRU.next\\n LRU.next.prev = LRU.prev\\n LRU.prev.next = LRU.next\\n #self.delete(self.head.next.key)\\n del self.storage[LRU.key]\\n \\n self.add(key, value)\\n\\n print('set ' , self.head.next.key, self.tail.prev.key)\\n \\n\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"912\"\n },\n {\n \"code\": \"class DoubleLinkedListNode:\\n def __init__(self, k, v):\\n self.k = k\\n self.v = v\\n self.prev = None\\n self.next = None\\n def __repr__(self):\\n return f'k={self.k}, v={self.v}'\\n\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.tail = None\\n self.head = None\\n self.size = 0\\n self.capacity = capacity\\n self.cache = {}\\n\\n def get(self, key: int) -> int:\\n k = self.cache.get(key, None)\\n print(f\\\"get {key}\\\")\\n if k:\\n self.move_to_front(k)\\n return k.v\\n return -1\\n\\n def move_to_front(self, node):\\n print(f\\\"moving {node} to front\\\")\\n if node == self.head:\\n pass\\n else:\\n if node == self.tail:\\n self.tail = node.prev\\n if node.prev:\\n node.prev.next = node.next\\n if node.next:\\n node.next.prev = node.prev\\n node.next = self.head\\n if self.head:\\n self.head.prev = node\\n self.head = node\\n print(f\\\"new head is {self.head}\\\")\\n print(f\\\"new tail is {self.tail}\\\")\\n\\n\\n def put(self, key: int, value: int) -> None:\\n print(f'put {key}')\\n exists = self.cache.get(key, None)\\n if exists:\\n exists.v = value\\n self.move_to_front(exists)\\n return\\n\\n if self.size == self.capacity:\\n if not self.tail:\\n print(f'h=[{self.head}], size={self.size}')\\n raise ValueError\\n del self.cache[self.tail.k]\\n self.tail = self.tail.prev\\n self.size -= 1\\n\\n node = DoubleLinkedListNode(key, value)\\n if self.size == 0:\\n self.tail = node\\n else:\\n self.head.prev = node\\n node.next = self.head\\n\\n self.size += 1\\n self.head = node\\n self.cache[key] = node\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"912\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, val):\\n self.val = val\\n self.next = None\\n self.prev = None\\n\\nclass DLL:\\n def __init__(self):\\n self.size = 0\\n self.head = None\\n self.tail = None\\n\\n def appendleft(self, node):\\n node.next = self.head\\n if self.head:\\n self.head.prev = node\\n self.head = node\\n if self.size == 0:\\n self.tail = node\\n self.size += 1\\n\\n def remove(self, node):\\n if node == self.head:\\n self.head = self.head.next\\n if self.head:\\n self.head.prev = None\\n else:\\n if node.prev:\\n node.prev.next = node.next\\n if node.next:\\n node.next.prev = node.prev\\n \\n if node == self.tail:\\n if self.tail:\\n self.tail = self.tail.prev\\n self.size -= 1\\n\\n def pop(self):\\n node = self.tail\\n self.tail = self.tail.prev\\n if self.tail:\\n self.tail.next = None\\n self.size -= 1\\n return node\\n \\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.H = {}\\n self.dll = DLL()\\n self.capacity = capacity\\n \\n def get(self, key: int) -> int:\\n if key not in self.H:\\n print(\\\"get missing\\\", key, -1, (self.dll.size, self.capacity))\\n return -1\\n node = self.H[key]\\n self.dll.remove(node)\\n self.dll.appendleft(node)\\n print(\\\"get\\\", key, node.val, (self.dll.size, self.capacity))\\n return node.val[1]\\n\\n def put(self, key: int, value: int) -> None:\\n node = Node((key, value))\\n if key in self.H:\\n self.dll.remove(self.H[key])\\n \\n self.dll.appendleft(node)\\n print(\\\"Adding\\\", key, (self.dll.size, self.capacity))\\n if self.dll.size > self.capacity:\\n tmp = self.dll.pop()\\n print(\\\"Removing\\\", tmp.val[0], (self.dll.size, self.capacity))\\n self.H.pop(tmp.val[0])\\n print(\\\"Removed\\\", tmp.val[0], (self.dll.size, self.capacity))\\n\\n self.H[key] = node\\n\\n \\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"936\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.d = {}\\n self.l_head = Node(None, None)\\n self.l_tail = Node(None, None)\\n self.l_head.next=self.l_tail\\n self.l_tail.next = None\\n self.l_head.prev = None\\n self.l_tail.prev = self.l_head\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key not in self.d:\\n return -1\\n\\n node = self.d[key]\\n #self.evict(node)\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n self.move_to_end(node)\\n return node.val\\n \\n def move_to_end(self, node):\\n node.next = self.l_tail\\n node.prev = self.l_tail.prev\\n self.l_tail.prev.next = node\\n self.l_tail.prev = node\\n\\n def put(self, key: int, value: int) -> None:\\n print (\\\"op : put \\\" , key, value, \\\"head \\\" , self.l_head.next.key, self.l_head.next.val)\\n\\n if key in self.d:\\n node = self.d[key]\\n node.val = value\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n print (\\\"put update\\\" , node.key , node.val)\\n self.move_to_end(node)\\n print (\\\"op_post : put \\\" , key, value, \\\"head \\\" , self.l_head.next.key, self.l_head.next.val)\\n return\\n\\n if len(self.d) == self.capacity:\\n print (\\\"put new with evict\\\" , key , value)\\n self.evict(self.l_head.next)\\n\\n \\n node = Node(key, value)\\n self.d[key] = node\\n self.move_to_end(node)\\n print (\\\"op_post : put \\\" , key, value, \\\"head \\\" , self.l_head.next.key, self.l_head.next.val)\\n\\n def evict(self, node):\\n print (\\\"evict \\\", node.key , node.val)\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n del self.d[node.key]\\n \\n\\nclass Node:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.prev = None\\n self.next = None\\n \\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"936\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, value, next_node, prev_node):\\n self.key = key\\n self.value = value\\n self.next = next_node\\n self.prev = prev_node\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.numb_ele = 0\\n self.cache = dict()\\n self.begin = None\\n self.end = None\\n self.recent = list()\\n\\n def get(self, key: int) -> int:\\n print(\\\"get: \\\", key)\\n ret = self.cache.get(key, -1)\\n if ret != -1:\\n # print(ret.key, ret.value)\\n prev_node = ret.prev\\n next_node = ret.next\\n print(prev_node, next_node)\\n \\n if prev_node != None:\\n prev_node.next = next_node\\n if next_node != None:\\n next_node.prev = prev_node\\n else:\\n self.end = prev_node\\n self.begin.prev = ret\\n ret.next = self.begin\\n ret.prev = None\\n self.begin = ret\\n \\n return ret.value\\n return ret\\n\\n def put(self, key: int, value: int) -> None:\\n print(\\\"put: \\\", key, value)\\n \\n if self.get(key) != -1:\\n self.cache[key].value = value\\n else:\\n new_node = Node(key=key, value=value, next_node=self.begin, prev_node=None)\\n # print(\\\"else: \\\", self.begin, self.end)\\n self.cache[key] = new_node\\n \\n self.numb_ele += 1\\n if self.numb_ele == 1:\\n self.end = new_node\\n else:\\n self.begin.prev = new_node\\n print(\\\"put, begin\\\", self.begin.key, self.begin.prev)\\n self.begin = new_node\\n if self.numb_ele > self.capacity:\\n end_node = self.end\\n new_end = end_node.prev\\n new_end.next = None\\n self.cache.pop(self.end.key, None)\\n self.end = new_end\\n self.numb_ele -= 1\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"959\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.ts = 0\\n self.capacity = capacity\\n self.history = []\\n\\n def get(self, key: int) -> int:\\n if not key in self.cache:\\n return -1\\n\\n val, ts = self.cache[key]\\n self.ts += 1\\n self.cache[key] = [val, self.ts]\\n self.history.append([key, self.ts])\\n return val\\n\\n def put(self, key: int, value: int) -> None:\\n self.ts += 1\\n self.cache[key] = [value, self.ts]\\n self.history.append([key, self.ts])\\n self.evict()\\n\\n def evict(self):\\n if len(self.cache) <= self.capacity:\\n return\\n\\n n = 0\\n for key, ts in self.history:\\n if len(self.cache) <= self.capacity:\\n break\\n v, t = self.cache[key]\\n if t == ts:\\n del self.cache[key]\\n n += 1\\n\\n self.history = self.history[n:]\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"959\"\n },\n {\n \"code\": \"'''class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache=[]\\n self.cap=capacity\\n self.dicti=dict()\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.dicti:\\n #print(self.cache)\\n self.cache.remove(key)\\n self.cache.append(key)\\n return self.dicti[key]\\n else:\\n return -1\\n\\n\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.dicti:\\n self.dicti[key]=value\\n self.cache.remove(key)\\n self.cache.append(key)\\n\\n else:\\n if len(self.cache)<self.cap:\\n \\n self.cache.append(key)\\n self.dicti[key]=value\\n else:\\n p=self.cache.pop(0)\\n self.cache.append(key)\\n self.dicti[key]=value\\n self.dicti.pop(p)\\n'''\\nclass LRUCache:\\n def __init__(self, capacity):\\n self.dict = {}\\n self.freeSpace = capacity\\n\\n\\n def get(self, key):\\n if key not in self.dict:\\n return -1\\n\\n self.dict[key] = self.dict.pop(key)\\n\\n return self.dict[key]\\n\\n\\n def put(self, key, value):\\n if key in self.dict:\\n self.dict.pop(key)\\n else:\\n if self.freeSpace:\\n self.freeSpace -= 1\\n else:\\n first=list(self.dict.keys())[0]\\n #self.dict.pop(next(iter(self.dict)))\\n self.dict.pop(first)\\n\\n self.dict[key] = value\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"983\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, val=0, key=0, next=None, prev=None):\\n self.next = next\\n self.prev = prev\\n self.val = val\\n self.key = key\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.cap = capacity\\n self.cache = {}\\n self.lru = Node()\\n self.mru = Node()\\n self.mru.prev = self.lru\\n self.lru.next = self.mru\\n\\n def insert(self, new_node):\\n n = self.mru.prev\\n new_node.next = self.mru\\n new_node.prev = n\\n self.mru.prev = new_node\\n n.next = new_node\\n\\n def remove(self, cur_node):\\n n1 = cur_node.prev\\n n2 = cur_node.next\\n n1.next = n2\\n n2.prev = n1\\n\\n def get(self, key: int) -> int:\\n # print(self.lru.next.key, self.lru.next.val )\\n if key in self.cache:\\n self.remove(self.cache[key])\\n self.insert(self.cache[key])\\n return self.cache[key].val\\n else:\\n return -1\\n \\n def put(self, key: int, value: int) -> None:\\n print(f'before put {key},{value}:', \\n 'mr:', self.mru.prev.key,self.mru.prev.val, \\n 'lr:', self.lru.next.key,self.lru.next.val)\\n if len(self.cache) < self.cap:\\n if key not in self.cache:\\n new_node = Node(value, key)\\n self.cache[key] = new_node\\n else:\\n self.remove(self.cache[key])\\n self.cache[key].val = value \\n else:\\n if key not in self.cache:\\n to_del_node = self.lru.next\\n print('to_del_node', to_del_node.key, to_del_node.val)\\n del self.cache[to_del_node.key]\\n self.remove(to_del_node)\\n\\n new_node = Node(value, key)\\n self.cache[key] = new_node\\n else:\\n self.remove(self.cache[key])\\n self.cache[key].val = value\\n\\n self.insert(self.cache[key])\\n print(f'after put {key},{value}:', \\n 'mr:', self.mru.prev.key,self.mru.prev.val, \\n 'lr:', self.lru.next.key,self.lru.next.val)\\n print()\\n \\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"983\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cap = capacity\\n self.store = {}\\n\\n def get(self, key: int) -> int:\\n val = self.store.get(key, -1)\\n if val != -1:\\n del self.store[key]\\n self.store[key] = val\\n return val\\n\\n def put(self, key: int, value: int) -> None:\\n if self.store.get(key):\\n del self.store[key]\\n self.store[key] = value\\n else:\\n if len(self.store) == self.cap:\\n del self.store[list(self.store.keys())[0]]\\n self.store[key] = value\\n else:\\n self.store[key] = value\\n # print(self.store)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1006\"\n },\n {\n \"code\": \"class DLL:\\n def __init__(self, key = 0, left = None, right = None):\\n self.key = key\\n self.left = left\\n self.right = right\\n \\n\\n\\nclass LRUCache:\\n def print_ptr(self, ptr):\\n ans = []\\n max_size = 10\\n while ptr is not None and max_size:\\n ans.append(ptr.key)\\n ptr = ptr.right\\n max_size -= 1\\n print(ans)\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.size = 0\\n\\n self.cache = {}\\n self.act_map = {}\\n\\n self.head = DLL() \\n self.end = self.head\\n \\n def delink_ptr(self, ptr):\\n if ptr is None:\\n return \\n _left = ptr.left\\n _right = ptr.right\\n if _right:\\n _left.right , _right.left = _right, _left\\n else:\\n _left.right= None\\n self.end = _left\\n return ptr\\n\\n def update_ptr(self, ptr):\\n if ptr is None:\\n return \\n \\n if ptr == self.end:\\n return\\n\\n ptr = self.delink_ptr(ptr)\\n self.end.right = ptr\\n ptr.left = self.end \\n ptr.right = None \\n self.end = ptr\\n\\n\\n def get(self, key: int) -> int:\\n print(\\\"\\\\n\\\\n\\\")\\n print(f\\\"get: {key}\\\")\\n if self.cache.get(key, None):\\n ptr = self.cache.get(key, None)\\n self.update_ptr(ptr)\\n (self.print_ptr(self.head))\\n return self.act_map[key] \\n return -1 \\n\\n\\n\\n def put(self, key: int, value: int) -> None:\\n print(\\\"\\\\n\\\\n\\\")\\n print(f\\\"put: {key}\\\")\\n\\n if self.cache.get(key, None):\\n ptr = self.cache.get(key, None)\\n self.update_ptr(ptr)\\n \\n else:\\n if self.size == self.capacity:\\n ptr = self.delink_ptr(self.head.right)\\n self.cache[ptr.key] = None\\n else:\\n self.size += 1\\n\\n ptr = DLL(key, self.end, None)\\n self.cache[key], self.end.right, self.end = ptr, ptr, ptr\\n \\n # print(f\\\"put: {key}\\\")\\n (self.print_ptr(self.head))\\n self.act_map[key] = value \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1006\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cap = capacity\\n self.store = {}\\n\\n def get(self, key: int) -> int:\\n val = self.store.get(key, -1)\\n if val != -1:\\n del self.store[key]\\n self.store[key] = val\\n return val\\n\\n def put(self, key: int, value: int) -> None:\\n if self.store.get(key):\\n del self.store[key]\\n self.store[key] = value\\n else:\\n if len(self.store) == self.cap:\\n del self.store[list(self.store.keys())[0]]\\n self.store[key] = value\\n else:\\n self.store[key] = value\\n # print(self.store)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1030\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cap = capacity\\n self.cache_map = {}\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.cache_map:\\n val = self.cache_map[key]\\n del self.cache_map[key]\\n self.cache_map[key] = val\\n return val\\n else:\\n return -1\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.cache_map:\\n del self.cache_map[key]\\n self.cache_map[key] = value\\n else:\\n if len(self.cache_map) < self.cap:\\n self.cache_map[key] = value\\n else:\\n del self.cache_map[list(self.cache_map)[0]]\\n self.cache_map[key] = value\\n\\n\\n\\n \\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1030\"\n },\n {\n \"code\": \"class LRUCache:\\n from collections import OrderedDict\\n def __init__(self, capacity: int):\\n self.capacity=capacity\\n self.cache=DefaultDict()\\n\\n def makeRecent(self, key):\\n value=self.cache[key]\\n del self.cache[key]\\n self.cache[key]=value\\n\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.makeRecent(key)\\n return self.cache[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.makeRecent(key)\\n self.cache[key]=value\\n else:\\n if len(self.cache)>=self.capacity:\\n oldest_key=list(self.cache)[0]\\n del self.cache[oldest_key]\\n\\n self.cache[key]=value\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1054\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.holder = {}\\n self.maxhold = capacity\\n\\n def get(self, key: int) -> int:\\n if key not in self.holder:\\n return -1\\n val = self.holder[key]\\n self.holder.pop(key)\\n self.holder[key]=val\\n return val\\n\\n#[_2_:_2_,_1_:_1_]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.holder.keys():\\n self.holder.pop(key)\\n self.holder[key] = value #added at the end saying it is most recently used\\n else:\\n if len(self.holder)>=self.maxhold:#remove in front (least recently used) and add at last\\n removekeys = list(self.holder.keys()) #must make .keys to list (cause its just for viewing)\\n removekeys = removekeys[0]\\n self.holder.pop(removekeys) \\n self.holder[key]=value\\n\\n else:#add in the last \\n self.holder[key]=value\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\\n\\n\",\n \"runtime\": \"1054\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n\\n def get(self, key: int) -> int:\\n if key in self.cache.keys():\\n temp = [ key , self.cache[key] ]\\n del self.cache[key]\\n self.cache[key] = temp[1]\\n return self.cache[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache.keys():\\n del self.cache[key]\\n self.cache[key] = value\\n elif len(self.cache) >= self.capacity:\\n del self.cache[list(self.cache)[0]]\\n self.cache[key] = value\\n else:\\n self.cache[key] = value\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1077\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.map = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if self.map.get(key) is not None:\\n val = self.map[key]\\n del(self.map[key]) \\n self.map[key] = val\\n return val\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if not self.map.get(key):\\n if len(self.map.keys()) == self.capacity:\\n i = list(self.map.keys())[0]\\n del(self.map[i])\\n else:\\n del(self.map[key])\\n \\n self.map[key] = value\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1077\"\n },\n {\n \"code\": \"\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.hmap = {}\\n self.count = 0\\n self.lru = {}\\n self.age = 0\\n self.age_to_key = {}\\n\\n def get(self, key: int) -> int:\\n if key in self.hmap:\\n self.age += 1\\n self.lru.pop(key)\\n self.lru[key] = self.age\\n self.age_to_key[self.age] = key\\n return self.hmap.get(key)\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if self.count < self.capacity and key not in self.hmap:\\n self.hmap[key] = value\\n self.count += 1\\n self.age += 1\\n self.lru[key] = self.age\\n self.age_to_key[self.age] = key\\n elif key in self.hmap:\\n self.hmap[key] = value\\n self.age += 1\\n self.lru.pop(key)\\n self.lru[key] = self.age\\n self.age_to_key[self.age] = key\\n elif self.count >= self.capacity:\\n least = float('inf')\\n remove_key = None\\n keys = list(self.lru.keys())\\n remove_key = keys[0]\\n self.age += 1\\n self.lru.pop(remove_key)\\n self.hmap.pop(remove_key)\\n self.hmap[key] = value\\n self.lru[key] = self.age\\n \\n \\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1101\"\n },\n {\n \"code\": \"\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.hmap = {}\\n self.count = 0\\n self.lru = {}\\n self.age = 0\\n self.age_to_key = {}\\n\\n def get(self, key: int) -> int:\\n if key in self.hmap:\\n self.age += 1\\n self.lru.pop(key)\\n self.lru[key] = self.age\\n self.age_to_key[self.age] = key\\n return self.hmap.get(key)\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if self.count < self.capacity and key not in self.hmap:\\n self.hmap[key] = value\\n self.count += 1\\n self.age += 1\\n self.lru[key] = self.age\\n self.age_to_key[self.age] = key\\n elif key in self.hmap:\\n self.hmap[key] = value\\n self.age += 1\\n self.lru.pop(key)\\n self.lru[key] = self.age\\n self.age_to_key[self.age] = key\\n elif self.count >= self.capacity:\\n least = float('inf')\\n remove_key = None\\n keys = list(self.lru.keys())\\n remove_key = keys[0]\\n self.age += 1\\n self.lru.pop(remove_key)\\n self.hmap.pop(remove_key)\\n self.hmap[key] = value\\n self.lru[key] = self.age\\n \\n \\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1101\"\n },\n {\n \"code\": \"\\nclass LRUCache:\\n # built by 2 data structure: doubly LL & HashMap\\n\\n #self.dict[key]: This retrieves the value associated with the key key from the dictionary self.dict.\\n #self.dict.key(): This calls a method named key() that belongs to the object self.dict.\\n def __init__(self, capacity: int):\\n # self.capacity = capacity\\n # self.dict = {}\\n self.capacity = capacity\\n self.dict = {}\\n\\n def get(self, key: int) -> int:\\n # if key in self.dict.keys():\\n # value = self.dict[key]\\n # del self.dict[key]\\n # self.dict[key] = value\\n # return value\\n # else:\\n # return -1\\n if key in self.dict.keys():\\n val = self.dict[key]\\n del self.dict[key]\\n self.dict[key] = val\\n return val\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n # if key in self.dict.keys():\\n # del self.dict[key]\\n # self.dict[key] = value\\n # else:\\n # if len(self.dict) < self.capacity:\\n # self.dict[key] = value\\n # else:\\n # del self.dict[list(self.dict)[0]]\\n # self.dict[key] = value \\n if key in self.dict.keys():\\n del self.dict[key]\\n self.dict[key] = value\\n else:\\n if len(self.dict) < self.capacity:\\n self.dict[key] = value\\n else:\\n del self.dict[list(self.dict)[0]]\\n \\n self.dict[key] = value \\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\\n\",\n \"runtime\": \"1124\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, val, prev=None, next_=None):\\n self.val = val\\n self.prev = prev\\n self.next = next_\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.__size = capacity\\n self.__map = {}\\n self.initialise()\\n\\n \\n def initialise(self):\\n self.head = Node(-1)\\n self.tail = Node(-1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.__map:\\n self.update_lru(key)\\n return self.__map[key].val\\n else:\\n return -1\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.__map:\\n self.__map[key].val = value\\n self.update_lru(key)\\n else:\\n if len(self.__map) >= self.__size:\\n self.delete_node()\\n self.__map[key] = Node(value)\\n self.append_node(key)\\n \\n def append_node(self, key):\\n node = self.__map[key]\\n\\n node.next = self.head.next\\n node.prev = self.head\\n self.head.next.prev = node\\n self.head.next = node\\n\\n def delete_node(self):\\n node = self.tail.prev\\n\\n self.tail.prev = node.prev\\n node.prev.next = self.tail\\n\\n for i, j in self.__map.items():\\n if j == node:\\n del self.__map[i]\\n break\\n\\n def update_lru(self, key):\\n node = self.__map[key]\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n self.head.next.prev = node\\n node.next = self.head.next\\n node.prev = self.head\\n self.head.next = node\\n\\n\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1148\"\n },\n {\n \"code\": \"class Node :\\n def __init__(self, val = None ):\\n self.next = None\\n self.prev = None\\n self.val = val\\n \\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.hashmap = {}\\n self.head = Node()\\n self.tail = Node()\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.count = 0\\n\\n # when inserting we can insert at head\\n # pop from tail\\n # so tail will have the most recently used\\n\\n def remove(self, node) :\\n next_node = node.next\\n prev_node = node.prev\\n\\n prev_node.next = next_node\\n next_node.prev = prev_node\\n\\n self.insert_at_head(node)\\n\\n def insert_at_head(self, node) :\\n # Now insert at head\\n next_node_head = self.head.next\\n self.head.next = node\\n node.next = next_node_head\\n node.prev = self.head\\n next_node_head.prev = node\\n \\n def get(self, key: int) -> int:\\n if key in self.hashmap :\\n # Pop from linked list\\n self.remove(self.hashmap[key])\\n return self.hashmap[key].val\\n else :\\n return -1 \\n \\n def put(self, key: int, value: int) -> None:\\n if self.head.next :\\n print(self.head.next.val)\\n # So that would be ,\\n if key in self.hashmap : # For Updating the value only\\n # The node exists, so updating the value\\n self.hashmap[key].val = value\\n self.remove(self.hashmap[key])\\n else :\\n new_node = Node(value)\\n self.hashmap[key] = new_node\\n if self.count < self.capacity : \\n # We insert at head position\\n # Now put it at the head\\n self.insert_at_head(new_node)\\n self.count += 1\\n else :\\n # If its greater than capacity, then we need to remove from tail\\n prev_node = self.tail.prev.prev # This is the LRU\\n prev_node_removed = self.tail.prev\\n prev_node.next = self.tail\\n self.tail.prev = prev_node\\n # Remove this node from hashmap as well\\n\\n for k, v in self.hashmap.items() :\\n if v == prev_node_removed :\\n del self.hashmap[k]\\n break\\n \\n # now we can insert the node at the head\\n self.insert_at_head(new_node)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1172\"\n },\n {\n \"code\": \"from bisect import insort\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.consequence = 0\\n self.cache_list = []\\n self.key_cache_vect = []\\n self.consequence_cache_vect = []\\n\\n def binary_search(self, vect, key):\\n left, right = 0, len(vect) - 1\\n while left <= right:\\n mid = left + (right - left) // 2\\n if vect[mid][0] == key:\\n return mid\\n elif vect[mid][0] < key:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return None\\n\\n def get(self, key: int) -> int:\\n # check if key exists\\n key_cache_ind = self.binary_search(self.key_cache_vect, key)\\n if key_cache_ind is not None:\\n # update consequence_cache_vect\\n cache_ind = self.key_cache_vect[key_cache_ind][1]\\n old_consequence = self.cache_list[cache_ind]['consequence']\\n consequence_cache_ind = self.binary_search(self.consequence_cache_vect, old_consequence)\\n\\n insort(self.consequence_cache_vect, [self.consequence, cache_ind])\\n self.consequence_cache_vect.pop(consequence_cache_ind)\\n #self.consequence_cache_vect[consequence_cache_ind][0] = self.consequence\\n #self.consequence_cache_vect.sort()\\n\\n\\n # update cache_list\\n self.cache_list[cache_ind]['consequence'] = self.consequence\\n self.consequence += 1\\n # get the value\\n return self.cache_list[cache_ind]['value']\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n # check if key exists\\n key_cache_ind = self.binary_search(self.key_cache_vect, key)\\n if key_cache_ind is not None:\\n # update consequence_cache_vect\\n cache_ind = self.key_cache_vect[key_cache_ind][1]\\n old_consequence = self.cache_list[cache_ind]['consequence']\\n consequence_cache_ind = self.binary_search(self.consequence_cache_vect, old_consequence)\\n\\n insort(self.consequence_cache_vect, [self.consequence, cache_ind])\\n self.consequence_cache_vect.pop(consequence_cache_ind)\\n #self.consequence_cache_vect[consequence_cache_ind][0] = self.consequence\\n #self.consequence_cache_vect.sort()\\n \\n \\n # update cache value\\n self.cache_list[cache_ind]['value'] = value\\n self.cache_list[cache_ind]['consequence'] = self.consequence\\n self.consequence += 1\\n return None\\n cache_Len = len(self.cache_list)\\n new_cache = {'key': key, 'value': value, 'consequence': self.consequence}\\n if cache_Len < self.capacity:\\n # put new cache\\n self.cache_list.append(new_cache)\\n \\n insort(self.key_cache_vect, [key, cache_Len])\\n #self.key_cache_vect.append([key, cache_Len])\\n #self.key_cache_vect.sort()\\n\\n insort(self.consequence_cache_vect, [self.consequence, cache_Len])\\n #self.consequence_cache_vect.append([self.consequence, cache_Len])\\n #self.consequence_cache_vect.sort()\\n self.consequence += 1\\n else:\\n # evict by new cache\\n # update consequence_cache_vect\\n ind = self.consequence_cache_vect[0][1]\\n \\n insort(self.consequence_cache_vect, [self.consequence, ind])\\n #self.consequence_cache_vect.append([self.consequence, ind])\\n #self.consequence_cache_vect.sort()\\n self.consequence_cache_vect.pop(0)\\n \\n # update cache_list\\n old_key = self.cache_list[ind]['key']\\n self.cache_list[ind] = new_cache\\n self.consequence += 1\\n # update key_cache_vect\\n key_cache_ind = self.binary_search(self.key_cache_vect, old_key)\\n self.key_cache_vect.pop(key_cache_ind)\\n insort(self.key_cache_vect, [key, ind])\\n #self.key_cache_vect.append([key, ind])\\n #self.key_cache_vect.sort()\\n return None\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\\n\",\n \"runtime\": \"1195\"\n },\n {\n \"code\": \"from typing import Dict, List\\n'''\\n 10s : 1\\n 20s : 1\\n 30s: 2\\n 40s: 1 \\n 50s : 3\\n\\n 1 : 10s, 20s,40s\\n 2: 30s\\n\\n 30s : 2\\n 40s: 1\\n\\n'''\\nfrom collections import OrderedDict\\nfrom datetime import datetime\\n\\ni = 0\\ndef get_i():\\n global i\\n i+=1\\n return i\\n\\nclass CacheValue:\\n last_timestamp: int\\n value: int\\n \\n def __init__(self, v: int):\\n self.value = v\\n self.last_timestamp = get_i()\\n\\nclass LRUCache:\\n caches: dict[int, CacheValue]\\n hisotry : OrderedDict\\n size : int \\n \\n \\n def __init__(self, capacity: int):\\n self.size = capacity\\n self.caches = {}\\n self.history = {}\\n \\n def get(self, key: int) -> int:\\n if key in self.caches:\\n self.update_history(key)\\n #self.show(f'get {key}')\\n return self.caches[key].value\\n else:\\n #self.show(f'get {key}')\\n return -1\\n \\n def put(self, key: int, value: int) -> None:\\n #print(f\\\"size: {self.size}\\\")\\n if key in self.caches:\\n self.caches[key].value = value \\n self.update_history(key) \\n #self.show(f'put({key}, {value})')\\n return\\n\\n if len(self.caches)==self.size:\\n # sort hisotry\\n ordered_timestamp = sorted(self.history.keys())\\n least_used_timestamp = ordered_timestamp[0]\\n least_used_key = self.history[least_used_timestamp]\\n \\n del self.caches[least_used_key] \\n del self.history[least_used_timestamp] \\n \\n self.caches[key] = CacheValue(value) \\n self.add_history(key) \\n #self.show(f'put({key}, {value})')\\n \\n def add_history(self, key:int) ->None:\\n cached_value = self.caches[key]\\n self.history[cached_value.last_timestamp] = key\\n \\n def update_history(self, key:int) ->None:\\n # delete old timestamp history\\n cached_value = self.caches[key]\\n old_timestamp = cached_value.last_timestamp\\n del self.history[old_timestamp]\\n \\n # update timestamp in caches and history dict\\n \\n new_timestamp = get_i()\\n \\n cached_value.last_timestamp = new_timestamp\\n self.history[new_timestamp] = key\\n \\n def show(self, action) -> None:\\n print(f\\\"----{action}\\\")\\n print('history')\\n print(self.history)\\n print('caches')\\n #print(self.caches)\\n for k, v in self.caches.items():\\n print(f\\\"cache: key-{k} value-{v.value} timestamp-{v.last_timestamp}\\\")\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1219\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.max_size = capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n tmp = self.cache.pop(key)\\n self.cache[key] = tmp\\n return self.cache[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n prev_size = len(self.cache)\\n self.cache[key] = value\\n if prev_size == len(self.cache):\\n tmp = self.cache.pop(key)\\n self.cache[key] = tmp\\n if len(self.cache) > self.max_size:\\n keys = list(self.cache.keys())\\n self.cache.pop(list(self.cache.keys())[0])\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1242\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.young = 0\\n self.capacity = capacity \\n self.hashmap_of_dict_priority = {}\\n self.hashmap_of_dict_age = {}\\n self.hashmap_of_dict_val = {}\\n \\n\\n def get(self, key: int) -> int:\\n #print(self.hashmap_of_dict_val)\\n if key in self.hashmap_of_dict_val:\\n self.hashmap_of_dict_priority[self.young] = key\\n age = self.hashmap_of_dict_age[key]\\n self.hashmap_of_dict_age[key] = self.young\\n del self.hashmap_of_dict_priority[age]\\n self.young +=1\\n return self.hashmap_of_dict_val[key]\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n #print(self.hashmap_of_dict_val)\\n if key in self.hashmap_of_dict_val:\\n self.hashmap_of_dict_priority[self.young] = key\\n age = self.hashmap_of_dict_age[key]\\n self.hashmap_of_dict_age[key] = self.young\\n del self.hashmap_of_dict_priority[age]\\n self.hashmap_of_dict_val[key] = value\\n self.young +=1\\n return \\n\\n if len(self.hashmap_of_dict_val) == self.capacity:\\n del_key_priority = min(self.hashmap_of_dict_priority)\\n del_key = self.hashmap_of_dict_priority[del_key_priority]\\n del self.hashmap_of_dict_val[del_key]\\n del self.hashmap_of_dict_priority[del_key_priority]\\n del self.hashmap_of_dict_age[del_key]\\n self.hashmap_of_dict_val[key] = value\\n self.hashmap_of_dict_priority[self.young] = key\\n self.hashmap_of_dict_age[key] = self.young\\n self.young +=1\\n\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1266\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cap = capacity\\n self.time = 0\\n self.time_to_key = {} # time:key\\n self.key_to_time = {} # key:time\\n self.key_to_val = {} # key:value\\n\\n def get(self, key: int) -> int:\\n if key not in self.key_to_val:\\n return -1\\n prev_time = self.key_to_time[key]\\n self.key_to_time[key] = self.time\\n del self.time_to_key[prev_time]\\n self.time_to_key[self.time] = key\\n self.time += 1\\n return self.key_to_val[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.key_to_val:\\n self.key_to_val[key] = value\\n prev_time = self.key_to_time[key]\\n del self.time_to_key[prev_time]\\n self.time_to_key[self.time] = key\\n self.key_to_time[key] = self.time\\n else:\\n if len(self.key_to_val) == self.cap:\\n min_time = min(self.time_to_key)\\n min_key = self.time_to_key[min_time]\\n del self.time_to_key[min_time]\\n del self.key_to_time[min_key]\\n del self.key_to_val[min_key]\\n self.time_to_key[self.time] = key\\n self.key_to_time[key] = self.time\\n self.key_to_val[key] = value\\n self.time += 1\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1289\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.size = capacity\\n self.map_key_rec = {} # To record when the key was last used\\n self.map_rec_key = {} # To map recency counts to keys\\n self.map_key_value = {} # To store key-value pairs\\n self.count = 0 # Instance variable to track recency\\n\\n def get(self, key: int) -> int:\\n if key in self.map_key_rec:\\n self.count += 1\\n rec_count = self.map_key_rec[key]\\n del self.map_rec_key[rec_count] # Remove old recency\\n self.map_key_rec[key] = self.count\\n self.map_rec_key[self.count] = key # Update with new recency\\n return self.map_key_value[key]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.map_key_rec:\\n # Update the value and recency if key already exists\\n rec_count = self.map_key_rec[key]\\n del self.map_rec_key[rec_count] # Remove old recency\\n elif len(self.map_key_value) >= self.size:\\n # Evict the least recently used key\\n oldest_recency = min(self.map_rec_key.keys())\\n lru_key = self.map_rec_key[oldest_recency]\\n del self.map_key_value[lru_key]\\n del self.map_key_rec[lru_key]\\n del self.map_rec_key[oldest_recency]\\n \\n # Insert the new key-value pair\\n self.map_key_value[key] = value\\n self.count += 1\\n self.map_key_rec[key] = self.count\\n self.map_rec_key[self.count] = key\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1313\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.young = 0\\n self.capacity = capacity \\n self.hashmap_of_dict_priority = {}\\n self.hashmap_of_dict_age = {}\\n self.hashmap_of_dict_val = {}\\n \\n\\n def get(self, key: int) -> int:\\n #print(self.hashmap_of_dict_val)\\n if key in self.hashmap_of_dict_val:\\n self.hashmap_of_dict_priority[self.young] = key\\n age = self.hashmap_of_dict_age[key]\\n self.hashmap_of_dict_age[key] = self.young\\n del self.hashmap_of_dict_priority[age]\\n self.young +=1\\n return self.hashmap_of_dict_val[key]\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n #print(self.hashmap_of_dict_val)\\n if key in self.hashmap_of_dict_val:\\n self.hashmap_of_dict_priority[self.young] = key\\n age = self.hashmap_of_dict_age[key]\\n self.hashmap_of_dict_age[key] = self.young\\n del self.hashmap_of_dict_priority[age]\\n self.hashmap_of_dict_val[key] = value\\n self.young +=1\\n return \\n\\n if len(self.hashmap_of_dict_val) == self.capacity:\\n del_key_priority = min(self.hashmap_of_dict_priority)\\n del_key = self.hashmap_of_dict_priority[del_key_priority]\\n del self.hashmap_of_dict_val[del_key]\\n del self.hashmap_of_dict_priority[del_key_priority]\\n del self.hashmap_of_dict_age[del_key]\\n self.hashmap_of_dict_val[key] = value\\n self.hashmap_of_dict_priority[self.young] = key\\n self.hashmap_of_dict_age[key] = self.young\\n self.young +=1\\n\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1337\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.keyCount = 0\\n self.capacity = capacity\\n self.use = {}\\n self.step = 100\\n self.minKey = None\\n \\n\\n def get(self, key: int) -> int:\\n self.step += 1\\n if key in self.cache:\\n lastUse, val = self.cache[key]\\n del self.use[lastUse]\\n self.use[self.step] = key\\n self.cache[key] = (self.step, val)\\n if self.minKey == lastUse:\\n self.minKey = min(self.use.keys())\\n \\n return val\\n else:\\n return -1\\n\\n \\n\\n def put(self, key: int, value: int) -> None:\\n self.step += 1\\n if key in self.cache:\\n lastUse, _ = self.cache[key]\\n del self.use[lastUse]\\n self.use[self.step] = key\\n self.cache[key] = (self.step, value)\\n\\n if self.minKey == lastUse:\\n self.minKey = min(self.use.keys())\\n elif self.keyCount < self.capacity:\\n self.cache[key] = (self.step, value)\\n self.use[self.step] = key\\n self.keyCount += 1\\n if self.minKey is None:\\n self.minKey = self.step\\n else:\\n ejectedKey = self.use[self.minKey]\\n del self.use[self.minKey]\\n if ejectedKey in self.cache:\\n del self.cache[ejectedKey]\\n self.cache[key] = (self.step, value)\\n self.use[self.step] = key\\n self.minKey = min(self.use.keys())\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1360\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n class Node:\\n def __init__(self, val):\\n self.val = val\\n self.prev = None\\n self.next = None\\n\\n def __init__(self, capacity: int):\\n self.keys_to_nodes = {}\\n self.sentinel = self.Node(0)\\n self.sentinel.prev = self.sentinel\\n self.sentinel.next = self.sentinel\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key not in self.keys_to_nodes:\\n return -1\\n self.remove(self.keys_to_nodes[key])\\n self.add(self.keys_to_nodes[key])\\n return self.keys_to_nodes[key].val\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.keys_to_nodes:\\n new_node = self.Node(value)\\n self.remove(self.keys_to_nodes[key])\\n self.keys_to_nodes[key] = new_node\\n self.add(new_node)\\n elif self.capacity > 0:\\n new_node = self.Node(value)\\n self.keys_to_nodes[key] = new_node\\n self.add(new_node)\\n self.capacity -= 1\\n else:\\n # print(f\\\"REMOVING {self.sentinel.prev.val}\\\")\\n last_node = self.sentinel.prev\\n bad_key = None\\n for val in self.keys_to_nodes.keys():\\n if self.keys_to_nodes[val] == last_node:\\n bad_key = val\\n break\\n del self.keys_to_nodes[bad_key]\\n self.remove(last_node)\\n new_node = self.Node(value)\\n self.keys_to_nodes[key] = new_node\\n self.add(new_node)\\n\\n def add(self, value) -> None:\\n temp = self.sentinel.next \\n self.sentinel.next = value\\n value.next = temp\\n value.prev = self.sentinel\\n value.next.prev = value\\n # print(f\\\"ADDED {value.val}\\\")\\n # print(self.sentinel.prev.val, self.sentinel.next.val)\\n\\n def remove(self, value) -> None:\\n value.prev.next = value.next\\n value.next.prev = value.prev\\n # print(f\\\"REMOVED {value.val}\\\")\\n # print(self.sentinel.prev, self.sentinel.next)\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1384\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cap = capacity\\n self.time = 0\\n self.time_to_key = {} # time:key\\n self.key_to_time = {} # key:time\\n self.key_to_val = {} # key:value\\n\\n def get(self, key: int) -> int:\\n if key not in self.key_to_val:\\n return -1\\n prev_time = self.key_to_time[key]\\n self.key_to_time[key] = self.time\\n del self.time_to_key[prev_time]\\n self.time_to_key[self.time] = key\\n self.time += 1\\n return self.key_to_val[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.key_to_val:\\n self.key_to_val[key] = value\\n prev_time = self.key_to_time[key]\\n del self.time_to_key[prev_time]\\n self.time_to_key[self.time] = key\\n self.key_to_time[key] = self.time\\n else:\\n if len(self.key_to_val) == self.cap:\\n min_time = min(self.time_to_key)\\n min_key = self.time_to_key[min_time]\\n del self.time_to_key[min_time]\\n del self.key_to_time[min_key]\\n del self.key_to_val[min_key]\\n self.time_to_key[self.time] = key\\n self.key_to_time[key] = self.time\\n self.key_to_val[key] = value\\n self.time += 1\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1407\"\n },\n {\n \"code\": \"class LRUCache:\\n cache = {}\\n lru = {}\\n capacity = 0\\n count = 0\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.lru = {}\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.lru.pop(self.cache[key][1])\\n value = self.cache[key][0]\\n self.cache[key] = (value, self.count)\\n self.lru[self.count] = key\\n self.count += 1\\n return self.cache[key][0]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key not in self.cache and len(self.cache) >= self.capacity:\\n minimum = min(self.lru)\\n self.cache.pop(self.lru[minimum])\\n self.lru.pop(minimum)\\n # self.lru.pop(self.cache[key][1])\\n if key in self.cache:\\n self.lru.pop(self.cache[key][1])\\n self.cache[key] = (value, self.count)\\n self.lru[self.count] = key\\n self.count += 1\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1431\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.lru = {}\\n self.count = 0\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.lru.pop(self.cache[key][1])\\n value = self.cache[key][0]\\n self.cache[key] = (value, self.count)\\n self.lru[self.count] = key\\n self.count += 1\\n return self.cache[key][0]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key not in self.cache and len(self.cache) >= self.capacity:\\n minimum = min(self.lru)\\n self.cache.pop(self.lru[minimum])\\n self.lru.pop(minimum)\\n # self.lru.pop(self.cache[key][1])\\n if key in self.cache:\\n self.lru.pop(self.cache[key][1])\\n self.cache[key] = (value, self.count)\\n self.lru[self.count] = key\\n self.count += 1\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1455\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.size = capacity\\n self.map_key_rec = {} \\n self.map_rec_key = {} \\n self.map_key_value = {} \\n self.count = 0 \\n\\n def get(self, key: int) -> int:\\n if key in self.map_key_rec:\\n self.count += 1\\n rec_count = self.map_key_rec[key]\\n del self.map_rec_key[rec_count] \\n self.map_key_rec[key] = self.count\\n self.map_rec_key[self.count] = key \\n return self.map_key_value[key]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.map_key_rec:\\n \\n rec_count = self.map_key_rec[key]\\n del self.map_rec_key[rec_count] \\n elif len(self.map_key_value) >= self.size:\\n \\n oldest_recency = min(self.map_rec_key.keys())\\n lru_key = self.map_rec_key[oldest_recency]\\n del self.map_key_value[lru_key]\\n del self.map_key_rec[lru_key]\\n del self.map_rec_key[oldest_recency]\\n \\n \\n self.map_key_value[key] = value\\n self.count += 1\\n self.map_key_rec[key] = self.count\\n self.map_rec_key[self.count] = key\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1478\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.young = 0\\n self.capacity = capacity \\n self.hashmap_of_dict_priority = {}\\n self.hashmap_of_dict_age = {}\\n self.hashmap_of_dict_val = {}\\n \\n\\n def get(self, key: int) -> int:\\n #print(self.hashmap_of_dict_val)\\n if key in self.hashmap_of_dict_val:\\n self.hashmap_of_dict_priority[self.young] = key\\n age = self.hashmap_of_dict_age[key]\\n self.hashmap_of_dict_age[key] = self.young\\n del self.hashmap_of_dict_priority[age]\\n self.young +=1\\n return self.hashmap_of_dict_val[key]\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n #print(self.hashmap_of_dict_val)\\n if key in self.hashmap_of_dict_val:\\n self.hashmap_of_dict_priority[self.young] = key\\n age = self.hashmap_of_dict_age[key]\\n self.hashmap_of_dict_age[key] = self.young\\n del self.hashmap_of_dict_priority[age]\\n self.hashmap_of_dict_val[key] = value\\n self.young +=1\\n return \\n\\n if len(self.hashmap_of_dict_val) == self.capacity:\\n del_key_priority = min(self.hashmap_of_dict_priority)\\n del_key = self.hashmap_of_dict_priority[del_key_priority]\\n del self.hashmap_of_dict_val[del_key]\\n del self.hashmap_of_dict_priority[del_key_priority]\\n del self.hashmap_of_dict_age[del_key]\\n self.hashmap_of_dict_val[key] = value\\n self.hashmap_of_dict_priority[self.young] = key\\n self.hashmap_of_dict_age[key] = self.young\\n self.young +=1\\n\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1502\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n val = self.cache[key]\\n del self.cache[key]\\n self.cache[key] = val\\n return val\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key not in self.cache:\\n self.cache[key] = value\\n if len(list(self.cache)) > self.capacity:\\n del self.cache[list(self.cache.keys())[0]]\\n else:\\n del self.cache[key]\\n self.cache[key] = value\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1525\"\n },\n {\n \"code\": \"#\\n#\\n# {2: ListNode(2), 1: ListNode(1), 3: ListNode(3)}\\n# \\n# [1, 2,3 ] \\n# \\n# None 1 <-> 2 <-> 3 get(2) ListNode(2).next() = 3, prev = 1, connect 1.next = 2.next take the #tail.next=2.next\\n# \\n\\nclass ListNode:\\n def __init__(self,key = 0, val = 0):\\n self.key = key\\n self.val = val\\n self.next = None\\n self.prev = None\\n\\n#\\n#\\n# cache {1: 1, 1: 2}\\n# linkedList = 1 <=> 2 \\n# everytime I put an item in the cache, append to the end of the linked List\\n# \\n# function -> adds item to the end of the linkedList\\n# function -> deletes item from the linkedList\\n\\n \\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = dict()\\n self.headNode = ListNode(-1, -1)\\n self.tailNode = self.headNode\\n self.currentCap = 0\\n self.capacity = capacity\\n \\n def deleteFromLinkedList(self, currNode):\\n prevElement = currNode.prev\\n nextElement = currNode.next\\n \\n prevElement.next = nextElement\\n if(nextElement == None):\\n self.tailNode = prevElement\\n else:\\n nextElement.prev = prevElement\\n \\n def appendNodeToEnd(self, currNode):\\n self.tailNode.next = currNode\\n currNode.prev = self.tailNode\\n self.tailNode = self.tailNode.next\\n currNode.next = None\\n \\n def get(self, key: int) -> int:\\n if(key in self.cache):\\n currentNode = self.cache[key]\\n self.deleteFromLinkedList(currentNode)\\n self.appendNodeToEnd(currentNode)\\n return currentNode.val\\n else: \\n return -1 \\n \\n\\n def put(self, key: int, value: int) -> None:\\n newNode = ListNode(key, value)\\n if(key in self.cache):\\n # delete from linkedList\\n self.deleteFromLinkedList(self.cache[key])\\n \\n # make a new node and replace it in cache\\n self.cache[key] = newNode\\n \\n # append the new node to the end of the LL\\n self.appendNodeToEnd(newNode)\\n \\n else:\\n if(self.currentCap != self.capacity):\\n self.currentCap +=1\\n else: \\n toBeDeleted = self.headNode.next\\n tempHead = self.headNode \\n \\n while(tempHead):\\n tempHead = tempHead.next \\n self.deleteFromLinkedList(toBeDeleted)\\n del self.cache[toBeDeleted.key]\\n \\n \\n self.cache[key] = newNode\\n self.appendNodeToEnd(newNode)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1549\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.lru_dict = {}\\n self.capacity = capacity\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.lru_dict:\\n value = self.lru_dict[key]\\n del self.lru_dict[key]\\n self.lru_dict[key] = value\\n return value\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.lru_dict:\\n del self.lru_dict[key]\\n self.lru_dict[key] = value\\n else:\\n self.lru_dict[key] = value\\n if len(list(self.lru_dict.keys())) > self.capacity:\\n first_key = list(self.lru_dict.keys())[0]\\n del self.lru_dict[first_key]\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1549\"\n },\n {\n \"code\": \"class LRUCache:\\n cache = {}\\n lru = {}\\n capacity = 0\\n count = 0\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.lru = {}\\n\\n def get(self, key: int) -> int:\\n # print(\\\"get\\\")\\n # print(self.cache)\\n # print(self.lru)\\n if key in self.cache:\\n self.lru.pop(self.cache[key][1])\\n value = self.cache[key][0]\\n self.cache[key] = (value, self.count)\\n self.lru[self.count] = key\\n self.count += 1\\n return self.cache[key][0]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n # print(\\\"put\\\")\\n if key not in self.cache and len(self.cache) >= self.capacity:\\n minimum = min(self.lru)\\n self.cache.pop(self.lru[minimum])\\n self.lru.pop(minimum)\\n # self.lru.pop(self.cache[key][1])\\n if key in self.cache:\\n self.lru.pop(self.cache[key][1])\\n self.cache[key] = (value, self.count)\\n self.lru[self.count] = key\\n self.count += 1\\n # print(self.cache)\\n # print(self.lru)\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1573\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n val = self.cache[key]\\n del self.cache[key]\\n self.cache[key] = val\\n return val\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key not in self.cache:\\n self.cache[key] = value\\n if len(list(self.cache)) > self.capacity:\\n del self.cache[list(self.cache)[0]]\\n else:\\n del self.cache[key]\\n self.cache[key] = value\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1573\"\n },\n {\n \"code\": \"class LinkedListNode:\\n def __init__(self, key: int, value: int):\\n self.key = key\\n self.value = value\\n self.next = None\\n self.prev = None\\n\\n def __repr__(self):\\n return self.__str__()\\n \\n def __str__(self):\\n return f\\\"key={self.key} value={self.value}\\\"\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.nodes = {}\\n self.list = None\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n # print(\\\"get\\\", key)\\n if key in self.nodes:\\n node = self.nodes[key]\\n value = node.value\\n self._move_to_head(node)\\n # self._print()\\n return value\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n # print(\\\"put\\\", key, value)\\n if key in self.nodes:\\n node = self.nodes[key]\\n node.value = value\\n self._move_to_head(node)\\n else:\\n if self.capacity == 1 and len(self.nodes) == self.capacity:\\n del self.nodes[self.list.key]\\n self.list = None\\n elif len(self.nodes) == self.capacity:\\n curr = self.list\\n while curr.next is not None:\\n curr = curr.next\\n # curr is now the tail\\n curr.prev.next = None\\n curr.prev = None\\n del self.nodes[curr.key]\\n node = LinkedListNode(key, value)\\n self.nodes[key] = node\\n self._move_to_head(node)\\n # self._print()\\n \\n\\n def _move_to_head(self, node: LinkedListNode):\\n # print(\\\"move to head\\\", node)\\n if self.list == node:\\n return\\n\\n if node.prev:\\n node.prev.next = node.next\\n if node.next:\\n node.next.prev = node.prev\\n\\n if self.list is not None:\\n self.list.prev = node\\n node.next = self.list\\n node.prev = None\\n self.list = node\\n\\n def _print(self):\\n print(\\\"nodes\\\", self.nodes)\\n curr = self.list\\n while curr is not None:\\n print(\\\"node\\\", curr)\\n curr = curr.next\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1596\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity=capacity\\n self.map={}\\n self.counts={}\\n self.history=[]\\n\\n def get(self, key: int) -> int:\\n if key in self.map:\\n self.counts[key]+=1\\n self.history+=[key]\\n return self.map[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if len(self.map)==self.capacity and key not in self.map:\\n while self.counts[self.history[0]]!=1:\\n self.counts[self.history[0]]-=1\\n self.history=self.history[1:]\\n\\n # remove value from LRU cache\\n self.counts.pop(self.history[0])\\n self.map.pop(self.history[0])\\n self.history=self.history[1:]\\n \\n self.map[key]=value\\n self.counts[key]=self.counts[key]+1 if key in self.counts else 1\\n self.history+=[key]\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1620\"\n },\n {\n \"code\": \"class LRUCache:\\n class Node:\\n def __init__(self, key, val=0, nxt=None, prev=None):\\n self.key = key\\n self.val = val\\n self.next = nxt\\n self.prev = prev\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.m = {}\\n self.head = None\\n\\n\\n def get(self, key: int) -> int:\\n if key in self.m:\\n node = self.m[key]\\n prev = node.prev\\n nxt = node.next\\n if not prev:\\n return self.m[key].val\\n prev.next = nxt\\n if nxt:\\n nxt.prev = prev\\n\\n node.prev = None\\n node.next = self.head\\n self.head.prev = node\\n self.head = node\\n\\n return self.m[key].val\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.m:\\n node = self.m[key]\\n node.val = value\\n\\n pre = node.prev\\n nxt = node.next\\n if not pre:\\n return\\n pre.next = nxt\\n if nxt:\\n nxt.prev = pre\\n\\n node.prev = None\\n node.next = self.head\\n self.head.prev = node\\n self.head = node\\n else:\\n self.m[key] = self.Node(key, value, self.head)\\n if self.head:\\n self.head.prev = self.m[key]\\n self.head = self.m[key]\\n\\n if self.capacity == 0:\\n temp = self.head\\n while temp.next:\\n temp = temp.next\\n t = temp.prev\\n t.next = None\\n self.m.pop(temp.key)\\n del temp\\n else:\\n self.capacity -= 1\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1643\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.queue = []\\n self.map = {}\\n self.occurences = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n value = self.map.get(key, -1) \\n if value >= 0:\\n # we found it in the map and need to put it to front of queue\\n self.capacity += 1\\n self.queue.append(key)\\n self.occurences[key] += 1\\n return value\\n \\n def put(self, key: int, value: int) -> None:\\n if self.occurences.get(key, 0) > 0:\\n # if already in cache we don't want to\\n # remove anything\\n self.capacity += 1\\n \\n if len(self.queue) == self.capacity:\\n valueToRemove = self.queue[0]\\n while self.occurences.get(valueToRemove, 0) > 1:\\n # there are multiple copies so we need to keep removing \\n # until we find one that only has one copy\\n self.occurences[valueToRemove] -= 1\\n self.capacity -= 1\\n self.queue = self.queue[1:]\\n valueToRemove = self.queue[0]\\n self.queue = self.queue[1:]\\n self.occurences[valueToRemove] = 0\\n self.map[valueToRemove] = -1\\n self.occurences[key] = self.occurences.get(key, 0) + 1\\n self.queue.append(key)\\n self.map[key] = value\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1667\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n val = self.cache[key]\\n del self.cache[key]\\n self.cache[key] = val\\n return val\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key not in self.cache:\\n self.cache[key] = value\\n if len(list(self.cache.values())) > self.capacity:\\n del self.cache[list(self.cache.keys())[0]]\\n else:\\n del self.cache[key]\\n self.cache[key] = value\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1690\"\n },\n {\n \"code\": \"#\\n#\\n# {2: ListNode(2), 1: ListNode(1), 3: ListNode(3)}\\n# \\n# [1, 2,3 ] \\n# \\n# None 1 <-> 2 <-> 3 get(2) ListNode(2).next() = 3, prev = 1, connect 1.next = 2.next take the #tail.next=2.next\\n# \\n\\nclass ListNode:\\n def __init__(self,key = 0, val = 0):\\n self.key = key\\n self.val = val\\n self.next = None\\n self.prev = None\\n\\n#\\n#\\n# cache {1: 1, 1: 2}\\n# linkedList = 1 <=> 2 \\n# everytime I put an item in the cache, append to the end of the linked List\\n# \\n# function -> adds item to the end of the linkedList\\n# function -> deletes item from the linkedList\\n\\n \\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = dict()\\n self.headNode = ListNode(-1, -1)\\n self.tailNode = self.headNode\\n self.currentCap = 0\\n self.capacity = capacity\\n \\n def deleteFromLinkedList(self, currNode):\\n prevElement = currNode.prev\\n nextElement = currNode.next\\n \\n prevElement.next = nextElement\\n if(nextElement == None):\\n self.tailNode = prevElement\\n else:\\n nextElement.prev = prevElement\\n \\n def appendNodeToEnd(self, currNode):\\n self.tailNode.next = currNode\\n currNode.prev = self.tailNode\\n self.tailNode = self.tailNode.next\\n currNode.next = None\\n \\n def get(self, key: int) -> int:\\n if(key in self.cache):\\n currentNode = self.cache[key]\\n self.deleteFromLinkedList(currentNode)\\n self.appendNodeToEnd(currentNode)\\n return currentNode.val\\n else: \\n return -1 \\n \\n\\n def put(self, key: int, value: int) -> None:\\n newNode = ListNode(key, value)\\n if(key in self.cache):\\n # delete from linkedList\\n self.deleteFromLinkedList(self.cache[key])\\n \\n # make a new node and replace it in cache\\n self.cache[key] = newNode\\n \\n # append the new node to the end of the LL\\n self.appendNodeToEnd(newNode)\\n \\n else:\\n if(self.currentCap != self.capacity):\\n self.currentCap +=1\\n else: \\n toBeDeleted = self.headNode.next\\n tempHead = self.headNode \\n \\n while(tempHead):\\n tempHead = tempHead.next \\n self.deleteFromLinkedList(toBeDeleted)\\n del self.cache[toBeDeleted.key]\\n \\n \\n self.cache[key] = newNode\\n self.appendNodeToEnd(newNode)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1714\"\n },\n {\n \"code\": \"import heapq\\n\\n\\nclass LRUCache:\\n class Node:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.prev = None\\n self.next = None\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.size = 0\\n self.queue = None\\n self.map = dict()\\n\\n def get(self, key: int) -> int:\\n if key not in self.map:\\n return -1\\n\\n node = self.map[key]\\n self.to_front(node)\\n\\n return node.val\\n\\n def to_front(self, node):\\n if node == self.queue:\\n return\\n\\n prev = node.prev\\n next_ = node.next\\n\\n prev.next = next_\\n if next_ is not None:\\n next_.prev = prev\\n\\n node.prev = None\\n node.next = self.queue\\n self.queue.prev = node\\n self.queue = node\\n\\n def insert_front(self, node):\\n node.next = self.queue\\n if self.queue is not None:\\n self.queue.prev = node\\n self.queue = node\\n def put(self, key: int, value: int) -> None:\\n\\n if key in self.map:\\n node = self.map[key]\\n node.val = value\\n self.to_front(node)\\n else:\\n node = LRUCache.Node(key, value)\\n self.map[key] = node\\n self.insert_front(node)\\n self.size += 1\\n\\n if self.size > self.capacity:\\n self.evict()\\n\\n def evict(self) -> None:\\n current = self.queue\\n while current.next is not None:\\n current = current.next\\n\\n current.prev.next = None\\n\\n del self.map[current.key]\\n\\n self.size -= 1\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\\n\",\n \"runtime\": \"1738\"\n },\n {\n \"code\": \"class LRUCache:\\n class Node:\\n def __init__(self, key, val=0, nxt=None, prev=None):\\n self.key = key\\n self.val = val\\n self.next = nxt\\n self.prev = prev\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.m = {}\\n self.head = None\\n\\n\\n def get(self, key: int) -> int:\\n if key in self.m:\\n node = self.m[key]\\n prev = node.prev\\n nxt = node.next\\n if not prev:\\n return self.m[key].val\\n prev.next = nxt\\n if nxt:\\n nxt.prev = prev\\n\\n node.prev = None\\n node.next = self.head\\n self.head.prev = node\\n self.head = node\\n\\n return self.m[key].val\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.m:\\n node = self.m[key]\\n node.val = value\\n\\n pre = node.prev\\n nxt = node.next\\n if not pre:\\n return\\n pre.next = nxt\\n if nxt:\\n nxt.prev = pre\\n\\n node.prev = None\\n node.next = self.head\\n self.head.prev = node\\n self.head = node\\n else:\\n self.m[key] = self.Node(key, value, self.head)\\n if self.head:\\n self.head.prev = self.m[key]\\n self.head = self.m[key]\\n\\n if self.capacity == 0:\\n temp = self.head\\n while temp.next:\\n temp = temp.next\\n t = temp.prev\\n t.next = None\\n self.m.pop(temp.key)\\n del temp\\n else:\\n self.capacity -= 1\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1738\"\n },\n {\n \"code\": \"class LRUCache:\\n class Node:\\n def __init__(self, key, val=0, nxt=None, prev=None):\\n self.key = key\\n self.val = val\\n self.next = nxt\\n self.prev = prev\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.m = {}\\n self.head = None\\n\\n\\n def get(self, key: int) -> int:\\n if key in self.m:\\n node = self.m[key]\\n prev = node.prev\\n nxt = node.next\\n if not prev:\\n return self.m[key].val\\n prev.next = nxt\\n if nxt:\\n nxt.prev = prev\\n\\n node.prev = None\\n node.next = self.head\\n self.head.prev = node\\n self.head = node\\n\\n return self.m[key].val\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.m:\\n node = self.m[key]\\n node.val = value\\n\\n pre = node.prev\\n nxt = node.next\\n if not pre:\\n return\\n pre.next = nxt\\n if nxt:\\n nxt.prev = pre\\n\\n node.prev = None\\n node.next = self.head\\n self.head.prev = node\\n self.head = node\\n else:\\n self.m[key] = self.Node(key, value, self.head)\\n if self.head:\\n self.head.prev = self.m[key]\\n self.head = self.m[key]\\n\\n if self.capacity == 0:\\n temp = self.head\\n while temp.next:\\n temp = temp.next\\n t = temp.prev\\n t.next = None\\n self.m.pop(temp.key)\\n del temp\\n else:\\n self.capacity -= 1\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1761\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.data = {\\n\\n }\\n self.used_key = []\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n value = self.data.get(key, None)\\n if value is None:\\n return -1\\n else:\\n self.used_key.remove(key)\\n self.used_key.append(key)\\n return value\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.data.keys():\\n self.data[key] = value\\n self.used_key.remove(key)\\n self.used_key.append(key)\\n return\\n if len(self.data.keys()) == self.capacity and len(self.used_key) > 0:\\n lru_key = self.used_key[0]\\n self.used_key.remove(lru_key)\\n del self.data[lru_key]\\n\\n self.data[key] = value\\n self.used_key.append(key)\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1761\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.order = []\\n\\n def get(self, key: int) -> int:\\n \\n if key in self.cache:\\n self.order.remove(key)\\n self.order.append(key)\\n return self.cache[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n\\n self.order.append(key)\\n if key in self.cache:\\n self.order.remove(key)\\n self.cache[key]= value\\n else:\\n\\n if len(self.cache)==self.capacity:\\n self.cache.pop(self.order.pop(0))\\n self.cache[key]= value\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1785\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.map = {}\\n self.array = []\\n def get(self, key: int) -> int:\\n if key in self.map:\\n self.array.remove(key)\\n self.array.append(key)\\n return self.map[key]\\n return -1\\n def put(self, key: int, value: int) -> None:\\n if key in self.map:\\n # If the key exists, update its value and move it to the most recently used\\n self.map[key] = value\\n self.array.remove(key)\\n self.array.append(key)\\n else:\\n if len(self.map) >= self.capacity:\\n # Evict the least recently used key (first in the array)\\n lru_key = self.array.pop(0)\\n del self.map[lru_key]\\n # Add the new key-value pair\\n self.map[key] = value\\n self.array.append(key)\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1785\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.memory = {} \\n self.capacity = capacity \\n self.lrutracker = [] \\n\\n def get(self, key: int) -> int:\\n if key not in self.memory:\\n return -1\\n \\n self.lrutracker.remove(key)\\n self.lrutracker.append(key)\\n return self.memory[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.memory:\\n self.lrutracker.remove(key)\\n elif len(self.memory) >= self.capacity:\\n lru = self.lrutracker.pop(0)\\n del self.memory[lru]\\n self.memory[key] = value\\n self.lrutracker.append(key)\\n \\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1808\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n if capacity > 0:\\n self.capacity = capacity\\n self.cache = {} # overall cache\\n self.cache_order = [] # used key order\\n \\n def get(self, key: int) -> int:\\n if key in self.cache:\\n # move key to the recently used (end) of list\\n self.cache_order.remove(key) \\n self.cache_order.append(key)\\n return self.cache[key]\\n\\n else: return -1\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.cache: \\n self.cache[key] = value\\n self.cache_order.remove(key) \\n self.cache_order.append(key)\\n else:\\n if len(self.cache_order) >= self.capacity:\\n lru_key = self.cache_order[0]\\n del self.cache[lru_key]\\n self.cache_order.remove(lru_key) \\n \\n self.cache[key] = value\\n self.cache_order.append(key) \\n\\n \\n \\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1808\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.bank = []\\n self.size = 0\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.bank.remove(key)\\n self.bank.append(key)\\n return self.cache[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache[key] = value\\n self.bank.remove(key)\\n self.bank.append(key)\\n elif self.size < self.capacity:\\n self.size += 1\\n self.cache[key] = value\\n self.bank.append(key)\\n else:\\n cur = self.bank.pop(0)\\n del self.cache[cur]\\n self.cache[key] = value\\n self.bank.append(key)\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1832\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.size = capacity\\n self.cache = {}\\n self.order = []\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.order.remove(key)\\n self.order.append(key)\\n return self.cache[key]\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache[key] = value\\n self.order.remove(key)\\n self.order.append(key)\\n else:\\n if len(self.cache) >= self.size:\\n x = self.order.pop(0)\\n self.cache.pop(x)\\n self.cache[key]=value\\n self.order.append(key)\\n \\n\\n\\n# class Node:\\n# def __init__(self, key = -1, val = -1):\\n# self.key = key\\n# self.val = val\\n# self.prev = None\\n# self.next = None\\n\\n# class DLL:\\n# def __init__(self):\\n# self.dummy_start = Node()\\n# self.dummy_end = Node()\\n# self.dummy_start.next = self.dummy_end\\n# self.dummy_end.prev = self.dummy_start\\n\\n# def appendleft(self, node) -> Node:\\n# left, right = self.dummy_start, self.dummy_start.next\\n# node.next = right\\n# right.prev = node\\n# left.next = node\\n# node.prev = left\\n \\n# return node\\n\\n# def remove(self, node) -> Node:\\n# left, right = node.prev, node.next\\n# left.next = right\\n# right.prev = left\\n \\n# return node\\n\\n# def move_to_start(self, node):\\n# return self.appendleft(self.remove(node))\\n\\n# def pop(self):\\n# return self.remove(self.dummy_end.prev)\\n \\n# def peek(self):\\n# return self.dummy_end.prev.val\\n\\n# class LRUCache:\\n# def __init__(self, capacity: int):\\n# self.capacity = capacity\\n# self.cache = dict()\\n# self.dll = DLL()\\n\\n# def get(self, key: int) -> int:\\n# if key not in self.cache: return -1\\n \\n# node = self.cache[key]\\n# self.dll.move_to_start(node)\\n \\n# return node.val\\n\\n# def put(self, key: int, value: int) -> None:\\n# if key in self.cache:\\n# node = self.dll.remove(self.cache[key])\\n# node.val = value\\n# else:\\n# node = Node(key, value)\\n# self.cache[key] = node\\n \\n# self.dll.appendleft(node)\\n \\n# if len(self.cache) > self.capacity:\\n# self.cache.pop(self.dll.pop().key)\\n\\n# class Node():\\n# def __init__(self, value, next):\\n# self.value = value\\n# self.next = next\\n\\n\\n# class LRUCache:\\n\\n# def __init__(self, capacity: int):\\n# self.capacity = capacity\\n# self.cache = {}\\n# self.left = None\\n# self.right = None\\n# self.count = 0\\n \\n# def put(self, key: int, value: int) -> None:\\n# if key in self.cache:\\n# prev, node = self.cache[key]\\n# if prev is None:\\n# self.left = self.left.next\\n# self.cache[self.node.val] = [None, self.left]\\n# else:\\n# prev.next = prev.next.next\\n \\n# self.right.next = Node(value)\\n# self.right = self.right.next\\n# if len(self.cache)<capacity:\\n# if self.left is None and self.right is None:\\n# self.left = self.right = Node(value)\\n# self.cache[key] = [None, self.right]\\n# else:\\n# self.right.next = Node(value)\\n# self.cache[key] = [self.right, self.right.next]\\n\\n# self.right = self.right.next\\n\\n# if len(self.cache)==self.capacity:\\n# self.left = self.left.next\\n# self.right.next = Node(value)\\n# self.right = self.right.next\\n\\n\\n\\n# else:\\n\\n# class LRUCache:\\n\\n# def __init__(self, capacity: int):\\n\\n# self.capacity = capacity\\n# self.k_to_v_i= {}\\n# self.i_to_k = {}\\n# self.idx = -1\\n\\n# def get(self, key: int) -> int:\\n# if key in self.k_to_v_i:\\n# self.put(key, self.k_to_v_i[key][0])\\n# return self.k_to_v_i[key][0]\\n# return -1\\n\\n\\n# def put(self, key: int, value: int) -> None:\\n# self.idx+=1\\n# if len(self.k_to_v_i) == self.capacity:\\n# if key not in self.k_to_v_i:\\n# # Delete the pair\\n \\n# idx_to_remove = self.idx - self.capacity\\n# k_to_remove = self.i_to_k.pop(idx_to_remove)\\n# del self.k_to_v_i[k_to_remove]\\n \\n# else:\\n# idx_to_update = self.k_to_v_i[key][1] - 1\\n# while idx_to_update in self.i_to_k:\\n# key_to_update = self.i_to_k[idx_to_update]\\n# self.k_to_v_i[key_to_update][1]+=1\\n\\n# del self.i_to_k[idx_to_update]\\n# self.i_to_k[idx_to_update+1] = key_to_update\\n# idx_to_update-=1\\n\\n# # Add the pair\\n# self.k_to_v_i[key] = [value, self.idx]\\n# self.i_to_k[self.idx] = key\\n\\n\\n\\n \\n\\n\\n# # Your LRUCache object will be instantiated and called as such:\\n# # obj = LRUCache(capacity)\\n# # param_1 = obj.get(key)\\n# # obj.put(key,value)\",\n \"runtime\": \"1832\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity \\n self.lru = [] \\n self.mp = {} \\n\\n def get(self, key: int) -> int:\\n if key in self.mp:\\n self.lru.remove(key)\\n self.lru.append(key)\\n return self.mp[key] \\n else:\\n return -1 \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.mp:\\n self.mp[key] = value\\n self.lru.remove(key) \\n else:\\n if len(self.mp) >= self.capacity:\\n \\n lru_key = self.lru.pop(0) \\n del self.mp[lru_key] \\n\\n\\n self.mp[key] = value\\n\\n\\n self.lru.append(key)\\n\",\n \"runtime\": \"1856\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.LRUtag = []\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.LRUtag.remove(key)\\n self.LRUtag.append(key)\\n return self.cache.get(key)\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n # need smt to keep track of the least recently used key\\n # print(\\\"put\\\", key)\\n if key in self.cache:\\n # If the key already exists, update its value and mark it as most recently used\\n self.cache[key] = value\\n self.LRUtag.remove(key) # Remove from its current position\\n self.LRUtag.append(key) # Add to the end to mark as most recently used\\n else:\\n # If the cache is full, remove the least recently used key (first key in LRUtag)\\n if len(self.cache) >= self.capacity:\\n least_recently_used = self.LRUtag.pop(0) # Evict the first (least recently used)\\n del self.cache[least_recently_used]\\n\\n # Add the new key-value pair\\n self.cache[key] = value\\n self.LRUtag.append(key) # Mark the new key as most recently used\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\\n\",\n \"runtime\": \"1856\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.used = []\\n self.size = capacity \\n self.capacity = 0\\n self.map = {}\\n\\n def get(self, key: int) -> int:\\n if key in self.map:\\n self.used.remove(key)\\n self.used.append(key)\\n return self.map[key]\\n else:\\n return -1\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.map:\\n self.map[key] = value\\n self.used.remove(key)\\n self.used.append(key)\\n else:\\n if self.capacity + 1 > self.size:\\n #check first value in LRU array\\n val = self.used[0]\\n self.used.remove(val)\\n del self.map[val]\\n self.used.append(key)\\n self.map[key] = value \\n else:\\n self.capacity +=1\\n self.map[key] = value \\n self.used.append(key)\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1879\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.order = []\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n # Update the order list by moving the accessed key to the end\\n self.order.remove(key)\\n self.order.append(key)\\n return self.cache[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.order.remove(key)\\n elif len(self.cache) >= self.capacity:\\n lru_key = self.order.pop(0)\\n del self.cache[lru_key]\\n \\n self.cache[key] = value\\n self.order.append(key)\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1879\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.keys = capacity\\n self.stack =[]\\n self.hmap= {}\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.hmap:\\n self.stack.remove(key)\\n self.stack.append(key)\\n return self.hmap[key]\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hmap:\\n self.stack.remove(key)\\n self.stack.append(key)\\n \\n elif len(self.hmap) < self.keys:\\n self.stack.append(key) \\n else:\\n evict = self.stack[0]\\n self.stack.remove(evict)\\n self.stack.append(key)\\n # print(\\\"bf def\\\", self.hmap)\\n del self.hmap[evict]\\n # print(\\\"af def\\\", self.hmap)\\n self.hmap[key] = value\\n return \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1903\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.d=dict()\\n self.stack=[]\\n self.capacity=capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.d.keys():\\n self.stack.remove(key)\\n self.stack.append(key)\\n return self.d[key]\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.d.keys():\\n self.d[key]=value\\n self.stack.remove(key)\\n self.stack.append(key)\\n \\n elif len(self.d.keys())>=self.capacity:\\n k=self.stack[0]\\n self.d.pop(k)\\n self.stack.pop(0)\\n self.d[key]=value\\n self.stack.append(key)\\n else:\\n self.d[key]=value\\n self.stack.append(key)\\n \\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1903\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.dic = dict()\\n self.lst = []\\n def get(self, key: int) -> int:\\n if self.dic.get(key) != None:\\n self.lst += [self.lst.pop(self.lst.index(key))]\\n return self.dic.get(key)\\n return -1\\n def put(self, key: int, value: int) -> None:\\n if self.dic.get(key) != None:\\n self.lst += [self.lst.pop(self.lst.index(key))]\\n else:\\n if len(self.lst) == self.capacity:\\n del self.dic[self.lst.pop(0)]\\n self.lst += [key]\\n self.dic[key] = value\\n\",\n \"runtime\": \"1926\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.lru_q = []\\n self.mp = {}\\n self.capacity = capacity\\n self.curr = 0\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.mp:\\n self.lru_q.remove(key)\\n self.lru_q.append(key)\\n return self.mp[key]\\n return -1\\n\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if self.curr < self.capacity and key not in self.mp:\\n self.mp[key] = value\\n self.curr += 1\\n self.lru_q.append(key)\\n if key in self.mp:\\n self.mp[key] = value\\n self.lru_q.remove(key)\\n self.lru_q.append(key)\\n\\n else:\\n while self.curr >= self.capacity:\\n evict = self.lru_q.pop(0)\\n self.mp.pop(evict)\\n self.curr -= 1\\n self.mp[key] = value\\n self.curr += 1\\n self.lru_q.append(key)\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1926\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.store = dict()\\n self.capacity = capacity\\n self.priority = collections.deque([])\\n\\n def get(self, key: int) -> int:\\n if key not in self.store:\\n return -1\\n\\n self.priority.remove(key)\\n self.priority.append(key)\\n\\n return self.store[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.store:\\n self.priority.remove(key)\\n\\n if len(self.priority) == self.capacity:\\n evicted = self.priority.popleft()\\n del self.store[evicted]\\n\\n self.store[key] = value\\n self.priority.append(key)\\n \\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1950\"\n },\n {\n \"code\": \"import collections\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.LRU=collections.deque()\\n self.LRUD={}\\n self.cap=capacity\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.LRUD:\\n self.LRU.remove(key)\\n self.LRU.append(key)\\n return self.LRUD[key]\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if self.cap>len(self.LRU) and key not in self.LRUD:\\n self.LRUD[key]=value\\n self.LRU.append(key)\\n elif key in self.LRUD:\\n self.LRUD[key]=value\\n self.LRU.remove(key)\\n self.LRU.append(key)\\n else:\\n k1=self.LRU[0]\\n self.LRU.popleft()\\n del self.LRUD[k1]\\n self.LRUD[key]=value\\n self.LRU.append(key)\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1950\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.s=deque()\\n self.d={}\\n self.c=capacity\\n def get(self, key: int) -> int:\\n if key in self.d:\\n self.s.remove(key)\\n self.s.appendleft(key)\\n return self.d[key]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.d:\\n self.d[key]=value\\n\\n self.s.remove(key)\\n self.s.appendleft(key)\\n else:\\n if len(self.s)>=self.c:\\n v=self.s.pop()\\n if v in self.d:\\n del self.d[v]\\n\\n self.d[key] = value\\n self.s.appendleft(key)\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1974\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.keys = collections.defaultdict(int)\\n self.q = deque()\\n self.capacity = capacity\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.keys:\\n self.q.remove(key)\\n self.q.append(key)\\n return self.keys[key]\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.keys:\\n ## Rearranging\\n self.q.remove(key)\\n self.q.append(key)\\n else:\\n self.q.append(key)\\n if len(self.q) > self.capacity:\\n LRUKey = self.q.popleft()\\n del self.keys[LRUKey]\\n self.keys[key] = value\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1974\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.cap = capacity\\n self.lru = {}\\n self.least = deque()\\n\\n def get(self, key: int) -> int:\\n if key not in self.lru:\\n return -1\\n else:\\n self.least.remove(key)\\n self.least.insert(0, key)\\n\\n return self.lru[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.lru:\\n self.least.remove(key)\\n\\n elif len(self.lru) >= self.cap:\\n least = self.least.pop()\\n self.lru.pop(least)\\n \\n\\n self.least.insert(0, key)\\n self.lru[key] = value\\n \\n\\n \\n\\n \\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1997\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = []\\n self.dict = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.dict:\\n self.cache.pop(self.cache.index(key))\\n self.cache.append(key)\\n return self.dict[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.dict:\\n self.cache.pop(self.cache.index(key))\\n self.cache.append(key)\\n self.dict[key] = value\\n if len(self.cache) > self.capacity:\\n del self.dict[self.cache[0]]\\n self.cache = self.cache[1:]\\n \\n\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"1997\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.limit = capacity\\n self.cache = {}\\n self.capacity = deque()\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.capacity.remove(key)\\n self.capacity.append(key)\\n return self.cache[key]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache[key] = value\\n self.capacity.remove(key)\\n self.capacity.append(key)\\n else:\\n if len(self.cache) >= self.limit:\\n lru = self.capacity.popleft()\\n del self.cache[lru]\\n self.cache[key] = value\\n self.capacity.append(key)\\n \\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"2021\"\n },\n {\n \"code\": \"from collections import deque,defaultdict\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity=capacity\\n self.cache=defaultdict(int)\\n self.lru=deque()\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n self.lru.remove(key)\\n self.lru.appendleft(key)\\n return self.cache[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.lru.remove(key)\\n elif len(self.cache) >= self.capacity:\\n lru=self.lru.pop()\\n self.cache.pop(lru)\\n self.lru.appendleft(key)\\n self.cache[key]=value\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"runtime\": \"2021\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":121,"string":"121"},"mm_list":{"kind":"list like","value":[{"code":"def lc(operations, params):\n cache = OrderedDict()\n result = []\n capacity = None\n for i, op in enumerate(operations):\n if op == \"LRUCache\":\n capacity = params[i][0]\n result.append(None)\n elif op == \"put\":\n key, value = params[i]\n if key in cache:\n cache.move_to_end(key)\n cache[key] = value\n if len(cache) > capacity:\n cache.popitem(last=False)\n result.append(None)\n elif op == \"get\":\n key = params[i][0]\n if key in cache:\n cache.move_to_end(key)\n result.append(cache[key])\n else:\n result.append(-1) \n return result\n\nwith open(\"user.out\",\"w\") as sys.stdout:\n print(*(str(lc(*h)).replace('None','null').replace(' ','') for h in zip(*[map(loads,stdin)]*2)),sep='\\n')\nexit(0)","memory":"68800"},{"code":"def lc(operations, params):\n cache = OrderedDict()\n result = []\n capacity = None\n for i, op in enumerate(operations):\n if op == \"LRUCache\":\n capacity = params[i][0]\n result.append(None)\n elif op == \"put\":\n key, value = params[i]\n if key in cache:\n cache.move_to_end(key)\n cache[key] = value\n if len(cache) > capacity:\n cache.popitem(last=False)\n result.append(None)\n elif op == \"get\":\n key = params[i][0]\n if key in cache:\n cache.move_to_end(key)\n result.append(cache[key])\n else:\n result.append(-1) \n return result\n\nwith open(\"user.out\",\"w\") as sys.stdout:\n print(*(str(lc(*h)).replace('None','null').replace(' ','') for h in zip(*[map(loads,stdin)]*2)),sep='\\n')\nexit(0)","memory":"68900"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.lru = []\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.lru.remove(key)\n self.lru.append(key)\n return self.cache[key]\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.lru.remove(key)\n elif len(self.lru) == self.capacity:\n del self.cache[self.lru.pop(0)]\n self.cache[key] = value\n self.lru.append(key)\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"73600"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.curr_len = 0\n self.dic = {}\n self.lst = []\n \n\n def get(self, key: int) -> int:\n if key in self.dic.keys():\n self.lst.remove(key)\n self.lst.append(key)\n return self.dic[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key not in self.dic.keys():\n if self.curr_len < self.capacity:\n self.dic[key] = value\n self.lst.append(key)\n self.curr_len = self.curr_len + 1\n else:\n lkey = self.lst.pop(0)\n del self.dic[lkey]\n self.dic[key] = value\n self.lst.append(key)\n else:\n self.dic[key] = value\n self.lst.remove(key)\n self.lst.append(key)\n # print(self.dic)\n # print(self.lst)\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"74100"},{"code":"class Node:\n def __init__(self, key, val, prev=None, next=None):\n self.val = val\n self.key = key\n self.prev = prev\n self.next = next\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.first = Node(0,0)\n self.last = Node(0,0)\n self.first.next = self.last\n self.last.prev = self.first\n self.capacity = capacity\n\n def lruRemove(self, node):\n node.next.prev = node.prev\n node.prev.next = node.next\n\n def lruInsert(self, node):\n prev, next = self.last.prev, self.last\n prev.next = node\n next.prev = node\n node.next = next\n node.prev = prev\n\n\n def get(self, key: int) -> int:\n if key in self.cache:\n node = self.cache[key]\n self.lruRemove(node)\n self.lruInsert(node)\n return node.val\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.lruRemove(self.cache[key])\n node = Node(key, value)\n self.cache[key] = node\n self.lruInsert(node)\n\n if len(self.cache) > self.capacity:\n node = self.first.next\n self.lruRemove(node)\n del self.cache[node.key]\n \n","memory":"74800"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.size = capacity\n self.q = deque(maxlen = capacity)\n self.mappings = {}\n\n def get(self, key: int) -> int:\n if key in self.mappings:\n self.q.remove(key)\n self.q.append(key)\n # print(f\"get : {key} q: {self.q} and map : {self.mappings}\")\n return self.mappings[key]\n else:\n return -1\n\n \n def put(self, key: int, value: int) -> None:\n if key in self.mappings:\n self.q.remove(key)\n self.q.append(key)\n\n elif len(self.q) == self.size:\n least_used = self.q.popleft()\n del self.mappings[least_used]\n self.q.append(key)\n\n else:\n self.q.append(key)\n \n self.mappings[key] = value\n \n # print(f\"put {key} q is: {self.q} and map is: {self.mappings}\")\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"74900"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.usage_order = []\n\n def get(self, key: int) -> int:\n if key in self.cache:\n # Move the accessed key to the end to mark it as recently used\n self.usage_order.remove(key)\n self.usage_order.append(key)\n return self.cache[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n # Update the value and move the key to the end to mark it as recently used\n self.cache[key] = value\n self.usage_order.remove(key)\n self.usage_order.append(key)\n else:\n if len(self.cache) >= self.capacity:\n # Remove the least recently used key\n lru_key = self.usage_order.pop(0)\n del self.cache[lru_key]\n # Add the new key-value pair\n self.cache[key] = value\n self.usage_order.append(key)\n","memory":"75100"},{"code":"class LRUCache:\n class Node:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.prev = None\n self.next = None\n\n def __init__(self, capacity: int):\n self.cap = capacity\n self.head = self.Node(-1, -1)\n self.tail = self.Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.m = {}\n\n def addNode(self, newnode):\n temp = self.head.next\n newnode.next = temp\n newnode.prev = self.head\n self.head.next = newnode\n temp.prev = newnode\n\n def deleteNode(self, delnode):\n prevv = delnode.prev\n nextt = delnode.next\n prevv.next = nextt\n nextt.prev = prevv\n\n def get(self, key: int) -> int:\n if key in self.m:\n resNode = self.m[key]\n ans = resNode.val\n del self.m[key]\n self.deleteNode(resNode)\n self.addNode(resNode)\n self.m[key] = self.head.next\n return ans\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.m:\n curr = self.m[key]\n del self.m[key]\n self.deleteNode(curr)\n\n if len(self.m) == self.cap:\n del self.m[self.tail.prev.key]\n self.deleteNode(self.tail.prev)\n\n self.addNode(self.Node(key, value))\n self.m[key] = self.head.next","memory":"75300"},{"code":"# Simple method\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {} # store key-value pair\n self.order = [] # sotre key order\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n\n self.order.remove(key)\n self.order.append(key)\n return self.cache[key] \n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache[key] = value\n self.order.remove(key)\n self.order.append(key)\n\n elif key not in self.cache:\n if len(self.cache) >= self.capacity:\n old = self.order.pop(0)\n del self.cache[old]\n self.order.append(key)\n self.cache[key] = value\n else:\n self.order.append(key)\n self.cache[key] = value\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"75400"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = OrderedDict()\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n val = self.cache.get(key, -1)\n if val != -1:\n self.cache.move_to_end(key)\n return val\n\n\n def put(self, key: int, value: int) -> None:\n if self.cache.get(key) is None and len(self.cache.keys()) == self.capacity:\n #evict LRU\n self.cache.pop(list(self.cache.keys())[0])\n self.cache[key] = value\n else:\n self.cache[key] = value\n self.cache.move_to_end(key)\n\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"75500"},{"code":"class Node:\n def __init__(self, key, value, prev = None, next = None):\n self.key = key\n self.value = value\n self.prev = prev\n self.next = next\n\nclass LRUCache:\n class Node:\n def __init__(self, key, value, prev = None, next = None):\n self.key = key\n self.value = value\n self.prev = prev\n self.next = next\n\n def __init__(self, capacity: int):\n self.dummy_head = Node(-1, -1)\n self.dummy_tail = Node(-1, -1)\n self.dummy_head.next = self.dummy_tail\n self.dummy_tail.prev = self.dummy_head\n\n self.capacity = capacity\n self.map = {}\n \n def _remove(self, node):\n \"\"\"Remove an existing node from the linked list.\"\"\"\n prev_node = node.prev\n next_node = node.next\n prev_node.next = next_node\n next_node.prev = prev_node\n\n def _add_to_head(self, node):\n \"\"\"Add a new node right after the dummy head.\"\"\"\n node.prev = self.dummy_head\n node.next = self.dummy_head.next\n self.dummy_head.next.prev = node\n self.dummy_head.next = node\n\n def get(self, key: int) -> int:\n if key in self.map:\n node = self.map[key]\n self._remove(node)\n self._add_to_head(node)\n return node.value\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.map:\n node = self.map[key]\n node.value = value\n self._remove(node)\n self._add_to_head(node)\n else:\n if len(self.map) == self.capacity:\n evict = self.dummy_tail.prev\n self._remove(evict)\n del self.map[evict.key]\n node = Node(key, value)\n self.map[key] = node\n self._add_to_head(node)\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"75600"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n # # everytime we perform a get we move it to the top of the stack and remove the last element\n # # use hashmap as a queue\n # self.capacity = capacity\n # self.cache = {}\n # pass\n\n # def get(self, key: int) -> int:\n # if key in self.cache:\n # value = self.cache[key]\n # del self.cache[key]\n # self.cache[key] = value\n # return value\n # return -1\n\n # def put(self, key: int, value: int) -> None:\n # # Even a put with update leads to moving the newly added key-value pair up\n # if key in self.cache:\n # del self.cache[key]\n # self.cache[key] = value\n # if len(self.cache) > self.capacity:\n # self.cache.pop(next(iter(self.cache)))\n # pass\n # using a deque for the design implementation\n # maintain a hashmap for the key - value pairs and a deque administering the LRU state\n self.capacity = capacity\n self.cache = deque([])\n self.hashmap = {}\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.cache.remove(key)\n self.cache.appendleft(key)\n return self.hashmap[key]\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.remove(key)\n self.hashmap[key] = value\n self.cache.appendleft(key)\n if len(self.cache) > self.capacity:\n self.cache.pop()\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"75700"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.k=[]\n self.c = capacity\n self.d = {}\n self.l = 0\n\n def get(self, key: int) -> int:\n \n if key in self.d.keys():\n self.k.remove(key)\n self.k = [key]+self.k\n return self.d[key]\n return -1\n def put(self, key: int, value: int) -> None:\n # print(self.d,self.k)\n if key in self.k:\n self.k.remove(key)\n self.k = [key]+self.k\n self.d[key] = value\n else:\n self.d[key] = value\n self.k = [key]+self.k\n self.l+=1\n if self.c<self.l:\n a=self.k.pop(-1)\n self.l-=1\n del self.d[a]\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"75800"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n \n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n val = self.cache[key]\n self.cache.pop(key)\n self.cache[key] = val\n return val\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.pop(key)\n elif len(self.cache) == self.capacity:\n self.cache.pop(list(self.cache.keys())[0])\n self.cache[key] = value\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76000"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.dict = collections.OrderedDict()\n\n def get(self, key: int) -> int:\n if key in self.dict:\n self.dict.move_to_end(key)\n return self.dict[key]\n \n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.dict:\n self.dict.move_to_end(key)\n self.dict[key] = value\n else:\n self.dict[key] = value\n \n if len(self.dict) > self.capacity:\n self.dict.popitem(False)\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76100"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key in self.cache:\n val = self.cache[key]\n del self.cache[key]\n self.cache[key] = val\n return val\n return -1\n \n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n del self.cache[key]\n self.cache[key] = value\n if len(self.cache) > self.capacity:\n del self.cache[list(self.cache)[0]]\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76200"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key in self.cache:\n val = self.cache[key]\n del self.cache[key]\n self.cache[key] = val\n return val\n return -1\n \n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n del self.cache[key]\n self.cache[key] = value\n if len(self.cache) > self.capacity:\n del self.cache[next(iter(self.cache))]\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76200"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n \n\n def get(self, key: int) -> int:\n if key in self.cache:\n val = self.cache.pop(key)\n self.cache[key] = val\n return val\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.pop(key)\n elif len(self.cache) == self.capacity:\n # remove the oldest key\n pop_key = next(iter(self.cache.keys()))\n self.cache.pop(pop_key)\n self.cache[key] = value\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76300"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.map = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if self.map.get(key) is not None:\n val = self.map[key]\n del(self.map[key]) \n self.map[key] = val\n return val\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if not self.map.get(key):\n if len(self.map.keys()) == self.capacity:\n i = list(self.map.keys())[0]\n del(self.map[i])\n else:\n del(self.map[key])\n \n self.map[key] = value\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76300"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.map = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if self.map.get(key) is not None:\n val = self.map[key]\n del(self.map[key]) \n self.map[key] = val\n return val\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if not self.map.get(key):\n if len(self.map.keys()) == self.capacity:\n i = list(self.map.keys())[0]\n del(self.map[i])\n else:\n del(self.map[key])\n \n self.map[key] = value\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76400"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n\n self.cache[key] = self.cache.pop(key)\n return self.cache[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.pop(key)\n\n self.cache[key] = value\n if len(self.cache) > self.capacity:\n self.cache.pop(next(iter(self.cache)))\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76400"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key in self.cache:\n val = self.cache[key]\n del self.cache[key]\n self.cache[key] = val\n return val\n return -1\n \n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n del self.cache[key]\n self.cache[key] = value\n if len(self.cache) > self.capacity:\n del self.cache[next(iter(self.cache))]\n \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76500"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.maxl = capacity\n self.data = {}\n\n def get(self, key: int) -> int:\n if key in self.data:\n data = self.data[key]\n del self.data[key]\n self.data[key] = data\n return data\n \n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.data:\n del self.data[key]\n self.data[key] = value\n totallen = len(self.data.keys())\n if totallen > self.maxl:\n tobedeleted = totallen - self.maxl\n\n keys = list(self.data.keys())[:tobedeleted]\n for k in keys:\n del self.data[k]\n \n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76500"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n \n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n \n self.cache[key] = self.cache.pop(key)\n return self.cache[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.pop(key)\n\n self.cache[key] = value\n if len(self.cache) > self.capacity:\n self.cache.pop(next(iter(self.cache)))\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76600"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.lru = {}\n self.capacity = capacity\n self.lastusedkey = []\n\n\n def get(self, key: int) -> int:\n if key in self.lru:\n self.lastusedkey[0]=key\n return self.lru[key]\n \n else:\n return -1\n\n \n def put(self, key: int, value: int) -> None:\n if self.get(key)!=-1:\n self.lastusedkey[0]=key\n self.lru[key]=value\n elif len(self.lru)<capacity:\n self.lastusedkey[0]=key\n self.lru[key]=value\n else:\n del self.lru[self.lastusedkey[0]]\n self.lastusedkey[0]=key\n self.lru[key]=value\n\n\n\n\n\n # def get(self, key: int) -> int:\n # if key not in self.dict:\n # return -1\n # val = self.dict.pop(key) #Remove it first before inserting it at the end again\n # self.dict[key] = val \n # return val \n\n # def put(self, key: int, value: int) -> None:\n # if key in self.dict: \n # self.dict.pop(key)\n # else:\n # if len(self.dict) == self.capacity:\n # del self.dict[next(iter(self.dict))] \n # self.dict[key] = value\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)\n\n\n\n\n\n\n\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key in self.cache:\n value = self.cache[key]\n del self.cache[key]\n self.cache[key] = value\n return self.cache[key]\n else:\n return -1\n \n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n del self.cache[key]\n self.cache[key]=value\n else:\n if (len(self.cache) == self.capacity):\n lrkey = next(iter(self.cache))\n del self.cache[lrkey]\n self.cache[key]=value","memory":"76600"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.dict = {}\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key not in self.dict:\n return -1\n self.dict[key] = self.dict.pop(key)\n return self.dict[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.dict:\n self.dict.pop(key)\n else:\n if self.capacity:\n self.capacity-=1\n else:\n self.dict.pop(next(iter(self.dict)))\n self.dict[key] = value\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76700"},{"code":"class LRUCache:\n class Node:\n def __init__(self, key, val, prev=None, next=None):\n self.key = key\n self.val = val\n self.prev = prev\n self.next = next\n\n def remove(self, cur):\n cur.prev.next = cur.next\n cur.next.prev = cur.prev\n\n def add(self, cur):\n temp = self.head.next\n self.head.next = cur\n cur.next = temp\n temp.prev = cur\n cur.prev = self.head\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.head, self.tail = self.Node(-1, -1), self.Node(-1, -1)\n self.head.next, self.tail.prev = self.tail, self.head\n self.lru = collections.defaultdict(self.Node) \n\n def get(self, key: int) -> int:\n if key not in self.lru:\n return -1\n node = self.lru[key]\n self.remove(node)\n self.add(node)\n\n return self.lru[key].val\n\n\n def put(self, key: int, value: int) -> None:\n if key in self.lru:\n node = self.lru[key]\n self.remove(node)\n del self.lru[node.key]\n self.capacity += 1\n node = self.Node(key, value)\n self.lru[key] = node\n self.add(node)\n self.capacity -= 1\n\n if self.capacity < 0:\n deleteNode = self.tail.prev\n self.remove(deleteNode)\n del self.lru[deleteNode.key]\n self.capacity += 1\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76700"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n # Key to value\n self.elements: dict[int, int] = {}\n # Map of element to most recent update id\n self.usage: dict[int, int] = {}\n self.update_id: int = 0\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n if key in self.elements:\n self.usage[key] = self.update_id\n self.update_id += 1\n return self.elements[key]\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key not in self.elements and len(self.elements) == self.capacity:\n key_to_evict = -1\n least_recently_used = 2 * 10**5 + 1\n for k, usage in self.usage.items():\n if usage < least_recently_used:\n key_to_evict = k\n least_recently_used = usage\n del self.elements[key_to_evict]\n del self.usage[key_to_evict]\n\n self.elements[key] = value\n self.usage[key] = self.update_id\n self.update_id += 1\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"76800"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.data_dict = {} # for leetcode since if instatied in the class it doesn't start empty, not sure why\n\n def get(self, key: int) -> int:\n if key in self.data_dict:\n data = self.data_dict.pop(key)\n self.__persist_used_data(key=key, value=data)\n return data\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key not in self.data_dict:\n self.__manage_least_used_data()\n\n self.data_dict[key] = value\n self.__persist_used_data(key=key, value=value)\n\n def __persist_used_data(self, key, value):\n new_data_dict = {key: value}\n new_data_dict.update(self.data_dict)\n self.data_dict = new_data_dict\n\n def __manage_least_used_data(self):\n limit_count = len(self.data_dict)\n if limit_count >= self.capacity:\n self.data_dict.popitem()\n","memory":"76900"},{"code":"class Node:\n def __init__ (self, key=None, value=None):\n self.key = key\n self.value = value\n self.pre = None\n self.nxt = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cap = capacity\n self.hm = {}\n self.head = Node()\n self.tail = Node()\n self.head.nxt = self.tail\n self.tail.pre = self.head\n\n def get(self, key: int) -> int:\n if key in self.hm:\n ret = self.hm[key].value \n # move the node to the front\n ## 1. remove the node from its original place\n ## 2. insert the node to the head.nxt\n self.removeNode(self.hm[key])\n self.addNodeToHead(self.hm[key])\n return ret\n else:\n return -1\n\n\n def put(self, key: int, value: int) -> None:\n if key in self.hm:\n self.hm[key].value = value\n # move the node to the front\n ## 1. remove the node from its original place\n ## 2. insert the node to the head.nxt\n self.removeNode(self.hm[key])\n self.addNodeToHead(self.hm[key])\n else:\n # create node\n new_node = Node(key, value)\n\n # if cache is full, first del node\n if len(self.hm) >= self.cap:\n node_to_del = self.tail.pre\n self.removeNode(node_to_del)\n self.hm.pop(node_to_del.key)\n # insert node\n self.hm[key] = new_node\n self.addNodeToHead(new_node)\n \n \n def removeNode(self, node):\n node.pre.nxt = node.nxt\n node.nxt.pre = node.pre\n \n def addNodeToHead(self, node): #指针更新的先后顺序要注意！\n node.pre = self.head\n node.nxt = self.head.nxt\n self.head.nxt.pre = node\n self.head.nxt = node\n \n \n \n\n \n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77000"},{"code":"class Node:\n def __init__(self, key, value):\n self.key, self.value = key, value\n self.prev = None\n self.next = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.c = capacity\n self.m = dict()\n self.deq = deque()\n \n def get(self, key):\n if key in self.m:\n value=self.m[key]\n self.deq.remove(key)\n self.deq.append(key)\n return value\n else:\n return -1\n \n def put(self, key, value):\n if key not in self.m:\n if len(self.deq) == self.c:\n oldest = self.deq.popleft()\n del self.m[oldest]\n else:\n self.deq.remove(key)\n \n self.m[key] = value\n self.deq.append(key)\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77100"},{"code":"class Node:\n def __init__(self, key, value):\n self.key, self.value = key, value\n self.prev = None\n self.next = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.c = capacity\n self.m = dict()\n self.deq = deque()\n \n def get(self, key):\n if key in self.m:\n value=self.m[key]\n self.deq.remove(key)\n self.deq.append(key)\n return value\n else:\n return -1\n \n def put(self, key, value):\n if key not in self.m:\n if len(self.deq) == self.c:\n oldest = self.deq.popleft()\n del self.m[oldest]\n else:\n self.deq.remove(key)\n \n self.m[key] = value\n self.deq.append(key)\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77100"},{"code":"from collections import OrderedDict\n\nclass LRUCache:\n __slots__ = ('data', 'capacity')\n\n def __init__(self, capacity: int):\n self.data: Dict[int, int] = OrderedDict()\n self.capacity: int = capacity\n\n def get(self, key: int) -> int:\n return -1 if key not in self.data else self.data.setdefault(key, self.data.pop(key))\n\n def put(self, key: int, value: int) -> None:\n try:\n self.data.move_to_end(key)\n self.data[key] = value\n except KeyError:\n self.data[key] = value\n if len(self.data) > self.capacity:\n self.data.popitem(last=False)","memory":"77200"},{"code":"from collections import OrderedDict\n\nclass LRUCache:\n __slots__ = ('data', 'capacity')\n\n def __init__(self, capacity: int):\n self.data: Dict[int, int] = OrderedDict()\n self.capacity: int = capacity\n\n def get(self, key: int) -> int:\n return -1 if key not in self.data else self.data.setdefault(key, self.data.pop(key))\n\n def put(self, key: int, value: int) -> None:\n try:\n self.data.move_to_end(key)\n self.data[key] = value\n except KeyError:\n self.data[key] = value\n if len(self.data) > self.capacity:\n self.data.popitem(last=False)","memory":"77200"},{"code":"class LinkedNode:\n def __init__(self, key = -1, value = -1):\n self.key = key\n self.value = value\n self.prev = None\n self.next = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = dict()\n self.head = LinkedNode()\n self.tail = LinkedNode()\n self.head.next = self.tail\n self.tail.prev = self.head\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n \n node = self.__evict(key)\n self.__addToEnd(node)\n return node.value\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n node = self.__delete(key)\n \n node = LinkedNode(key, value)\n self.cache[key] = node\n self.__addToEnd(node)\n\n if len(self.cache) > self.capacity:\n self.__delete(self.head.next.key)\n \n def __delete(self, key):\n deleteNode = self.__evict(key)\n del deleteNode\n del self.cache[key]\n \n def __addToEnd(self, node):\n node.prev = self.tail.prev\n node.next = self.tail\n self.tail.prev.next = node\n self.tail.prev = node\n \n def __evict(self, key) -> LinkedNode:\n node = self.cache[key]\n node.prev.next = node.next\n node.next.prev = node.prev\n node.next = None\n node.prev = None\n return node\n \n \n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77400"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n self.used = 0\n\n def get(self, key: int) -> int:\n if key in self.cache: \n self.cache[key]['lu'] = self.used\n self.used += 1\n return self.cache[key]['value']\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache[key]['lu'] = self.used\n self.used += 1\n self.cache[key]['value'] = value\n else:\n #First evict the last used key if needed\n if len(self.cache) == self.capacity:\n last_used = (None, 300000) #key, lu\n for k, info in self.cache.items():\n if last_used[0] is None or self.cache[k]['lu'] < last_used[1]:\n last_used = (k, self.cache[k]['lu'])\n \n del self.cache[last_used[0]]\n\n #Then add the new key\n self.cache[key]= {\"value\":value, \"lu\":self.used}\n self.used += 1\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77400"},{"code":"class LRUCache:\n class Node:\n def __init__(self, key, val, prev=None, next=None):\n self.key = key\n self.val = val\n self.prev = prev\n self.next = next\n\n def remove(self, cur):\n cur.prev.next = cur.next\n cur.next.prev = cur.prev\n\n def add(self, cur):\n temp = self.head.next\n self.head.next = cur\n cur.next = temp\n temp.prev = cur\n cur.prev = self.head\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.head, self.tail = self.Node(-1, -1), self.Node(-1, -1)\n self.head.next, self.tail.prev = self.tail, self.head\n self.lru = collections.defaultdict(self.Node) \n\n def get(self, key: int) -> int:\n if key not in self.lru:\n return -1\n node = self.lru[key]\n self.remove(node)\n self.add(node)\n\n return self.lru[key].val\n\n\n def put(self, key: int, value: int) -> None:\n if key in self.lru:\n node = self.lru[key]\n self.remove(node)\n del self.lru[node.key]\n self.capacity += 1\n node = self.Node(key, value)\n self.lru[key] = node\n self.add(node)\n self.capacity -= 1\n\n if self.capacity < 0:\n deleteNode = self.tail.prev\n self.remove(deleteNode)\n del self.lru[deleteNode.key]\n self.capacity += 1\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77500"},{"code":"from collections import defaultdict\nclass LRUCache:\n def __init__(self, capacity: int):\n self.q = []\n self.dict = defaultdict(lambda x: -1)\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n try: \n index = self.q.index(key)\n self.q.pop(index)\n self.q.append(key)\n return self.dict[key]\n except:\n return -1\n\n def put(self, key: int, value: int) -> None:\n n = len(self.q)\n try:\n index = self.q.index(key)\n k = self.q.pop(index)\n self.q.append(k)\n self.dict[key] = value\n print(\"updating\", k)\n except ValueError:\n if n >= self.capacity:\n k = self.q.pop(0)\n del self.dict[k]\n self.dict[key] = value\n self.q.append(key)\n print(\"adding\", key, value)\n print(\"capacity\", self.capacity)\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77500"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.keys_and_values = {}\n self.lru_info = []\n self.lru_len = 0\n self.capacity = capacity\n\n\n def get(self, key: int) -> int:\n value = self.keys_and_values.get(key, -1)\n if key in self.lru_info:\n self.lru_info.remove(key)\n self.lru_info.append(key)\n return value\n\n def put(self, key: int, value: int) -> None:\n self.keys_and_values[key] = value\n\n if key in self.lru_info:\n self.lru_info.remove(key)\n else:\n self.lru_len = self.lru_len + 1\n self.lru_info.append(key)\n\n if self.lru_len > self.capacity:\n removed_key = self.lru_info.pop(0)\n del self.keys_and_values[removed_key]\n self.lru_len = self.lru_len - 1\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77600"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n \n\n def get(self, key: int) -> int:\n # maintain order\n if key in self.cache:\n self.cache[key] = self.cache.pop(key)\n return self.cache[key]\n \n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.pop(key)\n\n self.cache[key] = value\n\n if len(self.cache) > self.capacity:\n self.cache.pop(next(iter(self.cache)))\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77600"},{"code":"class LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n\n self.cache[key] = self.cache.pop(key)\n return self.cache[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.cache.pop(key)\n\n self.cache[key] = value\n if len(self.cache) > self.capacity:\n self.cache.pop(next(iter(self.cache)))","memory":"77700"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n #assert 1 <= capacity <= 3000\n self.map = {}\n self.capacity = capacity\n \n\n def get(self, key: int) -> int:\n value = self.map.get(key, -1)\n if value != -1:\n self.map.pop(key)\n self.map[key] = value\n \n return value\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.map:\n self.map.pop(key)\n if len(self.map) == self.capacity:\n self.map.pop(list(self.map.keys())[0])\n\n self.map[key] = value\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77700"},{"code":"class Node:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.prev = self.next = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n self.head, self.tail = Node(0, 0), Node(0, 0)\n self.head.next = self.tail\n self.tail.prev = self.head\n \n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n \n def addToHead(self, node):\n node.next = self.head.next\n node.prev = self.head\n node.next.prev = node\n self.head.next = node\n\n def get(self, key: int) -> int:\n # If present return and remove and put in front\n if key in self.cache:\n node = self.cache[key]\n self.remove(node)\n self.addToHead(node)\n return node.val\n return -1\n\n def put(self, key: int, value: int) -> None:\n # If present, delete and then add to head\n if key in self.cache:\n self.remove(self.cache[key])\n del self.cache[key]\n \n self.cache[key] = Node(key, value)\n self.addToHead(self.cache[key])\n\n # check for capacity\n if len(self.cache) > self.capacity:\n curr_last = self.tail.prev\n self.remove(curr_last)\n del self.cache[curr_last.key]\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77800"},{"code":"class ListNode:\n def __init__(self,key,val):\n self.key = key\n self.val = val\n self.prev = None\n self.next = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.len = 0\n self.cache = {}\n self.head = ListNode(-1,-1)\n self.tail = ListNode(-1,-1)\n self.head.next = self.tail\n self.tail.prev = self.head\n\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n \n node = self.cache[key]\n self.remove(node)\n self.add(node)\n return node.val\n \n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n old_node = self.cache[key]\n self.remove(old_node)\n \n node = ListNode(key,value)\n self.cache[key] = node\n self.add(node)\n\n if len(self.cache) > self.capacity:\n to_del = self.head.next\n self.remove(to_del)\n del self.cache[to_del.key]\n \n def remove(self,node: ListNode) -> None:\n node.prev.next = node.next\n node.next.prev = node.prev\n\n\n def add(self,node: ListNode) -> None:\n prev_end = self.tail.prev\n prev_end.next = node\n node.next = self.tail\n node.prev = prev_end\n self.tail.prev = node\n \n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77800"},{"code":"from collections import OrderedDict\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = OrderedDict() # This will hold the cache items in order of usage\n self.capacity = capacity # Capacity of the cache\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1 # Return -1 if the key does not exist\n \n # Move the accessed key to the end to mark it as most recently used\n self.cache.move_to_end(key)\n return self.cache[key]\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n # If the key exists, move it to the end to mark it as most recently used\n self.cache.move_to_end(key)\n self.cache[key] = value\n \n if len(self.cache) > self.capacity:\n # If the cache exceeds capacity, pop the first item (least recently used)\n self.cache.popitem(last=False)\n","memory":"77900"},{"code":"from collections import OrderedDict\nclass LRUCache:\n\n def __init__(self, capacity: int):\n assert 1 <= capacity <= 3000\n print(capacity)\n self.map = OrderedDict()\n self.capacity = capacity\n \n\n def get(self, key: int) -> int:\n value = self.map.get(key, -1)\n if value != -1:\n self.map.pop(key)\n self.map[key] = value\n \n return value\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.map:\n self.map.pop(key)\n if len(self.map) == self.capacity:\n self.map.pop(list(self.map.keys())[0])\n\n self.map[key] = value\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"77900"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = OrderedDict()\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.cache.move_to_end(key)\n return self.cache[key]\n else:\n return -1\n \n\n def put(self, key: int, value: int) -> None:\n \n if key in self.cache:\n # Update the value and move the key to the end\n self.cache.move_to_end(key)\n self.cache[key] = value\n\n if len(self.cache) > self.capacity:\n self.cache.popitem(last=False) \n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78000"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.items = OrderedDict()\n\n def get(self, key: int) -> int:\n if key in self.items:\n self.items.move_to_end(key)\n return self.items[key]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.items:\n self.items.move_to_end(key)\n self.items[key] = value\n if len(self.items) > self.capacity:\n self.items.popitem(False)\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78000"},{"code":"class ListNode:\n def __init__(self, key, val):\n self.next = None\n self.prev = None\n self.val = val\n self.key = key\n\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.head = ListNode(-1,-1)\n self.tail = ListNode(-1,-1)\n self.cache = {}\n self.head.next = self.tail\n self.tail.prev = self.head\n\n def add(self,key,value):\n new_node = ListNode(key, value)\n last_element = self.tail.prev\n last_element.next = new_node\n new_node.prev = last_element\n new_node.next = self.tail\n self.tail.prev = new_node\n self.cache[key] = new_node\n \n\n def remove(self,key):\n node = self.cache[key]\n node_prev = node.prev\n node_next = node.next\n node_prev.next = node_next\n node_next.prev = node_prev\n del self.cache[key]\n\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n node_key = self.cache[key].key\n node_val = self.cache[key].val\n self.remove(key)\n self.add(node_key, node_val)\n\n return self.cache[key].val\n\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.remove(key)\n self.add(key, value)\n if len(self.cache) > self.capacity:\n self.remove(self.head.next.key)\n\n \n\n\n\n\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)\n","memory":"78100"},{"code":"class Node:\n def __init__(self, key, value, nex=None, prev=None):\n self.key = key\n self.value = value\n self.nex = nex\n self.prev = prev\n\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.head: Node | None = None\n self.tail: Node | None = None\n self.kv: dict[int, Node] = dict()\n\n def get(self, key: int) -> int:\n if key in self.kv:\n node = self.kv[key]\n self.to_tail(node)\n return node.value\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n \n # first put\n if self.head is None:\n node = Node(key, value)\n self.kv[key] = node\n self.head = node\n self.tail = node\n return\n\n # put\n if key not in self.kv:\n node = Node(key, value, prev=self.tail)\n self.tail.nex = node\n self.tail = node\n self.kv[key] = node\n else:\n # put this element to tail\n node = self.kv[key]\n self.to_tail(node)\n node.value = value\n\n if len(self.kv) > self.capacity:\n # delete from nodes\n head_key = self.head.key\n self.head = self.head.nex\n self.head.prev = None\n \n # delete from kv\n self.kv.pop(head_key)\n \n def to_tail(self, node: Node) -> None:\n if node != self.tail:\n if node == self.head:\n self.head = node.nex\n\n node_prev = node.prev\n node_next = node.nex\n if node_prev is not None:\n node_prev.nex = node_next\n node_next.prev = node_prev\n \n self.tail.nex = node\n node.prev = self.tail\n node.nex = None\n self.tail = node\n\n\n\n#\n# [\n# \"LRUCache\", 2\n# \"put\", 1, 1\n# \"put\", 2, 2\n# \"get\", 1\n# \"put\", 3, 3\n# \"get\", 2\n# \"put\", 4, 4\n# \"get\", 1 \n# \"get\", 3\n# \"get\" 4\n# ]\n\n# \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78100"},{"code":"class Node:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.next = None\n self.prev = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.size = 0\n self.nodes = {}\n self.head = Node(0, 0)\n self.head.next = self.head\n self.head.prev = self.head\n \n\n def get(self, key: int) -> int:\n #print(f\"get {key}\")\n val = -1\n if key in self.nodes:\n val = self.nodes[key].val\n self.remove(self.nodes[key])\n self.insert(self.head.next, self.nodes[key])\n #self.print_cache()\n return val\n \n\n def put(self, key: int, value: int) -> None:\n #print(f\"put {key}\")\n if key in self.nodes:\n self.nodes[key].val = value\n self.remove(self.nodes[key])\n self.insert(self.head.next, self.nodes[key])\n else:\n \n node = Node(key, value)\n self.nodes[key] = node\n self.insert(self.head.next, node)\n self.size += 1\n\n if self.size > self.capacity:\n del self.nodes[self.head.prev.key]\n self.remove(self.head.prev)\n self.size -= 1\n #self.print_cache()\n\n \n def remove(self, a) -> None:\n p = a.prev\n n = a.next\n p.next = a.next\n n.prev = a.prev\n\n def insert(self, cur_node, node) -> None:\n # insert behind cur\n p = cur_node.prev\n node.prev = p\n p.next = node\n node.next = cur_node\n cur_node.prev = node\n\n def print_cache(self):\n node = self.head.next\n print(\"head -> \")\n while (node is not self.head):\n print(f\"{node.key}\" + \" -> \")\n node = node.next\n print(\"head X\")\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78200"},{"code":"class Node:\n \n def __init__(self, key, value):\n self.key = key\n self.val = value\n self.prev = None\n self.next = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.node_map = {}\n self.head = Node(-1, -1) \n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n \n def remove_node(self, node: Node):\n n1 = node.prev\n n2 = node.next\n n1.next = n2\n n2.prev = n1\n\n def move_to_tail(self, node: Node):\n self.remove_node(node)\n self.add_to_tail(node)\n \n def add_to_tail(self, node: Node):\n last_node = self.tail.prev\n last_node.next = node\n node.prev = last_node\n node.next = self.tail\n self.tail.prev = node\n\n def get(self, key: int) -> int: \n if key not in self.node_map:\n return -1\n node = self.node_map[key]\n self.move_to_tail(node)\n return node.val\n \n def put(self, key: int, value: int) -> None: \n if key in self.node_map:\n # update key if already exists in map \n curr_node = self.node_map[key]\n curr_node.val = value\n self.move_to_tail(curr_node)\n else: \n if len(self.node_map) == self.capacity:\n # need to remove least used key\n lru_node = self.head.next\n self.remove_node(lru_node)\n del self.node_map[lru_node.key]\n new_node = Node(key, value)\n self.add_to_tail(new_node)\n self.node_map[key] = new_node\n\n \n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78200"},{"code":"class Node:\n def __init__(self, key: int, value: int):\n # Doubly Linked List (DLL)\n self.key: int = key\n self.value: int = value\n self.prev: Node | None = None\n self.next: Node | None = None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.head = Node(-1, -1)\n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.hash_map: dict[int, Node] = {}\n self.capacity: int = capacity\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n def get(self, key: int) -> int:\n node = self.hash_map.get(key)\n if not node:\n return -1\n # Move the node to the tail (most recently used)\n if node != self.tail.prev: # Optimization: move only if not already the most recent\n self.remove(node)\n self.add(node)\n return node.value\n\n def add(self, node) -> None:\n self.tail.prev.next = node\n node.prev = self.tail.prev \n node.next = self.tail\n self.tail.prev = node\n\n def put(self, key: int, value: int) -> None:\n if key in self.hash_map:\n self.remove(self.hash_map[key])\n\n node = Node(key, value) \n self.hash_map[key] = node\n self.add(node)\n\n if len(self.hash_map) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.hash_map[node_to_delete.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78300"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.capacity = capacity\n self.left, self.right = LLNode(0, 0), LLNode(0, 0)\n self.left.next, self.right.prev = self.right, self.left\n\n def insert(self, node):\n prev, nxt = self.right.prev, self.right\n prev.next = nxt.prev = node\n node.prev, node.next = prev, nxt\n\n def remove(self, node):\n prev, nxt = node.prev, node.next\n prev.next, nxt.prev = nxt, prev\n\n def get(self, key: int) -> int:\n if key not in self.cache:\n return -1\n node = self.cache[key]\n self.remove(node)\n self.insert(node)\n return node.value\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.remove(self.cache[key])\n node = LLNode(key, value)\n self.cache[key] = node\n self.insert(node)\n if len(self.cache) > self.capacity:\n lru_node = self.left.next\n del self.cache[lru_node.key]\n self.remove(lru_node)\n\n\n \nclass LLNode:\n def __init__(self, key, value):\n self.key, self.value = key, value\n self.next = self.prev = None\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78300"},{"code":"class Node:\n def __init__(self, key: int, value: int):\n # DDL\n self.key, self.value, self.prev, self.next = key, value, None, None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.head = Node(-1, -1)\n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.hash_map = {}\n self.capacity = capacity\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n def get(self, key: int) -> int:\n if not key in self.hash_map:\n return -1 \n node = self.hash_map[key]\n self.remove(node)\n self.add(node)\n return node.value\n\n def add(self, node):\n previous_end = self.tail.prev\n previous_end.next = node\n node.prev = previous_end\n node.next = self.tail\n self.tail.prev = node\n\n def put(self, key: int, value: int) -> None:\n if key in self.hash_map:\n self.remove(self.hash_map[key])\n\n node = Node(key, value) \n self.hash_map[key] = node\n self.add(node)\n\n if len(self.hash_map) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.hash_map[node_to_delete.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78400"},{"code":"class Node:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.prev = None\n self.next = None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.hmap = {}\n \n # Create dummy head and tail nodes\n self.head = Node(0, 0) # Least recently used\n self.tail = Node(0, 0) # Most recently used\n self.head.next = self.tail\n self.tail.prev = self.head\n\n def _remove(self, node):\n \"\"\"Remove a node from the linked list.\"\"\"\n prev_node = node.prev\n next_node = node.next\n prev_node.next = next_node\n next_node.prev = prev_node\n\n def _add(self, node):\n \"\"\"Add a node right before tail (most recently used).\"\"\"\n prev_node = self.tail.prev\n prev_node.next = node\n node.prev = prev_node\n node.next = self.tail\n self.tail.prev = node\n\n def get(self, key: int) -> int:\n if key in self.hmap:\n node = self.hmap[key]\n # Move accessed node to the end (most recently used)\n self._remove(node)\n self._add(node)\n return node.val\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.hmap:\n # Update existing node and move it to most recently used position\n node = self.hmap[key]\n node.val = value\n self._remove(node)\n self._add(node)\n else:\n if len(self.hmap) == self.capacity:\n # Remove least recently used item from cache and linked list\n lru_node = self.head.next # This is the least recently used item\n self._remove(lru_node)\n del self.hmap[lru_node.key]\n\n # Create new node and add to hashmap and linked list\n new_node = Node(key, value)\n self.hmap[key] = new_node\n self._add(new_node)\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78400"},{"code":"class Node:\n def __init__(self, key, value):\n self.key, self.value = key, value\n self.prev, self.next = None, None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.cap = capacity\n self.cache = {}\n self.left, self.right = Node(0, 0), Node(0, 0)\n self.left.next, self.right.prev = self.right, self.left\n \n def remove(self, node):\n prev, nxt = node.prev, node.next\n prev.next, nxt.prev = nxt, prev\n\n def insert(self, node):\n prev, nxt = self.right.prev, self.right\n prev.next, nxt.prev = node, node\n node.prev, node.next = prev, nxt\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.remove(self.cache[key])\n self.insert(self.cache[key])\n return self.cache[key].value\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.remove(self.cache[key])\n self.cache[key] = Node(key, value)\n self.insert(self.cache[key])\n if len(self.cache) > self.cap:\n lru = self.left.next\n self.remove(lru)\n del self.cache[lru.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78500"},{"code":"class Node:\n def __init__(self, key, val):\n self.key, self.val = key, val\n self.prev, self.next = None, None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n\n self.left, self.right = Node(0, 0), Node(0, 0)\n self.left.next, self.right.prev = self.right, self.left\n\n def add(self, node):\n prev, nxt = self.right.prev, self.right\n prev.next = nxt.prev = node\n node.next, node.prev = nxt, prev\n\n def remove(self, node):\n prev, nxt = node.prev, node.next\n prev.next, nxt.prev = nxt, prev\n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.remove(self.cache[key])\n self.add(self.cache[key])\n return self.cache[key].val\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.remove(self.cache[key])\n self.cache[key] = Node(key, value)\n self.add(self.cache[key])\n\n if len(self.cache) > self.capacity:\n lru = self.left.next\n self.remove(lru)\n del self.cache[lru.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78500"},{"code":"class Node:\n def __init__(self, key, value):\n self.key = key\n self.value = value\n self.next = self.prev = None\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.cache = {}\n self.left, self.right = Node(-1, -1), Node(-1, -1)\n self.left.next, self.right.prev = self.right, self.left\n \n def insert(self, node):\n prev, nxt = self.right.prev, self.right\n node.prev, node.next = prev, nxt\n prev.next, nxt.prev = node, node\n \n def delete(self, node):\n prev, nxt = node.prev, node.next\n prev.next, nxt.prev = nxt, prev \n\n def get(self, key: int) -> int:\n if key in self.cache:\n self.delete(self.cache[key])\n self.insert(self.cache[key])\n return self.cache[key].value\n \n return -1\n \n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.delete(self.cache[key])\n self.cache[key] = Node(key, value)\n self.insert(self.cache[key])\n\n if len(self.cache) > self.capacity:\n lru = self.left.next\n self.delete(lru)\n del self.cache[lru.key]\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78600"},{"code":"class ListNode:\n def __init__(self, key, val):\n self.key = key\n self.val = val\n self.next = None\n self.prev = None\n\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.dic = {}\n self.head = ListNode(-1, -1)\n self.tail = ListNode(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n\n def get(self, key: int) -> int:\n if key not in self.dic:\n return -1\n\n node = self.dic[key]\n self.remove(node)\n self.add(node)\n return node.val\n\n def put(self, key: int, value: int) -> None:\n if key in self.dic:\n old_node = self.dic[key]\n self.remove(old_node)\n\n node = ListNode(key, value)\n self.dic[key] = node\n self.add(node)\n\n if len(self.dic) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.dic[node_to_delete.key]\n\n def add(self, node):\n previous_end = self.tail.prev\n previous_end.next = node\n node.prev = previous_end\n node.next = self.tail\n self.tail.prev = node\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78600"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n 'initialize'\n self.cache = {x: None for x in range(capacity)}\n self.dll = Node(None, None)\n self.dllCount = 0\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n val = self.cache.get(key, -1)\n if not val or val == -1:\n return -1\n\n # now move the value to the head\n self.dll.drop(val)\n self.dll.add(val)\n # print('after get')\n # print(self.dll)\n return val.val\n \n\n def put(self, key: int, value: int) -> None:\n newNode = Node(key, value)\n if key in self.cache and self.cache[key] != None:\n self.dll.drop(self.cache[key])\n\n self.dll.add(newNode)\n # if the key is in the cache, we have to drop it from the list and move it to the head\n\n\n # make sure we are not over capacity\n if key not in self.cache or self.cache[key] == None:\n self.dllCount += 1\n\n if self.dllCount > self.capacity:\n oldTail = self.dll.tail\n self.dll.drop(oldTail)\n del self.cache[oldTail.key]\n self.dllCount -= 1\n \n # if we're not updating, we are inserting, so bump up the count\n\n # update the cache\n self.cache[key] = newNode\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)\n\nclass Node:\n 'a doubly linked list'\n\n def __init__(self, key, val):\n self.head = None\n self.tail = None\n\n self.key = key\n self.val = val\n\n self.next = None\n self.prev = None\n\n def add(self, node):\n 'add a node to the head'\n node.next = self.head\n node.prev = None\n\n self.head = node\n if self.head.next:\n self.head.next.prev = node\n\n if not self.tail:\n self.tail = node\n\n def drop(self, node):\n '''\n drop a node by reassigning its surrounding pointers.\n if necessary, reassign head and tail of the DLL\n '''\n\n if node.next:\n node.next.prev = node.prev\n if node.prev:\n node.prev.next = node.next\n\n if node == self.head:\n self.head = node.next\n if node == self.tail:\n self.tail = node.prev\n\n def __str__(self):\n res = ''\n node = self.head\n while node:\n res += f'{node.val}'\n node = node.next\n return res\n","memory":"78700"},{"code":"class DLLNode:\n\n def __init__(self, key=-1, val=-1, next=None, prev=None):\n self.key = key\n self.val = val\n self.prev = prev\n self.next = next\n\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.store = OrderedDict()\n self.capacity = capacity\n self.head = DLLNode()\n self.tail = DLLNode()\n self.head.next = self.tail\n self.tail.prev = self.head\n\n def get(self, key: int) -> int:\n if key not in self.store:\n return -1\n\n self.moveNodeToHead(self.store[key])\n return self.store[key].val\n \n\n def put(self, key: int, value: int) -> None:\n if key not in self.store:\n if len(self.store) == self.capacity:\n self.evictTailNode()\n node = DLLNode(key, value)\n else:\n node = self.store[key]\n node.val = value\n \n self.store[key] = node\n self.moveNodeToHead(node)\n\n \n def moveNodeToHead(self, node):\n if node.prev == self.head: return\n if len(self.store) == 1:\n self.head.next = node\n node.prev = self.head\n self.tail.prev = node\n node.next = self.tail\n return\n p, n = node.prev, node.next\n if p and n:\n p.next, n.prev = n, p\n temp = self.head.next\n temp.prev = node\n node.next = temp\n self.head.next = node\n node.prev = self.head\n \n def evictTailNode(self):\n node = self.tail.prev\n temp = node.prev\n temp.next = self.tail\n self.tail.prev = temp\n self.store.pop(node.key)\n del node\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78700"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n 'initialize'\n self.cache = {x: None for x in range(capacity)}\n self.dll = Node(None, None)\n self.dllCount = 0\n self.capacity = capacity\n\n def get(self, key: int) -> int:\n val = self.cache.get(key, -1)\n if not val or val == -1:\n return -1\n\n # now move the value to the head\n self.dll.drop(val)\n self.dll.add(val)\n # print('after get')\n # print(self.dll)\n return val.val\n \n\n def put(self, key: int, value: int) -> None:\n newNode = Node(key, value)\n if key in self.cache and self.cache[key] != None:\n self.dll.drop(self.cache[key])\n\n self.dll.add(newNode)\n # if the key is in the cache, we have to drop it from the list and move it to the head\n\n\n # make sure we are not over capacity\n if key not in self.cache or self.cache[key] == None:\n self.dllCount += 1\n\n if self.dllCount > self.capacity:\n oldTail = self.dll.tail\n self.dll.drop(oldTail)\n del self.cache[oldTail.key]\n self.dllCount -= 1\n \n # if we're not updating, we are inserting, so bump up the count\n\n # update the cache\n self.cache[key] = newNode\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)\n\nclass Node:\n 'a doubly linked list'\n\n def __init__(self, key, val):\n self.head = None\n self.tail = None\n\n self.key = key\n self.val = val\n\n self.next = None\n self.prev = None\n\n def add(self, node):\n 'add a node to the head'\n node.next = self.head\n node.prev = None\n\n self.head = node\n if self.head.next:\n self.head.next.prev = node\n\n if not self.tail:\n self.tail = node\n\n def drop(self, node):\n '''\n drop a node by reassigning its surrounding pointers.\n if necessary, reassign head and tail of the DLL\n '''\n\n if node.next:\n node.next.prev = node.prev\n if node.prev:\n node.prev.next = node.next\n\n if node == self.head:\n self.head = node.next\n if node == self.tail:\n self.tail = node.prev\n\n def __str__(self):\n res = ''\n node = self.head\n while node:\n res += f'{node.val}'\n node = node.next\n return res\n","memory":"78800"},{"code":"class DataNode:\n previous_node = None\n node = None\n next_node = None\n value = None\n\n def __init__(self, node, value, previous_node=None, next_node=None):\n self.node = node\n self.value = value\n self.previous_node = previous_node\n self.next_node = next_node\n\n\nclass LRUCache:\n def __init__(self, capacity):\n self.data_dict = {}\n self.previous_node = None\n self.next_node = None\n self.capacity = capacity or 1\n\n def get(self, key):\n if self.data_dict.get(key) is None:\n return -1\n\n node = self.data_dict[key].node\n value = self.data_dict[key].value\n self.removing(node)\n self.adding(node, value)\n return value\n\n def put(self, key, value):\n if key in self.data_dict:\n self.removing(key)\n elif len(self.data_dict) == self.capacity:\n self.removing(next(iter(self.data_dict)))\n\n self.adding(key, value)\n\n def adding(self, node, value):\n if len(self.data_dict) == 0:\n self.data_dict[node] = DataNode(node=node, value=value)\n else:\n self.data_dict[node] = DataNode(\n node=node, value=value, previous_node=self.previous_node\n )\n self.previous_node.next_node = self.data_dict[node]\n\n self.previous_node = self.data_dict[node]\n\n def removing(self, node):\n if getattr(self.data_dict[node], \"previous_node\") is not None:\n self.data_dict[node].previous_node.next_node = self.data_dict[\n node\n ].next_node\n if getattr(self.data_dict[node], \"next_node\") is not None:\n self.data_dict[node].next_node.previous_node = self.data_dict[\n node\n ].previous_node\n self.data_dict.pop(node)\n","memory":"78900"},{"code":"class LRUCache:\n\n def __init__(self, capacity: int):\n self.head = {}\n self.tail = {}\n self.head['next'] = self.tail\n self.tail['prev'] = self.head\n self.c = capacity\n self.map = {}\n\n def get(self, key: int) -> int:\n if key not in self.map:\n return -1\n\n item = self.map[key]\n x = item['prev']\n y = item['next']\n x['next'] = y\n y['prev'] = x\n\n head = self.head['next']\n self.head['next'] = item\n item['prev'] = self.head\n head['prev'] = item\n item['next'] = head\n\n return item['val']\n\n def put(self, key: int, value: int) -> None:\n self.map[key] = {} if key not in self.map else self.map[key]\n self.map[key]['val'] = value\n self.map[key]['key'] = key\n\n item = self.map[key]\n if 'prev' in self.map[key]:\n x = item['prev']\n y = item['next']\n x['next'] = y\n y['prev'] = x\n\n head = self.head['next']\n self.head['next'] = item\n item['prev'] = self.head\n head['prev'] = item\n item['next'] = head\n\n if len(self.map) > self.c:\n last = self.tail['prev']\n last_prev = last['prev']\n last_prev['next'] = self.tail\n self.tail['prev'] = last_prev\n del self.map[last['key']]\n\n\n\n\n \n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"78900"},{"code":"class Node:\n def __init__(self, key: int, value: int):\n # Doubly Linked List (DLL)\n self.key: int = key\n self.value: int = value\n self.prev: Node | None = None\n self.next: Node | None = None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.head = Node(-1, -1)\n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.hash_map: dict[int, Node] = {}\n self.capacity: int = capacity\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n def get(self, key: int) -> int:\n node = self.hash_map.get(key)\n if not node:\n return -1\n # Move the node to the tail (most recently used)\n if node != self.tail.prev: # Optimization: move only if not already the most recent\n self.remove(node)\n self.add(node)\n return node.value\n\n def add(self, node) -> None:\n self.tail.prev.next = node\n node.prev = self.tail.prev \n node.next = self.tail\n self.tail.prev = node\n\n def put(self, key: int, value: int) -> None:\n if key in self.hash_map:\n node = self.hash_map[key] \n node.value = value\n self.remove(node)\n else:\n node = Node(key, value) \n self.hash_map[key] = node\n\n self.add(node)\n\n if len(self.hash_map) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.hash_map[node_to_delete.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"79000"},{"code":"class LRUCache:\n def _removeNode(self, node):\n prev = node[\"prev\"]\n nxt = node[\"next\"]\n prev[\"next\"] = nxt\n nxt[\"prev\"] = prev\n\n def _moveToHead(self, node):\n self._removeNode(node)\n self._addToHead(node)\n \n def _addToHead(self, node):\n prev = self.head[\"prev\"]\n prev[\"next\"] = node\n node[\"prev\"] = prev\n node[\"next\"] = self.head\n self.head[\"prev\"] = node\n \n def _popTail(self):\n node = self.tail[\"next\"]\n self._removeNode(node)\n return node[\"key\"]\n\n def __init__(self, capacity: int):\n self.cache = {}\n self.head = { \"val\": None, \"key\": None, \"next\": None, \"prev\": None }\n self.tail = { \"val\": None, \"key\": None, \"next\": None, \"prev\": None }\n self.head[\"prev\"] = self.tail\n self.tail[\"next\"] = self.head\n self.max_capacity = capacity\n self.capacity = 0\n\n def get(self, key: int) -> int:\n if key in self.cache:\n node = self.cache[key]\n self._moveToHead(node)\n return node[\"val\"]\n else:\n return -1\n\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n node = self.cache[key]\n node[\"val\"] = value\n self._moveToHead(node)\n else:\n node = { \"val\": value, \"key\": key, \"next\": None, \"prev\": None }\n self._addToHead(node)\n self.cache[key] = node\n self.capacity += 1\n if self.capacity > self.max_capacity:\n self.capacity -= 1\n key = self._popTail()\n del self.cache[key]\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"79000"},{"code":"class Node:\n def __init__(self, key: int, value: int):\n # Doubly Linked List (DLL)\n self.key: int = key\n self.value: int = value\n self.prev: Node | None = None\n self.next: Node | None = None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.head = Node(-1, -1)\n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.hash_map: dict[int, Node] = {}\n self.capacity: int = capacity\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n def get(self, key: int) -> int:\n node = self.hash_map.get(key)\n if not node:\n return -1\n # Move the node to the tail (most recently used)\n if node != self.tail.prev: # Optimization: move only if not already the most recent\n self.remove(node)\n self.add(node)\n return node.value\n\n def add(self, node) -> None:\n self.tail.prev.next = node\n node.prev = self.tail.prev \n node.next = self.tail\n self.tail.prev = node\n\n def put(self, key: int, value: int) -> None:\n if key in self.hash_map:\n node = self.hash_map[key] \n node.value = value\n self.remove(node)\n else:\n node = Node(key, value) \n self.hash_map[key] = node\n\n self.add(node)\n\n if len(self.hash_map) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.hash_map[node_to_delete.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"79100"},{"code":"class Node:\n def __init__(self, key: int, value: int):\n # Doubly Linked List (DLL)\n self.key: int = key\n self.value: int = value\n self.prev: Node | None = None\n self.next: Node | None = None\n\nclass LRUCache:\n def __init__(self, capacity: int):\n self.head = Node(-1, -1)\n self.tail = Node(-1, -1)\n self.head.next = self.tail\n self.tail.prev = self.head\n self.hash_map: dict[int, Node] = {}\n self.capacity: int = capacity\n\n def remove(self, node):\n node.prev.next = node.next\n node.next.prev = node.prev\n\n def get(self, key: int) -> int:\n node = self.hash_map.get(key)\n if not node:\n return -1\n # Move the node to the tail (most recently used)\n if node != self.tail.prev: # Optimization: move only if not already the most recent\n self.remove(node)\n self.add(node)\n return node.value\n\n def add(self, node) -> None:\n self.tail.prev.next = node\n node.prev = self.tail.prev \n node.next = self.tail\n self.tail.prev = node\n\n def put(self, key: int, value: int) -> None:\n if key in self.hash_map:\n # If key exists, update the value and move to the most recent position\n node = self.hash_map[key]\n node.value = value\n self.remove(node)\n else:\n # Create a new node if key is not in the cache\n node = Node(key, value)\n self.hash_map[key] = node\n \n # Add the node as the most recently used\n self.add(node)\n\n if len(self.hash_map) > self.capacity:\n node_to_delete = self.head.next\n self.remove(node_to_delete)\n del self.hash_map[node_to_delete.key]\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"79100"},{"code":"class ListNode:\n def __init__(self, key = 0, val = None, next = None, prev = None):\n self.key = key\n self.val = val\n self.next = next\n self.prev = prev\n \nclass LRUCache:\n def __init__(self, capacity: int):\n self.head = ListNode()\n self.tail = ListNode()\n self.head.next = self.tail\n self.tail.prev = self.head\n self.capacity = capacity\n self.length = 0\n self.cache = {}\n def add(self, node):\n node.prev = self.tail.prev\n node.next = self.tail\n self.tail.prev.next = node\n self.tail.prev = node\n def pop(self, node):\n node.next.prev = node.prev\n node.prev.next = node.next\n def get(self, key: int) -> int:\n if key in self.cache:\n self.pop(self.cache[key]) \n self.add(self.cache[key]) \n return self.cache[key].val\n return -1\n def put(self, key: int, value: int) -> None:\n if key in self.cache:\n self.pop(self.cache[key])\n self.cache[key] = ListNode(key, value)\n self.add(self.cache[key])\n \n if len(self.cache) > self.capacity:\n node = self.head.next\n self.pop(node) \n del self.cache[node.key]\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"79200"},{"code":"class Node:\n key = None\n value = None\n previous = None\n next = None\n\n\nclass LRUCache:\n\n def __init__(self, capacity: int):\n self.capacity = capacity\n self.head = Node()\n self.last = Node()\n self.head.next = self.last\n self.last.previous = self.head\n self.dict = {}\n self.size = 0\n\n def _add_node(self, node):\n node.next = self.head.next\n node.previous = self.head\n\n self.head.next.previous = node\n self.head.next = node\n\n def _remove_node(self, node):\n node.previous.next = node.next\n node.next.previous = node.previous\n\n def _move_to_head(self, node):\n self._remove_node(node)\n self._add_node(node)\n\n def _pop_tail(self):\n res = self.last.previous\n self._remove_node(res)\n return res\n\n def get(self, key: int) -> int:\n node = self.dict.get(key, None)\n if not node:\n return -1\n self._move_to_head(node)\n return node.value\n\n def put(self, key: int, value: int) -> None:\n node = self.dict.get(key)\n\n if not node:\n newNode = Node()\n newNode.key = key\n newNode.value = value\n\n self.dict[key] = newNode\n self._add_node(newNode)\n\n self.size += 1\n\n if self.size > self.capacity:\n # pop the tail\n tail = self._pop_tail()\n del self.dict[tail.key]\n self.size -= 1\n else:\n # update the value.\n node.value = value\n self._move_to_head(node)\n\n\n# Your LRUCache object will be instantiated and called as such:\n# obj = LRUCache(capacity)\n# param_1 = obj.get(key)\n# obj.put(key,value)","memory":"79200"}],"string":"[\n {\n \"code\": \"def lc(operations, params):\\n cache = OrderedDict()\\n result = []\\n capacity = None\\n for i, op in enumerate(operations):\\n if op == \\\"LRUCache\\\":\\n capacity = params[i][0]\\n result.append(None)\\n elif op == \\\"put\\\":\\n key, value = params[i]\\n if key in cache:\\n cache.move_to_end(key)\\n cache[key] = value\\n if len(cache) > capacity:\\n cache.popitem(last=False)\\n result.append(None)\\n elif op == \\\"get\\\":\\n key = params[i][0]\\n if key in cache:\\n cache.move_to_end(key)\\n result.append(cache[key])\\n else:\\n result.append(-1) \\n return result\\n\\nwith open(\\\"user.out\\\",\\\"w\\\") as sys.stdout:\\n print(*(str(lc(*h)).replace('None','null').replace(' ','') for h in zip(*[map(loads,stdin)]*2)),sep='\\\\n')\\nexit(0)\",\n \"memory\": \"68800\"\n },\n {\n \"code\": \"def lc(operations, params):\\n cache = OrderedDict()\\n result = []\\n capacity = None\\n for i, op in enumerate(operations):\\n if op == \\\"LRUCache\\\":\\n capacity = params[i][0]\\n result.append(None)\\n elif op == \\\"put\\\":\\n key, value = params[i]\\n if key in cache:\\n cache.move_to_end(key)\\n cache[key] = value\\n if len(cache) > capacity:\\n cache.popitem(last=False)\\n result.append(None)\\n elif op == \\\"get\\\":\\n key = params[i][0]\\n if key in cache:\\n cache.move_to_end(key)\\n result.append(cache[key])\\n else:\\n result.append(-1) \\n return result\\n\\nwith open(\\\"user.out\\\",\\\"w\\\") as sys.stdout:\\n print(*(str(lc(*h)).replace('None','null').replace(' ','') for h in zip(*[map(loads,stdin)]*2)),sep='\\\\n')\\nexit(0)\",\n \"memory\": \"68900\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.lru = []\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.lru.remove(key)\\n self.lru.append(key)\\n return self.cache[key]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.lru.remove(key)\\n elif len(self.lru) == self.capacity:\\n del self.cache[self.lru.pop(0)]\\n self.cache[key] = value\\n self.lru.append(key)\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"73600\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.curr_len = 0\\n self.dic = {}\\n self.lst = []\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.dic.keys():\\n self.lst.remove(key)\\n self.lst.append(key)\\n return self.dic[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key not in self.dic.keys():\\n if self.curr_len < self.capacity:\\n self.dic[key] = value\\n self.lst.append(key)\\n self.curr_len = self.curr_len + 1\\n else:\\n lkey = self.lst.pop(0)\\n del self.dic[lkey]\\n self.dic[key] = value\\n self.lst.append(key)\\n else:\\n self.dic[key] = value\\n self.lst.remove(key)\\n self.lst.append(key)\\n # print(self.dic)\\n # print(self.lst)\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"74100\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val, prev=None, next=None):\\n self.val = val\\n self.key = key\\n self.prev = prev\\n self.next = next\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.first = Node(0,0)\\n self.last = Node(0,0)\\n self.first.next = self.last\\n self.last.prev = self.first\\n self.capacity = capacity\\n\\n def lruRemove(self, node):\\n node.next.prev = node.prev\\n node.prev.next = node.next\\n\\n def lruInsert(self, node):\\n prev, next = self.last.prev, self.last\\n prev.next = node\\n next.prev = node\\n node.next = next\\n node.prev = prev\\n\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n node = self.cache[key]\\n self.lruRemove(node)\\n self.lruInsert(node)\\n return node.val\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.lruRemove(self.cache[key])\\n node = Node(key, value)\\n self.cache[key] = node\\n self.lruInsert(node)\\n\\n if len(self.cache) > self.capacity:\\n node = self.first.next\\n self.lruRemove(node)\\n del self.cache[node.key]\\n \\n\",\n \"memory\": \"74800\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.size = capacity\\n self.q = deque(maxlen = capacity)\\n self.mappings = {}\\n\\n def get(self, key: int) -> int:\\n if key in self.mappings:\\n self.q.remove(key)\\n self.q.append(key)\\n # print(f\\\"get : {key} q: {self.q} and map : {self.mappings}\\\")\\n return self.mappings[key]\\n else:\\n return -1\\n\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.mappings:\\n self.q.remove(key)\\n self.q.append(key)\\n\\n elif len(self.q) == self.size:\\n least_used = self.q.popleft()\\n del self.mappings[least_used]\\n self.q.append(key)\\n\\n else:\\n self.q.append(key)\\n \\n self.mappings[key] = value\\n \\n # print(f\\\"put {key} q is: {self.q} and map is: {self.mappings}\\\")\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"74900\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.usage_order = []\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n # Move the accessed key to the end to mark it as recently used\\n self.usage_order.remove(key)\\n self.usage_order.append(key)\\n return self.cache[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n # Update the value and move the key to the end to mark it as recently used\\n self.cache[key] = value\\n self.usage_order.remove(key)\\n self.usage_order.append(key)\\n else:\\n if len(self.cache) >= self.capacity:\\n # Remove the least recently used key\\n lru_key = self.usage_order.pop(0)\\n del self.cache[lru_key]\\n # Add the new key-value pair\\n self.cache[key] = value\\n self.usage_order.append(key)\\n\",\n \"memory\": \"75100\"\n },\n {\n \"code\": \"class LRUCache:\\n class Node:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.prev = None\\n self.next = None\\n\\n def __init__(self, capacity: int):\\n self.cap = capacity\\n self.head = self.Node(-1, -1)\\n self.tail = self.Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.m = {}\\n\\n def addNode(self, newnode):\\n temp = self.head.next\\n newnode.next = temp\\n newnode.prev = self.head\\n self.head.next = newnode\\n temp.prev = newnode\\n\\n def deleteNode(self, delnode):\\n prevv = delnode.prev\\n nextt = delnode.next\\n prevv.next = nextt\\n nextt.prev = prevv\\n\\n def get(self, key: int) -> int:\\n if key in self.m:\\n resNode = self.m[key]\\n ans = resNode.val\\n del self.m[key]\\n self.deleteNode(resNode)\\n self.addNode(resNode)\\n self.m[key] = self.head.next\\n return ans\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.m:\\n curr = self.m[key]\\n del self.m[key]\\n self.deleteNode(curr)\\n\\n if len(self.m) == self.cap:\\n del self.m[self.tail.prev.key]\\n self.deleteNode(self.tail.prev)\\n\\n self.addNode(self.Node(key, value))\\n self.m[key] = self.head.next\",\n \"memory\": \"75300\"\n },\n {\n \"code\": \"# Simple method\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {} # store key-value pair\\n self.order = [] # sotre key order\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n\\n self.order.remove(key)\\n self.order.append(key)\\n return self.cache[key] \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache[key] = value\\n self.order.remove(key)\\n self.order.append(key)\\n\\n elif key not in self.cache:\\n if len(self.cache) >= self.capacity:\\n old = self.order.pop(0)\\n del self.cache[old]\\n self.order.append(key)\\n self.cache[key] = value\\n else:\\n self.order.append(key)\\n self.cache[key] = value\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"75400\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = OrderedDict()\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n val = self.cache.get(key, -1)\\n if val != -1:\\n self.cache.move_to_end(key)\\n return val\\n\\n\\n def put(self, key: int, value: int) -> None:\\n if self.cache.get(key) is None and len(self.cache.keys()) == self.capacity:\\n #evict LRU\\n self.cache.pop(list(self.cache.keys())[0])\\n self.cache[key] = value\\n else:\\n self.cache[key] = value\\n self.cache.move_to_end(key)\\n\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"75500\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, value, prev = None, next = None):\\n self.key = key\\n self.value = value\\n self.prev = prev\\n self.next = next\\n\\nclass LRUCache:\\n class Node:\\n def __init__(self, key, value, prev = None, next = None):\\n self.key = key\\n self.value = value\\n self.prev = prev\\n self.next = next\\n\\n def __init__(self, capacity: int):\\n self.dummy_head = Node(-1, -1)\\n self.dummy_tail = Node(-1, -1)\\n self.dummy_head.next = self.dummy_tail\\n self.dummy_tail.prev = self.dummy_head\\n\\n self.capacity = capacity\\n self.map = {}\\n \\n def _remove(self, node):\\n \\\"\\\"\\\"Remove an existing node from the linked list.\\\"\\\"\\\"\\n prev_node = node.prev\\n next_node = node.next\\n prev_node.next = next_node\\n next_node.prev = prev_node\\n\\n def _add_to_head(self, node):\\n \\\"\\\"\\\"Add a new node right after the dummy head.\\\"\\\"\\\"\\n node.prev = self.dummy_head\\n node.next = self.dummy_head.next\\n self.dummy_head.next.prev = node\\n self.dummy_head.next = node\\n\\n def get(self, key: int) -> int:\\n if key in self.map:\\n node = self.map[key]\\n self._remove(node)\\n self._add_to_head(node)\\n return node.value\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.map:\\n node = self.map[key]\\n node.value = value\\n self._remove(node)\\n self._add_to_head(node)\\n else:\\n if len(self.map) == self.capacity:\\n evict = self.dummy_tail.prev\\n self._remove(evict)\\n del self.map[evict.key]\\n node = Node(key, value)\\n self.map[key] = node\\n self._add_to_head(node)\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"75600\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n # # everytime we perform a get we move it to the top of the stack and remove the last element\\n # # use hashmap as a queue\\n # self.capacity = capacity\\n # self.cache = {}\\n # pass\\n\\n # def get(self, key: int) -> int:\\n # if key in self.cache:\\n # value = self.cache[key]\\n # del self.cache[key]\\n # self.cache[key] = value\\n # return value\\n # return -1\\n\\n # def put(self, key: int, value: int) -> None:\\n # # Even a put with update leads to moving the newly added key-value pair up\\n # if key in self.cache:\\n # del self.cache[key]\\n # self.cache[key] = value\\n # if len(self.cache) > self.capacity:\\n # self.cache.pop(next(iter(self.cache)))\\n # pass\\n # using a deque for the design implementation\\n # maintain a hashmap for the key - value pairs and a deque administering the LRU state\\n self.capacity = capacity\\n self.cache = deque([])\\n self.hashmap = {}\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.cache.remove(key)\\n self.cache.appendleft(key)\\n return self.hashmap[key]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.remove(key)\\n self.hashmap[key] = value\\n self.cache.appendleft(key)\\n if len(self.cache) > self.capacity:\\n self.cache.pop()\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"75700\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.k=[]\\n self.c = capacity\\n self.d = {}\\n self.l = 0\\n\\n def get(self, key: int) -> int:\\n \\n if key in self.d.keys():\\n self.k.remove(key)\\n self.k = [key]+self.k\\n return self.d[key]\\n return -1\\n def put(self, key: int, value: int) -> None:\\n # print(self.d,self.k)\\n if key in self.k:\\n self.k.remove(key)\\n self.k = [key]+self.k\\n self.d[key] = value\\n else:\\n self.d[key] = value\\n self.k = [key]+self.k\\n self.l+=1\\n if self.c<self.l:\\n a=self.k.pop(-1)\\n self.l-=1\\n del self.d[a]\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"75800\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n \\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n val = self.cache[key]\\n self.cache.pop(key)\\n self.cache[key] = val\\n return val\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.pop(key)\\n elif len(self.cache) == self.capacity:\\n self.cache.pop(list(self.cache.keys())[0])\\n self.cache[key] = value\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76000\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.dict = collections.OrderedDict()\\n\\n def get(self, key: int) -> int:\\n if key in self.dict:\\n self.dict.move_to_end(key)\\n return self.dict[key]\\n \\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.dict:\\n self.dict.move_to_end(key)\\n self.dict[key] = value\\n else:\\n self.dict[key] = value\\n \\n if len(self.dict) > self.capacity:\\n self.dict.popitem(False)\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76100\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n val = self.cache[key]\\n del self.cache[key]\\n self.cache[key] = val\\n return val\\n return -1\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n del self.cache[key]\\n self.cache[key] = value\\n if len(self.cache) > self.capacity:\\n del self.cache[list(self.cache)[0]]\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76200\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n val = self.cache[key]\\n del self.cache[key]\\n self.cache[key] = val\\n return val\\n return -1\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n del self.cache[key]\\n self.cache[key] = value\\n if len(self.cache) > self.capacity:\\n del self.cache[next(iter(self.cache))]\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76200\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n \\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n val = self.cache.pop(key)\\n self.cache[key] = val\\n return val\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.pop(key)\\n elif len(self.cache) == self.capacity:\\n # remove the oldest key\\n pop_key = next(iter(self.cache.keys()))\\n self.cache.pop(pop_key)\\n self.cache[key] = value\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76300\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.map = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if self.map.get(key) is not None:\\n val = self.map[key]\\n del(self.map[key]) \\n self.map[key] = val\\n return val\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if not self.map.get(key):\\n if len(self.map.keys()) == self.capacity:\\n i = list(self.map.keys())[0]\\n del(self.map[i])\\n else:\\n del(self.map[key])\\n \\n self.map[key] = value\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76300\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.map = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if self.map.get(key) is not None:\\n val = self.map[key]\\n del(self.map[key]) \\n self.map[key] = val\\n return val\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if not self.map.get(key):\\n if len(self.map.keys()) == self.capacity:\\n i = list(self.map.keys())[0]\\n del(self.map[i])\\n else:\\n del(self.map[key])\\n \\n self.map[key] = value\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76400\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n\\n self.cache[key] = self.cache.pop(key)\\n return self.cache[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.pop(key)\\n\\n self.cache[key] = value\\n if len(self.cache) > self.capacity:\\n self.cache.pop(next(iter(self.cache)))\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76400\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n val = self.cache[key]\\n del self.cache[key]\\n self.cache[key] = val\\n return val\\n return -1\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n del self.cache[key]\\n self.cache[key] = value\\n if len(self.cache) > self.capacity:\\n del self.cache[next(iter(self.cache))]\\n \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76500\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.maxl = capacity\\n self.data = {}\\n\\n def get(self, key: int) -> int:\\n if key in self.data:\\n data = self.data[key]\\n del self.data[key]\\n self.data[key] = data\\n return data\\n \\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.data:\\n del self.data[key]\\n self.data[key] = value\\n totallen = len(self.data.keys())\\n if totallen > self.maxl:\\n tobedeleted = totallen - self.maxl\\n\\n keys = list(self.data.keys())[:tobedeleted]\\n for k in keys:\\n del self.data[k]\\n \\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76500\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n \\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n \\n self.cache[key] = self.cache.pop(key)\\n return self.cache[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.pop(key)\\n\\n self.cache[key] = value\\n if len(self.cache) > self.capacity:\\n self.cache.pop(next(iter(self.cache)))\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76600\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.lru = {}\\n self.capacity = capacity\\n self.lastusedkey = []\\n\\n\\n def get(self, key: int) -> int:\\n if key in self.lru:\\n self.lastusedkey[0]=key\\n return self.lru[key]\\n \\n else:\\n return -1\\n\\n \\n def put(self, key: int, value: int) -> None:\\n if self.get(key)!=-1:\\n self.lastusedkey[0]=key\\n self.lru[key]=value\\n elif len(self.lru)<capacity:\\n self.lastusedkey[0]=key\\n self.lru[key]=value\\n else:\\n del self.lru[self.lastusedkey[0]]\\n self.lastusedkey[0]=key\\n self.lru[key]=value\\n\\n\\n\\n\\n\\n # def get(self, key: int) -> int:\\n # if key not in self.dict:\\n # return -1\\n # val = self.dict.pop(key) #Remove it first before inserting it at the end again\\n # self.dict[key] = val \\n # return val \\n\\n # def put(self, key: int, value: int) -> None:\\n # if key in self.dict: \\n # self.dict.pop(key)\\n # else:\\n # if len(self.dict) == self.capacity:\\n # del self.dict[next(iter(self.dict))] \\n # self.dict[key] = value\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\\n\\n\\n\\n\\n\\n\\n\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n value = self.cache[key]\\n del self.cache[key]\\n self.cache[key] = value\\n return self.cache[key]\\n else:\\n return -1\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n del self.cache[key]\\n self.cache[key]=value\\n else:\\n if (len(self.cache) == self.capacity):\\n lrkey = next(iter(self.cache))\\n del self.cache[lrkey]\\n self.cache[key]=value\",\n \"memory\": \"76600\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.dict = {}\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key not in self.dict:\\n return -1\\n self.dict[key] = self.dict.pop(key)\\n return self.dict[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.dict:\\n self.dict.pop(key)\\n else:\\n if self.capacity:\\n self.capacity-=1\\n else:\\n self.dict.pop(next(iter(self.dict)))\\n self.dict[key] = value\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76700\"\n },\n {\n \"code\": \"class LRUCache:\\n class Node:\\n def __init__(self, key, val, prev=None, next=None):\\n self.key = key\\n self.val = val\\n self.prev = prev\\n self.next = next\\n\\n def remove(self, cur):\\n cur.prev.next = cur.next\\n cur.next.prev = cur.prev\\n\\n def add(self, cur):\\n temp = self.head.next\\n self.head.next = cur\\n cur.next = temp\\n temp.prev = cur\\n cur.prev = self.head\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.head, self.tail = self.Node(-1, -1), self.Node(-1, -1)\\n self.head.next, self.tail.prev = self.tail, self.head\\n self.lru = collections.defaultdict(self.Node) \\n\\n def get(self, key: int) -> int:\\n if key not in self.lru:\\n return -1\\n node = self.lru[key]\\n self.remove(node)\\n self.add(node)\\n\\n return self.lru[key].val\\n\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.lru:\\n node = self.lru[key]\\n self.remove(node)\\n del self.lru[node.key]\\n self.capacity += 1\\n node = self.Node(key, value)\\n self.lru[key] = node\\n self.add(node)\\n self.capacity -= 1\\n\\n if self.capacity < 0:\\n deleteNode = self.tail.prev\\n self.remove(deleteNode)\\n del self.lru[deleteNode.key]\\n self.capacity += 1\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76700\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n # Key to value\\n self.elements: dict[int, int] = {}\\n # Map of element to most recent update id\\n self.usage: dict[int, int] = {}\\n self.update_id: int = 0\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n if key in self.elements:\\n self.usage[key] = self.update_id\\n self.update_id += 1\\n return self.elements[key]\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key not in self.elements and len(self.elements) == self.capacity:\\n key_to_evict = -1\\n least_recently_used = 2 * 10**5 + 1\\n for k, usage in self.usage.items():\\n if usage < least_recently_used:\\n key_to_evict = k\\n least_recently_used = usage\\n del self.elements[key_to_evict]\\n del self.usage[key_to_evict]\\n\\n self.elements[key] = value\\n self.usage[key] = self.update_id\\n self.update_id += 1\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"76800\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.data_dict = {} # for leetcode since if instatied in the class it doesn't start empty, not sure why\\n\\n def get(self, key: int) -> int:\\n if key in self.data_dict:\\n data = self.data_dict.pop(key)\\n self.__persist_used_data(key=key, value=data)\\n return data\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key not in self.data_dict:\\n self.__manage_least_used_data()\\n\\n self.data_dict[key] = value\\n self.__persist_used_data(key=key, value=value)\\n\\n def __persist_used_data(self, key, value):\\n new_data_dict = {key: value}\\n new_data_dict.update(self.data_dict)\\n self.data_dict = new_data_dict\\n\\n def __manage_least_used_data(self):\\n limit_count = len(self.data_dict)\\n if limit_count >= self.capacity:\\n self.data_dict.popitem()\\n\",\n \"memory\": \"76900\"\n },\n {\n \"code\": \"class Node:\\n def __init__ (self, key=None, value=None):\\n self.key = key\\n self.value = value\\n self.pre = None\\n self.nxt = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cap = capacity\\n self.hm = {}\\n self.head = Node()\\n self.tail = Node()\\n self.head.nxt = self.tail\\n self.tail.pre = self.head\\n\\n def get(self, key: int) -> int:\\n if key in self.hm:\\n ret = self.hm[key].value \\n # move the node to the front\\n ## 1. remove the node from its original place\\n ## 2. insert the node to the head.nxt\\n self.removeNode(self.hm[key])\\n self.addNodeToHead(self.hm[key])\\n return ret\\n else:\\n return -1\\n\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hm:\\n self.hm[key].value = value\\n # move the node to the front\\n ## 1. remove the node from its original place\\n ## 2. insert the node to the head.nxt\\n self.removeNode(self.hm[key])\\n self.addNodeToHead(self.hm[key])\\n else:\\n # create node\\n new_node = Node(key, value)\\n\\n # if cache is full, first del node\\n if len(self.hm) >= self.cap:\\n node_to_del = self.tail.pre\\n self.removeNode(node_to_del)\\n self.hm.pop(node_to_del.key)\\n # insert node\\n self.hm[key] = new_node\\n self.addNodeToHead(new_node)\\n \\n \\n def removeNode(self, node):\\n node.pre.nxt = node.nxt\\n node.nxt.pre = node.pre\\n \\n def addNodeToHead(self, node): #指针更新的先后顺序要注意！\\n node.pre = self.head\\n node.nxt = self.head.nxt\\n self.head.nxt.pre = node\\n self.head.nxt = node\\n \\n \\n \\n\\n \\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77000\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, value):\\n self.key, self.value = key, value\\n self.prev = None\\n self.next = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.c = capacity\\n self.m = dict()\\n self.deq = deque()\\n \\n def get(self, key):\\n if key in self.m:\\n value=self.m[key]\\n self.deq.remove(key)\\n self.deq.append(key)\\n return value\\n else:\\n return -1\\n \\n def put(self, key, value):\\n if key not in self.m:\\n if len(self.deq) == self.c:\\n oldest = self.deq.popleft()\\n del self.m[oldest]\\n else:\\n self.deq.remove(key)\\n \\n self.m[key] = value\\n self.deq.append(key)\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77100\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, value):\\n self.key, self.value = key, value\\n self.prev = None\\n self.next = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.c = capacity\\n self.m = dict()\\n self.deq = deque()\\n \\n def get(self, key):\\n if key in self.m:\\n value=self.m[key]\\n self.deq.remove(key)\\n self.deq.append(key)\\n return value\\n else:\\n return -1\\n \\n def put(self, key, value):\\n if key not in self.m:\\n if len(self.deq) == self.c:\\n oldest = self.deq.popleft()\\n del self.m[oldest]\\n else:\\n self.deq.remove(key)\\n \\n self.m[key] = value\\n self.deq.append(key)\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77100\"\n },\n {\n \"code\": \"from collections import OrderedDict\\n\\nclass LRUCache:\\n __slots__ = ('data', 'capacity')\\n\\n def __init__(self, capacity: int):\\n self.data: Dict[int, int] = OrderedDict()\\n self.capacity: int = capacity\\n\\n def get(self, key: int) -> int:\\n return -1 if key not in self.data else self.data.setdefault(key, self.data.pop(key))\\n\\n def put(self, key: int, value: int) -> None:\\n try:\\n self.data.move_to_end(key)\\n self.data[key] = value\\n except KeyError:\\n self.data[key] = value\\n if len(self.data) > self.capacity:\\n self.data.popitem(last=False)\",\n \"memory\": \"77200\"\n },\n {\n \"code\": \"from collections import OrderedDict\\n\\nclass LRUCache:\\n __slots__ = ('data', 'capacity')\\n\\n def __init__(self, capacity: int):\\n self.data: Dict[int, int] = OrderedDict()\\n self.capacity: int = capacity\\n\\n def get(self, key: int) -> int:\\n return -1 if key not in self.data else self.data.setdefault(key, self.data.pop(key))\\n\\n def put(self, key: int, value: int) -> None:\\n try:\\n self.data.move_to_end(key)\\n self.data[key] = value\\n except KeyError:\\n self.data[key] = value\\n if len(self.data) > self.capacity:\\n self.data.popitem(last=False)\",\n \"memory\": \"77200\"\n },\n {\n \"code\": \"class LinkedNode:\\n def __init__(self, key = -1, value = -1):\\n self.key = key\\n self.value = value\\n self.prev = None\\n self.next = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = dict()\\n self.head = LinkedNode()\\n self.tail = LinkedNode()\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n \\n node = self.__evict(key)\\n self.__addToEnd(node)\\n return node.value\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n node = self.__delete(key)\\n \\n node = LinkedNode(key, value)\\n self.cache[key] = node\\n self.__addToEnd(node)\\n\\n if len(self.cache) > self.capacity:\\n self.__delete(self.head.next.key)\\n \\n def __delete(self, key):\\n deleteNode = self.__evict(key)\\n del deleteNode\\n del self.cache[key]\\n \\n def __addToEnd(self, node):\\n node.prev = self.tail.prev\\n node.next = self.tail\\n self.tail.prev.next = node\\n self.tail.prev = node\\n \\n def __evict(self, key) -> LinkedNode:\\n node = self.cache[key]\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n node.next = None\\n node.prev = None\\n return node\\n \\n \\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77400\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n self.used = 0\\n\\n def get(self, key: int) -> int:\\n if key in self.cache: \\n self.cache[key]['lu'] = self.used\\n self.used += 1\\n return self.cache[key]['value']\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache[key]['lu'] = self.used\\n self.used += 1\\n self.cache[key]['value'] = value\\n else:\\n #First evict the last used key if needed\\n if len(self.cache) == self.capacity:\\n last_used = (None, 300000) #key, lu\\n for k, info in self.cache.items():\\n if last_used[0] is None or self.cache[k]['lu'] < last_used[1]:\\n last_used = (k, self.cache[k]['lu'])\\n \\n del self.cache[last_used[0]]\\n\\n #Then add the new key\\n self.cache[key]= {\\\"value\\\":value, \\\"lu\\\":self.used}\\n self.used += 1\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77400\"\n },\n {\n \"code\": \"class LRUCache:\\n class Node:\\n def __init__(self, key, val, prev=None, next=None):\\n self.key = key\\n self.val = val\\n self.prev = prev\\n self.next = next\\n\\n def remove(self, cur):\\n cur.prev.next = cur.next\\n cur.next.prev = cur.prev\\n\\n def add(self, cur):\\n temp = self.head.next\\n self.head.next = cur\\n cur.next = temp\\n temp.prev = cur\\n cur.prev = self.head\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.head, self.tail = self.Node(-1, -1), self.Node(-1, -1)\\n self.head.next, self.tail.prev = self.tail, self.head\\n self.lru = collections.defaultdict(self.Node) \\n\\n def get(self, key: int) -> int:\\n if key not in self.lru:\\n return -1\\n node = self.lru[key]\\n self.remove(node)\\n self.add(node)\\n\\n return self.lru[key].val\\n\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.lru:\\n node = self.lru[key]\\n self.remove(node)\\n del self.lru[node.key]\\n self.capacity += 1\\n node = self.Node(key, value)\\n self.lru[key] = node\\n self.add(node)\\n self.capacity -= 1\\n\\n if self.capacity < 0:\\n deleteNode = self.tail.prev\\n self.remove(deleteNode)\\n del self.lru[deleteNode.key]\\n self.capacity += 1\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77500\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.q = []\\n self.dict = defaultdict(lambda x: -1)\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n try: \\n index = self.q.index(key)\\n self.q.pop(index)\\n self.q.append(key)\\n return self.dict[key]\\n except:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n n = len(self.q)\\n try:\\n index = self.q.index(key)\\n k = self.q.pop(index)\\n self.q.append(k)\\n self.dict[key] = value\\n print(\\\"updating\\\", k)\\n except ValueError:\\n if n >= self.capacity:\\n k = self.q.pop(0)\\n del self.dict[k]\\n self.dict[key] = value\\n self.q.append(key)\\n print(\\\"adding\\\", key, value)\\n print(\\\"capacity\\\", self.capacity)\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77500\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.keys_and_values = {}\\n self.lru_info = []\\n self.lru_len = 0\\n self.capacity = capacity\\n\\n\\n def get(self, key: int) -> int:\\n value = self.keys_and_values.get(key, -1)\\n if key in self.lru_info:\\n self.lru_info.remove(key)\\n self.lru_info.append(key)\\n return value\\n\\n def put(self, key: int, value: int) -> None:\\n self.keys_and_values[key] = value\\n\\n if key in self.lru_info:\\n self.lru_info.remove(key)\\n else:\\n self.lru_len = self.lru_len + 1\\n self.lru_info.append(key)\\n\\n if self.lru_len > self.capacity:\\n removed_key = self.lru_info.pop(0)\\n del self.keys_and_values[removed_key]\\n self.lru_len = self.lru_len - 1\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77600\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n \\n\\n def get(self, key: int) -> int:\\n # maintain order\\n if key in self.cache:\\n self.cache[key] = self.cache.pop(key)\\n return self.cache[key]\\n \\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.pop(key)\\n\\n self.cache[key] = value\\n\\n if len(self.cache) > self.capacity:\\n self.cache.pop(next(iter(self.cache)))\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77600\"\n },\n {\n \"code\": \"class LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n\\n self.cache[key] = self.cache.pop(key)\\n return self.cache[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.cache.pop(key)\\n\\n self.cache[key] = value\\n if len(self.cache) > self.capacity:\\n self.cache.pop(next(iter(self.cache)))\",\n \"memory\": \"77700\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n #assert 1 <= capacity <= 3000\\n self.map = {}\\n self.capacity = capacity\\n \\n\\n def get(self, key: int) -> int:\\n value = self.map.get(key, -1)\\n if value != -1:\\n self.map.pop(key)\\n self.map[key] = value\\n \\n return value\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.map:\\n self.map.pop(key)\\n if len(self.map) == self.capacity:\\n self.map.pop(list(self.map.keys())[0])\\n\\n self.map[key] = value\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77700\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.prev = self.next = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n self.head, self.tail = Node(0, 0), Node(0, 0)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n \\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n \\n def addToHead(self, node):\\n node.next = self.head.next\\n node.prev = self.head\\n node.next.prev = node\\n self.head.next = node\\n\\n def get(self, key: int) -> int:\\n # If present return and remove and put in front\\n if key in self.cache:\\n node = self.cache[key]\\n self.remove(node)\\n self.addToHead(node)\\n return node.val\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n # If present, delete and then add to head\\n if key in self.cache:\\n self.remove(self.cache[key])\\n del self.cache[key]\\n \\n self.cache[key] = Node(key, value)\\n self.addToHead(self.cache[key])\\n\\n # check for capacity\\n if len(self.cache) > self.capacity:\\n curr_last = self.tail.prev\\n self.remove(curr_last)\\n del self.cache[curr_last.key]\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77800\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self,key,val):\\n self.key = key\\n self.val = val\\n self.prev = None\\n self.next = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.len = 0\\n self.cache = {}\\n self.head = ListNode(-1,-1)\\n self.tail = ListNode(-1,-1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n \\n node = self.cache[key]\\n self.remove(node)\\n self.add(node)\\n return node.val\\n \\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n old_node = self.cache[key]\\n self.remove(old_node)\\n \\n node = ListNode(key,value)\\n self.cache[key] = node\\n self.add(node)\\n\\n if len(self.cache) > self.capacity:\\n to_del = self.head.next\\n self.remove(to_del)\\n del self.cache[to_del.key]\\n \\n def remove(self,node: ListNode) -> None:\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n\\n def add(self,node: ListNode) -> None:\\n prev_end = self.tail.prev\\n prev_end.next = node\\n node.next = self.tail\\n node.prev = prev_end\\n self.tail.prev = node\\n \\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77800\"\n },\n {\n \"code\": \"from collections import OrderedDict\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = OrderedDict() # This will hold the cache items in order of usage\\n self.capacity = capacity # Capacity of the cache\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1 # Return -1 if the key does not exist\\n \\n # Move the accessed key to the end to mark it as most recently used\\n self.cache.move_to_end(key)\\n return self.cache[key]\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n # If the key exists, move it to the end to mark it as most recently used\\n self.cache.move_to_end(key)\\n self.cache[key] = value\\n \\n if len(self.cache) > self.capacity:\\n # If the cache exceeds capacity, pop the first item (least recently used)\\n self.cache.popitem(last=False)\\n\",\n \"memory\": \"77900\"\n },\n {\n \"code\": \"from collections import OrderedDict\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n assert 1 <= capacity <= 3000\\n print(capacity)\\n self.map = OrderedDict()\\n self.capacity = capacity\\n \\n\\n def get(self, key: int) -> int:\\n value = self.map.get(key, -1)\\n if value != -1:\\n self.map.pop(key)\\n self.map[key] = value\\n \\n return value\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.map:\\n self.map.pop(key)\\n if len(self.map) == self.capacity:\\n self.map.pop(list(self.map.keys())[0])\\n\\n self.map[key] = value\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"77900\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = OrderedDict()\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.cache.move_to_end(key)\\n return self.cache[key]\\n else:\\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n \\n if key in self.cache:\\n # Update the value and move the key to the end\\n self.cache.move_to_end(key)\\n self.cache[key] = value\\n\\n if len(self.cache) > self.capacity:\\n self.cache.popitem(last=False) \\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78000\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.items = OrderedDict()\\n\\n def get(self, key: int) -> int:\\n if key in self.items:\\n self.items.move_to_end(key)\\n return self.items[key]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.items:\\n self.items.move_to_end(key)\\n self.items[key] = value\\n if len(self.items) > self.capacity:\\n self.items.popitem(False)\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78000\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, key, val):\\n self.next = None\\n self.prev = None\\n self.val = val\\n self.key = key\\n\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.head = ListNode(-1,-1)\\n self.tail = ListNode(-1,-1)\\n self.cache = {}\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n\\n def add(self,key,value):\\n new_node = ListNode(key, value)\\n last_element = self.tail.prev\\n last_element.next = new_node\\n new_node.prev = last_element\\n new_node.next = self.tail\\n self.tail.prev = new_node\\n self.cache[key] = new_node\\n \\n\\n def remove(self,key):\\n node = self.cache[key]\\n node_prev = node.prev\\n node_next = node.next\\n node_prev.next = node_next\\n node_next.prev = node_prev\\n del self.cache[key]\\n\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n node_key = self.cache[key].key\\n node_val = self.cache[key].val\\n self.remove(key)\\n self.add(node_key, node_val)\\n\\n return self.cache[key].val\\n\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.remove(key)\\n self.add(key, value)\\n if len(self.cache) > self.capacity:\\n self.remove(self.head.next.key)\\n\\n \\n\\n\\n\\n\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\\n\",\n \"memory\": \"78100\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, value, nex=None, prev=None):\\n self.key = key\\n self.value = value\\n self.nex = nex\\n self.prev = prev\\n\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.head: Node | None = None\\n self.tail: Node | None = None\\n self.kv: dict[int, Node] = dict()\\n\\n def get(self, key: int) -> int:\\n if key in self.kv:\\n node = self.kv[key]\\n self.to_tail(node)\\n return node.value\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n \\n # first put\\n if self.head is None:\\n node = Node(key, value)\\n self.kv[key] = node\\n self.head = node\\n self.tail = node\\n return\\n\\n # put\\n if key not in self.kv:\\n node = Node(key, value, prev=self.tail)\\n self.tail.nex = node\\n self.tail = node\\n self.kv[key] = node\\n else:\\n # put this element to tail\\n node = self.kv[key]\\n self.to_tail(node)\\n node.value = value\\n\\n if len(self.kv) > self.capacity:\\n # delete from nodes\\n head_key = self.head.key\\n self.head = self.head.nex\\n self.head.prev = None\\n \\n # delete from kv\\n self.kv.pop(head_key)\\n \\n def to_tail(self, node: Node) -> None:\\n if node != self.tail:\\n if node == self.head:\\n self.head = node.nex\\n\\n node_prev = node.prev\\n node_next = node.nex\\n if node_prev is not None:\\n node_prev.nex = node_next\\n node_next.prev = node_prev\\n \\n self.tail.nex = node\\n node.prev = self.tail\\n node.nex = None\\n self.tail = node\\n\\n\\n\\n#\\n# [\\n# \\\"LRUCache\\\", 2\\n# \\\"put\\\", 1, 1\\n# \\\"put\\\", 2, 2\\n# \\\"get\\\", 1\\n# \\\"put\\\", 3, 3\\n# \\\"get\\\", 2\\n# \\\"put\\\", 4, 4\\n# \\\"get\\\", 1 \\n# \\\"get\\\", 3\\n# \\\"get\\\" 4\\n# ]\\n\\n# \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78100\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.next = None\\n self.prev = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.size = 0\\n self.nodes = {}\\n self.head = Node(0, 0)\\n self.head.next = self.head\\n self.head.prev = self.head\\n \\n\\n def get(self, key: int) -> int:\\n #print(f\\\"get {key}\\\")\\n val = -1\\n if key in self.nodes:\\n val = self.nodes[key].val\\n self.remove(self.nodes[key])\\n self.insert(self.head.next, self.nodes[key])\\n #self.print_cache()\\n return val\\n \\n\\n def put(self, key: int, value: int) -> None:\\n #print(f\\\"put {key}\\\")\\n if key in self.nodes:\\n self.nodes[key].val = value\\n self.remove(self.nodes[key])\\n self.insert(self.head.next, self.nodes[key])\\n else:\\n \\n node = Node(key, value)\\n self.nodes[key] = node\\n self.insert(self.head.next, node)\\n self.size += 1\\n\\n if self.size > self.capacity:\\n del self.nodes[self.head.prev.key]\\n self.remove(self.head.prev)\\n self.size -= 1\\n #self.print_cache()\\n\\n \\n def remove(self, a) -> None:\\n p = a.prev\\n n = a.next\\n p.next = a.next\\n n.prev = a.prev\\n\\n def insert(self, cur_node, node) -> None:\\n # insert behind cur\\n p = cur_node.prev\\n node.prev = p\\n p.next = node\\n node.next = cur_node\\n cur_node.prev = node\\n\\n def print_cache(self):\\n node = self.head.next\\n print(\\\"head -> \\\")\\n while (node is not self.head):\\n print(f\\\"{node.key}\\\" + \\\" -> \\\")\\n node = node.next\\n print(\\\"head X\\\")\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78200\"\n },\n {\n \"code\": \"class Node:\\n \\n def __init__(self, key, value):\\n self.key = key\\n self.val = value\\n self.prev = None\\n self.next = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.node_map = {}\\n self.head = Node(-1, -1) \\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n \\n def remove_node(self, node: Node):\\n n1 = node.prev\\n n2 = node.next\\n n1.next = n2\\n n2.prev = n1\\n\\n def move_to_tail(self, node: Node):\\n self.remove_node(node)\\n self.add_to_tail(node)\\n \\n def add_to_tail(self, node: Node):\\n last_node = self.tail.prev\\n last_node.next = node\\n node.prev = last_node\\n node.next = self.tail\\n self.tail.prev = node\\n\\n def get(self, key: int) -> int: \\n if key not in self.node_map:\\n return -1\\n node = self.node_map[key]\\n self.move_to_tail(node)\\n return node.val\\n \\n def put(self, key: int, value: int) -> None: \\n if key in self.node_map:\\n # update key if already exists in map \\n curr_node = self.node_map[key]\\n curr_node.val = value\\n self.move_to_tail(curr_node)\\n else: \\n if len(self.node_map) == self.capacity:\\n # need to remove least used key\\n lru_node = self.head.next\\n self.remove_node(lru_node)\\n del self.node_map[lru_node.key]\\n new_node = Node(key, value)\\n self.add_to_tail(new_node)\\n self.node_map[key] = new_node\\n\\n \\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78200\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int):\\n # Doubly Linked List (DLL)\\n self.key: int = key\\n self.value: int = value\\n self.prev: Node | None = None\\n self.next: Node | None = None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.head = Node(-1, -1)\\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.hash_map: dict[int, Node] = {}\\n self.capacity: int = capacity\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n def get(self, key: int) -> int:\\n node = self.hash_map.get(key)\\n if not node:\\n return -1\\n # Move the node to the tail (most recently used)\\n if node != self.tail.prev: # Optimization: move only if not already the most recent\\n self.remove(node)\\n self.add(node)\\n return node.value\\n\\n def add(self, node) -> None:\\n self.tail.prev.next = node\\n node.prev = self.tail.prev \\n node.next = self.tail\\n self.tail.prev = node\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hash_map:\\n self.remove(self.hash_map[key])\\n\\n node = Node(key, value) \\n self.hash_map[key] = node\\n self.add(node)\\n\\n if len(self.hash_map) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.hash_map[node_to_delete.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78300\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.capacity = capacity\\n self.left, self.right = LLNode(0, 0), LLNode(0, 0)\\n self.left.next, self.right.prev = self.right, self.left\\n\\n def insert(self, node):\\n prev, nxt = self.right.prev, self.right\\n prev.next = nxt.prev = node\\n node.prev, node.next = prev, nxt\\n\\n def remove(self, node):\\n prev, nxt = node.prev, node.next\\n prev.next, nxt.prev = nxt, prev\\n\\n def get(self, key: int) -> int:\\n if key not in self.cache:\\n return -1\\n node = self.cache[key]\\n self.remove(node)\\n self.insert(node)\\n return node.value\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.remove(self.cache[key])\\n node = LLNode(key, value)\\n self.cache[key] = node\\n self.insert(node)\\n if len(self.cache) > self.capacity:\\n lru_node = self.left.next\\n del self.cache[lru_node.key]\\n self.remove(lru_node)\\n\\n\\n \\nclass LLNode:\\n def __init__(self, key, value):\\n self.key, self.value = key, value\\n self.next = self.prev = None\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78300\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int):\\n # DDL\\n self.key, self.value, self.prev, self.next = key, value, None, None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.head = Node(-1, -1)\\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.hash_map = {}\\n self.capacity = capacity\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n def get(self, key: int) -> int:\\n if not key in self.hash_map:\\n return -1 \\n node = self.hash_map[key]\\n self.remove(node)\\n self.add(node)\\n return node.value\\n\\n def add(self, node):\\n previous_end = self.tail.prev\\n previous_end.next = node\\n node.prev = previous_end\\n node.next = self.tail\\n self.tail.prev = node\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hash_map:\\n self.remove(self.hash_map[key])\\n\\n node = Node(key, value) \\n self.hash_map[key] = node\\n self.add(node)\\n\\n if len(self.hash_map) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.hash_map[node_to_delete.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78400\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.prev = None\\n self.next = None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.hmap = {}\\n \\n # Create dummy head and tail nodes\\n self.head = Node(0, 0) # Least recently used\\n self.tail = Node(0, 0) # Most recently used\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n\\n def _remove(self, node):\\n \\\"\\\"\\\"Remove a node from the linked list.\\\"\\\"\\\"\\n prev_node = node.prev\\n next_node = node.next\\n prev_node.next = next_node\\n next_node.prev = prev_node\\n\\n def _add(self, node):\\n \\\"\\\"\\\"Add a node right before tail (most recently used).\\\"\\\"\\\"\\n prev_node = self.tail.prev\\n prev_node.next = node\\n node.prev = prev_node\\n node.next = self.tail\\n self.tail.prev = node\\n\\n def get(self, key: int) -> int:\\n if key in self.hmap:\\n node = self.hmap[key]\\n # Move accessed node to the end (most recently used)\\n self._remove(node)\\n self._add(node)\\n return node.val\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hmap:\\n # Update existing node and move it to most recently used position\\n node = self.hmap[key]\\n node.val = value\\n self._remove(node)\\n self._add(node)\\n else:\\n if len(self.hmap) == self.capacity:\\n # Remove least recently used item from cache and linked list\\n lru_node = self.head.next # This is the least recently used item\\n self._remove(lru_node)\\n del self.hmap[lru_node.key]\\n\\n # Create new node and add to hashmap and linked list\\n new_node = Node(key, value)\\n self.hmap[key] = new_node\\n self._add(new_node)\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78400\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, value):\\n self.key, self.value = key, value\\n self.prev, self.next = None, None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.cap = capacity\\n self.cache = {}\\n self.left, self.right = Node(0, 0), Node(0, 0)\\n self.left.next, self.right.prev = self.right, self.left\\n \\n def remove(self, node):\\n prev, nxt = node.prev, node.next\\n prev.next, nxt.prev = nxt, prev\\n\\n def insert(self, node):\\n prev, nxt = self.right.prev, self.right\\n prev.next, nxt.prev = node, node\\n node.prev, node.next = prev, nxt\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.remove(self.cache[key])\\n self.insert(self.cache[key])\\n return self.cache[key].value\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.remove(self.cache[key])\\n self.cache[key] = Node(key, value)\\n self.insert(self.cache[key])\\n if len(self.cache) > self.cap:\\n lru = self.left.next\\n self.remove(lru)\\n del self.cache[lru.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78500\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, val):\\n self.key, self.val = key, val\\n self.prev, self.next = None, None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n\\n self.left, self.right = Node(0, 0), Node(0, 0)\\n self.left.next, self.right.prev = self.right, self.left\\n\\n def add(self, node):\\n prev, nxt = self.right.prev, self.right\\n prev.next = nxt.prev = node\\n node.next, node.prev = nxt, prev\\n\\n def remove(self, node):\\n prev, nxt = node.prev, node.next\\n prev.next, nxt.prev = nxt, prev\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.remove(self.cache[key])\\n self.add(self.cache[key])\\n return self.cache[key].val\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.remove(self.cache[key])\\n self.cache[key] = Node(key, value)\\n self.add(self.cache[key])\\n\\n if len(self.cache) > self.capacity:\\n lru = self.left.next\\n self.remove(lru)\\n del self.cache[lru.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78500\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key, value):\\n self.key = key\\n self.value = value\\n self.next = self.prev = None\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.cache = {}\\n self.left, self.right = Node(-1, -1), Node(-1, -1)\\n self.left.next, self.right.prev = self.right, self.left\\n \\n def insert(self, node):\\n prev, nxt = self.right.prev, self.right\\n node.prev, node.next = prev, nxt\\n prev.next, nxt.prev = node, node\\n \\n def delete(self, node):\\n prev, nxt = node.prev, node.next\\n prev.next, nxt.prev = nxt, prev \\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.delete(self.cache[key])\\n self.insert(self.cache[key])\\n return self.cache[key].value\\n \\n return -1\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.delete(self.cache[key])\\n self.cache[key] = Node(key, value)\\n self.insert(self.cache[key])\\n\\n if len(self.cache) > self.capacity:\\n lru = self.left.next\\n self.delete(lru)\\n del self.cache[lru.key]\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78600\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, key, val):\\n self.key = key\\n self.val = val\\n self.next = None\\n self.prev = None\\n\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.dic = {}\\n self.head = ListNode(-1, -1)\\n self.tail = ListNode(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n\\n def get(self, key: int) -> int:\\n if key not in self.dic:\\n return -1\\n\\n node = self.dic[key]\\n self.remove(node)\\n self.add(node)\\n return node.val\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.dic:\\n old_node = self.dic[key]\\n self.remove(old_node)\\n\\n node = ListNode(key, value)\\n self.dic[key] = node\\n self.add(node)\\n\\n if len(self.dic) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.dic[node_to_delete.key]\\n\\n def add(self, node):\\n previous_end = self.tail.prev\\n previous_end.next = node\\n node.prev = previous_end\\n node.next = self.tail\\n self.tail.prev = node\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78600\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n 'initialize'\\n self.cache = {x: None for x in range(capacity)}\\n self.dll = Node(None, None)\\n self.dllCount = 0\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n val = self.cache.get(key, -1)\\n if not val or val == -1:\\n return -1\\n\\n # now move the value to the head\\n self.dll.drop(val)\\n self.dll.add(val)\\n # print('after get')\\n # print(self.dll)\\n return val.val\\n \\n\\n def put(self, key: int, value: int) -> None:\\n newNode = Node(key, value)\\n if key in self.cache and self.cache[key] != None:\\n self.dll.drop(self.cache[key])\\n\\n self.dll.add(newNode)\\n # if the key is in the cache, we have to drop it from the list and move it to the head\\n\\n\\n # make sure we are not over capacity\\n if key not in self.cache or self.cache[key] == None:\\n self.dllCount += 1\\n\\n if self.dllCount > self.capacity:\\n oldTail = self.dll.tail\\n self.dll.drop(oldTail)\\n del self.cache[oldTail.key]\\n self.dllCount -= 1\\n \\n # if we're not updating, we are inserting, so bump up the count\\n\\n # update the cache\\n self.cache[key] = newNode\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\\n\\nclass Node:\\n 'a doubly linked list'\\n\\n def __init__(self, key, val):\\n self.head = None\\n self.tail = None\\n\\n self.key = key\\n self.val = val\\n\\n self.next = None\\n self.prev = None\\n\\n def add(self, node):\\n 'add a node to the head'\\n node.next = self.head\\n node.prev = None\\n\\n self.head = node\\n if self.head.next:\\n self.head.next.prev = node\\n\\n if not self.tail:\\n self.tail = node\\n\\n def drop(self, node):\\n '''\\n drop a node by reassigning its surrounding pointers.\\n if necessary, reassign head and tail of the DLL\\n '''\\n\\n if node.next:\\n node.next.prev = node.prev\\n if node.prev:\\n node.prev.next = node.next\\n\\n if node == self.head:\\n self.head = node.next\\n if node == self.tail:\\n self.tail = node.prev\\n\\n def __str__(self):\\n res = ''\\n node = self.head\\n while node:\\n res += f'{node.val}'\\n node = node.next\\n return res\\n\",\n \"memory\": \"78700\"\n },\n {\n \"code\": \"class DLLNode:\\n\\n def __init__(self, key=-1, val=-1, next=None, prev=None):\\n self.key = key\\n self.val = val\\n self.prev = prev\\n self.next = next\\n\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.store = OrderedDict()\\n self.capacity = capacity\\n self.head = DLLNode()\\n self.tail = DLLNode()\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n\\n def get(self, key: int) -> int:\\n if key not in self.store:\\n return -1\\n\\n self.moveNodeToHead(self.store[key])\\n return self.store[key].val\\n \\n\\n def put(self, key: int, value: int) -> None:\\n if key not in self.store:\\n if len(self.store) == self.capacity:\\n self.evictTailNode()\\n node = DLLNode(key, value)\\n else:\\n node = self.store[key]\\n node.val = value\\n \\n self.store[key] = node\\n self.moveNodeToHead(node)\\n\\n \\n def moveNodeToHead(self, node):\\n if node.prev == self.head: return\\n if len(self.store) == 1:\\n self.head.next = node\\n node.prev = self.head\\n self.tail.prev = node\\n node.next = self.tail\\n return\\n p, n = node.prev, node.next\\n if p and n:\\n p.next, n.prev = n, p\\n temp = self.head.next\\n temp.prev = node\\n node.next = temp\\n self.head.next = node\\n node.prev = self.head\\n \\n def evictTailNode(self):\\n node = self.tail.prev\\n temp = node.prev\\n temp.next = self.tail\\n self.tail.prev = temp\\n self.store.pop(node.key)\\n del node\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78700\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n 'initialize'\\n self.cache = {x: None for x in range(capacity)}\\n self.dll = Node(None, None)\\n self.dllCount = 0\\n self.capacity = capacity\\n\\n def get(self, key: int) -> int:\\n val = self.cache.get(key, -1)\\n if not val or val == -1:\\n return -1\\n\\n # now move the value to the head\\n self.dll.drop(val)\\n self.dll.add(val)\\n # print('after get')\\n # print(self.dll)\\n return val.val\\n \\n\\n def put(self, key: int, value: int) -> None:\\n newNode = Node(key, value)\\n if key in self.cache and self.cache[key] != None:\\n self.dll.drop(self.cache[key])\\n\\n self.dll.add(newNode)\\n # if the key is in the cache, we have to drop it from the list and move it to the head\\n\\n\\n # make sure we are not over capacity\\n if key not in self.cache or self.cache[key] == None:\\n self.dllCount += 1\\n\\n if self.dllCount > self.capacity:\\n oldTail = self.dll.tail\\n self.dll.drop(oldTail)\\n del self.cache[oldTail.key]\\n self.dllCount -= 1\\n \\n # if we're not updating, we are inserting, so bump up the count\\n\\n # update the cache\\n self.cache[key] = newNode\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\\n\\nclass Node:\\n 'a doubly linked list'\\n\\n def __init__(self, key, val):\\n self.head = None\\n self.tail = None\\n\\n self.key = key\\n self.val = val\\n\\n self.next = None\\n self.prev = None\\n\\n def add(self, node):\\n 'add a node to the head'\\n node.next = self.head\\n node.prev = None\\n\\n self.head = node\\n if self.head.next:\\n self.head.next.prev = node\\n\\n if not self.tail:\\n self.tail = node\\n\\n def drop(self, node):\\n '''\\n drop a node by reassigning its surrounding pointers.\\n if necessary, reassign head and tail of the DLL\\n '''\\n\\n if node.next:\\n node.next.prev = node.prev\\n if node.prev:\\n node.prev.next = node.next\\n\\n if node == self.head:\\n self.head = node.next\\n if node == self.tail:\\n self.tail = node.prev\\n\\n def __str__(self):\\n res = ''\\n node = self.head\\n while node:\\n res += f'{node.val}'\\n node = node.next\\n return res\\n\",\n \"memory\": \"78800\"\n },\n {\n \"code\": \"class DataNode:\\n previous_node = None\\n node = None\\n next_node = None\\n value = None\\n\\n def __init__(self, node, value, previous_node=None, next_node=None):\\n self.node = node\\n self.value = value\\n self.previous_node = previous_node\\n self.next_node = next_node\\n\\n\\nclass LRUCache:\\n def __init__(self, capacity):\\n self.data_dict = {}\\n self.previous_node = None\\n self.next_node = None\\n self.capacity = capacity or 1\\n\\n def get(self, key):\\n if self.data_dict.get(key) is None:\\n return -1\\n\\n node = self.data_dict[key].node\\n value = self.data_dict[key].value\\n self.removing(node)\\n self.adding(node, value)\\n return value\\n\\n def put(self, key, value):\\n if key in self.data_dict:\\n self.removing(key)\\n elif len(self.data_dict) == self.capacity:\\n self.removing(next(iter(self.data_dict)))\\n\\n self.adding(key, value)\\n\\n def adding(self, node, value):\\n if len(self.data_dict) == 0:\\n self.data_dict[node] = DataNode(node=node, value=value)\\n else:\\n self.data_dict[node] = DataNode(\\n node=node, value=value, previous_node=self.previous_node\\n )\\n self.previous_node.next_node = self.data_dict[node]\\n\\n self.previous_node = self.data_dict[node]\\n\\n def removing(self, node):\\n if getattr(self.data_dict[node], \\\"previous_node\\\") is not None:\\n self.data_dict[node].previous_node.next_node = self.data_dict[\\n node\\n ].next_node\\n if getattr(self.data_dict[node], \\\"next_node\\\") is not None:\\n self.data_dict[node].next_node.previous_node = self.data_dict[\\n node\\n ].previous_node\\n self.data_dict.pop(node)\\n\",\n \"memory\": \"78900\"\n },\n {\n \"code\": \"class LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.head = {}\\n self.tail = {}\\n self.head['next'] = self.tail\\n self.tail['prev'] = self.head\\n self.c = capacity\\n self.map = {}\\n\\n def get(self, key: int) -> int:\\n if key not in self.map:\\n return -1\\n\\n item = self.map[key]\\n x = item['prev']\\n y = item['next']\\n x['next'] = y\\n y['prev'] = x\\n\\n head = self.head['next']\\n self.head['next'] = item\\n item['prev'] = self.head\\n head['prev'] = item\\n item['next'] = head\\n\\n return item['val']\\n\\n def put(self, key: int, value: int) -> None:\\n self.map[key] = {} if key not in self.map else self.map[key]\\n self.map[key]['val'] = value\\n self.map[key]['key'] = key\\n\\n item = self.map[key]\\n if 'prev' in self.map[key]:\\n x = item['prev']\\n y = item['next']\\n x['next'] = y\\n y['prev'] = x\\n\\n head = self.head['next']\\n self.head['next'] = item\\n item['prev'] = self.head\\n head['prev'] = item\\n item['next'] = head\\n\\n if len(self.map) > self.c:\\n last = self.tail['prev']\\n last_prev = last['prev']\\n last_prev['next'] = self.tail\\n self.tail['prev'] = last_prev\\n del self.map[last['key']]\\n\\n\\n\\n\\n \\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"78900\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int):\\n # Doubly Linked List (DLL)\\n self.key: int = key\\n self.value: int = value\\n self.prev: Node | None = None\\n self.next: Node | None = None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.head = Node(-1, -1)\\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.hash_map: dict[int, Node] = {}\\n self.capacity: int = capacity\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n def get(self, key: int) -> int:\\n node = self.hash_map.get(key)\\n if not node:\\n return -1\\n # Move the node to the tail (most recently used)\\n if node != self.tail.prev: # Optimization: move only if not already the most recent\\n self.remove(node)\\n self.add(node)\\n return node.value\\n\\n def add(self, node) -> None:\\n self.tail.prev.next = node\\n node.prev = self.tail.prev \\n node.next = self.tail\\n self.tail.prev = node\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hash_map:\\n node = self.hash_map[key] \\n node.value = value\\n self.remove(node)\\n else:\\n node = Node(key, value) \\n self.hash_map[key] = node\\n\\n self.add(node)\\n\\n if len(self.hash_map) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.hash_map[node_to_delete.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"79000\"\n },\n {\n \"code\": \"class LRUCache:\\n def _removeNode(self, node):\\n prev = node[\\\"prev\\\"]\\n nxt = node[\\\"next\\\"]\\n prev[\\\"next\\\"] = nxt\\n nxt[\\\"prev\\\"] = prev\\n\\n def _moveToHead(self, node):\\n self._removeNode(node)\\n self._addToHead(node)\\n \\n def _addToHead(self, node):\\n prev = self.head[\\\"prev\\\"]\\n prev[\\\"next\\\"] = node\\n node[\\\"prev\\\"] = prev\\n node[\\\"next\\\"] = self.head\\n self.head[\\\"prev\\\"] = node\\n \\n def _popTail(self):\\n node = self.tail[\\\"next\\\"]\\n self._removeNode(node)\\n return node[\\\"key\\\"]\\n\\n def __init__(self, capacity: int):\\n self.cache = {}\\n self.head = { \\\"val\\\": None, \\\"key\\\": None, \\\"next\\\": None, \\\"prev\\\": None }\\n self.tail = { \\\"val\\\": None, \\\"key\\\": None, \\\"next\\\": None, \\\"prev\\\": None }\\n self.head[\\\"prev\\\"] = self.tail\\n self.tail[\\\"next\\\"] = self.head\\n self.max_capacity = capacity\\n self.capacity = 0\\n\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n node = self.cache[key]\\n self._moveToHead(node)\\n return node[\\\"val\\\"]\\n else:\\n return -1\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n node = self.cache[key]\\n node[\\\"val\\\"] = value\\n self._moveToHead(node)\\n else:\\n node = { \\\"val\\\": value, \\\"key\\\": key, \\\"next\\\": None, \\\"prev\\\": None }\\n self._addToHead(node)\\n self.cache[key] = node\\n self.capacity += 1\\n if self.capacity > self.max_capacity:\\n self.capacity -= 1\\n key = self._popTail()\\n del self.cache[key]\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"79000\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int):\\n # Doubly Linked List (DLL)\\n self.key: int = key\\n self.value: int = value\\n self.prev: Node | None = None\\n self.next: Node | None = None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.head = Node(-1, -1)\\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.hash_map: dict[int, Node] = {}\\n self.capacity: int = capacity\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n def get(self, key: int) -> int:\\n node = self.hash_map.get(key)\\n if not node:\\n return -1\\n # Move the node to the tail (most recently used)\\n if node != self.tail.prev: # Optimization: move only if not already the most recent\\n self.remove(node)\\n self.add(node)\\n return node.value\\n\\n def add(self, node) -> None:\\n self.tail.prev.next = node\\n node.prev = self.tail.prev \\n node.next = self.tail\\n self.tail.prev = node\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hash_map:\\n node = self.hash_map[key] \\n node.value = value\\n self.remove(node)\\n else:\\n node = Node(key, value) \\n self.hash_map[key] = node\\n\\n self.add(node)\\n\\n if len(self.hash_map) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.hash_map[node_to_delete.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"79100\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, key: int, value: int):\\n # Doubly Linked List (DLL)\\n self.key: int = key\\n self.value: int = value\\n self.prev: Node | None = None\\n self.next: Node | None = None\\n\\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.head = Node(-1, -1)\\n self.tail = Node(-1, -1)\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.hash_map: dict[int, Node] = {}\\n self.capacity: int = capacity\\n\\n def remove(self, node):\\n node.prev.next = node.next\\n node.next.prev = node.prev\\n\\n def get(self, key: int) -> int:\\n node = self.hash_map.get(key)\\n if not node:\\n return -1\\n # Move the node to the tail (most recently used)\\n if node != self.tail.prev: # Optimization: move only if not already the most recent\\n self.remove(node)\\n self.add(node)\\n return node.value\\n\\n def add(self, node) -> None:\\n self.tail.prev.next = node\\n node.prev = self.tail.prev \\n node.next = self.tail\\n self.tail.prev = node\\n\\n def put(self, key: int, value: int) -> None:\\n if key in self.hash_map:\\n # If key exists, update the value and move to the most recent position\\n node = self.hash_map[key]\\n node.value = value\\n self.remove(node)\\n else:\\n # Create a new node if key is not in the cache\\n node = Node(key, value)\\n self.hash_map[key] = node\\n \\n # Add the node as the most recently used\\n self.add(node)\\n\\n if len(self.hash_map) > self.capacity:\\n node_to_delete = self.head.next\\n self.remove(node_to_delete)\\n del self.hash_map[node_to_delete.key]\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"79100\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, key = 0, val = None, next = None, prev = None):\\n self.key = key\\n self.val = val\\n self.next = next\\n self.prev = prev\\n \\nclass LRUCache:\\n def __init__(self, capacity: int):\\n self.head = ListNode()\\n self.tail = ListNode()\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.capacity = capacity\\n self.length = 0\\n self.cache = {}\\n def add(self, node):\\n node.prev = self.tail.prev\\n node.next = self.tail\\n self.tail.prev.next = node\\n self.tail.prev = node\\n def pop(self, node):\\n node.next.prev = node.prev\\n node.prev.next = node.next\\n def get(self, key: int) -> int:\\n if key in self.cache:\\n self.pop(self.cache[key]) \\n self.add(self.cache[key]) \\n return self.cache[key].val\\n return -1\\n def put(self, key: int, value: int) -> None:\\n if key in self.cache:\\n self.pop(self.cache[key])\\n self.cache[key] = ListNode(key, value)\\n self.add(self.cache[key])\\n \\n if len(self.cache) > self.capacity:\\n node = self.head.next\\n self.pop(node) \\n del self.cache[node.key]\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"79200\"\n },\n {\n \"code\": \"class Node:\\n key = None\\n value = None\\n previous = None\\n next = None\\n\\n\\nclass LRUCache:\\n\\n def __init__(self, capacity: int):\\n self.capacity = capacity\\n self.head = Node()\\n self.last = Node()\\n self.head.next = self.last\\n self.last.previous = self.head\\n self.dict = {}\\n self.size = 0\\n\\n def _add_node(self, node):\\n node.next = self.head.next\\n node.previous = self.head\\n\\n self.head.next.previous = node\\n self.head.next = node\\n\\n def _remove_node(self, node):\\n node.previous.next = node.next\\n node.next.previous = node.previous\\n\\n def _move_to_head(self, node):\\n self._remove_node(node)\\n self._add_node(node)\\n\\n def _pop_tail(self):\\n res = self.last.previous\\n self._remove_node(res)\\n return res\\n\\n def get(self, key: int) -> int:\\n node = self.dict.get(key, None)\\n if not node:\\n return -1\\n self._move_to_head(node)\\n return node.value\\n\\n def put(self, key: int, value: int) -> None:\\n node = self.dict.get(key)\\n\\n if not node:\\n newNode = Node()\\n newNode.key = key\\n newNode.value = value\\n\\n self.dict[key] = newNode\\n self._add_node(newNode)\\n\\n self.size += 1\\n\\n if self.size > self.capacity:\\n # pop the tail\\n tail = self._pop_tail()\\n del self.dict[tail.key]\\n self.size -= 1\\n else:\\n # update the value.\\n node.value = value\\n self._move_to_head(node)\\n\\n\\n# Your LRUCache object will be instantiated and called as such:\\n# obj = LRUCache(capacity)\\n# param_1 = obj.get(key)\\n# obj.put(key,value)\",\n \"memory\": \"79200\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":71,"string":"71"}}},{"rowIdx":51,"cells":{"question_id":{"kind":"number","value":147,"string":"147"},"name":{"kind":"string","value":"insertion-sort-list"},"content":{"kind":"string","value":"<p>Given the <code>head</code> of a singly linked list, sort the list using <strong>insertion sort</strong>, and return <em>the sorted list's head</em>.</p>\n\n<p>The steps of the <strong>insertion sort</strong> algorithm:</p>\n\n<ol>\n\t<li>Insertion sort iterates, consuming one input element each repetition and growing a sorted output list.</li>\n\t<li>At each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list and inserts it there.</li>\n\t<li>It repeats until no input elements remain.</li>\n</ol>\n\n<p>The following is a graphical example of the insertion sort algorithm. The partially sorted list (black) initially contains only the first element in the list. One element (red) is removed from the input data and inserted in-place into the sorted list with each iteration.</p>\n<img alt=\"\" src=\"https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif\" style=\"height:180px; width:300px\" />\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/03/04/sort1linked-list.jpg\" style=\"width: 422px; height: 222px;\" />\n<pre>\n<strong>Input:</strong> head = [4,2,1,3]\n<strong>Output:</strong> [1,2,3,4]\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/03/04/sort2linked-list.jpg\" style=\"width: 542px; height: 222px;\" />\n<pre>\n<strong>Input:</strong> head = [-1,5,3,4,0]\n<strong>Output:</strong> [-1,0,3,4,5]\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of nodes in the list is in the range <code>[1, 5000]</code>.</li>\n\t<li><code>-5000 <= Node.val <= 5000</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":54.56627705633785,"string":"54.566277"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["linked-list","sorting"],"string":"[\n \"linked-list\",\n \"sorting\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"30\", 3.3314999999999997], [\"44\", 11.3875], [\"57\", 3.8289999999999997], [\"71\", 19.4431], [\"84\", 5.320699999999999], [\"98\", 0.9948], [\"112\", 0.1492], [\"125\", 0.0497], [\"139\", 0.0497], [\"152\", 0.0497], [\"166\", 0.0497], [\"179\", 0.0497], [\"193\", 0.0497], [\"206\", 0.0497], [\"220\", 0.0497], [\"234\", 0.0497], [\"247\", 0.0497], [\"261\", 0.0497], [\"274\", 0.0497], [\"288\", 0.0497], [\"301\", 0.1988], [\"315\", 0.0497], [\"328\", 0.0995], [\"342\", 0.2486], [\"355\", 0.6962], [\"369\", 1.7902], [\"383\", 3.7792], [\"396\", 9.448], [\"410\", 9.796299999999999], [\"423\", 5.7682], [\"437\", 2.1383], [\"450\", 0.5967], [\"464\", 0.7459], [\"477\", 0.3977], [\"491\", 0.1988], [\"505\", 0.49720000000000003], [\"518\", 0.5469], [\"532\", 0.5967], [\"545\", 0.7459], [\"559\", 0.2982], [\"572\", 0.6463], [\"586\", 0.5471], [\"599\", 0.547], [\"613\", 0.7957], [\"626\", 0.34790000000000004], [\"640\", 0.39790000000000003], [\"654\", 0.2982], [\"667\", 0.895], [\"681\", 1.2931], [\"694\", 0.9945999999999999], [\"708\", 0.547], [\"721\", 0.49720000000000003], [\"735\", 0.1988], [\"748\", 0.2485], [\"762\", 0.1988], [\"776\", 0.1988], [\"789\", 0.1988], [\"803\", 0.2983], [\"816\", 0.3481], [\"830\", 0.1988], [\"843\", 0.0994], [\"857\", 0.0497], [\"870\", 0.1988], [\"884\", 0.0497], [\"897\", 0.0497], [\"911\", 0.0497], [\"925\", 0.0497], [\"938\", 0.0497], [\"952\", 0.0497], [\"965\", 0.0497], [\"979\", 0.0995], [\"992\", 0.0497], [\"1006\", 0.1491], [\"1019\", 0.1492], [\"1033\", 0.0497], [\"1047\", 0.0497], [\"1060\", 0.0497], [\"1074\", 0.0995], [\"1087\", 0.0497], [\"1101\", 0.0995]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"18100\", 0.0995], [\"18200\", 0.2486], [\"18300\", 3.7295], [\"18400\", 21.4321], [\"18500\", 36.7976], [\"18600\", 19.7911], [\"18700\", 7.6579]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head==None:\n return\n \n temparr = []\n temp = head\n while temp!=None:\n temparr.append(temp.val)\n temp=temp.next\n \n temparr.sort()\n \n temp = head\n i=0\n while temp!=None:\n temp.val = temparr[i]\n i+=1\n temp = temp.next\n \n return head\n \n \n \n ","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n result = []\n\n while head:\n result.append(head.val)\n head = head.next\n\n result.sort(reverse = True)\n\n answer = ListNode(result[0])\n\n for i in result[1:]:\n answer = ListNode(i, answer) \n\n return answer","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n values = []\n dict_list = {}\n curr = head\n while curr:\n values.append(curr.val)\n if curr.val not in dict_list:\n dict_list[curr.val] = [curr]\n else:\n dict_list[curr.val].append(curr)\n curr = curr.next\n \n values = sorted(values)\n\n for i in range(len(values) - 1):\n for j in range(len(dict_list[values[i]]) - 1):\n dict_list[values[i]][j].next = dict_list[values[i]][j+1]\n dict_list[values[i]][-1].next = dict_list[values[i+1]][0]\n \n for j in range(len(dict_list[values[-1]]) - 1):\n dict_list[values[-1]][j].next = dict_list[values[-1]][j+1]\n dict_list[values[-1]][-1].next = None\n return dict_list[values[0]][0]","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n vals=[]\n while head:\n vals.append(head.val)\n head=head.next\n vals.sort()\n dummy=ListNode()\n curr=dummy\n for item in vals:\n curr.next=ListNode(item)\n curr=curr.next\n return dummy.next\n ","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def makeALink(values):\n if not values:\n return None\n head = ListNode(values[0])\n current = head\n for val in values[1:]:\n current.next = ListNode(val)\n current = current.next\n return head\n def insert_sorted(lst, val):\n left, right = 0, len(lst)\n while left < right:\n mid = (left + right) // 2\n if lst[mid] < val:\n left = mid + 1\n else:\n right = mid\n lst.insert(left, val)\n return lst\n \n final = []\n while head:\n final = insert_sorted(final, head.val)\n head = head.next\n return makeALink(final)","runtime":"57"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n self.digits = []\n self._bfs_collect_digits(head)\n if not self.digits:\n return None\n\n self.digits.sort()\n self.list_node = ListNode(self.digits.pop(0))\n self._bfs_build_nodes(self.list_node)\n return self.list_node\n \n def _bfs_collect_digits(self, node: ListNode) -> list[int]:\n if node is not None:\n if node.next: # Can extend.\n self._bfs_collect_digits(node.next)\n self.digits.append(node.val)\n return\n \n def _bfs_build_nodes(self, list_node: ListNode) -> None:\n if self.digits: # Still remaining digits.\n list_node.next = ListNode(self.digits.pop(0))\n self._bfs_build_nodes(list_node.next)\n return\n","runtime":"57"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(val=-5001)\n cur, nxt = head, None # for giving list\n pre, tail = dummy, dummy\n while cur:\n nxt = cur.next\n cur.next = None\n # 1. cur bigger than largest one\n if tail.val <= cur.val:\n tail.next = cur # put cur at the tail\n tail = tail.next\n cur = nxt\n continue\n # 2. cur will insert before largest one\n node = dummy # for output list, reset every time\n while cur.val >= node.val:\n pre, node = node, node.next # iterate next\n pre.next, cur.next = cur, node # insert cur between pre and node\n\n cur = nxt\n return dummy.next","runtime":"71"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return head\n \n dummy = ListNode(0)\n dummy.next = head\n curr = head.next\n lastSorted = head\n\n while curr:\n if lastSorted.val <= curr.val:\n lastSorted = lastSorted.next\n else:\n prev = dummy\n while prev.next.val <= curr.val:\n prev = prev.next\n lastSorted.next = curr.next\n curr.next = prev.next\n prev.next = curr\n curr = lastSorted.next\n return dummy.next\n","runtime":"71"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return head\n\n dummy_head = ListNode(-float(inf))\n last_sorted = head\n cur = last_sorted.next\n dummy_head.next = last_sorted\n # print(dummy_head)\n\n while cur is not None:\n # print(\"==\"*5)\n # print(dummy_head.next)\n # print('\\n')\n prev = dummy_head\n if cur.val < last_sorted.val:\n while prev.next.val < cur.val:\n prev = prev.next\n\n last_sorted.next = cur.next\n\n # print(\"ls\", last_sorted)\n # print(\"prev\", prev.next)\n ##cur.next = last_sorted # wrong\n cur.next = prev.next\n prev.next = cur\n\n cur = last_sorted.next\n else:\n last_sorted = last_sorted.next\n cur = cur.next\n\n return dummy_head.next\n","runtime":"84"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # Edge case: if the list is empty or has only one node, it's already sorted\n if not head or not head.next:\n return head\n\n # Initialize a dummy node to act as the head of the sorted part of the list\n dummy = ListNode(0) # dummy node with a value of 0\n dummy.next = head \n curr = head\n \n while curr.next:\n if curr.val <= curr.next.val:\n curr = curr.next\n else:\n prev = dummy\n to_insert = curr.next\n\n while prev.next and prev.next.val < to_insert.val:\n prev = prev.next\n\n curr.next = curr.next.next\n to_insert.next = prev.next\n prev.next = to_insert\n \n return dummy.next\n \n \n \n ","runtime":"84"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n if not head or not head.next:\n return head\n \n curr = head\n new_head = ListNode(0)\n new_head.next = head\n new_curr = new_head\n\n while curr:\n if curr.next and curr.val> curr.next.val:\n while new_curr.next and new_curr.next.val < curr.next.val:\n new_curr= new_curr.next\n temp = new_curr.next\n new_curr.next = curr.next\n curr.next = curr.next.next\n new_curr.next.next = temp\n new_curr = new_head\n else:\n curr = curr.next\n return new_head.next\n\n","runtime":"98"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head.next == None:\n return head\n prev = head\n node = head.next\n while node != None:\n if node.val >= prev.val:\n prev = node\n node = node.next\n else:\n curr = node.val\n prev.next = node.next\n node = prev.next\n curr_node = head\n print(curr)\n while True:\n if curr <= curr_node.val:\n head = ListNode(val=curr, next=curr_node)\n break\n elif curr > curr_node.val and curr <= curr_node.next.val:\n next_node = curr_node.next\n curr_node.next = ListNode(val=curr, next=next_node)\n break\n else:\n curr_node = curr_node.next\n \n return head\n ","runtime":"98"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0)\n dummy.next = head\n pre, cur = dummy, head\n while cur:\n if cur.next and cur.next.val < cur.val:\n while pre.next and pre.next.val < cur.next.val:\n pre = pre.next\n temp = pre.next\n pre.next = cur.next\n cur.next = cur.next.next\n pre.next.next = temp\n pre = dummy\n else:\n cur = cur.next\n return dummy.next","runtime":"112"},{"code":"class Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # 创建一个虚拟节点，它的 next 指向链表的头节点\n\n dummy = ListNode(0)\n dummy.next = head\n curr = head\n\n while curr and curr.next:\n if curr.val <= curr.next.val:\n curr = curr.next\n continue\n\n to_insert = curr.next\n prev = dummy\n \n while prev.next and prev.next.val <= to_insert.val:\n prev = prev.next\n \n curr.next = to_insert.next\n to_insert.next = prev.next\n prev.next = to_insert\n \n return dummy.next\n\n","runtime":"112"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n temp=head\n val={}\n nodes=[]\n\n while temp is not None:\n if temp.val not in val.keys():\n val[temp.val]=[temp]\n else:\n val[temp.val]=[*val[temp.val],temp]\n if temp.val not in nodes:\n nodes.append(temp.val)\n temp=temp.next\n\n nodes.sort()\n ans=[]\n\n for i in range(len(nodes)):\n ans.extend(val[nodes[i]])\n\n head=ans[0]\n temp=head\n count=1\n\n while temp is not None:\n if count < len(ans):\n temp.next=ans[count]\n if count==len(ans):\n temp.next=None\n temp=temp.next\n count+=1\n \n return head","runtime":"125"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n temp=head\n val={}\n nodes=[]\n\n while temp is not None:\n if temp.val not in val.keys():\n val[temp.val]=[temp]\n else:\n val[temp.val]=[*val[temp.val],temp]\n if temp.val not in nodes:\n nodes.append(temp.val)\n temp=temp.next\n\n nodes.sort()\n ans=[]\n\n for i in range(len(nodes)):\n print(i)\n ans.extend(val[nodes[i]])\n\n head=ans[0]\n temp=head\n count=1\n\n while temp is not None:\n if count < len(ans):\n temp.next=ans[count]\n if count==len(ans):\n temp.next=None\n temp=temp.next\n count+=1\n \n return head","runtime":"139"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(float('-inf'), head) \n \n previous = new_head\n node = head\n while node:\n node.previous = previous\n previous = node\n node = node.next\n\n node = head\n while node:\n \n curr = node.previous\n while node.val < curr.val:\n curr = curr.previous\n \n if node.previous == curr:\n node = node.next\n continue\n \n node_previous = node.previous\n node_next = node.next\n node_previous.next = node_next\n if node_next:\n node_next.previous = node_previous\n\n curr_next = curr.next\n curr.next = node\n node.next = curr_next\n node.previous = curr\n curr_next.previous = node\n\n node = node_next\n \n return new_head.next\n","runtime":"152"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(float('-inf'), head)\n \n previous = new_head\n node = head\n while node:\n node.previous = previous\n previous = node\n node = node.next\n\n node = head\n while node:\n \n curr = node.previous\n while node.val < curr.val:\n curr = curr.previous\n \n if node.previous == curr:\n node = node.next\n continue\n \n node_previous = node.previous\n node_next = node.next\n node_previous.next = node_next\n if node_next:\n node_next.previous = node_previous\n\n curr_next = curr.next\n curr.next = node\n node.next = curr_next\n node.previous = curr\n curr_next.previous = node\n\n node = node_next\n \n return new_head.next\n","runtime":"166"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(float('-inf'), head)\n \n previous = new_head\n node = head\n while node:\n node.previous = previous\n previous = node\n node = node.next\n\n node = head\n while node:\n \n curr = node.previous\n while node.val < curr.val:\n curr = curr.previous\n \n if node.previous == curr:\n node = node.next\n continue\n \n node_previous = node.previous\n node_next = node.next\n node_previous.next = node_next\n if node_next:\n node_next.previous = node_previous\n\n curr_next = curr.next\n curr.next = node\n node.next = curr_next\n node.previous = curr\n curr_next.previous = node\n\n node = node_next\n \n return new_head.next\n","runtime":"179"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(float('-inf'), head)\n \n previous = new_head\n node = head\n while node:\n node.previous = previous\n previous = node\n node = node.next\n\n node = head\n while node:\n \n curr = node.previous\n while node.val < curr.val:\n curr = curr.previous\n \n if node.previous == curr:\n node = node.next\n continue\n \n node_previous = node.previous\n node_next = node.next\n node_previous.next = node_next\n if node_next:\n node_next.previous = node_previous\n\n curr_next = curr.next\n curr.next = node\n node.next = curr_next\n node.previous = curr\n curr_next.previous = node\n\n node = node_next\n \n return new_head.next\n","runtime":"193"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(float('-inf'), head) \n \n previous = new_head\n node = head\n while node:\n node.previous = previous\n previous = node\n node = node.next\n\n node = head\n while node:\n \n curr = node.previous\n if node.val > curr.val:\n node = node.next\n continue\n\n while node.val < curr.val:\n curr = curr.previous\n \n if node.previous == curr:\n node = node.next\n continue\n \n node_previous = node.previous\n node_next = node.next\n node_previous.next = node_next\n if node_next:\n node_next.previous = node_previous\n\n curr_next = curr.next\n curr.next = node\n node.next = curr_next\n node.previous = curr\n curr_next.previous = node\n\n node = node_next\n \n return new_head.next\n","runtime":"206"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(float('-inf'), head) \n \n previous = new_head\n node = head\n while node:\n node.previous = previous\n previous = node\n node = node.next\n\n node = head\n while node:\n \n curr = node.previous\n if node.val > curr.val:\n node = node.next\n continue\n\n while node.val < curr.val:\n curr = curr.previous\n \n if node.previous == curr:\n node = node.next\n continue\n \n node_previous = node.previous\n node_next = node.next\n node_previous.next = node_next\n if node_next:\n node_next.previous = node_previous\n\n curr_next = curr.next\n curr.next = node\n node.next = curr_next\n node.previous = curr\n curr_next.previous = node\n\n node = node_next\n \n return new_head.next\n","runtime":"220"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(float('-inf'), head)\n \n previous = new_head\n node = head\n while node:\n node.previous = previous\n previous = node\n node = node.next\n\n node = head\n while node:\n \n curr = node.previous\n while node.val < curr.val:\n curr = curr.previous\n \n if node.previous == curr:\n node = node.next\n continue\n \n node_previous = node.previous\n node_next = node.next\n node_previous.next = node_next\n if node_next:\n node_next.previous = node_previous\n\n curr_next = curr.next\n curr.next = node\n node.next = curr_next\n node.previous = curr\n curr_next.previous = node\n\n node = node_next\n \n return new_head.next\n","runtime":"247"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(float('-inf'), head) \n \n previous = new_head\n node = head\n while node:\n node.previous = previous\n previous = node\n node = node.next\n\n node = head\n while node:\n \n curr = node.previous\n if node.val > curr.val:\n node = node.next\n continue\n\n while node.val < curr.val:\n curr = curr.previous\n \n if node.previous == curr:\n node = node.next\n continue\n \n node_previous = node.previous\n node_next = node.next\n node_previous.next = node_next\n if node_next:\n node_next.previous = node_previous\n\n curr_next = curr.next\n curr.next = node\n node.next = curr_next\n node.previous = curr\n curr_next.previous = node\n\n node = node_next\n \n return new_head.next\n","runtime":"261"},{"code":"# Definition for singly-linked list.\nclass ListNode(object):\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\nclass Solution(object):\n def insertionSortList(self, head):\n \"\"\"\n :type head: ListNode\n :rtype: ListNode\n \"\"\"\n def insert(head, j, ins, prev_ins, prev_j):\n \"\"\" insert ins in front of j\"\"\"\n prev_ins.next = ins.next\n ins.next=j\n if prev_j is not None:\n prev_j.next = ins\n else:\n head = ins\n return head, prev_ins\n \n current = head\n prev_current = None\n while current is not None:\n prev_current = current\n current = current.next\n if current is None:\n break\n j = head\n prev_j = None\n while current.val > j.val:\n prev_j = j\n j = j.next\n if current != j:\n head, current = insert(head, j, current, prev_current, prev_j)\n\n return head","runtime":"274"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n curr_node = head.next\n curr_node_prev = head\n \n while curr_node:\n next_node = curr_node.next\n comparison_node_prev = None\n comparison_node = head\n \n while curr_node.val > comparison_node.val:\n comparison_node_prev = comparison_node\n comparison_node = comparison_node.next\n if comparison_node == curr_node:\n curr_node_prev = curr_node\n curr_node = next_node\n continue\n\n curr_node_prev.next = curr_node.next\n curr_node.next = comparison_node\n \n if comparison_node_prev:\n comparison_node_prev.next = curr_node\n else:\n head = curr_node\n \n curr_node = next_node\n \n return head","runtime":"288"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n def insertionSort(arr: list,val: int) -> list:\n flag = 0\n if len(arr) == 0:\n arr.append(val)\n else:\n for i in range(len(arr)):\n if arr[i] < val:\n continue\n \n arr.insert(i,val)\n flag = 1\n break\n if flag == 0:\n arr.append(val)\n return arr\n temp = head\n arr = []\n while temp != None:\n arr = insertionSort(arr,temp.val)\n temp = temp.next\n \n temp = head\n for i in arr:\n temp.val = i\n temp=temp.next\n \n return head","runtime":"301"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n fs = ListNode(0, head)\n prev_sort, cur_sort = head, head.next\n # sort each node\n while cur_sort:\n prev, cur = fs, fs.next\n # print(\"cur_sort\", cur_sort.val)\n # print(\"list\", fs)\n while cur_sort.val > cur.val:\n prev = cur\n cur = cur.next\n # print(\"prev\", prev.val, \"cur\", cur.val)\n if cur == cur_sort:\n prev_sort = cur_sort\n cur_sort = cur_sort.next\n else:\n # remove cur_sort from initial position\n prev_sort.next = cur_sort.next \n \n # place cur_sort inbetween prev and cur\n prev.next = cur_sort \n cur_sort.next = cur\n \n cur_sort = prev_sort.next\n return fs.next\n","runtime":"301"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return None\n new_head = head\n old_head = head.next\n head.next = None\n while old_head is not None:\n cur = old_head\n old_head = old_head.next\n if cur.val < new_head.val:\n cur.next = new_head\n new_head = cur\n else:\n prev, cur2 = new_head, new_head.next\n while cur2 is not None and cur.val >= cur2.val:\n cur2, prev = cur2.next, cur2\n\n prev.next = cur\n cur.next = cur2\n return new_head\n\n ","runtime":"315"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sorted, unsorted = ListNode(-sys.maxsize - 1), head\n while unsorted:\n next_unsorted = unsorted.next #save next pointer\n #insert the unsorted node between prev & next\n prev, next = None, sorted\n while next and unsorted.val > next.val:\n prev, next = next, next.next\n prev.next = unsorted\n unsorted.next = next\n unsorted = next_unsorted\n return sorted.next","runtime":"328"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insert_sorted(self, sent, num):\n node = sent.next\n prev = sent\n while node is not None:\n if num <= node.val:\n break\n prev = node\n node = node.next\n prev.next = ListNode(num, node)\n\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sent = ListNode(None, None)\n node = head\n while node is not None:\n self.insert_sorted(sent, node.val)\n node = node.next\n return sent.next\n","runtime":"342"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n if not head: \n return head \n\n nxt = head.next \n head.next = None\n sorted_head = head\n \n while nxt: \n temp_next = nxt.next \n sorted_head = self.sorted_insert(sorted_head, nxt)\n nxt = temp_next \n return sorted_head \n\n\n def sorted_insert(self, head, node ):\n curr_val = node.val\n curr_node = head \n\n if head.val > node.val: \n node.next = head\n return node \n\n # advance until we reach the end of the list or find a value \n # greater than the current node \n while curr_node.next is not None and curr_node.next.val < curr_val: \n curr_node = curr_node.next \n\n \n nxt = curr_node.next \n curr_node.next = node \n node.next = nxt \n return head \n\n\n\n","runtime":"342"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n #1st & 2nd part: sorted and unsorted part\n first, second = ListNode(-sys.maxsize - 1), head\n while second:\n next = second.next #save next pointer\n prev, current = None, first\n while current and second.val > current.val:\n prev, current = current, current.next\n prev.next = second\n if current:\n second.next = current\n else:\n second.next = None\n second = next\n return first.next","runtime":"355"},{"code":"class ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\nclass Solution:\n def insertNode(self, node):\n\n nodeVal = node.val\n currentSorted = self.sortedNodes\n if nodeVal <= currentSorted.val:\n\n node.next = currentSorted\n self.sortedNodes = node\n return None\n while currentSorted.next:\n\n if currentSorted.next.val >= nodeVal:\n node.next = currentSorted.next\n currentSorted.next = node\n return None\n currentSorted = currentSorted.next\n currentSorted.next = node\n node.next = None\n\n \n def insertionSortList(self, head):\n current = head.next\n if current:\n nextCurrent = current.next\n else:\n return head\n self.sortedNodes = head\n self.sortedNodes.next = None\n while current:\n self.insertNode(current)\n \n current = nextCurrent\n if current:\n if current.next:\n nextCurrent = current.next\n else:\n break\n else:\n return self.sortedNodes\n self.insertNode(current)\n return self.sortedNodes","runtime":"355"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(-float('inf'), ListNode(head.val))\n head = head.next\n while head:\n prev, cur = dummy, dummy.next\n while cur and head.val > cur.val:\n prev, cur = cur, cur.next\n nxt = head.next\n head.next = cur\n prev.next = head\n head = nxt\n return dummy.next\n","runtime":"369"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n \n sorted_head = ListNode(0)\n curr = head\n # arr = []\n\n while curr:\n prev = sorted_head\n next_node = sorted_head.next\n \n while next_node:\n if next_node.val > curr.val:\n break\n\n prev = next_node\n next_node = next_node.next\n\n next_iter = curr.next\n curr.next = next_node\n prev.next = curr\n curr = next_iter\n \n return sorted_head.next","runtime":"369"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n dummy=ListNode(0)\n current=head\n while current:\n prev=dummy\n nextnode=dummy.next\n\n while nextnode and nextnode.val<current.val:\n prev=nextnode\n nextnode=nextnode.next\n\n nextiter=current.next\n\n prev.next=current\n current.next=nextnode\n\n current=nextiter\n\n return dummy.next","runtime":"383"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n start = ListNode(float('-inf'), head)\n prev = head\n node = prev.next\n while node:\n nxt = node.next\n head = start\n prev.next = None\n tmp = head\n while head and head.val < node.val:\n tmp = head\n head = head.next\n if not head: \n prev.next = node \n prev = node\n else:\n tmp.next = node \n node.next = head\n prev.next = nxt\n node = nxt\n return start.next\n \n\n\n ","runtime":"383"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\n\n\n\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n # edge cases:\n if head is None:\n return None\n\n dummy = ListNode(0)\n current = head\n\n while current is not None:\n prev = dummy\n while prev.next is not None and prev.next.val < current.val:\n prev = prev.next\n \n next_node = current.next\n\n current.next = prev.next\n prev.next = current\n\n current = next_node\n\n return dummy.next\n\n # p = head.next\n\n # while p is not None:\n \n # if (p.val < head.val):\n\n \n # newNode = ListNode(p.val)\n # newNode.next = head\n # head = newNode\n\n\n # else:\n # c = head\n # while c is not p:\n # if p.val >= c.val and p.val <= c.next.val:\n # newNode = ListNode(p.val)\n # newNode.next = c.next\n # c.next = newNode\n\n # if c.next is p:\n # c.next = p.next\n\n # c = c.next\n\n # p = p.next\n\n # return head\n\n\n\n # while current_node is not None:\n # iteration_node = current_node\n # while iteration_node.next is not None:\n # if iteration_node.val > iteration_node.next.val:\n # temp = iteration_node.val\n # iteration_node.val = iteration_node.next.val\n # iteration_node.next.val = temp\n # iteration_node = iteration_node.next\n # else:\n # break\n # current_node = head\n\n # return head\n \n \n # def loop(node):\n # prev = root.node\n # while :\n # temp = node.val\n # node.val = node.next.val\n # node.next.val = node\n\n # node = head\n # while ()\n\n\n\n\n # while node is not None:\n\n","runtime":"396"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n res = ListNode(-5001)\n h=res\n h.next = head\n while h.next:\n hprev = h\n h = h.next\n temp = res\n while temp.next and temp.next.val < h.val:\n temp = temp.next\n \n if temp.next and temp.next is not h:\n hprev.next = h.next\n h.next = temp.next\n temp.next = h\n h = hprev\n return res.next\n","runtime":"396"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode()\n dummy.next = head\n \n last, pointer = head, head.next\n while pointer:\n temp = pointer.next\n\n prev, cur = dummy, dummy.next\n\n while cur and cur.val < pointer.val:\n cur, prev = cur.next, prev.next\n \n\n if cur != pointer:\n prev.next = pointer\n pointer.next = cur\n last.next = temp\n else:\n last = pointer\n \n pointer = temp\n\n return dummy.next\n\n ","runtime":"410"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy_head = ListNode()\n curr = head\n\n while curr:\n prev_pointer = dummy_head\n next_pointer = dummy_head.next\n\n while next_pointer:\n if curr.val < next_pointer.val:\n break\n prev_pointer = prev_pointer.next\n next_pointer = next_pointer.next\n # assign the curr to the temp varibale in order to move the next \n temp = curr.next\n #insert the node to the correct position\n curr.next = next_pointer\n prev_pointer.next = curr \n \n # move the curr to next node \n curr = temp \n \n return dummy_head.next ","runtime":"410"},{"code":"class Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0)\n curr = head\n\n while curr:\n prev = dummy\n while prev.next and prev.next.val < curr.val:\n prev = prev.next\n temp = curr.next\n curr.next = prev.next\n prev.next = curr\n curr = temp\n\n return dummy.next","runtime":"423"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n src = head.next \n dest = ListNode(head.val)\n # 1-->2--->3-->4--->5\n # 5--8--7\n while src:\n node = ListNode(src.val)\n if src.val < dest.val:\n node.next = dest\n dest = node\n else:\n prev = None\n temp = dest\n while temp and temp.val <= src.val:\n prev = temp\n temp = temp.next\n prev.next = node\n node.next = temp \n\n src = src.next \n return dest\n \n\n\n\n\n \n ","runtime":"423"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n sentinel = ListNode()\n curr = head\n\n while curr:\n prev = sentinel\n while prev.next and prev.next.val < curr.val:\n prev = prev.next\n\n curr.next, prev.next, curr = prev.next, curr, curr.next\n\n return sentinel.next\n\n\n def insertionSortList2(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n sorted_head = ListNode(next=head)\n cur = head.next\n head.next = None # cut the link!\n\n while cur:\n cur_sorted = sorted_head\n while cur_sorted.next and cur_sorted.next.val < cur.val:\n cur_sorted = cur_sorted.next\n\n cur.next, cur_sorted.next, cur = cur_sorted.next, cur, cur.next\n\n return sorted_head.next\n\n\n # not working as no clear delimitation between sorted and non sorted part\n def insertionSortList_not(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n sorted_head = ListNode(next=head)\n cur = head.next\n\n while cur:\n cur_sorted = sorted_head\n while cur_sorted.next and cur_sorted.next.val < cur.val:\n cur_sorted = cur_sorted.next\n\n cur.next, cur_sorted.next, cur = cur_sorted.next, cur, cur.next\n\n return sorted_head.next","runtime":"437"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode()\n curr_node = head\n while curr_node:\n prev_node = dummy\n while prev_node.next and prev_node.next.val <= curr_node.val:\n prev_node = prev_node.next\n next_node = curr_node.next\n curr_node.next = prev_node.next\n prev_node.next = curr_node\n curr_node = next_node\n return dummy.next","runtime":"437"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head.next:\n return head\n dummy=ListNode(-1)\n re=dummy\n cur=head\n nxt=None\n while cur:\n nxt=cur.next\n while re.next and re.next.val<cur.val:\n re=re.next\n cur.next=re.next\n re.next=cur\n re=dummy\n cur=nxt\n return dummy.next","runtime":"450"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: ListNode) -> ListNode:\n dummy = ListNode()\n curr = head\n\n while curr:\n # At each iteration, we insert an element into the resulting list.\n prev = dummy\n\n # find the position to insert the current node\n while prev.next and prev.next.val <= curr.val:\n prev = prev.next\n\n next = curr.next\n # insert the current node to the new list\n curr.next = prev.next\n prev.next = curr\n\n # moving on to the next iteration\n curr = next\n\n return dummy.next\n \n ","runtime":"450"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0)\n curr = head\n \n while curr:\n # At each iteration, insert curr into the sorted part of the list\n prev = dummy\n next_node = curr.next\n \n # Find the right place to insert the current node\n while prev.next and prev.next.val < curr.val:\n prev = prev.next\n \n # Insert the current node into the sorted list\n curr.next = prev.next\n prev.next = curr\n \n # Move to the next node in the original list\n curr = next_node\n \n return dummy.next\n ","runtime":"464"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sorted_list = ListNode(val=head.val)\n node = head.next\n while node:\n val = node.val\n\n s_node = sorted_list\n prev_el = None\n while s_node:\n if val > s_node.val:\n if s_node.next:\n prev_el = s_node\n s_node = s_node.next\n else:\n s_node.next = ListNode(val=val)\n break\n else:\n newNode = ListNode(val=val, next=s_node)\n if prev_el:\n prev_el.next = newNode\n else:\n sorted_list = newNode\n break\n\n node = node.next\n \n return sorted_list","runtime":"464"},{"code":"class Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # Create a dummy head to simplify insertion\n dummy_head = ListNode(-1)\n dummy_head.next = None\n\n curr = head\n while curr:\n # Sort each node one by one\n curr = self.sort(curr, dummy_head)\n \n # Return the sorted list (excluding the dummy head)\n return dummy_head.next\n \n def sort(self, curr: Optional[ListNode], dummy_head: ListNode) -> ListNode:\n # Save the next node to be processed\n next_node = curr.next\n # Detach the current node from the original list\n curr.next = None\n\n ptr = dummy_head\n while ptr:\n # Find the correct position to insert the current node\n if not ptr.next or ptr.next.val > curr.val:\n # Insert the current node\n next_segment = ptr.next\n ptr.next = curr\n curr.next = next_segment\n break\n \n ptr = ptr.next\n \n # Return the next node to be processed\n return next_node","runtime":"477"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\n\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0)\n curr = head # The node we are currently processing in the original list\n \n while curr:\n # At each step, we need to insert curr into the correct place in the sorted part.\n prev = dummy\n # Find the correct place to insert curr\n while prev.next and prev.next.val < curr.val:\n prev = prev.next\n \n # Store the next node to process in a temp variable\n next_temp = curr.next\n # Insert curr into the sorted part of the list\n curr.next = prev.next\n prev.next = curr\n \n # Move to the next node in the original list\n curr = next_temp\n \n # Return the sorted list, which starts at dummy.next\n return dummy.next\n ","runtime":"477"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def insert(head, value):\n if value <= head.val:\n head = ListNode(value, head)\n return head\n node = head\n next_node = head.next\n while node is not None and next_node is not None:\n if value > node.val and value <= next_node.val:\n new_node = ListNode(value, next_node)\n node.next = new_node\n return head\n else:\n next_node = next_node.next\n node = node.next\n node.next = ListNode(value, None)\n return head\n\n new_head = ListNode(head.val, None)\n node = head.next\n while node is not None:\n # print(new_head, node)\n new_head = insert(new_head, node.val)\n node = node.next\n return new_head\n","runtime":"491"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n\n if not head.next:\n return head\n\n l, r = head, head.next\n l.next = None\n while r:\n if r.val <= l.val:\n tmp = r.next\n r.next = l\n l = r\n r = tmp\n continue\n curr = l\n while curr.next and curr.next.val < r.val:\n curr = curr.next\n tmp = curr.next\n curr.next = r\n r = r.next\n curr.next.next = tmp\n return l\n \n","runtime":"491"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n dummy = ListNode(0)\n # any nodes before head are sorted\n while head:\n next = head.next\n prev = dummy\n while prev and prev.next and prev.next.val < head.val:\n prev = prev.next\n head.next = prev.next\n prev.next = head\n head = next\n return dummy.next\n\n# 0->2->4\n# p\n# 1,3\n# h n\n\n ","runtime":"505"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n if head is None or head.next is None:\n return head\n \n\n def insert(head, node):\n if head.next is None:\n node.next = None\n head.next = node\n else:\n prev = head\n nxt = head.next\n while nxt is not None:\n if nxt.val > node.val:\n node.next = nxt\n prev.next = node\n break\n else:\n nxt = nxt.next\n prev = prev.next\n \n if nxt is None:\n prev.next = node\n\n curr = head\n nxt = head.next\n\n output = ListNode()\n\n while nxt is not None:\n if curr.val > nxt.val:\n insert(output, ListNode(nxt.val))\n curr.next = nxt.next\n nxt = nxt.next\n else:\n insert(output, ListNode(curr.val))\n curr = curr.next\n nxt = nxt.next\n \n insert(output, ListNode(curr.val))\n return output.next","runtime":"505"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def insort(head, new):\n if head is None:\n return ListNode(new)\n if new < head.val:\n return ListNode(new, head)\n else:\n # Insert element in middle of linked list\n node = head\n while node.next:\n if node.val <= new <= node.next.val:\n tmp = node.next\n node.next = ListNode(new)\n node.next.next = tmp\n return head\n node = node.next\n else:\n node.next = ListNode(new)\n return head\n \n new_head = None\n while head:\n new_head = insort(new_head, head.val)\n head = head.next\n return new_head\n\n ","runtime":"518"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(float('-inf'))\n \n while head:\n # On each iteration, remove head from the original list\n curr = head\n head = head.next\n \n # Find the correct place to insert the current node in the sorted list\n prev = dummy\n while prev.next and prev.next.val < curr.val:\n prev = prev.next\n \n # Insert the current node into the sorted list\n curr.next = prev.next\n prev.next = curr\n \n return dummy.next\n","runtime":"518"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n end = head.next\n prev_end = head\n while end:\n curr = head\n prev = None\n while curr != end and curr.val < end.val:\n prev = curr\n curr = curr.next\n if curr != end:\n prev_end.next = end.next\n end.next = curr\n if prev:\n prev.next = end\n else:\n head = end\n end = prev_end.next\n else:\n prev_end = end\n end = end.next\n return head\n \n\n ","runtime":"532"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n tmp1 = head.next\n prev = head\n\n dummy = ListNode(-1, head)\n\n while tmp1:\n curr = tmp1\n tmp2 = prev2 = dummy.next\n while tmp2 != curr and curr.val >= tmp2.val:\n prev2 = tmp2\n tmp2 = tmp2.next\n #already in order\n if curr == tmp2:\n prev = tmp1\n tmp1 = tmp1.next\n continue\n\n # not the very front\n if prev2 != tmp2:\n prev2.next = curr\n else:\n dummy.next = curr\n #link last element to next\n prev.next = curr.next\n #linke curr.next to actual next\n\n curr.next = tmp2\n tmp1 = prev.next\n # self.print(dummy)\n # if tmp1:\n # print(tmp1.val)\n # print(prev.val)\n\n return dummy.next\n\n def print(self, head):\n ret = []\n while head:\n ret.append(head.val)\n head = head.next\n \n print(ret)","runtime":"532"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head.next == None:\n return head\n sorted_head = head\n curr = head.next\n head.next = None\n while curr:\n nxt = curr.next\n sorted_prev = None\n sorted_curr = sorted_head\n while sorted_curr:\n if sorted_curr == sorted_head and curr.val < sorted_curr.val:\n curr.next = sorted_curr\n sorted_head = curr\n break\n elif curr.val < sorted_curr.val:\n sorted_prev.next = curr\n curr.next = sorted_curr\n break\n else:\n sorted_prev = sorted_curr\n sorted_curr = sorted_curr.next\n if sorted_curr == None:\n sorted_prev.next = curr\n curr.next = None\n curr = nxt\n\n return sorted_head\n\n\n\n \n \n\n\n\n","runtime":"545"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def insert(head: ListNode, node: ListNode):\n if node.val <= head.val:\n nuNode = ListNode(node.val)\n nuNode.next = head\n return nuNode\n left = head\n right = head.next\n while right is not None:\n if node.val > left.val and node.val <= right.val:\n nuNode = ListNode(node.val)\n left.next = nuNode\n nuNode.next = right\n return head\n left = right\n right = right.next\n left.next = ListNode(node.val)\n return head\n\n nuHead = ListNode(head.val)\n node = head.next\n while node is not None:\n nuHead = insert(nuHead, node)\n node = node.next\n return nuHead","runtime":"545"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return head\n runn = head.next\n head.next = None\n while not runn is None:\n curr = runn\n runn = runn.next\n if head.val > curr.val:\n curr.next = head\n head = curr\n else:\n loop = head\n while not loop.next is None and loop.next.val < curr.val:\n loop = loop.next\n curr.next = loop.next\n loop.next = curr\n return head\n ","runtime":"559"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummyhead = ListNode(next=head)\n start = head\n prev = dummyhead\n while start is not None:\n temp = dummyhead\n nxt = start.next\n inserted = False\n while temp.next != start:\n if start.val < temp.next.val:\n # insert here\n prev.next = start.next\n tmp = temp.next\n temp.next = start\n start.next = tmp \n inserted = True\n break\n temp = temp.next\n if not inserted:\n prev = start\n start = nxt\n return dummyhead.next","runtime":"559"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def f(head,l):\n if head==None:\n return l\n if l==None:\n k=head.next\n head.next=None\n return f(k,head)\n if l.val>=head.val:\n k=head.next\n head.next=l\n l=head\n return f(k,l)\n r=l\n prec=None\n while r!=None:\n if head.val<=r.val:\n k=head.next\n head.next=r\n r=head\n prec.next=r\n return f(k,l)\n prec=r\n r=r.next\n k=head.next\n head.next=None\n r=head\n prec.next=r\n return f(k,l)\n return f(head,None)\n \n\n\n\n","runtime":"572"},{"code":"class Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n node = head.next\n head.next = None\n head = ListNode(-10_000, next=head)\n while node:\n head_tmp = head\n tmp = node\n node = node.next\n \n while head_tmp:\n if head_tmp.next == None or head_tmp.next.val > tmp.val:\n tmp.next = head_tmp.next\n head_tmp.next = tmp\n break\n head_tmp = head_tmp.next\n \n return head.next","runtime":"572"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n curr = head.next\n prev = head\n head.next = None\n\n while curr:\n succ = curr.next\n curr.next = prev\n prev = curr\n curr = succ\n\n key = prev.val\n ptr1 = prev.next\n ptr2 = prev\n\n while ptr1 and ptr1.val < key:\n ptr2.val = ptr1.val\n ptr1 = ptr1.next\n ptr2 = ptr2.next\n \n ptr2.val = key\n return prev","runtime":"586"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def insert(to_insert: ListNode, head: ListNode, n: int):\n prev = None\n curr = head\n counter = 0\n while curr and curr.val <= to_insert.val and counter < n:\n prev = curr\n curr = curr.next\n counter += 1\n \n if not prev:\n to_insert.next = curr\n return to_insert\n \n if counter == n or not curr:\n prev.next = to_insert\n return head\n\n prev.next = to_insert\n to_insert.next = curr\n return head\n \n counter = 1\n ret = head\n curr = head.next\n ret.next = None\n while curr:\n nxt = curr.next\n curr.next = None\n ret = insert(curr, ret, counter)\n curr = nxt\n counter += 1\n return ret\n \n ","runtime":"586"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0)\n curr = head\n prev = None\n while curr != None:\n prev = dummy\n while prev.next != None and prev.next.val < curr.val:\n prev = prev.next\n tmp = curr.next\n tmp1 = prev.next\n prev.next = curr\n curr.next = tmp1\n curr = tmp\n return dummy.next\n\n \n\n\n \n \n ","runtime":"599"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n #creat a new list and find the position for current element\n #do the operations in place \n dummy=ListNode(-1)\n\n cur=head\n while cur!=None:\n #insert current in to pre\n #hold the next element and deal with the current \n pre=dummy\n while pre.next!=None and cur.val>=pre.next.val:\n pre=pre.next\n \n #find the place for cur\n succ=cur.next\n \n cur.next=pre.next\n pre.next=cur\n\n #move current to the next \n cur=succ\n\n return dummy.next\n#time O(n**2) space O(1) \n#insert sort!\n \n\n \n \n ","runtime":"599"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n node = head.next\n head.next = None\n while node:\n n = node.next\n head = self.insert(node=node, head=head)\n node = n\n return head\n\n \n def insert(self, node: Optional[ListNode], head: Optional[ListNode]) -> Optional[ListNode]:\n curr = head\n prev = None\n while curr:\n if curr.val >= node.val:\n if prev == None:\n node.next = curr\n return node\n if prev.val <= node.val:\n prev.next = node\n node.next = curr\n return head\n if curr.next == None:\n curr.next = node\n node.next = None\n return head\n prev = curr\n curr = curr.next\n ","runtime":"613"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n frontNode = ListNode(-1, head)\n lastSortedNode = head\n insertionNode = head.next\n nextInsertionNode = insertionNode.next if insertionNode else None\n\n while insertionNode:\n prevNode = frontNode\n currNode = frontNode.next\n while currNode and prevNode != lastSortedNode and currNode.val < insertionNode.val:\n prevNode = prevNode.next\n currNode = currNode.next\n if prevNode != lastSortedNode:\n prevNode.next = insertionNode\n insertionNode.next = currNode\n lastSortedNode.next = nextInsertionNode\n else:\n lastSortedNode = lastSortedNode.next\n insertionNode = nextInsertionNode\n nextInsertionNode = nextInsertionNode.next if nextInsertionNode else None\n \n return frontNode.next","runtime":"613"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head.next == None:\n return head\n sorted_lst = [head]\n curr = head.next\n head.next = None\n while curr:\n nxt = curr.next\n i=len(sorted_lst)-1\n while i > -1:\n if sorted_lst[i].val <= curr.val:\n sorted_lst[i].next = curr\n if i < len(sorted_lst)-1:\n curr.next = sorted_lst[i+1]\n else:\n curr.next = None\n sorted_lst = sorted_lst[:i+1]+[curr]+sorted_lst[i+1:]\n break\n else:\n i-=1\n if i == -1:\n curr.next = sorted_lst[0]\n sorted_lst = [curr]+sorted_lst\n curr = nxt\n # print([x.val for x in sorted_lst])\n # for x in sorted_lst:\n # if x.next:\n # print((x.val,x.next.val))\n # else:\n # print((x.val,\"NONE\"))\n return sorted_lst[0]\n \n \n \n\n\n\n","runtime":"626"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n oc = head\n i = 0\n prev = head\n\n l = 0\n while oc != None: \n oc = oc.next\n l += 1\n \n print(l)\n oc = head\n\n while oc != None: \n val = oc.val\n\n prev = oc\n oc = oc.next\n\n c = head\n j = 0\n\n while c.next and c.next.val < val and j < i:\n c = c.next\n j += 1\n \n t = c.next\n c.next = ListNode(val, t)\n \n i += 1\n\n oc = head\n\n\n for i in range(l): \n oc = oc.next\n\n oc.next = None\n return head.next\n ","runtime":"626"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n last = head\n \n while last:\n temp = last\n min_pointer = last\n while temp:\n if temp.val < min_pointer.val:\n min_pointer = temp\n temp = temp.next\n last.val, min_pointer.val = min_pointer.val, last.val\n last = last.next\n \n return head\n \n","runtime":"640"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n result = res = ListNode(-5001)\n\n def insertResult(node):\n nonlocal res\n res = result\n while res.next:\n\n if res.val <= node.val <= res.next.val:\n node.next = res.next\n res.next = node\n return\n res = res.next\n if not res.next:\n node.next = None\n res.next = node\n\n while head:\n temp = head.next\n insertResult(head)\n head = temp\n return result.next\n","runtime":"640"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n h1 = head.next\n prev1 = head\n while (h1 != None):\n if h1.val >= prev1.val: # if fist node greater than prev1\n prev1 = h1\n h1 = h1.next\n else:\n # Deletion operations\n\n nn = ListNode(0) # insertion node\n nn.val = h1.val\n if h1.next == None: # if last node is smaller than prev1 node\n prev1.next = None\n else:\n prev1.next = h1.next\n h1 = h1.next\n\n #insertion operations\n\n p1 = head\n if head.val >= nn.val: # if nn(insertion node) is smaller than the first node\n nn.next = p1\n head = nn \n else:\n p1 = p1.next\n prev2 = head\n while p1:\n if (p1.val >= nn.val):\n nn.next = p1\n prev2.next = nn\n break\n prev2 = p1\n p1 = p1.next\n h1 = head.next\n prev1 = head\n return head","runtime":"654"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode()\n cur = head\n while cur:\n prev = dummy\n while prev.next!=None and prev.next.val < cur.val:\n prev = prev.next\n \n next = cur.next\n cur.next = prev.next\n prev.next = cur\n cur = next\n \n return dummy.next\n\n","runtime":"654"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: ListNode) -> ListNode:\n if not head:\n return None\n\n arr = []\n current = head\n\n while current:\n arr.append(current.val)\n current = current.next\n\n for i in range(1, len(arr)):\n curr_val = arr[i]\n j = i - 1\n while j >= 0 and arr[j] > curr_val:\n arr[j + 1] = arr[j]\n j -= 1\n arr[j + 1] = curr_val\n\n current = head\n for i in range(len(arr)):\n current.val = arr[i]\n current = current.next\n\n return head","runtime":"667"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: ListNode) -> ListNode:\n if not head:\n return None\n arr=[]\n c=head\n while c:\n arr.append(c.val)\n c=c.next\n for i in range(1, len(arr)):\n curr_val=arr[i]\n j=i-1\n while j>=0 and arr[j]>curr_val:\n arr[j+1]=arr[j]\n j-=1\n arr[j+1]=curr_val\n c=head\n for i in range(len(arr)):\n c.val=arr[i]\n c=c.next\n return head\n \n\n ","runtime":"667"},{"code":"class Solution:\n def insertionSortList(self, head: ListNode) -> ListNode:\n if not head:\n return None\n\n arr = []\n current = head\n\n while current:\n arr.append(current.val)\n current = current.next\n\n for i in range(1, len(arr)):\n curr_val = arr[i]\n j = i - 1\n while j >= 0 and arr[j] > curr_val:\n arr[j + 1] = arr[j]\n j -= 1\n arr[j + 1] = curr_val\n\n current = head\n for i in range(len(arr)):\n current.val = arr[i]\n current = current.next\n\n return head","runtime":"681"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n temp=head.next\n prev=head\n dummy=ListNode(-5005)\n dummy.next=head\n head=dummy\n before=prev\n while(temp!=None):\n prev=head\n p=head\n while(prev.next!=temp):\n if(prev.next.val>temp.val):\n before.next=before.next.next\n x=prev.next\n prev.next=temp\n temp.next=x\n temp=before\n break\n p=prev\n prev=prev.next\n before=temp\n temp=temp.next\n return head.next\n\n\n ","runtime":"681"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n curr = head\n prev = None\n while curr != None:\n nextNode = curr.next\n itr = head\n prevItr = None\n while itr != curr:\n if curr.val < itr.val and prevItr == None:\n curr.next = itr\n head = curr\n break\n if curr.val < itr.val:\n curr.next = itr\n prevItr.next = curr\n break\n prevItr = itr\n itr = itr.next\n if prev:\n if itr != curr:\n prev.next = nextNode\n else:\n prev = curr\n curr = nextNode\n else:\n prev = curr\n curr = curr.next\n return head","runtime":"721"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n if not head:\n return None\n\n node = head\n\n array = []\n\n while node:\n array.append(node.val)\n node = node.next\n\n # print(array)\n\n for i in range(len(array)):\n current_val = array[i]\n j = i-1\n while j >= 0 and array[j] > current_val:\n array[j+1] = array[j]\n j -= 1\n array[j+1] = current_val\n\n node = head\n for i in range(len(array)):\n node.val = array[i]\n node = node.next\n\n return head\n\n ","runtime":"721"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n\n arr = []\n current = head\n\n while current:\n arr.append(current.val)\n current = current.next\n\n for i in range(1, len(arr)):\n curr_val = arr[i]\n j = i - 1\n while j >= 0 and arr[j] > curr_val:\n arr[j + 1] = arr[j]\n j -= 1\n arr[j + 1] = curr_val\n\n current = head\n for i in range(len(arr)):\n current.val = arr[i]\n current = current.next\n\n return head\n ","runtime":"735"},{"code":"class Solution:\n def insert_sort(self, head, node, n):\n next_node = node.next\n current = head\n inserted = False\n prev = None\n\n for i in range(n):\n if not inserted and node.val <= current.val:\n if prev:\n prev.next = node\n else:\n head = node\n node.next = current\n inserted = True\n prev = current\n current = current.next\n \n if not inserted:\n prev.next = node\n node.next = next_node\n else:\n prev.next = next_node\n return (head, next_node)\n\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n node = head\n i = 0\n while node:\n if i == 0:\n node = node.next\n else:\n head, node = self.insert_sort(head, node, i)\n i += 1\n return head\n","runtime":"735"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return head\n t=head\n a=[]\n while t:\n a.append(t.val)\n t=t.next\n for i in range(1,len(a)):\n k=a[i]\n j=i-1\n while j>=0 and k<a[j]:\n a[j+1]=a[j]\n j-=1\n a[j+1]=k\n i=0\n head=ListNode()\n t=head\n while i<len(a):\n t.next=ListNode(a[i])\n i+=1\n t=t.next\n return head.next","runtime":"748"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n now = head\n while now:\n if now.next is not None:\n cur = now.next\n while cur is not None:\n if now.val > cur.val:\n now.val, cur.val = cur.val, now.val\n cur = cur.next\n now = now.next\n else:\n return head","runtime":"748"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # two loops\n dummy = ListNode()\n dummy.next =head\n \n while head:\n \n prev = dummy\n while prev.next and prev.next.val < head.val:\n prev = prev.next \n if prev.next != head:\n n = head.next\n p = dummy\n while p.next != head:\n p = p.next\n p.next = n\n head.next = prev.next\n prev.next = head\n\n head = n\n else:\n head = head.next \n # can't use three equal together, have to save head.next first \n return dummy.next\n\n\n \n\n\n","runtime":"762"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n\n lft = head\n\n while lft:\n cur = lft\n while cur:\n if cur.val < lft.val:\n cur.val, lft.val = lft.val, cur.val\n cur = cur.next\n\n lft = lft.next\n return head","runtime":"762"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head):\n \n def insert(head, node):\n if node.val <= head.val:\n node.next = head\n return node\n else:\n curr = head\n curr_next = curr.next\n while(curr and curr_next):\n if node.val > curr.val and node.val <= curr_next.val:\n curr.next = node\n node.next = curr_next\n return head\n else:\n curr = curr_next\n curr_next = curr.next\n if node.val > curr.val:\n curr.next = node\n return head\n\n \n \n if head is None: return None\n node = head.next\n head.next = None\n while(node):\n curr = node\n node = curr.next\n curr.next = None\n head = insert(head, curr)\n return head\n\n\n ","runtime":"776"},{"code":"class Solution:\n def insertionSortList(self, head: ListNode) -> ListNode:\n if not head:\n return None\n arr = []\n current = head\n while current:\n arr.append(current.val)\n current = current.next\n for i in range(1, len(arr)):\n curr_val = arr[i]\n j = i - 1\n while j >= 0 and arr[j] > curr_val:\n arr[j + 1] = arr[j]\n j -= 1\n arr[j + 1] = curr_val\n current = head\n for i in range(len(arr)):\n current.val = arr[i]\n current = current.next\n return head","runtime":"776"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n\n lft = head\n\n while lft:\n\n cur = lft\n while cur:\n if cur.val < lft.val:\n cur.val, lft.val = lft.val, cur.val\n cur = cur.next\n\n lft = lft.next\n return head","runtime":"789"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n new_head = ListNode(val=None, next=head)\n\n sort = new_head\n\n while sort.next:\n min_prev, prev = sort, sort\n min_curr, curr = sort.next, sort.next\n while curr:\n if curr.val < min_curr.val:\n min_curr = curr\n min_prev = prev\n prev = curr\n curr = curr.next\n \n min_prev.next = min_curr.next\n min_curr.next = sort.next \n sort.next = min_curr\n sort = sort.next\n \n\n return(new_head.next)\n \n \n\n\n \n\n\n \n\n\n \n ","runtime":"789"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n curr = head\n start, end = None, None\n while curr:\n # print(curr.val)\n nxt = curr.next\n if start:\n if curr.val <= start.val:\n curr.next = start\n start = curr\n # print(start.val)\n else:\n scurr = start\n while scurr:\n slots = scurr.next and scurr.next.val > curr.val\n if curr.val >= scurr.val and (slots or scurr.next is None):\n curr.next = scurr.next\n scurr.next = curr\n break\n scurr = scurr.next\n else:\n start = curr\n start.next = None\n curr = nxt\n return start","runtime":"803"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def get_list():\n current_node = head\n l = []\n while current_node:\n l.append(current_node)\n current_node = current_node.next\n return l\n \n list_to_sort = get_list()\n for i in range(1, len(list_to_sort)):\n number_to_order = list_to_sort[i].val\n j = i - 1\n\n while j >= 0 and number_to_order < list_to_sort[j].val:\n list_to_sort[j + 1].val = list_to_sort[j].val\n j -= 1\n list_to_sort[j + 1].val = number_to_order\n return list_to_sort[0] \n\n","runtime":"803"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \"\"\"\n Potential solutions:\n - Insertion sort\n Approach:\n - Initialize head of sorted list\n - Iterate over original list. Grab head and iterate over second list. Find the two that the new item fits between\n - Take head of current and set it to the node to insert. Set node to insert .next as the previous .next\n - Iterate until you've reached the tail of the original list\n Edge cases:\n - []\n - [4,2,1,3]\n - [-1,5,3,4,0]\n - [3, 1, 2, 2]\n\n trace:\n \n current_list = [4,2,1,3]\n new_list = [-5001, 4,]\n\n current_list = [4,2,1,3]\n new_list = [-5001, 4,]\n\n \"\"\"\n if head is None or head.next is None:\n return head\n\n placeholder = ListNode(val=-5001)\n current_original = head\n\n while current_original is not None:\n current_new_node = placeholder\n while current_new_node is not None:\n if current_original.val >= current_new_node.val and current_new_node.next is None:\n current_new_node.next = ListNode(val=current_original.val)\n break\n if (\n current_original.val >= current_new_node.val\n and current_new_node.next is not None\n and current_new_node.next.val >= current_original.val\n ):\n current_new_node.next = ListNode(val=current_original.val, next=current_new_node.next)\n break\n\n current_new_node = current_new_node.next\n\n current_original = current_original.next\n\n return placeholder.next\n\n","runtime":"816"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n res = []\n dummy = ListNode(None)\n while head:\n res.append(head.val)\n head = head.next\n for i in range(1,len(res)):\n temp = res[i]\n j = i - 1\n while temp < res[j] and j >= 0:\n res[j+1] = res[j]\n res[j] = temp\n j -= 1\n tail = dummy\n for i in res:\n new_node = ListNode(i)\n tail.next = new_node\n tail = tail.next\n return dummy.next","runtime":"816"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(-1)\n dummy.next = head\n curr = head.next\n while curr:\n unsorted_next = curr.next\n prev = head\n while prev.next != curr:\n prev = prev.next\n sorted_curr = dummy\n while sorted_curr != curr:\n if curr.val < sorted_curr.next.val:\n prev.next = curr.next\n temp = sorted_curr.next\n sorted_curr.next = curr\n curr.next = temp\n sorted_curr = sorted_curr.next\n curr = unsorted_next\n return dummy.next","runtime":"830"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(-1)\n dummy.next = head\n curr = head.next\n while curr:\n unsorted_next = curr.next\n prev = head\n while prev.next != curr:\n prev = prev.next\n sorted_curr = dummy\n while sorted_curr != curr:\n if curr.val < sorted_curr.next.val:\n prev.next = curr.next\n temp = sorted_curr.next\n sorted_curr.next = curr\n curr.next = temp\n sorted_curr = sorted_curr.next\n curr = unsorted_next\n return dummy.next","runtime":"830"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next: \n return head\n elements = list()\n while head: \n elements.append(head.val)\n head = head.next\n \n for k_int in range(1, len(elements)): \n curr = elements[k_int]\n j_int = k_int\n while j_int > 0: \n if elements[j_int-1] > curr:\n elements[j_int] = elements[j_int-1]\n j_int -= 1\n else:\n break\n elements[j_int] = curr\n result = ListNode()\n curr = result\n\n for k_int in range(len(elements)): \n if k_int == len(elements) - 1:\n curr.next = ListNode(val=elements[-1], next=None)\n else:\n curr.next = ListNode(val=elements[k_int])\n curr = curr.next\n\n return result.next\n","runtime":"843"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n \n prevMap = {}\n prev = None\n curr = head\n while curr:\n prevMap[curr] = prev\n prev = curr\n curr = curr.next\n \n # prev = head\n curr = head.next\n while curr:\n\n currForIter = curr\n prevForIter = prevMap[currForIter]\n\n while currForIter and prevForIter and currForIter.val < prevForIter.val:\n temp = currForIter.val\n currForIter.val = prevForIter.val\n prevForIter.val = temp\n currForIter = prevForIter\n prevForIter = prevMap[prevForIter]\n curr = curr.next\n\n return head\n\n\n\n\n ","runtime":"843"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n ptr_list = []\n\n ptr1 = head\n while( ptr1):\n ptr_list.append(ptr1)\n ptr1 = ptr1.next #[4 , 2 , 1, 3]\n \n for i in range(1, len(ptr_list)): #[2 , 4 , 1, 3] \n target = ptr_list[i]\n for j in reversed(range(i)):\n if(ptr_list[j].val > target.val):\n tmp = ptr_list[j].val\n ptr_list[j].val = target.val\n target.val = tmp\n target = ptr_list[j]\n else:\n break\n \n return ptr_list[0]\n\n\n\n# [ptr1 , ptr2 , ptr3 , ptr4 , ptr5]\n# \n#\n#\n#\n#","runtime":"857"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(-1)\n dummy.next = head\n curr = head.next\n while curr:\n unsorted_next = curr.next\n prev = head\n while prev.next != curr:\n prev = prev.next\n sorted_curr = dummy\n while sorted_curr != curr:\n if curr.val < sorted_curr.next.val:\n prev.next = curr.next\n temp = sorted_curr.next\n sorted_curr.next = curr\n curr.next = temp\n sorted_curr = sorted_curr.next\n curr = unsorted_next\n return dummy.next","runtime":"870"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n tracker1 = head\n while tracker1:\n tracker2=tracker1.next\n while tracker2:\n if tracker2.val<tracker1.val:\n tracker1.val, tracker2.val = tracker2.val, tracker1.val\n tracker2 = tracker2.next\n tracker1 = tracker1.next\n \n return head\n","runtime":"870"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n if head.next is None:\n return head\n\n root_node = head\n\n while head.next is not None:\n val_to_insert = head.next.val\n\n if val_to_insert <= root_node.val:\n root_node = ListNode(val_to_insert, root_node)\n # delete moved node\n head.next = head.next.next\n else:\n insert_head = root_node\n while id(insert_head) != id(head):\n if val_to_insert <= insert_head.next.val:\n # insert node in ordered index\n insert_head.next = ListNode(val_to_insert, insert_head.next)\n # remove the moved node\n head.next = head.next.next\n break\n else:\n insert_head = insert_head.next\n if id(insert_head) == id(head):\n head = head.next\n\n\n return root_node\n\n\n\n\n\n\n\n # sorted_head = ListNode(head.val)\n # head = head.next\n\n # while head is not None:\n # val_to_sort = head.val\n # if val_to_sort <= sorted_head.val:\n # sorted_head = ListNode(val_to_sort, sorted_head)\n # else:\n # insertion_head = sorted_head\n # while insertion_head.next is not None:\n # if val_to_sort <= insertion_head.next.val:\n # insertion_head.next = ListNode(val_to_sort, insertion_head.next)\n # break\n # else:\n # insertion_head = insertion_head.next\n \n # if insertion_head.next is None:\n # insertion_head.next = ListNode(val_to_sort)\n \n # head = head.next\n \n # return sorted_head\n","runtime":"884"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n temp = ListNode(0, head)\n elem = head\n pre_elem = temp\n while elem: \n elem_next = elem.next \n pre = temp \n curr = temp.next \n while curr != elem:\n if curr.val <= elem.val:\n pre = curr\n curr = curr.next\n else:\n pre.next = elem \n elem.next = curr \n pre_elem.next = elem_next \n while curr.next != elem_next:\n curr = curr.next\n break\n pre_elem = curr\n elem = elem_next \n return temp.next\n","runtime":"897"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n l = []\n x = head\n while x != None:\n l.append(x.val)\n x = x.next\n if len(l) == 0:\n return\n for i in range(1, len(l)):\n for j in range(0, i):\n if l[i] < l[j]:\n l[i], l[j] = l[j], l[i]\n x = head\n i = 0\n while x != None:\n x.val = l[i]\n i += 1\n x = x.next\n return head\n\n","runtime":"911"},{"code":"class Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n vals = [head.val]\n cur = head\n while cur.next:\n cur = cur.next\n vals.append(cur.val)\n \n l = len(vals)\n for i in range(1, l):\n if vals[i] < vals[i - 1]:\n for j in range(i, 0, -1):\n if vals[j] < vals[j - 1]:\n vals[j], vals[j - 1] = vals[j - 1], vals[j]\n else:\n break\n \n head.val = vals[0]\n cur = head\n i = 1\n while cur.next:\n cur = cur.next\n cur.val = vals[i]\n i += 1\n return head\n\n","runtime":"925"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n temp = head\n nums = []\n while temp:\n nums.append(temp)\n temp = temp.next\n for i in range(1, len(nums)):\n temp = nums[i].val\n j = i - 1\n while temp < nums[j].val and j > -1:\n nums[j + 1].val = nums[j].val\n nums[j].val = temp\n j -= 1\n return head","runtime":"938"},{"code":"class Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n vals = [head.val]\n cur = head\n while cur.next:\n cur = cur.next\n vals.append(cur.val)\n \n l = len(vals)\n for i in range(1, l):\n if vals[i] < vals[i - 1]:\n for j in range(i, 0, -1):\n if vals[j] < vals[j - 1]:\n vals[j], vals[j - 1] = vals[j - 1], vals[j]\n else:\n break\n \n head.val = vals[0]\n cur = head\n i = 1\n while cur.next:\n cur = cur.next\n cur.val = vals[i]\n i += 1\n return head\n","runtime":"952"},{"code":"class Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n vals = [head.val]\n cur = head\n while cur.next:\n cur = cur.next\n vals.append(cur.val)\n \n l = len(vals)\n for i in range(1, l):\n if vals[i] < vals[i - 1]:\n for j in range(i, 0, -1):\n if vals[j] < vals[j - 1]:\n vals[j], vals[j - 1] = vals[j - 1], vals[j]\n else:\n break\n \n head.val = vals[0]\n cur = head\n i = 1\n while cur.next:\n cur = cur.next\n cur.val = vals[i]\n i += 1\n return head\n","runtime":"965"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n insertList = []\n\n if head == None or head.next == None:\n return head\n \n curr = head\n while (curr != None):\n insertList.append(curr.val)\n curr = curr.next\n\n print(insertList)\n for i in range(0, len(insertList)):\n for j in range(i+1,len(insertList)):\n if insertList[i] > insertList[j]:\n insertList[i],insertList[j] = insertList[j],insertList[i]\n print(insertList)\n\n i = 0\n curr = head\n while(curr != None):\n curr.val = insertList[i]\n i += 1\n curr = curr.next\n\n return head\n\n\n","runtime":"979"},{"code":"class Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n vals = [head.val]\n cur = head\n while cur.next:\n cur = cur.next\n vals.append(cur.val)\n \n l = len(vals)\n for i in range(1, l):\n if vals[i] < vals[i - 1]:\n for j in range(i, 0, -1):\n if vals[j] < vals[j - 1]:\n vals[j], vals[j - 1] = vals[j - 1], vals[j]\n else:\n break\n \n head.val = vals[0]\n cur = head\n i = 1\n while cur.next:\n cur = cur.next\n cur.val = vals[i]\n i += 1\n return head\n","runtime":"992"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n insertList = []\n\n if head == None or head.next == None:\n return head\n \n curr = head\n while (curr != None):\n insertList.append(curr.val)\n curr = curr.next\n\n\n for i in range(0, len(insertList)):\n for j in range(i+1,len(insertList)):\n if insertList[i] > insertList[j]:\n insertList[i],insertList[j] = insertList[j],insertList[i]\n\n\n i = 0\n curr = head\n while(curr != None):\n curr.val = insertList[i]\n i += 1\n curr = curr.next\n\n return head\n\n\n","runtime":"1006"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insert(self, head, end):\n tmp = end.val\n curr = head\n while curr != end:\n if curr.val >= tmp:\n curr.val, tmp = tmp, curr.val\n curr = curr.next\n end.val = tmp\n \n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n \n curr = head.next\n while curr:\n self.insert(head, curr)\n curr = curr.next\n \n return head","runtime":"1006"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return head\n\n curr = head\n aux = []\n while curr is not None:\n aux.append(curr)\n curr = curr.next\n self.insertionSort(aux)\n\n for i in range(len(aux)):\n if i == len(aux)-1:\n aux[i].next = None\n else:\n aux[i].next = aux[i + 1]\n return aux[0]\n\n\n def insertionSort(self, nums):\n if len(nums) <= 1: return\n\n sortedRight = 1 # length of sorted region\n for i in range(1, len(nums), 1):\n self.reinsertEnd(nums, 0, i)\n # sortedRight += 1\n\n # arr[0], ... , arr[end-1] is sorted; insert end to maintain sort\n def reinsertEnd(self, array, start, end):\n # find index to insert at\n endNode = array[end]\n ptr = start\n while ptr < end:\n if endNode.val <= array[ptr].val:\n break\n ptr += 1\n\n c = end\n while c > ptr:\n array[c] = array[c-1]\n c -= 1\n array[c] = endNode","runtime":"1019"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: return None\n if not head.next: return head\n node_stack = []\n pass_stack = []\n node = head\n while node:\n nxt = node.next\n node.next = None\n while node_stack and node_stack[-1].val > node.val:\n pass_stack.append(node_stack.pop())\n if node_stack:\n node_stack[-1].next = node\n if pass_stack:\n node.next = pass_stack[-1]\n node_stack.append(node)\n while pass_stack:\n node_stack.append(pass_stack.pop())\n node = nxt\n return node_stack[0]\n","runtime":"1019"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n \n new_head=temp=ListNode(float(\"-inf\"))\n \n \n \n def recursion(head,new_node,val):\n \n if not head:\n return\n \n \n if head.val<=val and head.next is None:\n head.next=new_node\n return\n \n if head.val<=val and head.next.val>=val:\n new_node.next=head.next\n head.next=new_node\n \n \n return\n \n recursion(head.next,new_node,val)\n \n \n \n while head:\n new_temp=head.next\n \n val=head.val\n head.next=None\n \n \n recursion(temp,head,val)\n \n head=new_temp\n \n return new_head.next\n \n \n \n \n \n ","runtime":"1033"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n stack=[]\n temp=head\n while temp:\n stack.append(temp.val)\n temp=temp.next\n n=len(stack)\n for i in range(n):\n j=i\n while j>0 and stack[j-1]>stack[j]:\n stack[j],stack[j-1] = stack[j-1],stack[j]\n j-=1\n temp=head\n i=0\n while temp:\n temp.val=stack[i]\n i+=1\n temp=temp.next\n return head\n","runtime":"1047"},{"code":"class Solution:\n def insertionSortList(self, head):\n cur = head\n while cur:\n j = head\n while j != cur:\n if j.val > cur.val: \n j.val, cur.val = cur.val, j.val\n j = j.next\n cur = cur.next\n return head","runtime":"1060"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass LLIterator:\n def __init__(self, lst:ListNode):\n self.lst = lst\n \n\n def __iter__(self):\n self.curr = self.lst\n return self\n def __next__(self):\n if self.curr:\n a = self.curr\n self.curr = self.curr.next\n return a\n else:\n raise StopIteration\n\n \nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n out = ListNode(-1000, ListNode(head.val))\n curr = out\n iterator = LLIterator(head.next)\n for node in iterator:\n prev = out\n added = False\n for outNode in LLIterator(out.next):\n if outNode.val > node.val:\n prev.next = ListNode(node.val)\n prev.next.next = outNode\n added = True\n break\n prev = outNode\n if not added:\n prev.next = ListNode(node.val)\n \n return out.next\n","runtime":"1074"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return head\n \n node_list = []\n while head:\n node_list.append(head.val)\n head = head.next\n \n self.sort(node_list)\n dummy = ListNode(0)\n head = ListNode(0)\n dummy.next = head\n for i in node_list:\n temp =ListNode(i)\n head.next = temp\n head = head.next\n \n return dummy.next.next\n \n def sort(self, arr):\n \n for i in range(1, len(arr)):\n curr_index = i\n while curr_index >= 1 and arr[curr_index-1] > arr[curr_index]:\n arr[curr_index-1], arr[curr_index] = arr[curr_index], arr[curr_index-1]\n curr_index -= 1\n ","runtime":"1087"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, A: Optional[ListNode]) -> Optional[ListNode]:\n temp=A\n while temp!=None:\n temp2=A\n while temp2!=temp:\n if temp2.val > temp.val:\n temp2.val,temp.val=temp.val,temp2.val\n temp2=temp2.next\n temp=temp.next\n return A","runtime":"1101"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head==None:\\n return\\n \\n temparr = []\\n temp = head\\n while temp!=None:\\n temparr.append(temp.val)\\n temp=temp.next\\n \\n temparr.sort()\\n \\n temp = head\\n i=0\\n while temp!=None:\\n temp.val = temparr[i]\\n i+=1\\n temp = temp.next\\n \\n return head\\n \\n \\n \\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n result = []\\n\\n while head:\\n result.append(head.val)\\n head = head.next\\n\\n result.sort(reverse = True)\\n\\n answer = ListNode(result[0])\\n\\n for i in result[1:]:\\n answer = ListNode(i, answer) \\n\\n return answer\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n values = []\\n dict_list = {}\\n curr = head\\n while curr:\\n values.append(curr.val)\\n if curr.val not in dict_list:\\n dict_list[curr.val] = [curr]\\n else:\\n dict_list[curr.val].append(curr)\\n curr = curr.next\\n \\n values = sorted(values)\\n\\n for i in range(len(values) - 1):\\n for j in range(len(dict_list[values[i]]) - 1):\\n dict_list[values[i]][j].next = dict_list[values[i]][j+1]\\n dict_list[values[i]][-1].next = dict_list[values[i+1]][0]\\n \\n for j in range(len(dict_list[values[-1]]) - 1):\\n dict_list[values[-1]][j].next = dict_list[values[-1]][j+1]\\n dict_list[values[-1]][-1].next = None\\n return dict_list[values[0]][0]\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n vals=[]\\n while head:\\n vals.append(head.val)\\n head=head.next\\n vals.sort()\\n dummy=ListNode()\\n curr=dummy\\n for item in vals:\\n curr.next=ListNode(item)\\n curr=curr.next\\n return dummy.next\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def makeALink(values):\\n if not values:\\n return None\\n head = ListNode(values[0])\\n current = head\\n for val in values[1:]:\\n current.next = ListNode(val)\\n current = current.next\\n return head\\n def insert_sorted(lst, val):\\n left, right = 0, len(lst)\\n while left < right:\\n mid = (left + right) // 2\\n if lst[mid] < val:\\n left = mid + 1\\n else:\\n right = mid\\n lst.insert(left, val)\\n return lst\\n \\n final = []\\n while head:\\n final = insert_sorted(final, head.val)\\n head = head.next\\n return makeALink(final)\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n self.digits = []\\n self._bfs_collect_digits(head)\\n if not self.digits:\\n return None\\n\\n self.digits.sort()\\n self.list_node = ListNode(self.digits.pop(0))\\n self._bfs_build_nodes(self.list_node)\\n return self.list_node\\n \\n def _bfs_collect_digits(self, node: ListNode) -> list[int]:\\n if node is not None:\\n if node.next: # Can extend.\\n self._bfs_collect_digits(node.next)\\n self.digits.append(node.val)\\n return\\n \\n def _bfs_build_nodes(self, list_node: ListNode) -> None:\\n if self.digits: # Still remaining digits.\\n list_node.next = ListNode(self.digits.pop(0))\\n self._bfs_build_nodes(list_node.next)\\n return\\n\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(val=-5001)\\n cur, nxt = head, None # for giving list\\n pre, tail = dummy, dummy\\n while cur:\\n nxt = cur.next\\n cur.next = None\\n # 1. cur bigger than largest one\\n if tail.val <= cur.val:\\n tail.next = cur # put cur at the tail\\n tail = tail.next\\n cur = nxt\\n continue\\n # 2. cur will insert before largest one\\n node = dummy # for output list, reset every time\\n while cur.val >= node.val:\\n pre, node = node, node.next # iterate next\\n pre.next, cur.next = cur, node # insert cur between pre and node\\n\\n cur = nxt\\n return dummy.next\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return head\\n \\n dummy = ListNode(0)\\n dummy.next = head\\n curr = head.next\\n lastSorted = head\\n\\n while curr:\\n if lastSorted.val <= curr.val:\\n lastSorted = lastSorted.next\\n else:\\n prev = dummy\\n while prev.next.val <= curr.val:\\n prev = prev.next\\n lastSorted.next = curr.next\\n curr.next = prev.next\\n prev.next = curr\\n curr = lastSorted.next\\n return dummy.next\\n\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return head\\n\\n dummy_head = ListNode(-float(inf))\\n last_sorted = head\\n cur = last_sorted.next\\n dummy_head.next = last_sorted\\n # print(dummy_head)\\n\\n while cur is not None:\\n # print(\\\"==\\\"*5)\\n # print(dummy_head.next)\\n # print('\\\\n')\\n prev = dummy_head\\n if cur.val < last_sorted.val:\\n while prev.next.val < cur.val:\\n prev = prev.next\\n\\n last_sorted.next = cur.next\\n\\n # print(\\\"ls\\\", last_sorted)\\n # print(\\\"prev\\\", prev.next)\\n ##cur.next = last_sorted # wrong\\n cur.next = prev.next\\n prev.next = cur\\n\\n cur = last_sorted.next\\n else:\\n last_sorted = last_sorted.next\\n cur = cur.next\\n\\n return dummy_head.next\\n\",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # Edge case: if the list is empty or has only one node, it's already sorted\\n if not head or not head.next:\\n return head\\n\\n # Initialize a dummy node to act as the head of the sorted part of the list\\n dummy = ListNode(0) # dummy node with a value of 0\\n dummy.next = head \\n curr = head\\n \\n while curr.next:\\n if curr.val <= curr.next.val:\\n curr = curr.next\\n else:\\n prev = dummy\\n to_insert = curr.next\\n\\n while prev.next and prev.next.val < to_insert.val:\\n prev = prev.next\\n\\n curr.next = curr.next.next\\n to_insert.next = prev.next\\n prev.next = to_insert\\n \\n return dummy.next\\n \\n \\n \\n \",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n if not head or not head.next:\\n return head\\n \\n curr = head\\n new_head = ListNode(0)\\n new_head.next = head\\n new_curr = new_head\\n\\n while curr:\\n if curr.next and curr.val> curr.next.val:\\n while new_curr.next and new_curr.next.val < curr.next.val:\\n new_curr= new_curr.next\\n temp = new_curr.next\\n new_curr.next = curr.next\\n curr.next = curr.next.next\\n new_curr.next.next = temp\\n new_curr = new_head\\n else:\\n curr = curr.next\\n return new_head.next\\n\\n\",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head.next == None:\\n return head\\n prev = head\\n node = head.next\\n while node != None:\\n if node.val >= prev.val:\\n prev = node\\n node = node.next\\n else:\\n curr = node.val\\n prev.next = node.next\\n node = prev.next\\n curr_node = head\\n print(curr)\\n while True:\\n if curr <= curr_node.val:\\n head = ListNode(val=curr, next=curr_node)\\n break\\n elif curr > curr_node.val and curr <= curr_node.next.val:\\n next_node = curr_node.next\\n curr_node.next = ListNode(val=curr, next=next_node)\\n break\\n else:\\n curr_node = curr_node.next\\n \\n return head\\n \",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0)\\n dummy.next = head\\n pre, cur = dummy, head\\n while cur:\\n if cur.next and cur.next.val < cur.val:\\n while pre.next and pre.next.val < cur.next.val:\\n pre = pre.next\\n temp = pre.next\\n pre.next = cur.next\\n cur.next = cur.next.next\\n pre.next.next = temp\\n pre = dummy\\n else:\\n cur = cur.next\\n return dummy.next\",\n \"runtime\": \"112\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # 创建一个虚拟节点，它的 next 指向链表的头节点\\n\\n dummy = ListNode(0)\\n dummy.next = head\\n curr = head\\n\\n while curr and curr.next:\\n if curr.val <= curr.next.val:\\n curr = curr.next\\n continue\\n\\n to_insert = curr.next\\n prev = dummy\\n \\n while prev.next and prev.next.val <= to_insert.val:\\n prev = prev.next\\n \\n curr.next = to_insert.next\\n to_insert.next = prev.next\\n prev.next = to_insert\\n \\n return dummy.next\\n\\n\",\n \"runtime\": \"112\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n temp=head\\n val={}\\n nodes=[]\\n\\n while temp is not None:\\n if temp.val not in val.keys():\\n val[temp.val]=[temp]\\n else:\\n val[temp.val]=[*val[temp.val],temp]\\n if temp.val not in nodes:\\n nodes.append(temp.val)\\n temp=temp.next\\n\\n nodes.sort()\\n ans=[]\\n\\n for i in range(len(nodes)):\\n ans.extend(val[nodes[i]])\\n\\n head=ans[0]\\n temp=head\\n count=1\\n\\n while temp is not None:\\n if count < len(ans):\\n temp.next=ans[count]\\n if count==len(ans):\\n temp.next=None\\n temp=temp.next\\n count+=1\\n \\n return head\",\n \"runtime\": \"125\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n temp=head\\n val={}\\n nodes=[]\\n\\n while temp is not None:\\n if temp.val not in val.keys():\\n val[temp.val]=[temp]\\n else:\\n val[temp.val]=[*val[temp.val],temp]\\n if temp.val not in nodes:\\n nodes.append(temp.val)\\n temp=temp.next\\n\\n nodes.sort()\\n ans=[]\\n\\n for i in range(len(nodes)):\\n print(i)\\n ans.extend(val[nodes[i]])\\n\\n head=ans[0]\\n temp=head\\n count=1\\n\\n while temp is not None:\\n if count < len(ans):\\n temp.next=ans[count]\\n if count==len(ans):\\n temp.next=None\\n temp=temp.next\\n count+=1\\n \\n return head\",\n \"runtime\": \"139\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(float('-inf'), head) \\n \\n previous = new_head\\n node = head\\n while node:\\n node.previous = previous\\n previous = node\\n node = node.next\\n\\n node = head\\n while node:\\n \\n curr = node.previous\\n while node.val < curr.val:\\n curr = curr.previous\\n \\n if node.previous == curr:\\n node = node.next\\n continue\\n \\n node_previous = node.previous\\n node_next = node.next\\n node_previous.next = node_next\\n if node_next:\\n node_next.previous = node_previous\\n\\n curr_next = curr.next\\n curr.next = node\\n node.next = curr_next\\n node.previous = curr\\n curr_next.previous = node\\n\\n node = node_next\\n \\n return new_head.next\\n\",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(float('-inf'), head)\\n \\n previous = new_head\\n node = head\\n while node:\\n node.previous = previous\\n previous = node\\n node = node.next\\n\\n node = head\\n while node:\\n \\n curr = node.previous\\n while node.val < curr.val:\\n curr = curr.previous\\n \\n if node.previous == curr:\\n node = node.next\\n continue\\n \\n node_previous = node.previous\\n node_next = node.next\\n node_previous.next = node_next\\n if node_next:\\n node_next.previous = node_previous\\n\\n curr_next = curr.next\\n curr.next = node\\n node.next = curr_next\\n node.previous = curr\\n curr_next.previous = node\\n\\n node = node_next\\n \\n return new_head.next\\n\",\n \"runtime\": \"166\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(float('-inf'), head)\\n \\n previous = new_head\\n node = head\\n while node:\\n node.previous = previous\\n previous = node\\n node = node.next\\n\\n node = head\\n while node:\\n \\n curr = node.previous\\n while node.val < curr.val:\\n curr = curr.previous\\n \\n if node.previous == curr:\\n node = node.next\\n continue\\n \\n node_previous = node.previous\\n node_next = node.next\\n node_previous.next = node_next\\n if node_next:\\n node_next.previous = node_previous\\n\\n curr_next = curr.next\\n curr.next = node\\n node.next = curr_next\\n node.previous = curr\\n curr_next.previous = node\\n\\n node = node_next\\n \\n return new_head.next\\n\",\n \"runtime\": \"179\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(float('-inf'), head)\\n \\n previous = new_head\\n node = head\\n while node:\\n node.previous = previous\\n previous = node\\n node = node.next\\n\\n node = head\\n while node:\\n \\n curr = node.previous\\n while node.val < curr.val:\\n curr = curr.previous\\n \\n if node.previous == curr:\\n node = node.next\\n continue\\n \\n node_previous = node.previous\\n node_next = node.next\\n node_previous.next = node_next\\n if node_next:\\n node_next.previous = node_previous\\n\\n curr_next = curr.next\\n curr.next = node\\n node.next = curr_next\\n node.previous = curr\\n curr_next.previous = node\\n\\n node = node_next\\n \\n return new_head.next\\n\",\n \"runtime\": \"193\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(float('-inf'), head) \\n \\n previous = new_head\\n node = head\\n while node:\\n node.previous = previous\\n previous = node\\n node = node.next\\n\\n node = head\\n while node:\\n \\n curr = node.previous\\n if node.val > curr.val:\\n node = node.next\\n continue\\n\\n while node.val < curr.val:\\n curr = curr.previous\\n \\n if node.previous == curr:\\n node = node.next\\n continue\\n \\n node_previous = node.previous\\n node_next = node.next\\n node_previous.next = node_next\\n if node_next:\\n node_next.previous = node_previous\\n\\n curr_next = curr.next\\n curr.next = node\\n node.next = curr_next\\n node.previous = curr\\n curr_next.previous = node\\n\\n node = node_next\\n \\n return new_head.next\\n\",\n \"runtime\": \"206\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(float('-inf'), head) \\n \\n previous = new_head\\n node = head\\n while node:\\n node.previous = previous\\n previous = node\\n node = node.next\\n\\n node = head\\n while node:\\n \\n curr = node.previous\\n if node.val > curr.val:\\n node = node.next\\n continue\\n\\n while node.val < curr.val:\\n curr = curr.previous\\n \\n if node.previous == curr:\\n node = node.next\\n continue\\n \\n node_previous = node.previous\\n node_next = node.next\\n node_previous.next = node_next\\n if node_next:\\n node_next.previous = node_previous\\n\\n curr_next = curr.next\\n curr.next = node\\n node.next = curr_next\\n node.previous = curr\\n curr_next.previous = node\\n\\n node = node_next\\n \\n return new_head.next\\n\",\n \"runtime\": \"220\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(float('-inf'), head)\\n \\n previous = new_head\\n node = head\\n while node:\\n node.previous = previous\\n previous = node\\n node = node.next\\n\\n node = head\\n while node:\\n \\n curr = node.previous\\n while node.val < curr.val:\\n curr = curr.previous\\n \\n if node.previous == curr:\\n node = node.next\\n continue\\n \\n node_previous = node.previous\\n node_next = node.next\\n node_previous.next = node_next\\n if node_next:\\n node_next.previous = node_previous\\n\\n curr_next = curr.next\\n curr.next = node\\n node.next = curr_next\\n node.previous = curr\\n curr_next.previous = node\\n\\n node = node_next\\n \\n return new_head.next\\n\",\n \"runtime\": \"247\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(float('-inf'), head) \\n \\n previous = new_head\\n node = head\\n while node:\\n node.previous = previous\\n previous = node\\n node = node.next\\n\\n node = head\\n while node:\\n \\n curr = node.previous\\n if node.val > curr.val:\\n node = node.next\\n continue\\n\\n while node.val < curr.val:\\n curr = curr.previous\\n \\n if node.previous == curr:\\n node = node.next\\n continue\\n \\n node_previous = node.previous\\n node_next = node.next\\n node_previous.next = node_next\\n if node_next:\\n node_next.previous = node_previous\\n\\n curr_next = curr.next\\n curr.next = node\\n node.next = curr_next\\n node.previous = curr\\n curr_next.previous = node\\n\\n node = node_next\\n \\n return new_head.next\\n\",\n \"runtime\": \"261\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode(object):\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\nclass Solution(object):\\n def insertionSortList(self, head):\\n \\\"\\\"\\\"\\n :type head: ListNode\\n :rtype: ListNode\\n \\\"\\\"\\\"\\n def insert(head, j, ins, prev_ins, prev_j):\\n \\\"\\\"\\\" insert ins in front of j\\\"\\\"\\\"\\n prev_ins.next = ins.next\\n ins.next=j\\n if prev_j is not None:\\n prev_j.next = ins\\n else:\\n head = ins\\n return head, prev_ins\\n \\n current = head\\n prev_current = None\\n while current is not None:\\n prev_current = current\\n current = current.next\\n if current is None:\\n break\\n j = head\\n prev_j = None\\n while current.val > j.val:\\n prev_j = j\\n j = j.next\\n if current != j:\\n head, current = insert(head, j, current, prev_current, prev_j)\\n\\n return head\",\n \"runtime\": \"274\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n curr_node = head.next\\n curr_node_prev = head\\n \\n while curr_node:\\n next_node = curr_node.next\\n comparison_node_prev = None\\n comparison_node = head\\n \\n while curr_node.val > comparison_node.val:\\n comparison_node_prev = comparison_node\\n comparison_node = comparison_node.next\\n if comparison_node == curr_node:\\n curr_node_prev = curr_node\\n curr_node = next_node\\n continue\\n\\n curr_node_prev.next = curr_node.next\\n curr_node.next = comparison_node\\n \\n if comparison_node_prev:\\n comparison_node_prev.next = curr_node\\n else:\\n head = curr_node\\n \\n curr_node = next_node\\n \\n return head\",\n \"runtime\": \"288\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n def insertionSort(arr: list,val: int) -> list:\\n flag = 0\\n if len(arr) == 0:\\n arr.append(val)\\n else:\\n for i in range(len(arr)):\\n if arr[i] < val:\\n continue\\n \\n arr.insert(i,val)\\n flag = 1\\n break\\n if flag == 0:\\n arr.append(val)\\n return arr\\n temp = head\\n arr = []\\n while temp != None:\\n arr = insertionSort(arr,temp.val)\\n temp = temp.next\\n \\n temp = head\\n for i in arr:\\n temp.val = i\\n temp=temp.next\\n \\n return head\",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n fs = ListNode(0, head)\\n prev_sort, cur_sort = head, head.next\\n # sort each node\\n while cur_sort:\\n prev, cur = fs, fs.next\\n # print(\\\"cur_sort\\\", cur_sort.val)\\n # print(\\\"list\\\", fs)\\n while cur_sort.val > cur.val:\\n prev = cur\\n cur = cur.next\\n # print(\\\"prev\\\", prev.val, \\\"cur\\\", cur.val)\\n if cur == cur_sort:\\n prev_sort = cur_sort\\n cur_sort = cur_sort.next\\n else:\\n # remove cur_sort from initial position\\n prev_sort.next = cur_sort.next \\n \\n # place cur_sort inbetween prev and cur\\n prev.next = cur_sort \\n cur_sort.next = cur\\n \\n cur_sort = prev_sort.next\\n return fs.next\\n\",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return None\\n new_head = head\\n old_head = head.next\\n head.next = None\\n while old_head is not None:\\n cur = old_head\\n old_head = old_head.next\\n if cur.val < new_head.val:\\n cur.next = new_head\\n new_head = cur\\n else:\\n prev, cur2 = new_head, new_head.next\\n while cur2 is not None and cur.val >= cur2.val:\\n cur2, prev = cur2.next, cur2\\n\\n prev.next = cur\\n cur.next = cur2\\n return new_head\\n\\n \",\n \"runtime\": \"315\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sorted, unsorted = ListNode(-sys.maxsize - 1), head\\n while unsorted:\\n next_unsorted = unsorted.next #save next pointer\\n #insert the unsorted node between prev & next\\n prev, next = None, sorted\\n while next and unsorted.val > next.val:\\n prev, next = next, next.next\\n prev.next = unsorted\\n unsorted.next = next\\n unsorted = next_unsorted\\n return sorted.next\",\n \"runtime\": \"328\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insert_sorted(self, sent, num):\\n node = sent.next\\n prev = sent\\n while node is not None:\\n if num <= node.val:\\n break\\n prev = node\\n node = node.next\\n prev.next = ListNode(num, node)\\n\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sent = ListNode(None, None)\\n node = head\\n while node is not None:\\n self.insert_sorted(sent, node.val)\\n node = node.next\\n return sent.next\\n\",\n \"runtime\": \"342\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n if not head: \\n return head \\n\\n nxt = head.next \\n head.next = None\\n sorted_head = head\\n \\n while nxt: \\n temp_next = nxt.next \\n sorted_head = self.sorted_insert(sorted_head, nxt)\\n nxt = temp_next \\n return sorted_head \\n\\n\\n def sorted_insert(self, head, node ):\\n curr_val = node.val\\n curr_node = head \\n\\n if head.val > node.val: \\n node.next = head\\n return node \\n\\n # advance until we reach the end of the list or find a value \\n # greater than the current node \\n while curr_node.next is not None and curr_node.next.val < curr_val: \\n curr_node = curr_node.next \\n\\n \\n nxt = curr_node.next \\n curr_node.next = node \\n node.next = nxt \\n return head \\n\\n\\n\\n\",\n \"runtime\": \"342\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n #1st & 2nd part: sorted and unsorted part\\n first, second = ListNode(-sys.maxsize - 1), head\\n while second:\\n next = second.next #save next pointer\\n prev, current = None, first\\n while current and second.val > current.val:\\n prev, current = current, current.next\\n prev.next = second\\n if current:\\n second.next = current\\n else:\\n second.next = None\\n second = next\\n return first.next\",\n \"runtime\": \"355\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\nclass Solution:\\n def insertNode(self, node):\\n\\n nodeVal = node.val\\n currentSorted = self.sortedNodes\\n if nodeVal <= currentSorted.val:\\n\\n node.next = currentSorted\\n self.sortedNodes = node\\n return None\\n while currentSorted.next:\\n\\n if currentSorted.next.val >= nodeVal:\\n node.next = currentSorted.next\\n currentSorted.next = node\\n return None\\n currentSorted = currentSorted.next\\n currentSorted.next = node\\n node.next = None\\n\\n \\n def insertionSortList(self, head):\\n current = head.next\\n if current:\\n nextCurrent = current.next\\n else:\\n return head\\n self.sortedNodes = head\\n self.sortedNodes.next = None\\n while current:\\n self.insertNode(current)\\n \\n current = nextCurrent\\n if current:\\n if current.next:\\n nextCurrent = current.next\\n else:\\n break\\n else:\\n return self.sortedNodes\\n self.insertNode(current)\\n return self.sortedNodes\",\n \"runtime\": \"355\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(-float('inf'), ListNode(head.val))\\n head = head.next\\n while head:\\n prev, cur = dummy, dummy.next\\n while cur and head.val > cur.val:\\n prev, cur = cur, cur.next\\n nxt = head.next\\n head.next = cur\\n prev.next = head\\n head = nxt\\n return dummy.next\\n\",\n \"runtime\": \"369\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n \\n sorted_head = ListNode(0)\\n curr = head\\n # arr = []\\n\\n while curr:\\n prev = sorted_head\\n next_node = sorted_head.next\\n \\n while next_node:\\n if next_node.val > curr.val:\\n break\\n\\n prev = next_node\\n next_node = next_node.next\\n\\n next_iter = curr.next\\n curr.next = next_node\\n prev.next = curr\\n curr = next_iter\\n \\n return sorted_head.next\",\n \"runtime\": \"369\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n dummy=ListNode(0)\\n current=head\\n while current:\\n prev=dummy\\n nextnode=dummy.next\\n\\n while nextnode and nextnode.val<current.val:\\n prev=nextnode\\n nextnode=nextnode.next\\n\\n nextiter=current.next\\n\\n prev.next=current\\n current.next=nextnode\\n\\n current=nextiter\\n\\n return dummy.next\",\n \"runtime\": \"383\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n start = ListNode(float('-inf'), head)\\n prev = head\\n node = prev.next\\n while node:\\n nxt = node.next\\n head = start\\n prev.next = None\\n tmp = head\\n while head and head.val < node.val:\\n tmp = head\\n head = head.next\\n if not head: \\n prev.next = node \\n prev = node\\n else:\\n tmp.next = node \\n node.next = head\\n prev.next = nxt\\n node = nxt\\n return start.next\\n \\n\\n\\n \",\n \"runtime\": \"383\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\n\\n\\n\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n # edge cases:\\n if head is None:\\n return None\\n\\n dummy = ListNode(0)\\n current = head\\n\\n while current is not None:\\n prev = dummy\\n while prev.next is not None and prev.next.val < current.val:\\n prev = prev.next\\n \\n next_node = current.next\\n\\n current.next = prev.next\\n prev.next = current\\n\\n current = next_node\\n\\n return dummy.next\\n\\n # p = head.next\\n\\n # while p is not None:\\n \\n # if (p.val < head.val):\\n\\n \\n # newNode = ListNode(p.val)\\n # newNode.next = head\\n # head = newNode\\n\\n\\n # else:\\n # c = head\\n # while c is not p:\\n # if p.val >= c.val and p.val <= c.next.val:\\n # newNode = ListNode(p.val)\\n # newNode.next = c.next\\n # c.next = newNode\\n\\n # if c.next is p:\\n # c.next = p.next\\n\\n # c = c.next\\n\\n # p = p.next\\n\\n # return head\\n\\n\\n\\n # while current_node is not None:\\n # iteration_node = current_node\\n # while iteration_node.next is not None:\\n # if iteration_node.val > iteration_node.next.val:\\n # temp = iteration_node.val\\n # iteration_node.val = iteration_node.next.val\\n # iteration_node.next.val = temp\\n # iteration_node = iteration_node.next\\n # else:\\n # break\\n # current_node = head\\n\\n # return head\\n \\n \\n # def loop(node):\\n # prev = root.node\\n # while :\\n # temp = node.val\\n # node.val = node.next.val\\n # node.next.val = node\\n\\n # node = head\\n # while ()\\n\\n\\n\\n\\n # while node is not None:\\n\\n\",\n \"runtime\": \"396\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n res = ListNode(-5001)\\n h=res\\n h.next = head\\n while h.next:\\n hprev = h\\n h = h.next\\n temp = res\\n while temp.next and temp.next.val < h.val:\\n temp = temp.next\\n \\n if temp.next and temp.next is not h:\\n hprev.next = h.next\\n h.next = temp.next\\n temp.next = h\\n h = hprev\\n return res.next\\n\",\n \"runtime\": \"396\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode()\\n dummy.next = head\\n \\n last, pointer = head, head.next\\n while pointer:\\n temp = pointer.next\\n\\n prev, cur = dummy, dummy.next\\n\\n while cur and cur.val < pointer.val:\\n cur, prev = cur.next, prev.next\\n \\n\\n if cur != pointer:\\n prev.next = pointer\\n pointer.next = cur\\n last.next = temp\\n else:\\n last = pointer\\n \\n pointer = temp\\n\\n return dummy.next\\n\\n \",\n \"runtime\": \"410\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy_head = ListNode()\\n curr = head\\n\\n while curr:\\n prev_pointer = dummy_head\\n next_pointer = dummy_head.next\\n\\n while next_pointer:\\n if curr.val < next_pointer.val:\\n break\\n prev_pointer = prev_pointer.next\\n next_pointer = next_pointer.next\\n # assign the curr to the temp varibale in order to move the next \\n temp = curr.next\\n #insert the node to the correct position\\n curr.next = next_pointer\\n prev_pointer.next = curr \\n \\n # move the curr to next node \\n curr = temp \\n \\n return dummy_head.next \",\n \"runtime\": \"410\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0)\\n curr = head\\n\\n while curr:\\n prev = dummy\\n while prev.next and prev.next.val < curr.val:\\n prev = prev.next\\n temp = curr.next\\n curr.next = prev.next\\n prev.next = curr\\n curr = temp\\n\\n return dummy.next\",\n \"runtime\": \"423\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n src = head.next \\n dest = ListNode(head.val)\\n # 1-->2--->3-->4--->5\\n # 5--8--7\\n while src:\\n node = ListNode(src.val)\\n if src.val < dest.val:\\n node.next = dest\\n dest = node\\n else:\\n prev = None\\n temp = dest\\n while temp and temp.val <= src.val:\\n prev = temp\\n temp = temp.next\\n prev.next = node\\n node.next = temp \\n\\n src = src.next \\n return dest\\n \\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"423\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n sentinel = ListNode()\\n curr = head\\n\\n while curr:\\n prev = sentinel\\n while prev.next and prev.next.val < curr.val:\\n prev = prev.next\\n\\n curr.next, prev.next, curr = prev.next, curr, curr.next\\n\\n return sentinel.next\\n\\n\\n def insertionSortList2(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n sorted_head = ListNode(next=head)\\n cur = head.next\\n head.next = None # cut the link!\\n\\n while cur:\\n cur_sorted = sorted_head\\n while cur_sorted.next and cur_sorted.next.val < cur.val:\\n cur_sorted = cur_sorted.next\\n\\n cur.next, cur_sorted.next, cur = cur_sorted.next, cur, cur.next\\n\\n return sorted_head.next\\n\\n\\n # not working as no clear delimitation between sorted and non sorted part\\n def insertionSortList_not(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n sorted_head = ListNode(next=head)\\n cur = head.next\\n\\n while cur:\\n cur_sorted = sorted_head\\n while cur_sorted.next and cur_sorted.next.val < cur.val:\\n cur_sorted = cur_sorted.next\\n\\n cur.next, cur_sorted.next, cur = cur_sorted.next, cur, cur.next\\n\\n return sorted_head.next\",\n \"runtime\": \"437\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode()\\n curr_node = head\\n while curr_node:\\n prev_node = dummy\\n while prev_node.next and prev_node.next.val <= curr_node.val:\\n prev_node = prev_node.next\\n next_node = curr_node.next\\n curr_node.next = prev_node.next\\n prev_node.next = curr_node\\n curr_node = next_node\\n return dummy.next\",\n \"runtime\": \"437\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head.next:\\n return head\\n dummy=ListNode(-1)\\n re=dummy\\n cur=head\\n nxt=None\\n while cur:\\n nxt=cur.next\\n while re.next and re.next.val<cur.val:\\n re=re.next\\n cur.next=re.next\\n re.next=cur\\n re=dummy\\n cur=nxt\\n return dummy.next\",\n \"runtime\": \"450\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: ListNode) -> ListNode:\\n dummy = ListNode()\\n curr = head\\n\\n while curr:\\n # At each iteration, we insert an element into the resulting list.\\n prev = dummy\\n\\n # find the position to insert the current node\\n while prev.next and prev.next.val <= curr.val:\\n prev = prev.next\\n\\n next = curr.next\\n # insert the current node to the new list\\n curr.next = prev.next\\n prev.next = curr\\n\\n # moving on to the next iteration\\n curr = next\\n\\n return dummy.next\\n \\n \",\n \"runtime\": \"450\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0)\\n curr = head\\n \\n while curr:\\n # At each iteration, insert curr into the sorted part of the list\\n prev = dummy\\n next_node = curr.next\\n \\n # Find the right place to insert the current node\\n while prev.next and prev.next.val < curr.val:\\n prev = prev.next\\n \\n # Insert the current node into the sorted list\\n curr.next = prev.next\\n prev.next = curr\\n \\n # Move to the next node in the original list\\n curr = next_node\\n \\n return dummy.next\\n \",\n \"runtime\": \"464\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sorted_list = ListNode(val=head.val)\\n node = head.next\\n while node:\\n val = node.val\\n\\n s_node = sorted_list\\n prev_el = None\\n while s_node:\\n if val > s_node.val:\\n if s_node.next:\\n prev_el = s_node\\n s_node = s_node.next\\n else:\\n s_node.next = ListNode(val=val)\\n break\\n else:\\n newNode = ListNode(val=val, next=s_node)\\n if prev_el:\\n prev_el.next = newNode\\n else:\\n sorted_list = newNode\\n break\\n\\n node = node.next\\n \\n return sorted_list\",\n \"runtime\": \"464\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # Create a dummy head to simplify insertion\\n dummy_head = ListNode(-1)\\n dummy_head.next = None\\n\\n curr = head\\n while curr:\\n # Sort each node one by one\\n curr = self.sort(curr, dummy_head)\\n \\n # Return the sorted list (excluding the dummy head)\\n return dummy_head.next\\n \\n def sort(self, curr: Optional[ListNode], dummy_head: ListNode) -> ListNode:\\n # Save the next node to be processed\\n next_node = curr.next\\n # Detach the current node from the original list\\n curr.next = None\\n\\n ptr = dummy_head\\n while ptr:\\n # Find the correct position to insert the current node\\n if not ptr.next or ptr.next.val > curr.val:\\n # Insert the current node\\n next_segment = ptr.next\\n ptr.next = curr\\n curr.next = next_segment\\n break\\n \\n ptr = ptr.next\\n \\n # Return the next node to be processed\\n return next_node\",\n \"runtime\": \"477\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\n\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0)\\n curr = head # The node we are currently processing in the original list\\n \\n while curr:\\n # At each step, we need to insert curr into the correct place in the sorted part.\\n prev = dummy\\n # Find the correct place to insert curr\\n while prev.next and prev.next.val < curr.val:\\n prev = prev.next\\n \\n # Store the next node to process in a temp variable\\n next_temp = curr.next\\n # Insert curr into the sorted part of the list\\n curr.next = prev.next\\n prev.next = curr\\n \\n # Move to the next node in the original list\\n curr = next_temp\\n \\n # Return the sorted list, which starts at dummy.next\\n return dummy.next\\n \",\n \"runtime\": \"477\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def insert(head, value):\\n if value <= head.val:\\n head = ListNode(value, head)\\n return head\\n node = head\\n next_node = head.next\\n while node is not None and next_node is not None:\\n if value > node.val and value <= next_node.val:\\n new_node = ListNode(value, next_node)\\n node.next = new_node\\n return head\\n else:\\n next_node = next_node.next\\n node = node.next\\n node.next = ListNode(value, None)\\n return head\\n\\n new_head = ListNode(head.val, None)\\n node = head.next\\n while node is not None:\\n # print(new_head, node)\\n new_head = insert(new_head, node.val)\\n node = node.next\\n return new_head\\n\",\n \"runtime\": \"491\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n\\n if not head.next:\\n return head\\n\\n l, r = head, head.next\\n l.next = None\\n while r:\\n if r.val <= l.val:\\n tmp = r.next\\n r.next = l\\n l = r\\n r = tmp\\n continue\\n curr = l\\n while curr.next and curr.next.val < r.val:\\n curr = curr.next\\n tmp = curr.next\\n curr.next = r\\n r = r.next\\n curr.next.next = tmp\\n return l\\n \\n\",\n \"runtime\": \"491\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n dummy = ListNode(0)\\n # any nodes before head are sorted\\n while head:\\n next = head.next\\n prev = dummy\\n while prev and prev.next and prev.next.val < head.val:\\n prev = prev.next\\n head.next = prev.next\\n prev.next = head\\n head = next\\n return dummy.next\\n\\n# 0->2->4\\n# p\\n# 1,3\\n# h n\\n\\n \",\n \"runtime\": \"505\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n if head is None or head.next is None:\\n return head\\n \\n\\n def insert(head, node):\\n if head.next is None:\\n node.next = None\\n head.next = node\\n else:\\n prev = head\\n nxt = head.next\\n while nxt is not None:\\n if nxt.val > node.val:\\n node.next = nxt\\n prev.next = node\\n break\\n else:\\n nxt = nxt.next\\n prev = prev.next\\n \\n if nxt is None:\\n prev.next = node\\n\\n curr = head\\n nxt = head.next\\n\\n output = ListNode()\\n\\n while nxt is not None:\\n if curr.val > nxt.val:\\n insert(output, ListNode(nxt.val))\\n curr.next = nxt.next\\n nxt = nxt.next\\n else:\\n insert(output, ListNode(curr.val))\\n curr = curr.next\\n nxt = nxt.next\\n \\n insert(output, ListNode(curr.val))\\n return output.next\",\n \"runtime\": \"505\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def insort(head, new):\\n if head is None:\\n return ListNode(new)\\n if new < head.val:\\n return ListNode(new, head)\\n else:\\n # Insert element in middle of linked list\\n node = head\\n while node.next:\\n if node.val <= new <= node.next.val:\\n tmp = node.next\\n node.next = ListNode(new)\\n node.next.next = tmp\\n return head\\n node = node.next\\n else:\\n node.next = ListNode(new)\\n return head\\n \\n new_head = None\\n while head:\\n new_head = insort(new_head, head.val)\\n head = head.next\\n return new_head\\n\\n \",\n \"runtime\": \"518\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(float('-inf'))\\n \\n while head:\\n # On each iteration, remove head from the original list\\n curr = head\\n head = head.next\\n \\n # Find the correct place to insert the current node in the sorted list\\n prev = dummy\\n while prev.next and prev.next.val < curr.val:\\n prev = prev.next\\n \\n # Insert the current node into the sorted list\\n curr.next = prev.next\\n prev.next = curr\\n \\n return dummy.next\\n\",\n \"runtime\": \"518\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n end = head.next\\n prev_end = head\\n while end:\\n curr = head\\n prev = None\\n while curr != end and curr.val < end.val:\\n prev = curr\\n curr = curr.next\\n if curr != end:\\n prev_end.next = end.next\\n end.next = curr\\n if prev:\\n prev.next = end\\n else:\\n head = end\\n end = prev_end.next\\n else:\\n prev_end = end\\n end = end.next\\n return head\\n \\n\\n \",\n \"runtime\": \"532\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n tmp1 = head.next\\n prev = head\\n\\n dummy = ListNode(-1, head)\\n\\n while tmp1:\\n curr = tmp1\\n tmp2 = prev2 = dummy.next\\n while tmp2 != curr and curr.val >= tmp2.val:\\n prev2 = tmp2\\n tmp2 = tmp2.next\\n #already in order\\n if curr == tmp2:\\n prev = tmp1\\n tmp1 = tmp1.next\\n continue\\n\\n # not the very front\\n if prev2 != tmp2:\\n prev2.next = curr\\n else:\\n dummy.next = curr\\n #link last element to next\\n prev.next = curr.next\\n #linke curr.next to actual next\\n\\n curr.next = tmp2\\n tmp1 = prev.next\\n # self.print(dummy)\\n # if tmp1:\\n # print(tmp1.val)\\n # print(prev.val)\\n\\n return dummy.next\\n\\n def print(self, head):\\n ret = []\\n while head:\\n ret.append(head.val)\\n head = head.next\\n \\n print(ret)\",\n \"runtime\": \"532\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head.next == None:\\n return head\\n sorted_head = head\\n curr = head.next\\n head.next = None\\n while curr:\\n nxt = curr.next\\n sorted_prev = None\\n sorted_curr = sorted_head\\n while sorted_curr:\\n if sorted_curr == sorted_head and curr.val < sorted_curr.val:\\n curr.next = sorted_curr\\n sorted_head = curr\\n break\\n elif curr.val < sorted_curr.val:\\n sorted_prev.next = curr\\n curr.next = sorted_curr\\n break\\n else:\\n sorted_prev = sorted_curr\\n sorted_curr = sorted_curr.next\\n if sorted_curr == None:\\n sorted_prev.next = curr\\n curr.next = None\\n curr = nxt\\n\\n return sorted_head\\n\\n\\n\\n \\n \\n\\n\\n\\n\",\n \"runtime\": \"545\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def insert(head: ListNode, node: ListNode):\\n if node.val <= head.val:\\n nuNode = ListNode(node.val)\\n nuNode.next = head\\n return nuNode\\n left = head\\n right = head.next\\n while right is not None:\\n if node.val > left.val and node.val <= right.val:\\n nuNode = ListNode(node.val)\\n left.next = nuNode\\n nuNode.next = right\\n return head\\n left = right\\n right = right.next\\n left.next = ListNode(node.val)\\n return head\\n\\n nuHead = ListNode(head.val)\\n node = head.next\\n while node is not None:\\n nuHead = insert(nuHead, node)\\n node = node.next\\n return nuHead\",\n \"runtime\": \"545\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return head\\n runn = head.next\\n head.next = None\\n while not runn is None:\\n curr = runn\\n runn = runn.next\\n if head.val > curr.val:\\n curr.next = head\\n head = curr\\n else:\\n loop = head\\n while not loop.next is None and loop.next.val < curr.val:\\n loop = loop.next\\n curr.next = loop.next\\n loop.next = curr\\n return head\\n \",\n \"runtime\": \"559\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummyhead = ListNode(next=head)\\n start = head\\n prev = dummyhead\\n while start is not None:\\n temp = dummyhead\\n nxt = start.next\\n inserted = False\\n while temp.next != start:\\n if start.val < temp.next.val:\\n # insert here\\n prev.next = start.next\\n tmp = temp.next\\n temp.next = start\\n start.next = tmp \\n inserted = True\\n break\\n temp = temp.next\\n if not inserted:\\n prev = start\\n start = nxt\\n return dummyhead.next\",\n \"runtime\": \"559\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def f(head,l):\\n if head==None:\\n return l\\n if l==None:\\n k=head.next\\n head.next=None\\n return f(k,head)\\n if l.val>=head.val:\\n k=head.next\\n head.next=l\\n l=head\\n return f(k,l)\\n r=l\\n prec=None\\n while r!=None:\\n if head.val<=r.val:\\n k=head.next\\n head.next=r\\n r=head\\n prec.next=r\\n return f(k,l)\\n prec=r\\n r=r.next\\n k=head.next\\n head.next=None\\n r=head\\n prec.next=r\\n return f(k,l)\\n return f(head,None)\\n \\n\\n\\n\\n\",\n \"runtime\": \"572\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n node = head.next\\n head.next = None\\n head = ListNode(-10_000, next=head)\\n while node:\\n head_tmp = head\\n tmp = node\\n node = node.next\\n \\n while head_tmp:\\n if head_tmp.next == None or head_tmp.next.val > tmp.val:\\n tmp.next = head_tmp.next\\n head_tmp.next = tmp\\n break\\n head_tmp = head_tmp.next\\n \\n return head.next\",\n \"runtime\": \"572\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n curr = head.next\\n prev = head\\n head.next = None\\n\\n while curr:\\n succ = curr.next\\n curr.next = prev\\n prev = curr\\n curr = succ\\n\\n key = prev.val\\n ptr1 = prev.next\\n ptr2 = prev\\n\\n while ptr1 and ptr1.val < key:\\n ptr2.val = ptr1.val\\n ptr1 = ptr1.next\\n ptr2 = ptr2.next\\n \\n ptr2.val = key\\n return prev\",\n \"runtime\": \"586\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def insert(to_insert: ListNode, head: ListNode, n: int):\\n prev = None\\n curr = head\\n counter = 0\\n while curr and curr.val <= to_insert.val and counter < n:\\n prev = curr\\n curr = curr.next\\n counter += 1\\n \\n if not prev:\\n to_insert.next = curr\\n return to_insert\\n \\n if counter == n or not curr:\\n prev.next = to_insert\\n return head\\n\\n prev.next = to_insert\\n to_insert.next = curr\\n return head\\n \\n counter = 1\\n ret = head\\n curr = head.next\\n ret.next = None\\n while curr:\\n nxt = curr.next\\n curr.next = None\\n ret = insert(curr, ret, counter)\\n curr = nxt\\n counter += 1\\n return ret\\n \\n \",\n \"runtime\": \"586\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0)\\n curr = head\\n prev = None\\n while curr != None:\\n prev = dummy\\n while prev.next != None and prev.next.val < curr.val:\\n prev = prev.next\\n tmp = curr.next\\n tmp1 = prev.next\\n prev.next = curr\\n curr.next = tmp1\\n curr = tmp\\n return dummy.next\\n\\n \\n\\n\\n \\n \\n \",\n \"runtime\": \"599\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n #creat a new list and find the position for current element\\n #do the operations in place \\n dummy=ListNode(-1)\\n\\n cur=head\\n while cur!=None:\\n #insert current in to pre\\n #hold the next element and deal with the current \\n pre=dummy\\n while pre.next!=None and cur.val>=pre.next.val:\\n pre=pre.next\\n \\n #find the place for cur\\n succ=cur.next\\n \\n cur.next=pre.next\\n pre.next=cur\\n\\n #move current to the next \\n cur=succ\\n\\n return dummy.next\\n#time O(n**2) space O(1) \\n#insert sort!\\n \\n\\n \\n \\n \",\n \"runtime\": \"599\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n node = head.next\\n head.next = None\\n while node:\\n n = node.next\\n head = self.insert(node=node, head=head)\\n node = n\\n return head\\n\\n \\n def insert(self, node: Optional[ListNode], head: Optional[ListNode]) -> Optional[ListNode]:\\n curr = head\\n prev = None\\n while curr:\\n if curr.val >= node.val:\\n if prev == None:\\n node.next = curr\\n return node\\n if prev.val <= node.val:\\n prev.next = node\\n node.next = curr\\n return head\\n if curr.next == None:\\n curr.next = node\\n node.next = None\\n return head\\n prev = curr\\n curr = curr.next\\n \",\n \"runtime\": \"613\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n frontNode = ListNode(-1, head)\\n lastSortedNode = head\\n insertionNode = head.next\\n nextInsertionNode = insertionNode.next if insertionNode else None\\n\\n while insertionNode:\\n prevNode = frontNode\\n currNode = frontNode.next\\n while currNode and prevNode != lastSortedNode and currNode.val < insertionNode.val:\\n prevNode = prevNode.next\\n currNode = currNode.next\\n if prevNode != lastSortedNode:\\n prevNode.next = insertionNode\\n insertionNode.next = currNode\\n lastSortedNode.next = nextInsertionNode\\n else:\\n lastSortedNode = lastSortedNode.next\\n insertionNode = nextInsertionNode\\n nextInsertionNode = nextInsertionNode.next if nextInsertionNode else None\\n \\n return frontNode.next\",\n \"runtime\": \"613\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head.next == None:\\n return head\\n sorted_lst = [head]\\n curr = head.next\\n head.next = None\\n while curr:\\n nxt = curr.next\\n i=len(sorted_lst)-1\\n while i > -1:\\n if sorted_lst[i].val <= curr.val:\\n sorted_lst[i].next = curr\\n if i < len(sorted_lst)-1:\\n curr.next = sorted_lst[i+1]\\n else:\\n curr.next = None\\n sorted_lst = sorted_lst[:i+1]+[curr]+sorted_lst[i+1:]\\n break\\n else:\\n i-=1\\n if i == -1:\\n curr.next = sorted_lst[0]\\n sorted_lst = [curr]+sorted_lst\\n curr = nxt\\n # print([x.val for x in sorted_lst])\\n # for x in sorted_lst:\\n # if x.next:\\n # print((x.val,x.next.val))\\n # else:\\n # print((x.val,\\\"NONE\\\"))\\n return sorted_lst[0]\\n \\n \\n \\n\\n\\n\\n\",\n \"runtime\": \"626\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n oc = head\\n i = 0\\n prev = head\\n\\n l = 0\\n while oc != None: \\n oc = oc.next\\n l += 1\\n \\n print(l)\\n oc = head\\n\\n while oc != None: \\n val = oc.val\\n\\n prev = oc\\n oc = oc.next\\n\\n c = head\\n j = 0\\n\\n while c.next and c.next.val < val and j < i:\\n c = c.next\\n j += 1\\n \\n t = c.next\\n c.next = ListNode(val, t)\\n \\n i += 1\\n\\n oc = head\\n\\n\\n for i in range(l): \\n oc = oc.next\\n\\n oc.next = None\\n return head.next\\n \",\n \"runtime\": \"626\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n last = head\\n \\n while last:\\n temp = last\\n min_pointer = last\\n while temp:\\n if temp.val < min_pointer.val:\\n min_pointer = temp\\n temp = temp.next\\n last.val, min_pointer.val = min_pointer.val, last.val\\n last = last.next\\n \\n return head\\n \\n\",\n \"runtime\": \"640\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n result = res = ListNode(-5001)\\n\\n def insertResult(node):\\n nonlocal res\\n res = result\\n while res.next:\\n\\n if res.val <= node.val <= res.next.val:\\n node.next = res.next\\n res.next = node\\n return\\n res = res.next\\n if not res.next:\\n node.next = None\\n res.next = node\\n\\n while head:\\n temp = head.next\\n insertResult(head)\\n head = temp\\n return result.next\\n\",\n \"runtime\": \"640\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n h1 = head.next\\n prev1 = head\\n while (h1 != None):\\n if h1.val >= prev1.val: # if fist node greater than prev1\\n prev1 = h1\\n h1 = h1.next\\n else:\\n # Deletion operations\\n\\n nn = ListNode(0) # insertion node\\n nn.val = h1.val\\n if h1.next == None: # if last node is smaller than prev1 node\\n prev1.next = None\\n else:\\n prev1.next = h1.next\\n h1 = h1.next\\n\\n #insertion operations\\n\\n p1 = head\\n if head.val >= nn.val: # if nn(insertion node) is smaller than the first node\\n nn.next = p1\\n head = nn \\n else:\\n p1 = p1.next\\n prev2 = head\\n while p1:\\n if (p1.val >= nn.val):\\n nn.next = p1\\n prev2.next = nn\\n break\\n prev2 = p1\\n p1 = p1.next\\n h1 = head.next\\n prev1 = head\\n return head\",\n \"runtime\": \"654\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode()\\n cur = head\\n while cur:\\n prev = dummy\\n while prev.next!=None and prev.next.val < cur.val:\\n prev = prev.next\\n \\n next = cur.next\\n cur.next = prev.next\\n prev.next = cur\\n cur = next\\n \\n return dummy.next\\n\\n\",\n \"runtime\": \"654\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: ListNode) -> ListNode:\\n if not head:\\n return None\\n\\n arr = []\\n current = head\\n\\n while current:\\n arr.append(current.val)\\n current = current.next\\n\\n for i in range(1, len(arr)):\\n curr_val = arr[i]\\n j = i - 1\\n while j >= 0 and arr[j] > curr_val:\\n arr[j + 1] = arr[j]\\n j -= 1\\n arr[j + 1] = curr_val\\n\\n current = head\\n for i in range(len(arr)):\\n current.val = arr[i]\\n current = current.next\\n\\n return head\",\n \"runtime\": \"667\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: ListNode) -> ListNode:\\n if not head:\\n return None\\n arr=[]\\n c=head\\n while c:\\n arr.append(c.val)\\n c=c.next\\n for i in range(1, len(arr)):\\n curr_val=arr[i]\\n j=i-1\\n while j>=0 and arr[j]>curr_val:\\n arr[j+1]=arr[j]\\n j-=1\\n arr[j+1]=curr_val\\n c=head\\n for i in range(len(arr)):\\n c.val=arr[i]\\n c=c.next\\n return head\\n \\n\\n \",\n \"runtime\": \"667\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: ListNode) -> ListNode:\\n if not head:\\n return None\\n\\n arr = []\\n current = head\\n\\n while current:\\n arr.append(current.val)\\n current = current.next\\n\\n for i in range(1, len(arr)):\\n curr_val = arr[i]\\n j = i - 1\\n while j >= 0 and arr[j] > curr_val:\\n arr[j + 1] = arr[j]\\n j -= 1\\n arr[j + 1] = curr_val\\n\\n current = head\\n for i in range(len(arr)):\\n current.val = arr[i]\\n current = current.next\\n\\n return head\",\n \"runtime\": \"681\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n temp=head.next\\n prev=head\\n dummy=ListNode(-5005)\\n dummy.next=head\\n head=dummy\\n before=prev\\n while(temp!=None):\\n prev=head\\n p=head\\n while(prev.next!=temp):\\n if(prev.next.val>temp.val):\\n before.next=before.next.next\\n x=prev.next\\n prev.next=temp\\n temp.next=x\\n temp=before\\n break\\n p=prev\\n prev=prev.next\\n before=temp\\n temp=temp.next\\n return head.next\\n\\n\\n \",\n \"runtime\": \"681\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n curr = head\\n prev = None\\n while curr != None:\\n nextNode = curr.next\\n itr = head\\n prevItr = None\\n while itr != curr:\\n if curr.val < itr.val and prevItr == None:\\n curr.next = itr\\n head = curr\\n break\\n if curr.val < itr.val:\\n curr.next = itr\\n prevItr.next = curr\\n break\\n prevItr = itr\\n itr = itr.next\\n if prev:\\n if itr != curr:\\n prev.next = nextNode\\n else:\\n prev = curr\\n curr = nextNode\\n else:\\n prev = curr\\n curr = curr.next\\n return head\",\n \"runtime\": \"721\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n if not head:\\n return None\\n\\n node = head\\n\\n array = []\\n\\n while node:\\n array.append(node.val)\\n node = node.next\\n\\n # print(array)\\n\\n for i in range(len(array)):\\n current_val = array[i]\\n j = i-1\\n while j >= 0 and array[j] > current_val:\\n array[j+1] = array[j]\\n j -= 1\\n array[j+1] = current_val\\n\\n node = head\\n for i in range(len(array)):\\n node.val = array[i]\\n node = node.next\\n\\n return head\\n\\n \",\n \"runtime\": \"721\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n\\n arr = []\\n current = head\\n\\n while current:\\n arr.append(current.val)\\n current = current.next\\n\\n for i in range(1, len(arr)):\\n curr_val = arr[i]\\n j = i - 1\\n while j >= 0 and arr[j] > curr_val:\\n arr[j + 1] = arr[j]\\n j -= 1\\n arr[j + 1] = curr_val\\n\\n current = head\\n for i in range(len(arr)):\\n current.val = arr[i]\\n current = current.next\\n\\n return head\\n \",\n \"runtime\": \"735\"\n },\n {\n \"code\": \"class Solution:\\n def insert_sort(self, head, node, n):\\n next_node = node.next\\n current = head\\n inserted = False\\n prev = None\\n\\n for i in range(n):\\n if not inserted and node.val <= current.val:\\n if prev:\\n prev.next = node\\n else:\\n head = node\\n node.next = current\\n inserted = True\\n prev = current\\n current = current.next\\n \\n if not inserted:\\n prev.next = node\\n node.next = next_node\\n else:\\n prev.next = next_node\\n return (head, next_node)\\n\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n node = head\\n i = 0\\n while node:\\n if i == 0:\\n node = node.next\\n else:\\n head, node = self.insert_sort(head, node, i)\\n i += 1\\n return head\\n\",\n \"runtime\": \"735\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return head\\n t=head\\n a=[]\\n while t:\\n a.append(t.val)\\n t=t.next\\n for i in range(1,len(a)):\\n k=a[i]\\n j=i-1\\n while j>=0 and k<a[j]:\\n a[j+1]=a[j]\\n j-=1\\n a[j+1]=k\\n i=0\\n head=ListNode()\\n t=head\\n while i<len(a):\\n t.next=ListNode(a[i])\\n i+=1\\n t=t.next\\n return head.next\",\n \"runtime\": \"748\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n now = head\\n while now:\\n if now.next is not None:\\n cur = now.next\\n while cur is not None:\\n if now.val > cur.val:\\n now.val, cur.val = cur.val, now.val\\n cur = cur.next\\n now = now.next\\n else:\\n return head\",\n \"runtime\": \"748\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # two loops\\n dummy = ListNode()\\n dummy.next =head\\n \\n while head:\\n \\n prev = dummy\\n while prev.next and prev.next.val < head.val:\\n prev = prev.next \\n if prev.next != head:\\n n = head.next\\n p = dummy\\n while p.next != head:\\n p = p.next\\n p.next = n\\n head.next = prev.next\\n prev.next = head\\n\\n head = n\\n else:\\n head = head.next \\n # can't use three equal together, have to save head.next first \\n return dummy.next\\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"762\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n\\n lft = head\\n\\n while lft:\\n cur = lft\\n while cur:\\n if cur.val < lft.val:\\n cur.val, lft.val = lft.val, cur.val\\n cur = cur.next\\n\\n lft = lft.next\\n return head\",\n \"runtime\": \"762\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head):\\n \\n def insert(head, node):\\n if node.val <= head.val:\\n node.next = head\\n return node\\n else:\\n curr = head\\n curr_next = curr.next\\n while(curr and curr_next):\\n if node.val > curr.val and node.val <= curr_next.val:\\n curr.next = node\\n node.next = curr_next\\n return head\\n else:\\n curr = curr_next\\n curr_next = curr.next\\n if node.val > curr.val:\\n curr.next = node\\n return head\\n\\n \\n \\n if head is None: return None\\n node = head.next\\n head.next = None\\n while(node):\\n curr = node\\n node = curr.next\\n curr.next = None\\n head = insert(head, curr)\\n return head\\n\\n\\n \",\n \"runtime\": \"776\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: ListNode) -> ListNode:\\n if not head:\\n return None\\n arr = []\\n current = head\\n while current:\\n arr.append(current.val)\\n current = current.next\\n for i in range(1, len(arr)):\\n curr_val = arr[i]\\n j = i - 1\\n while j >= 0 and arr[j] > curr_val:\\n arr[j + 1] = arr[j]\\n j -= 1\\n arr[j + 1] = curr_val\\n current = head\\n for i in range(len(arr)):\\n current.val = arr[i]\\n current = current.next\\n return head\",\n \"runtime\": \"776\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n\\n lft = head\\n\\n while lft:\\n\\n cur = lft\\n while cur:\\n if cur.val < lft.val:\\n cur.val, lft.val = lft.val, cur.val\\n cur = cur.next\\n\\n lft = lft.next\\n return head\",\n \"runtime\": \"789\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n new_head = ListNode(val=None, next=head)\\n\\n sort = new_head\\n\\n while sort.next:\\n min_prev, prev = sort, sort\\n min_curr, curr = sort.next, sort.next\\n while curr:\\n if curr.val < min_curr.val:\\n min_curr = curr\\n min_prev = prev\\n prev = curr\\n curr = curr.next\\n \\n min_prev.next = min_curr.next\\n min_curr.next = sort.next \\n sort.next = min_curr\\n sort = sort.next\\n \\n\\n return(new_head.next)\\n \\n \\n\\n\\n \\n\\n\\n \\n\\n\\n \\n \",\n \"runtime\": \"789\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n curr = head\\n start, end = None, None\\n while curr:\\n # print(curr.val)\\n nxt = curr.next\\n if start:\\n if curr.val <= start.val:\\n curr.next = start\\n start = curr\\n # print(start.val)\\n else:\\n scurr = start\\n while scurr:\\n slots = scurr.next and scurr.next.val > curr.val\\n if curr.val >= scurr.val and (slots or scurr.next is None):\\n curr.next = scurr.next\\n scurr.next = curr\\n break\\n scurr = scurr.next\\n else:\\n start = curr\\n start.next = None\\n curr = nxt\\n return start\",\n \"runtime\": \"803\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def get_list():\\n current_node = head\\n l = []\\n while current_node:\\n l.append(current_node)\\n current_node = current_node.next\\n return l\\n \\n list_to_sort = get_list()\\n for i in range(1, len(list_to_sort)):\\n number_to_order = list_to_sort[i].val\\n j = i - 1\\n\\n while j >= 0 and number_to_order < list_to_sort[j].val:\\n list_to_sort[j + 1].val = list_to_sort[j].val\\n j -= 1\\n list_to_sort[j + 1].val = number_to_order\\n return list_to_sort[0] \\n\\n\",\n \"runtime\": \"803\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\\"\\\"\\\"\\n Potential solutions:\\n - Insertion sort\\n Approach:\\n - Initialize head of sorted list\\n - Iterate over original list. Grab head and iterate over second list. Find the two that the new item fits between\\n - Take head of current and set it to the node to insert. Set node to insert .next as the previous .next\\n - Iterate until you've reached the tail of the original list\\n Edge cases:\\n - []\\n - [4,2,1,3]\\n - [-1,5,3,4,0]\\n - [3, 1, 2, 2]\\n\\n trace:\\n \\n current_list = [4,2,1,3]\\n new_list = [-5001, 4,]\\n\\n current_list = [4,2,1,3]\\n new_list = [-5001, 4,]\\n\\n \\\"\\\"\\\"\\n if head is None or head.next is None:\\n return head\\n\\n placeholder = ListNode(val=-5001)\\n current_original = head\\n\\n while current_original is not None:\\n current_new_node = placeholder\\n while current_new_node is not None:\\n if current_original.val >= current_new_node.val and current_new_node.next is None:\\n current_new_node.next = ListNode(val=current_original.val)\\n break\\n if (\\n current_original.val >= current_new_node.val\\n and current_new_node.next is not None\\n and current_new_node.next.val >= current_original.val\\n ):\\n current_new_node.next = ListNode(val=current_original.val, next=current_new_node.next)\\n break\\n\\n current_new_node = current_new_node.next\\n\\n current_original = current_original.next\\n\\n return placeholder.next\\n\\n\",\n \"runtime\": \"816\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n res = []\\n dummy = ListNode(None)\\n while head:\\n res.append(head.val)\\n head = head.next\\n for i in range(1,len(res)):\\n temp = res[i]\\n j = i - 1\\n while temp < res[j] and j >= 0:\\n res[j+1] = res[j]\\n res[j] = temp\\n j -= 1\\n tail = dummy\\n for i in res:\\n new_node = ListNode(i)\\n tail.next = new_node\\n tail = tail.next\\n return dummy.next\",\n \"runtime\": \"816\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(-1)\\n dummy.next = head\\n curr = head.next\\n while curr:\\n unsorted_next = curr.next\\n prev = head\\n while prev.next != curr:\\n prev = prev.next\\n sorted_curr = dummy\\n while sorted_curr != curr:\\n if curr.val < sorted_curr.next.val:\\n prev.next = curr.next\\n temp = sorted_curr.next\\n sorted_curr.next = curr\\n curr.next = temp\\n sorted_curr = sorted_curr.next\\n curr = unsorted_next\\n return dummy.next\",\n \"runtime\": \"830\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(-1)\\n dummy.next = head\\n curr = head.next\\n while curr:\\n unsorted_next = curr.next\\n prev = head\\n while prev.next != curr:\\n prev = prev.next\\n sorted_curr = dummy\\n while sorted_curr != curr:\\n if curr.val < sorted_curr.next.val:\\n prev.next = curr.next\\n temp = sorted_curr.next\\n sorted_curr.next = curr\\n curr.next = temp\\n sorted_curr = sorted_curr.next\\n curr = unsorted_next\\n return dummy.next\",\n \"runtime\": \"830\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next: \\n return head\\n elements = list()\\n while head: \\n elements.append(head.val)\\n head = head.next\\n \\n for k_int in range(1, len(elements)): \\n curr = elements[k_int]\\n j_int = k_int\\n while j_int > 0: \\n if elements[j_int-1] > curr:\\n elements[j_int] = elements[j_int-1]\\n j_int -= 1\\n else:\\n break\\n elements[j_int] = curr\\n result = ListNode()\\n curr = result\\n\\n for k_int in range(len(elements)): \\n if k_int == len(elements) - 1:\\n curr.next = ListNode(val=elements[-1], next=None)\\n else:\\n curr.next = ListNode(val=elements[k_int])\\n curr = curr.next\\n\\n return result.next\\n\",\n \"runtime\": \"843\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n \\n prevMap = {}\\n prev = None\\n curr = head\\n while curr:\\n prevMap[curr] = prev\\n prev = curr\\n curr = curr.next\\n \\n # prev = head\\n curr = head.next\\n while curr:\\n\\n currForIter = curr\\n prevForIter = prevMap[currForIter]\\n\\n while currForIter and prevForIter and currForIter.val < prevForIter.val:\\n temp = currForIter.val\\n currForIter.val = prevForIter.val\\n prevForIter.val = temp\\n currForIter = prevForIter\\n prevForIter = prevMap[prevForIter]\\n curr = curr.next\\n\\n return head\\n\\n\\n\\n\\n \",\n \"runtime\": \"843\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n ptr_list = []\\n\\n ptr1 = head\\n while( ptr1):\\n ptr_list.append(ptr1)\\n ptr1 = ptr1.next #[4 , 2 , 1, 3]\\n \\n for i in range(1, len(ptr_list)): #[2 , 4 , 1, 3] \\n target = ptr_list[i]\\n for j in reversed(range(i)):\\n if(ptr_list[j].val > target.val):\\n tmp = ptr_list[j].val\\n ptr_list[j].val = target.val\\n target.val = tmp\\n target = ptr_list[j]\\n else:\\n break\\n \\n return ptr_list[0]\\n\\n\\n\\n# [ptr1 , ptr2 , ptr3 , ptr4 , ptr5]\\n# \\n#\\n#\\n#\\n#\",\n \"runtime\": \"857\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(-1)\\n dummy.next = head\\n curr = head.next\\n while curr:\\n unsorted_next = curr.next\\n prev = head\\n while prev.next != curr:\\n prev = prev.next\\n sorted_curr = dummy\\n while sorted_curr != curr:\\n if curr.val < sorted_curr.next.val:\\n prev.next = curr.next\\n temp = sorted_curr.next\\n sorted_curr.next = curr\\n curr.next = temp\\n sorted_curr = sorted_curr.next\\n curr = unsorted_next\\n return dummy.next\",\n \"runtime\": \"870\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n tracker1 = head\\n while tracker1:\\n tracker2=tracker1.next\\n while tracker2:\\n if tracker2.val<tracker1.val:\\n tracker1.val, tracker2.val = tracker2.val, tracker1.val\\n tracker2 = tracker2.next\\n tracker1 = tracker1.next\\n \\n return head\\n\",\n \"runtime\": \"870\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n if head.next is None:\\n return head\\n\\n root_node = head\\n\\n while head.next is not None:\\n val_to_insert = head.next.val\\n\\n if val_to_insert <= root_node.val:\\n root_node = ListNode(val_to_insert, root_node)\\n # delete moved node\\n head.next = head.next.next\\n else:\\n insert_head = root_node\\n while id(insert_head) != id(head):\\n if val_to_insert <= insert_head.next.val:\\n # insert node in ordered index\\n insert_head.next = ListNode(val_to_insert, insert_head.next)\\n # remove the moved node\\n head.next = head.next.next\\n break\\n else:\\n insert_head = insert_head.next\\n if id(insert_head) == id(head):\\n head = head.next\\n\\n\\n return root_node\\n\\n\\n\\n\\n\\n\\n\\n # sorted_head = ListNode(head.val)\\n # head = head.next\\n\\n # while head is not None:\\n # val_to_sort = head.val\\n # if val_to_sort <= sorted_head.val:\\n # sorted_head = ListNode(val_to_sort, sorted_head)\\n # else:\\n # insertion_head = sorted_head\\n # while insertion_head.next is not None:\\n # if val_to_sort <= insertion_head.next.val:\\n # insertion_head.next = ListNode(val_to_sort, insertion_head.next)\\n # break\\n # else:\\n # insertion_head = insertion_head.next\\n \\n # if insertion_head.next is None:\\n # insertion_head.next = ListNode(val_to_sort)\\n \\n # head = head.next\\n \\n # return sorted_head\\n\",\n \"runtime\": \"884\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n temp = ListNode(0, head)\\n elem = head\\n pre_elem = temp\\n while elem: \\n elem_next = elem.next \\n pre = temp \\n curr = temp.next \\n while curr != elem:\\n if curr.val <= elem.val:\\n pre = curr\\n curr = curr.next\\n else:\\n pre.next = elem \\n elem.next = curr \\n pre_elem.next = elem_next \\n while curr.next != elem_next:\\n curr = curr.next\\n break\\n pre_elem = curr\\n elem = elem_next \\n return temp.next\\n\",\n \"runtime\": \"897\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n l = []\\n x = head\\n while x != None:\\n l.append(x.val)\\n x = x.next\\n if len(l) == 0:\\n return\\n for i in range(1, len(l)):\\n for j in range(0, i):\\n if l[i] < l[j]:\\n l[i], l[j] = l[j], l[i]\\n x = head\\n i = 0\\n while x != None:\\n x.val = l[i]\\n i += 1\\n x = x.next\\n return head\\n\\n\",\n \"runtime\": \"911\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n vals = [head.val]\\n cur = head\\n while cur.next:\\n cur = cur.next\\n vals.append(cur.val)\\n \\n l = len(vals)\\n for i in range(1, l):\\n if vals[i] < vals[i - 1]:\\n for j in range(i, 0, -1):\\n if vals[j] < vals[j - 1]:\\n vals[j], vals[j - 1] = vals[j - 1], vals[j]\\n else:\\n break\\n \\n head.val = vals[0]\\n cur = head\\n i = 1\\n while cur.next:\\n cur = cur.next\\n cur.val = vals[i]\\n i += 1\\n return head\\n\\n\",\n \"runtime\": \"925\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n temp = head\\n nums = []\\n while temp:\\n nums.append(temp)\\n temp = temp.next\\n for i in range(1, len(nums)):\\n temp = nums[i].val\\n j = i - 1\\n while temp < nums[j].val and j > -1:\\n nums[j + 1].val = nums[j].val\\n nums[j].val = temp\\n j -= 1\\n return head\",\n \"runtime\": \"938\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n vals = [head.val]\\n cur = head\\n while cur.next:\\n cur = cur.next\\n vals.append(cur.val)\\n \\n l = len(vals)\\n for i in range(1, l):\\n if vals[i] < vals[i - 1]:\\n for j in range(i, 0, -1):\\n if vals[j] < vals[j - 1]:\\n vals[j], vals[j - 1] = vals[j - 1], vals[j]\\n else:\\n break\\n \\n head.val = vals[0]\\n cur = head\\n i = 1\\n while cur.next:\\n cur = cur.next\\n cur.val = vals[i]\\n i += 1\\n return head\\n\",\n \"runtime\": \"952\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n vals = [head.val]\\n cur = head\\n while cur.next:\\n cur = cur.next\\n vals.append(cur.val)\\n \\n l = len(vals)\\n for i in range(1, l):\\n if vals[i] < vals[i - 1]:\\n for j in range(i, 0, -1):\\n if vals[j] < vals[j - 1]:\\n vals[j], vals[j - 1] = vals[j - 1], vals[j]\\n else:\\n break\\n \\n head.val = vals[0]\\n cur = head\\n i = 1\\n while cur.next:\\n cur = cur.next\\n cur.val = vals[i]\\n i += 1\\n return head\\n\",\n \"runtime\": \"965\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n insertList = []\\n\\n if head == None or head.next == None:\\n return head\\n \\n curr = head\\n while (curr != None):\\n insertList.append(curr.val)\\n curr = curr.next\\n\\n print(insertList)\\n for i in range(0, len(insertList)):\\n for j in range(i+1,len(insertList)):\\n if insertList[i] > insertList[j]:\\n insertList[i],insertList[j] = insertList[j],insertList[i]\\n print(insertList)\\n\\n i = 0\\n curr = head\\n while(curr != None):\\n curr.val = insertList[i]\\n i += 1\\n curr = curr.next\\n\\n return head\\n\\n\\n\",\n \"runtime\": \"979\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n vals = [head.val]\\n cur = head\\n while cur.next:\\n cur = cur.next\\n vals.append(cur.val)\\n \\n l = len(vals)\\n for i in range(1, l):\\n if vals[i] < vals[i - 1]:\\n for j in range(i, 0, -1):\\n if vals[j] < vals[j - 1]:\\n vals[j], vals[j - 1] = vals[j - 1], vals[j]\\n else:\\n break\\n \\n head.val = vals[0]\\n cur = head\\n i = 1\\n while cur.next:\\n cur = cur.next\\n cur.val = vals[i]\\n i += 1\\n return head\\n\",\n \"runtime\": \"992\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n insertList = []\\n\\n if head == None or head.next == None:\\n return head\\n \\n curr = head\\n while (curr != None):\\n insertList.append(curr.val)\\n curr = curr.next\\n\\n\\n for i in range(0, len(insertList)):\\n for j in range(i+1,len(insertList)):\\n if insertList[i] > insertList[j]:\\n insertList[i],insertList[j] = insertList[j],insertList[i]\\n\\n\\n i = 0\\n curr = head\\n while(curr != None):\\n curr.val = insertList[i]\\n i += 1\\n curr = curr.next\\n\\n return head\\n\\n\\n\",\n \"runtime\": \"1006\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insert(self, head, end):\\n tmp = end.val\\n curr = head\\n while curr != end:\\n if curr.val >= tmp:\\n curr.val, tmp = tmp, curr.val\\n curr = curr.next\\n end.val = tmp\\n \\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n \\n curr = head.next\\n while curr:\\n self.insert(head, curr)\\n curr = curr.next\\n \\n return head\",\n \"runtime\": \"1006\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return head\\n\\n curr = head\\n aux = []\\n while curr is not None:\\n aux.append(curr)\\n curr = curr.next\\n self.insertionSort(aux)\\n\\n for i in range(len(aux)):\\n if i == len(aux)-1:\\n aux[i].next = None\\n else:\\n aux[i].next = aux[i + 1]\\n return aux[0]\\n\\n\\n def insertionSort(self, nums):\\n if len(nums) <= 1: return\\n\\n sortedRight = 1 # length of sorted region\\n for i in range(1, len(nums), 1):\\n self.reinsertEnd(nums, 0, i)\\n # sortedRight += 1\\n\\n # arr[0], ... , arr[end-1] is sorted; insert end to maintain sort\\n def reinsertEnd(self, array, start, end):\\n # find index to insert at\\n endNode = array[end]\\n ptr = start\\n while ptr < end:\\n if endNode.val <= array[ptr].val:\\n break\\n ptr += 1\\n\\n c = end\\n while c > ptr:\\n array[c] = array[c-1]\\n c -= 1\\n array[c] = endNode\",\n \"runtime\": \"1019\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: return None\\n if not head.next: return head\\n node_stack = []\\n pass_stack = []\\n node = head\\n while node:\\n nxt = node.next\\n node.next = None\\n while node_stack and node_stack[-1].val > node.val:\\n pass_stack.append(node_stack.pop())\\n if node_stack:\\n node_stack[-1].next = node\\n if pass_stack:\\n node.next = pass_stack[-1]\\n node_stack.append(node)\\n while pass_stack:\\n node_stack.append(pass_stack.pop())\\n node = nxt\\n return node_stack[0]\\n\",\n \"runtime\": \"1019\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n \\n new_head=temp=ListNode(float(\\\"-inf\\\"))\\n \\n \\n \\n def recursion(head,new_node,val):\\n \\n if not head:\\n return\\n \\n \\n if head.val<=val and head.next is None:\\n head.next=new_node\\n return\\n \\n if head.val<=val and head.next.val>=val:\\n new_node.next=head.next\\n head.next=new_node\\n \\n \\n return\\n \\n recursion(head.next,new_node,val)\\n \\n \\n \\n while head:\\n new_temp=head.next\\n \\n val=head.val\\n head.next=None\\n \\n \\n recursion(temp,head,val)\\n \\n head=new_temp\\n \\n return new_head.next\\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"1033\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n stack=[]\\n temp=head\\n while temp:\\n stack.append(temp.val)\\n temp=temp.next\\n n=len(stack)\\n for i in range(n):\\n j=i\\n while j>0 and stack[j-1]>stack[j]:\\n stack[j],stack[j-1] = stack[j-1],stack[j]\\n j-=1\\n temp=head\\n i=0\\n while temp:\\n temp.val=stack[i]\\n i+=1\\n temp=temp.next\\n return head\\n\",\n \"runtime\": \"1047\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head):\\n cur = head\\n while cur:\\n j = head\\n while j != cur:\\n if j.val > cur.val: \\n j.val, cur.val = cur.val, j.val\\n j = j.next\\n cur = cur.next\\n return head\",\n \"runtime\": \"1060\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass LLIterator:\\n def __init__(self, lst:ListNode):\\n self.lst = lst\\n \\n\\n def __iter__(self):\\n self.curr = self.lst\\n return self\\n def __next__(self):\\n if self.curr:\\n a = self.curr\\n self.curr = self.curr.next\\n return a\\n else:\\n raise StopIteration\\n\\n \\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n out = ListNode(-1000, ListNode(head.val))\\n curr = out\\n iterator = LLIterator(head.next)\\n for node in iterator:\\n prev = out\\n added = False\\n for outNode in LLIterator(out.next):\\n if outNode.val > node.val:\\n prev.next = ListNode(node.val)\\n prev.next.next = outNode\\n added = True\\n break\\n prev = outNode\\n if not added:\\n prev.next = ListNode(node.val)\\n \\n return out.next\\n\",\n \"runtime\": \"1074\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return head\\n \\n node_list = []\\n while head:\\n node_list.append(head.val)\\n head = head.next\\n \\n self.sort(node_list)\\n dummy = ListNode(0)\\n head = ListNode(0)\\n dummy.next = head\\n for i in node_list:\\n temp =ListNode(i)\\n head.next = temp\\n head = head.next\\n \\n return dummy.next.next\\n \\n def sort(self, arr):\\n \\n for i in range(1, len(arr)):\\n curr_index = i\\n while curr_index >= 1 and arr[curr_index-1] > arr[curr_index]:\\n arr[curr_index-1], arr[curr_index] = arr[curr_index], arr[curr_index-1]\\n curr_index -= 1\\n \",\n \"runtime\": \"1087\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, A: Optional[ListNode]) -> Optional[ListNode]:\\n temp=A\\n while temp!=None:\\n temp2=A\\n while temp2!=temp:\\n if temp2.val > temp.val:\\n temp2.val,temp.val=temp.val,temp2.val\\n temp2=temp2.next\\n temp=temp.next\\n return A\",\n \"runtime\": \"1101\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":124,"string":"124"},"mm_list":{"kind":"list like","value":[{"code":"class ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\nclass Solution:\n def insertionSortList(self, head: ListNode) -> ListNode:\n dummy = ListNode(0)\n curr = head\n \n while curr:\n prev = dummy\n # Find the right place to insert the current node\n while prev.next and prev.next.val < curr.val:\n prev = prev.next\n \n next_temp = curr.next\n # Insert the current node into the new list\n curr.next = prev.next\n prev.next = curr\n curr = next_temp\n \n return dummy.next\n","memory":"18100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head and not head.next:\n return head\n dummy = ListNode(0)\n current = head\n while current:\n nextN = current.next\n prev = dummy\n while prev.next and prev.next.val < current.val:\n prev = prev.next\n current.next = prev.next\n prev.next = current\n current = nextN\n return dummy.next","memory":"18200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n dummy = ListNode(next=head)\n prev = head\n cur = head.next\n\n while cur:\n if cur.val >= prev.val:\n prev, cur = cur, cur.next\n continue\n\n cur_sorted = dummy\n while cur_sorted.next and cur_sorted.next.val < cur.val:\n cur_sorted = cur_sorted.next\n\n prev.next = cur.next # no need to move prev as we move cur so prev can stay the same\n cur.next, cur_sorted.next, cur = cur_sorted.next, cur, cur.next\n\n return dummy.next\n\n# Time: worst case: O(n ^ 2) but best case O(n)\n# Space: O(1)\n\n\n def insertionSortList2(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n dummy = ListNode()\n curr = head\n\n while curr:\n prev = dummy\n while prev.next and prev.next.val < curr.val:\n prev = prev.next\n\n curr.next, prev.next, curr = prev.next, curr, curr.next\n\n return dummy.next\n\n# Time: O(n ^ 2)\n# Space: O(1)\n\n\n def insertionSortList2(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n sorted_head = ListNode(next=head)\n cur = head.next\n head.next = None # cut the link!\n\n while cur:\n cur_sorted = sorted_head\n while cur_sorted.next and cur_sorted.next.val < cur.val:\n cur_sorted = cur_sorted.next\n\n cur.next, cur_sorted.next, cur = cur_sorted.next, cur, cur.next\n\n return sorted_head.next\n\n# Time: O(n ^ 2)\n# Space: O(1)\n\n\n # not working as no clear delimitation between sorted and non sorted part\n def insertionSortList_not(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n sorted_head = ListNode(next=head)\n cur = head.next\n\n while cur:\n cur_sorted = sorted_head\n while cur_sorted.next and cur_sorted.next.val < cur.val:\n cur_sorted = cur_sorted.next\n\n cur.next, cur_sorted.next, cur = cur_sorted.next, cur, cur.next\n\n return sorted_head.next\n\n# Time: O(n ^ 2)\n# Space: O(1)","memory":"18300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode()\n curr = head\n\n while curr:\n # At each iteration, we insert an element into the resulting list.\n prev = dummy\n\n # find the position to insert the current node\n while prev.next and prev.next.val <= curr.val:\n prev = prev.next\n\n next = curr.next\n # insert the current node to the new list\n curr.next = prev.next\n prev.next = curr\n\n # moving on to the next iteration\n curr = next\n\n return dummy.next \n","memory":"18300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode(0)\n current = head\n while current:\n prev = dummy\n while prev.next and prev.next.val < current.val:\n prev = prev.next\n next_node = current.next\n current.next = prev.next\n prev.next = current\n current = next_node\n return dummy.next","memory":"18400"},{"code":"class Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head.next is None: return head\n else:\n dummy = ListNode() # new list which we add sorted node to\n cur = head\n while cur:\n pre = dummy\n while pre.next and (pre.next).val < cur.val:\n pre = pre.next\n next_cur = cur.next\n cur.next = pre.next\n pre.next = cur\n cur = next_cur\n return dummy.next","memory":"18400"},{"code":"class Solution:\n def insertionSortList(self, head: ListNode | None) -> ListNode | None:\n dummy = ListNode(0)\n prev = dummy # the last and thus largest of the sorted list\n\n while head: # the current inserting node\n next = head.next # Cache the next inserting node.\n if prev.val >= head.val:\n prev = dummy # Move `prev` to the front.\n while prev.next and prev.next.val < head.val:\n prev = prev.next\n head.next = prev.next\n prev.next = head\n head = next # Update the current inserting node.\n\n return dummy.next","memory":"18500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n dummy = ListNode()\n curr = head\n\n while curr:\n prev = dummy\n\n while prev.next and prev.next.val <= curr.val:\n prev = prev.next\n \n next = curr.next\n curr.next = prev.next\n prev.next = curr\n\n curr = next\n \n return dummy.next","memory":"18500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: ListNode | None) -> ListNode | None:\n dummy = ListNode(0)\n prev = dummy # the last and thus largest of the sorted list\n\n while head: # the current inserting node\n next = head.next # Cache the next inserting node.\n if prev.val >= head.val:\n prev = dummy # Move `prev` to the front.\n while prev.next and prev.next.val < head.val:\n prev = prev.next\n head.next = prev.next\n prev.next = head\n head = next # Update the current inserting node.\n\n return dummy.next\n\n ","memory":"18600"},{"code":"class Solution:\n def insertionSortList(self, head: ListNode) -> ListNode:\n \n # No need to sort for empty list or list of size 1\n if not head or not head.next:\n return head\n \n # Use dummy_head will help us to handle insertion before head easily\n dummy_head = ListNode(val=-5000, next=head)\n last_sorted = head # last node of the sorted part\n cur = head.next # cur is always the next node of last_sorted\n while cur:\n if cur.val >= last_sorted.val:\n last_sorted = last_sorted.next\n else:\n # Search for the position to insert\n prev = dummy_head\n while prev.next.val <= cur.val:\n prev = prev.next\n \n # Insert\n last_sorted.next = cur.next\n cur.next = prev.next\n prev.next = cur\n \n cur = last_sorted.next\n \n return dummy_head.next","memory":"18600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n src = head.next \n dest = ListNode(head.val)\n # 1-->2--->3-->4--->5\n # 5--8--7\n while src:\n node = ListNode(src.val)\n if src.val < dest.val:\n node.next = dest\n dest = node\n else:\n prev = None\n temp = dest\n while temp and temp.val <= src.val:\n prev = temp\n temp = temp.next\n prev.next = node\n node.next = temp \n\n src = src.next \n return dest\n \n\n\n\n\n \n ","memory":"18700"}],"string":"[\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\nclass Solution:\\n def insertionSortList(self, head: ListNode) -> ListNode:\\n dummy = ListNode(0)\\n curr = head\\n \\n while curr:\\n prev = dummy\\n # Find the right place to insert the current node\\n while prev.next and prev.next.val < curr.val:\\n prev = prev.next\\n \\n next_temp = curr.next\\n # Insert the current node into the new list\\n curr.next = prev.next\\n prev.next = curr\\n curr = next_temp\\n \\n return dummy.next\\n\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head and not head.next:\\n return head\\n dummy = ListNode(0)\\n current = head\\n while current:\\n nextN = current.next\\n prev = dummy\\n while prev.next and prev.next.val < current.val:\\n prev = prev.next\\n current.next = prev.next\\n prev.next = current\\n current = nextN\\n return dummy.next\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n dummy = ListNode(next=head)\\n prev = head\\n cur = head.next\\n\\n while cur:\\n if cur.val >= prev.val:\\n prev, cur = cur, cur.next\\n continue\\n\\n cur_sorted = dummy\\n while cur_sorted.next and cur_sorted.next.val < cur.val:\\n cur_sorted = cur_sorted.next\\n\\n prev.next = cur.next # no need to move prev as we move cur so prev can stay the same\\n cur.next, cur_sorted.next, cur = cur_sorted.next, cur, cur.next\\n\\n return dummy.next\\n\\n# Time: worst case: O(n ^ 2) but best case O(n)\\n# Space: O(1)\\n\\n\\n def insertionSortList2(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n dummy = ListNode()\\n curr = head\\n\\n while curr:\\n prev = dummy\\n while prev.next and prev.next.val < curr.val:\\n prev = prev.next\\n\\n curr.next, prev.next, curr = prev.next, curr, curr.next\\n\\n return dummy.next\\n\\n# Time: O(n ^ 2)\\n# Space: O(1)\\n\\n\\n def insertionSortList2(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n sorted_head = ListNode(next=head)\\n cur = head.next\\n head.next = None # cut the link!\\n\\n while cur:\\n cur_sorted = sorted_head\\n while cur_sorted.next and cur_sorted.next.val < cur.val:\\n cur_sorted = cur_sorted.next\\n\\n cur.next, cur_sorted.next, cur = cur_sorted.next, cur, cur.next\\n\\n return sorted_head.next\\n\\n# Time: O(n ^ 2)\\n# Space: O(1)\\n\\n\\n # not working as no clear delimitation between sorted and non sorted part\\n def insertionSortList_not(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n sorted_head = ListNode(next=head)\\n cur = head.next\\n\\n while cur:\\n cur_sorted = sorted_head\\n while cur_sorted.next and cur_sorted.next.val < cur.val:\\n cur_sorted = cur_sorted.next\\n\\n cur.next, cur_sorted.next, cur = cur_sorted.next, cur, cur.next\\n\\n return sorted_head.next\\n\\n# Time: O(n ^ 2)\\n# Space: O(1)\",\n \"memory\": \"18300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode()\\n curr = head\\n\\n while curr:\\n # At each iteration, we insert an element into the resulting list.\\n prev = dummy\\n\\n # find the position to insert the current node\\n while prev.next and prev.next.val <= curr.val:\\n prev = prev.next\\n\\n next = curr.next\\n # insert the current node to the new list\\n curr.next = prev.next\\n prev.next = curr\\n\\n # moving on to the next iteration\\n curr = next\\n\\n return dummy.next \\n\",\n \"memory\": \"18300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode(0)\\n current = head\\n while current:\\n prev = dummy\\n while prev.next and prev.next.val < current.val:\\n prev = prev.next\\n next_node = current.next\\n current.next = prev.next\\n prev.next = current\\n current = next_node\\n return dummy.next\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head.next is None: return head\\n else:\\n dummy = ListNode() # new list which we add sorted node to\\n cur = head\\n while cur:\\n pre = dummy\\n while pre.next and (pre.next).val < cur.val:\\n pre = pre.next\\n next_cur = cur.next\\n cur.next = pre.next\\n pre.next = cur\\n cur = next_cur\\n return dummy.next\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: ListNode | None) -> ListNode | None:\\n dummy = ListNode(0)\\n prev = dummy # the last and thus largest of the sorted list\\n\\n while head: # the current inserting node\\n next = head.next # Cache the next inserting node.\\n if prev.val >= head.val:\\n prev = dummy # Move `prev` to the front.\\n while prev.next and prev.next.val < head.val:\\n prev = prev.next\\n head.next = prev.next\\n prev.next = head\\n head = next # Update the current inserting node.\\n\\n return dummy.next\",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n dummy = ListNode()\\n curr = head\\n\\n while curr:\\n prev = dummy\\n\\n while prev.next and prev.next.val <= curr.val:\\n prev = prev.next\\n \\n next = curr.next\\n curr.next = prev.next\\n prev.next = curr\\n\\n curr = next\\n \\n return dummy.next\",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: ListNode | None) -> ListNode | None:\\n dummy = ListNode(0)\\n prev = dummy # the last and thus largest of the sorted list\\n\\n while head: # the current inserting node\\n next = head.next # Cache the next inserting node.\\n if prev.val >= head.val:\\n prev = dummy # Move `prev` to the front.\\n while prev.next and prev.next.val < head.val:\\n prev = prev.next\\n head.next = prev.next\\n prev.next = head\\n head = next # Update the current inserting node.\\n\\n return dummy.next\\n\\n \",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"class Solution:\\n def insertionSortList(self, head: ListNode) -> ListNode:\\n \\n # No need to sort for empty list or list of size 1\\n if not head or not head.next:\\n return head\\n \\n # Use dummy_head will help us to handle insertion before head easily\\n dummy_head = ListNode(val=-5000, next=head)\\n last_sorted = head # last node of the sorted part\\n cur = head.next # cur is always the next node of last_sorted\\n while cur:\\n if cur.val >= last_sorted.val:\\n last_sorted = last_sorted.next\\n else:\\n # Search for the position to insert\\n prev = dummy_head\\n while prev.next.val <= cur.val:\\n prev = prev.next\\n \\n # Insert\\n last_sorted.next = cur.next\\n cur.next = prev.next\\n prev.next = cur\\n \\n cur = last_sorted.next\\n \\n return dummy_head.next\",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n src = head.next \\n dest = ListNode(head.val)\\n # 1-->2--->3-->4--->5\\n # 5--8--7\\n while src:\\n node = ListNode(src.val)\\n if src.val < dest.val:\\n node.next = dest\\n dest = node\\n else:\\n prev = None\\n temp = dest\\n while temp and temp.val <= src.val:\\n prev = temp\\n temp = temp.next\\n prev.next = node\\n node.next = temp \\n\\n src = src.next \\n return dest\\n \\n\\n\\n\\n\\n \\n \",\n \"memory\": \"18700\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":11,"string":"11"}}},{"rowIdx":52,"cells":{"question_id":{"kind":"number","value":148,"string":"148"},"name":{"kind":"string","value":"sort-list"},"content":{"kind":"string","value":"<p>Given the <code>head</code> of a linked list, return <em>the list after sorting it in <strong>ascending order</strong></em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2020/09/14/sort_list_1.jpg\" style=\"width: 450px; height: 194px;\" />\n<pre>\n<strong>Input:</strong> head = [4,2,1,3]\n<strong>Output:</strong> [1,2,3,4]\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2020/09/14/sort_list_2.jpg\" style=\"width: 550px; height: 184px;\" />\n<pre>\n<strong>Input:</strong> head = [-1,5,3,4,0]\n<strong>Output:</strong> [-1,0,3,4,5]\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> head = []\n<strong>Output:</strong> []\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of nodes in the list is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.</li>\n\t<li><code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code></li>\n</ul>\n\n<p> </p>\n<p><strong>Follow up:</strong> Can you sort the linked list in <code>O(n logn)</code> time and <code>O(1)</code> memory (i.e. constant space)?</p>\n"},"acRate":{"kind":"number","value":59.49196613924632,"string":"59.491966"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["linked-list","two-pointers","divide-and-conquer","sorting","merge-sort"],"string":"[\n \"linked-list\",\n \"two-pointers\",\n \"divide-and-conquer\",\n \"sorting\",\n \"merge-sort\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"51\", 0.0791], [\"57\", 0.0527], [\"63\", 0.0132], [\"69\", 0.0132], [\"75\", 0.0263], [\"81\", 0.0132], [\"87\", 0.0132], [\"93\", 0.0263], [\"99\", 0.1579], [\"105\", 0.7103], [\"111\", 1.5259], [\"117\", 3.0518], [\"123\", 2.6965999999999997], [\"128\", 1.5259], [\"134\", 0.9208999999999998], [\"140\", 0.6708000000000001], [\"146\", 1.1708], [\"152\", 2.3547000000000002], [\"158\", 3.9463], [\"164\", 3.5517], [\"170\", 2.5651], [\"176\", 1.5390000000000001], [\"182\", 0.6839999999999999], [\"188\", 0.38149999999999995], [\"194\", 0.34209999999999996], [\"200\", 0.4734999999999999], [\"206\", 0.2236], [\"211\", 0.2368], [\"217\", 0.18430000000000002], [\"223\", 0.0922], [\"229\", 0.11850000000000001], [\"235\", 0.1974], [\"241\", 0.2763], [\"247\", 0.2894], [\"253\", 0.5525], [\"259\", 1.1181], [\"265\", 2.1047000000000002], [\"271\", 3.4069000000000003], [\"277\", 5.2356], [\"283\", 5.761500000000001], [\"288\", 6.958799999999999], [\"294\", 7.1691], [\"300\", 5.5249], [\"306\", 3.9463], [\"312\", 2.9993], [\"318\", 2.5652], [\"324\", 2.0389], [\"330\", 1.6574], [\"336\", 1.276], [\"342\", 1.0524], [\"348\", 1.0129000000000001], [\"354\", 0.9209], [\"360\", 0.8681000000000001], [\"365\", 0.7497999999999999], [\"371\", 0.5787], [\"377\", 0.6971999999999999], [\"383\", 0.6445], [\"389\", 0.6446000000000001], [\"395\", 0.6578], [\"401\", 0.513], [\"407\", 0.4603], [\"413\", 0.3159], [\"419\", 0.34209999999999996], [\"425\", 0.32889999999999997], [\"431\", 0.2894], [\"437\", 0.35509999999999997], [\"443\", 0.2894], [\"448\", 0.2894], [\"454\", 0.158], [\"460\", 0.15789999999999998], [\"466\", 0.1447], [\"472\", 0.15789999999999998], [\"478\", 0.18419999999999997], [\"484\", 0.1317], [\"490\", 0.1317], [\"496\", 0.11850000000000001], [\"502\", 0.11850000000000001], [\"508\", 0.09230000000000001], [\"514\", 0.0791], [\"520\", 0.0527]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"20900\", 0.0263], [\"21000\", 0.0658], [\"21100\", 0.0132], [\"21200\", 0.0132], [\"26200\", 0.0132], [\"30600\", 0.0132], [\"31200\", 0.0132], [\"31500\", 0.0263], [\"31600\", 0.0132], [\"31700\", 0.0263], [\"31800\", 0.0263], [\"31900\", 0.0921], [\"32000\", 0.1052], [\"32100\", 0.2368], [\"32200\", 1.6838], [\"32299\", 6.0773], [\"32400\", 22.5862], [\"32500\", 38.9634], [\"32600\", 5.9721], [\"32700\", 0.4209], [\"32800\", 0.2499], [\"32900\", 0.2105], [\"33000\", 0.1842], [\"33100\", 0.0658], [\"33300\", 0.0395], [\"33400\", 0.0395], [\"34100\", 0.0132], [\"34200\", 0.0395], [\"34400\", 0.0132], [\"34600\", 0.0132], [\"34700\", 0.0526], [\"34800\", 0.0132], [\"35000\", 0.0132], [\"35200\", 0.0132], [\"35300\", 0.0921], [\"35400\", 0.1184], [\"35500\", 0.0789], [\"35600\", 0.0395], [\"35700\", 0.0132], [\"36100\", 0.0132], [\"36200\", 0.0395], [\"36300\", 0.0263], [\"36400\", 0.0658], [\"36500\", 0.0132], [\"36600\", 0.0132], [\"36800\", 0.0132], [\"36900\", 0.0658], [\"37000\", 0.2368], [\"37100\", 0.6183], [\"37200\", 2.0126], [\"37300\", 2.1705], [\"37400\", 3.407], [\"37500\", 2.4204], [\"37600\", 1.3944], [\"37700\", 2.0521], [\"37800\", 0.8419], [\"37900\", 1.6838]]}"},"rt_list":{"kind":"list like","value":[{"code":"with open(\"user.out\", \"w\") as Solution:\n for head in map(loads, stdin):\n Solution.write(f\"{sorted(head)}\\n\".replace(\" \",\"\"))\nexit()","runtime":"51"},{"code":"f = open('user.out','w')\nfor arr in map(loads, stdin):\n print(str(sorted(arr)).replace(' ',''), file=f)\nexit(0)","runtime":"51"},{"code":"f = open('user.out','w')\nfor arr in map(loads, stdin):\n print(str(sorted(arr)).replace(' ',''), file=f)\nexit(0)","runtime":"57"},{"code":"f = open('user.out','w')\nfor arr in map(loads, stdin):\n print(str(sorted(arr)).replace(' ',''), file=f)\nexit(0)","runtime":"57"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n curr = head\n l =[]\n while curr:\n l.append(curr.val)\n curr = curr.next\n l.sort()\n curr = head\n for i in l:\n curr.val = i\n curr = curr.next\n return head","runtime":"63"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n l = []\n cur = head\n while cur:\n l.append(cur.val)\n cur = cur.next\n l.sort()\n cur = head\n for num in l:\n cur.val = num\n cur = cur.next\n return head\n\n ","runtime":"69"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # Step 0\n if not head:\n return head\n\n node = head\n sorted_list = []\n\n # Step 1: \n while node:\n sorted_list.append(node.val)\n node = node.next\n\n # Step 2:\n sorted_list.sort()\n\n # Step 3: \n node = head\n for val in sorted_list:\n node.val = val\n node = node.next\n\n return head","runtime":"81"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n values = []\n current = head\n while current:\n values.append(current.val)\n current = current.next\n values.sort()\n current = head\n for value in values:\n current.val = value\n current = current.next\n \n return head\n","runtime":"87"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n values = []\n curr = head\n while curr:\n values.append(curr.val)\n curr = curr.next\n \n values = sorted(values, reverse = True)\n\n curr = head\n while curr:\n curr.val = values.pop()\n curr = curr.next\n \n return head","runtime":"93"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n if not head or not head.next:\n return head\n \n sortedL=[]\n curr=head\n while curr:\n sortedL.append(curr.val)\n curr=curr.next\n \n # sort the list\n sortedL.sort()\n\n # create a new linked list based on sorted value\n curr=head\n for val in sortedL:\n curr.val=val\n curr=curr.next\n return head\n\n\n \n ","runtime":"99"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n list2=[]\n k=head\n while k:\n list2.append(k.val)\n k=k.next\n \n list2.sort()\n\n k=head\n i=0\n while k:\n k.val = list2[i]\n i=i+1\n k = k.next\n\n return head","runtime":"99"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n arr, itr = [], head # take an array to store all the extracted values\n while itr: # iterate and copy\n arr.append(itr.val) \n itr = itr.next\n arr.sort() # sort it\n itr, i = head, 0 # take i to traverse the array along with linked list\n\t\t\t\t\n while itr: # fill the sorted values\n itr.val = arr[i] \n i += 1\n itr = itr.next\n return head","runtime":"105"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n arr, itr = [], head\n while itr:\n arr.append(itr.val)\n itr = itr.next\n arr.sort()\n itr, i = head, 0\n while itr:\n itr.val = arr[i]\n i += 1\n itr = itr.next\n return head","runtime":"105"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n curr = head\n valList = list()\n while curr:\n valList.append(curr.val)\n curr = curr.next\n \n curr = head\n valList.sort(reverse=True)\n while curr:\n curr.val = valList.pop()\n curr = curr.next\n return head\n","runtime":"111"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n values = []\n curr = head\n while curr:\n values.append(curr.val)\n curr = curr.next\n \n values = sorted(values, reverse = True)\n\n curr = head\n while curr:\n curr.val = values.pop()\n curr = curr.next\n \n return head","runtime":"111"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n arr = []\n temp = head\n temp2 = head\n while temp:\n arr.append(temp.val)\n temp = temp.next\n arr.sort()\n i = 0\n while temp2:\n temp2.val = arr[i]\n i += 1\n temp2 = temp2.next\n return head\n\n ","runtime":"117"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n arr=[]\n temp=head\n while(temp!=None):\n arr.append(temp.val)\n temp=temp.next\n arr.sort()\n temp=head\n i=0\n while(temp!=None):\n temp.val=arr[i]\n i+=1\n temp=temp.next\n return(head)\n ","runtime":"117"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n \n nums = []\n node = head\n while node:\n nums.append(node.val)\n node = node.next\n \n nums.sort()\n node = head\n for num in nums:\n node.val = num\n node = node.next\n \n return head","runtime":"123"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n l=[]\n temp=head\n while temp is not None:\n l.append(temp.val)\n temp=temp.next\n i=0\n l=sorted(l)\n current=head\n while current is not None:\n current.val=l[i]\n i=i+1\n current=current.next\n return head\n\n \n ","runtime":"123"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n k=[]\n node=head\n while node:\n k.append(node.val)\n node=node.next\n k.sort()\n \n node=head\n for i in k:\n node.val=i\n node=node.next\n return head\n ","runtime":"128"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n allElements = []\n \n temp = head\n temp2 = head\n if head == None:\n return head\n while temp != None:\n allElements.append(temp.val)\n temp = temp.next\n \n allElements.sort()\n for i in range(0, len(allElements)):\n temp2.val = allElements[i]\n temp2 = temp2.next\n \n return head\n ","runtime":"128"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n l = []\n while head:\n l.append(head)\n head = head.next\n \n l.sort(key=lambda x: x.val, reverse=True)\n \n dummy = ListNode()\n curr = dummy\n while l:\n curr.next = l.pop()\n curr = curr.next\n \n curr.next = None\n return dummy.next","runtime":"134"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n nodes_arr = []\n\n curr = head\n while curr:\n nodes_arr.append(curr)\n curr = curr.next\n\n nodes_arr.sort(key=lambda node: node.val)\n\n for i in range(len(nodes_arr) - 1):\n nodes_arr[i].next = nodes_arr[i + 1]\n \n nodes_arr[-1].next = None\n\n return nodes_arr[0]\n","runtime":"134"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nimport heapq\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n heap = []\n curr = head\n\n while curr:\n heapq.heappush(heap,curr.val)\n curr = curr.next\n\n curr= head\n while curr:\n pop = heapq.heappop(heap)\n curr.val = pop\n curr = curr.next\n \n return head\n ","runtime":"140"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n cur=head\n l=[]\n while cur:\n l.append(cur.val)\n cur=cur.next\n l.sort()\n cur=head\n i=0\n while cur:\n cur.val=l[i]\n i+=1\n cur=cur.next\n return head","runtime":"140"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nimport heapq\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n heap = []\n curr = head\n\n while curr:\n heapq.heappush(heap,curr.val)\n curr = curr.next\n \n curr = head\n while curr:\n pop = heapq.heappop(heap)\n curr.val = pop\n curr = curr.next\n \n return head","runtime":"146"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n l = []\n node = head\n while node:\n l.append(node.val)\n node = node.next\n l.sort()\n ret = ListNode()\n node = ret\n for n in l:\n node.next = ListNode(n)\n node = node.next\n return ret.next","runtime":"146"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \"\"\"\n 1. use a hashtable to store all the nodes, space complexity: O(n) \n 2. there could be duplocated keys\n \"\"\"\n\n if not head:\n return head\n\n\n store = defaultdict(list) # key: the val, value: the node list\n\n curr = head \n while curr:\n store[curr.val].append(curr)\n curr = curr.next\n \n keys = list(store.keys())\n keys.sort()\n\n # note store[keys[i]] should be a list \n dummy_node = ListNode()\n new_curr = dummy_node\n for i in range(len(keys)):\n for node in store[keys[i]]:\n new_curr.next = node \n new_curr = node\n\n\n new_curr.next = None \n return dummy_node.next","runtime":"152"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nimport heapq\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n heap=[]\n curr=head\n while curr:\n heapq.heappush(heap,curr.val)\n curr=curr.next\n curr=head\n while curr:\n pop=heapq.heappop(heap)\n curr.val=pop\n curr=curr.next\n return head\n ","runtime":"152"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n elems = []\n\n curr = head\n while curr:\n elems.append(curr.val)\n curr = curr.next\n elems.sort()\n\n dummyHead = ListNode(0)\n prev = dummyHead\n\n for elem in elems:\n new = ListNode(elem)\n prev.next = new\n prev = prev.next\n return dummyHead.next","runtime":"158"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nimport heapq\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n heap = []\n curr = head\n\n while curr:\n heapq.heappush(heap,curr.val)\n curr = curr.next\n\n curr= head\n while curr:\n pop = heapq.heappop(heap)\n curr.val = pop\n curr = curr.next\n \n return head","runtime":"158"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n heap = []\n curr = head\n\n while curr:\n heapq.heappush(heap, curr.val)\n curr = curr.next\n\n curr = head\n while curr:\n val = heapq.heappop(heap)\n curr.val = val\n curr = curr.next\n\n \n return head\n\n ","runtime":"164"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n values = []\n while head:\n values.append(head.val)\n head = head.next\n values = sorted(values)\n head = None\n p = head\n for x in values[::-1]:\n head = ListNode(x, p)\n p = head\n # ListNode()\n ## my solution, get nodes, sort\n return head","runtime":"164"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nimport heapq\n\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n heap = []\n curr = head\n\n while curr:\n heapq.heappush(heap, curr.val)\n curr = curr.next\n \n curr = head\n while curr:\n pop = heapq.heappop(heap)\n curr.val = pop\n curr= curr.next\n return head\n\n \n\n\n\n\n ","runtime":"170"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n arr = []\n temp = head\n while temp is not None:\n arr.append(temp.val)\n temp = temp.next\n arr.sort()\n print(arr)\n temp = head\n for i in arr:\n print(i)\n temp.val = i\n temp = temp.next\n return head\n # temp = head\n # if head is None or head.next is None:\n # return head\n # slow = head\n # fast = head.next\n # while fast and fast.next:\n # slow = slow.next\n # fast = fast.next.next\n # mid = slow.next\n # slow.next = None\n # left = self.sortList(head)\n # right = self.sortList(mid)\n\n # dummy = ListNode(0)\n # curr = dummy\n \n # while left and right:\n # if left.val <= right.val:\n # curr.next = left\n # left = left.next\n # else:\n # curr.next = right\n # right= right.next\n # curr = curr.next\n # if left:\n # curr.next = left\n # else:\n # curr.next = right\n # return dummy.next\n\n\n ","runtime":"170"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: return None\n nums = []\n dummy = head\n while dummy != None:\n nums.append(dummy.val)\n dummy = dummy.next\n nums.sort()\n head1 = ListNode()\n dummy1 = head1\n for i in range(len(nums)):\n dummy1.next = ListNode(nums[i])\n dummy1 = dummy1.next\n return head1.next","runtime":"176"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return None\n arr = []\n while head:\n arr.append(head.val)\n head = head.next\n arr.sort()\n print(arr)\n\n h = ListNode(arr[0])\n hh = h\n for i in range(1,len(arr)):\n a = ListNode(arr[i])\n h.next = a\n h = h.next\n return hh\n \n ","runtime":"176"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom collections import defaultdict\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n d = defaultdict(list)\n cur = head\n while cur:\n d[cur.val].append(cur)\n cur = cur.next\n new_head, cur = None, None\n for value, nodes in sorted(d.items()):\n for node in nodes:\n if not cur:\n new_head, cur = node, node\n else:\n cur.next = node\n cur = cur.next\n if cur:\n cur.next = None\n return new_head\n","runtime":"182"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n li=[]\n if not head:return head\n while head:\n li.append(head.val)\n head=head.next\n li.sort()\n header=ListNode(li[0])\n head=header\n for i in range(1,len(li)):\n node=ListNode(li[i])\n head.next=node\n head=node\n return header","runtime":"182"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n nums = []\n tmp_head = head\n while tmp_head:\n nums.append(tmp_head.val)\n tmp_head = tmp_head.next\n nums.sort(reverse=True)\n if len(nums) <= 0:\n return head\n \n head = ListNode(val=nums.pop())\n return self.build_list(nums, head)\n\n def build_list(self, nums, head):\n if len(nums) == 0:\n return head\n \n next_element = nums.pop()\n head.next = ListNode(val=next_element)\n self.build_list(nums, head.next)\n return head\n\n\n \n\n ","runtime":"188"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return head\n hashmap = {}\n nums = []\n cur = head\n while cur:\n nums.append((cur.val, cur))\n hashmap[(cur.val, cur)] = cur\n cur = cur.next\n nums.sort(key=lambda x: x[0])\n hashmap[nums[len(nums)-1]].next = None\n for i in range(len(nums)-2, -1, -1):\n hashmap[nums[i]].next = hashmap[nums[i+1]]\n \n return head if head is None else hashmap[nums[0]]","runtime":"188"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n \"\"\"\n Time Complexity: O(N log N)\n Space Complexity: O(1)\n \"\"\"\n \n dummy = ListNode()\n res = dummy\n\n min_heap = []\n \n if not head:\n return head\n \n curr = head\n\n while curr:\n heapq.heappush(min_heap, curr.val)\n curr = curr.next\n \n while min_heap:\n next_node = ListNode(heapq.heappop(min_heap))\n res.next = next_node\n res = next_node\n \n return dummy.next","runtime":"194"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def mergeLists(self, left, right):\n head = tail = None\n while left or right:\n if left and right:\n if right.val < left.val:\n nxt = right\n right = right.next\n else:\n nxt = left\n left = left.next\n if tail:\n tail.next = nxt\n tail = nxt\n else:\n head = tail = nxt\n else:\n nxt = left or right\n if tail:\n tail.next = nxt\n else:\n head = tail = nxt\n break\n \n return head\n\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n i = head\n stack = []\n while i:\n heappush(stack, i.val)\n i = i.next\n head = tail = ListNode(heappop(stack))\n while stack:\n tail.next = ListNode(heappop(stack))\n tail = tail.next\n tail.next = None\n return head\n\n ","runtime":"194"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n curr = head\n heap = []\n while curr:\n heapq.heappush(heap , curr.val)\n curr = curr.next\n dummy = ListNode(0)\n curr = dummy\n while heap:\n temp = heapq.heappop(heap)\n curr.next = ListNode(temp)\n curr = curr.next\n return dummy.next\n\n ","runtime":"200"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n store = []\n curr = head\n while curr:\n store.append(curr.val)\n curr = curr.next\n store.sort()\n dummyNode = ListNode(0)\n temp = dummyNode\n \n for i in store:\n x = ListNode(val = i)\n temp.next = x\n temp = x\n return dummyNode.next","runtime":"200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n heap = []\n\n cur = head\n while cur:\n heapq.heappush(heap, cur.val)\n cur = cur.next\n \n res = ListNode()\n cur = res\n while heap:\n val = heapq.heappop(heap)\n cur.next = ListNode(val)\n cur = cur.next\n\n return res.next","runtime":"206"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom heapq import heappush\n\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return head\n\n heap = []\n node = head\n\n while node is not None:\n heappush(heap, node.val)\n node = node.next\n\n vals = []\n while heap:\n vals.append(heapq.heappop(heap))\n\n head = ListNode(vals[0])\n node = head\n\n for val in vals[1:]:\n next_node = ListNode(val)\n node.next = next_node\n node = next_node\n\n return head","runtime":"206"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n l = []\n while head:\n heapq.heappush(l,head.val)\n head = head.next\n \n head_val = heapq.heappop(l)\n head = ListNode(head_val)\n tmp = head\n while l:\n val = heapq.heappop(l)\n node = ListNode(val)\n tmp.next = node\n tmp = tmp.next\n return head","runtime":"211"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom heapq import *\n\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n if not head or not head.next:\n return head\n \n min_heap = []\n cur = head\n while cur:\n heappush(min_heap,cur.val)\n cur = cur.next\n \n dummy = newHead = ListNode()\n while min_heap:\n n = heappop(min_heap)\n newHead.next = ListNode(n)\n newHead = newHead.next\n return dummy.next","runtime":"211"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n curr = head\n minHeap = []\n while curr is not None:\n heapq.heappush(minHeap, (curr.val))\n curr = curr.next\n result = ListNode()\n curr = result\n while len(minHeap) > 0:\n curr.next = ListNode(heapq.heappop(minHeap))\n curr = curr.next\n return result.next","runtime":"217"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return head\n \n array = []\n curr = head\n while curr:\n array.append((curr.val, ListNode(curr.val)))\n curr = curr.next\n\n array.sort(key=lambda row: row[0], reverse=True)\n dummy = ListNode()\n curr = dummy\n for _ in range(len(array)):\n val, node = array.pop()\n curr.next = node\n curr = curr.next\n \n return dummy.next","runtime":"217"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom heapq import heappush, heappop\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n heap = []\n dummy = ListNode()\n index = 0\n while head:\n heappush(heap, (head.val, index, head))\n head = head.next\n index += 1\n \n current = dummy\n while heap:\n val, index, node = heappop(heap)\n current.next = node\n current = current.next\n current.next = None\n return dummy.next\n ","runtime":"223"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # use min_heap to sort the list\n min_heap = []\n\n p = head\n dummy_node = ListNode(-1)\n index = 0\n\n while p:\n heappush(min_heap, (p.val, index, p))\n p = p.next\n index += 1\n \n p = dummy_node\n while min_heap:\n _, _, curr_node = heappop(min_heap)\n p.next = curr_node\n p = p.next\n \n p.next = None\n return dummy_node.next ","runtime":"223"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nimport heapq\n\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n h = []\n node = head\n while(node):\n h.append((node.val,id(node), node))\n node = node.next\n #print(h)\n heapq.heapify(h)\n root = ListNode(val=float(\"inf\"))\n node = root\n while(h):\n _,_, ans = heapq.heappop(h)\n node.next = ans\n node = node.next\n node.next = None\n return root.next","runtime":"229"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return head\n sorted_head = self.mergeSort(head)\n return sorted_head\n\n def mergeSort(self,head):\n if head.next == None:\n return head\n\n #find the midpoint and split\n slow = head\n fast = head.next\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n\n #recursivly call mergesort\n right = self.mergeSort(slow.next)\n slow.next = None\n left= self.mergeSort(head)\n\n #order\n right_curr = right\n left_curr = left\n sorted_head = None\n if left_curr.val < right_curr.val:\n sorted_head = left_curr\n left_curr = left_curr.next\n else:\n sorted_head = right_curr\n right_curr = right_curr.next\n sorted_end = sorted_head\n while right_curr is not None and left_curr is not None:\n if left_curr.val < right_curr.val:\n sorted_end.next = left_curr\n left_curr = left_curr.next\n else:\n sorted_end.next = right_curr\n right_curr = right_curr.next\n sorted_end = sorted_end.next\n\n if right_curr:\n sorted_end.next = right_curr\n else:\n sorted_end.next = left_curr\n\n return sorted_head\n\n\n\n \n \n\n \n def swap(self, node_1, node_2):\n #print(\"swapping\")\n temp = node_1.val\n node_1.val = node_2.val\n node_2.val = temp\n\n def bubblesort(self, head):\n if head is None:\n return head\n swap = True #init\n while swap:\n curr = head\n swap = False\n # print(f\"Resetting Curr {curr}\")\n while curr.next is not None:\n if curr.val > curr.next.val:\n #print(head)\n self.swap(curr, curr.next)\n swap = True\n # print(f\"swapped: {head}\")\n curr = curr.next\n \n return head\n\n\n \n\n \n ","runtime":"229"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return None\n\n heap = []\n\n current_node = head\n i = 0\n while current_node:\n heapq.heappush(heap, (current_node.val, i, current_node))\n i += 1\n current_node = current_node.next\n\n current_node = heapq.heappop(heap)[2]\n head = current_node\n\n while len(heap) > 0:\n next_node = heapq.heappop(heap)[2]\n current_node.next = next_node\n current_node = next_node\n current_node.next = None\n\n return head\n\n ","runtime":"235"},{"code":"from heapq import heapify, heappush, heappop\n\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n h = []\n heapify(h)\n\n if head == None:\n return head\n\n cur = head\n \n while cur != None:\n heappush(h, cur.val)\n cur = cur.next\n \n head = prev = None\n while len(h) > 0:\n node = ListNode(val=heappop(h), next=None)\n if prev:\n prev.next = node\n prev = node\n if head == None:\n head = node\n return head","runtime":"235"},{"code":"import heapq\n\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n node_heap = []\n\n curr = head\n while curr:\n heapq.heappush(node_heap, (curr.val, id(curr), curr))\n curr = curr.next\n \n _, _, new_head = heapq.heappop(node_heap)\n curr = new_head\n \n while node_heap:\n _, _, curr.next = heapq.heappop(node_heap)\n curr = curr.next\n \n curr.next = None\n return new_head\n \n","runtime":"241"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n node_map = defaultdict(list)\n curr = head\n dummyHead = ListNode(0)\n while curr:\n node_map[curr.val].append(curr)\n curr = curr.next\n \n curr = dummyHead\n # n log n\n for key, value in sorted(node_map.items()):\n for node in value:\n curr.next = ListNode(node.val)\n curr = curr.next\n\n return dummyHead.next","runtime":"241"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n sz = 0\n h = head\n while h:\n h = h.next\n sz += 1\n \n def mergesort(sz, h):\n if sz == 0: return None\n if sz == 1: return h\n if sz == 2:\n if h.val > h.next.val:\n tmp = h.next\n h.next = None\n tmp.next = h\n h = tmp\n return h\n mid = sz // 2\n k = h\n for _ in range(mid - 1):\n k = k.next\n k.next, k = None, k.next\n h1, h2 = mergesort(mid, h), mergesort(sz - mid, k)\n res = dummy = ListNode(-1)\n while h1 and h2:\n if h1.val < h2.val:\n dummy.next = h1\n h1 = h1.next\n else:\n dummy.next = h2\n h2 = h2.next\n dummy = dummy.next\n if h1: dummy.next = h1\n if h2: dummy.next = h2\n return res.next\n\n return mergesort(sz, head)\n\n ","runtime":"247"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return head\n \n count = 0\n ptr = head\n while ptr:\n ptr = ptr.next\n count += 1\n \n self.prehead = ListNode()\n\n return self.sort(head, count)[0]\n \n def sort(self, head: ListNode, count: int) -> (ListNode, ListNode):\n if count == 1:\n ans = (head, head.next)\n head.next = None\n return ans\n \n (left, right) = self.sort(head, (count+1)//2)\n (left_2, right) = self.sort(right, count - (count+1)//2)\n return (self.merge(left, left_2), right)\n \n def merge(self, head_1:ListNode, head_2:ListNode) -> ListNode:\n self.prehead.next = None\n head = self.prehead\n while head_1 and head_2:\n if head_1.val <= head_2.val:\n head.next = head_1\n head = head_1\n head_1 = head_1.next\n else:\n head.next = head_2\n head = head_2\n head_2 = head_2.next\n \n head.next = head_1 if head_1 else head_2\n return self.prehead.next","runtime":"247"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n DEBUG = False\n\n # if not head:\n # return None\n\n # node_pointers = [head]\n # while node_pointers[-1].next:\n # node_pointers.append(node_pointers[-1].next)\n\n # if DEBUG:\n # for node in node_pointers:\n # print(f'{node.val}, ')\n # print(f'\\n')\n\n # def sort_values(array):\n # if DEBUG:\n # for node in array:\n # print(f'{node.val}, ')\n # print(f'\\n')\n\n # n = len(array)\n # if n < 2:\n # return array\n\n # m = n // 2\n # sub_array_1 = sort_values(array[:m])\n # sub_array_2 = sort_values(array[m:])\n\n # # concatenation\n # i_1 = 0\n # i_2 = 0\n # output = []\n # while i_1 < m and i_2 < n - m:\n # if sub_array_1[i_1].val <= sub_array_2[i_2].val:\n # output += [sub_array_1[i_1]]\n # i_1 += 1\n # else:\n # output += [sub_array_2[i_2]]\n # i_2 += 1\n # if i_1 < len(sub_array_1):\n # output += sub_array_1[i_1:]\n # if i_2 < len(sub_array_2):\n # output += sub_array_2[i_2:]\n\n # return output\n\n # node_pointers = sort_values(node_pointers)\n # for i in range(len(node_pointers) - 1):\n # node_pointers[i].next = node_pointers[i + 1]\n # node_pointers[-1].next = None\n\n # return node_pointers[0]\n\n\n if not head:\n return head\n\n if not head.next:\n return head\n\n # find the pointer to the middle node\n pointer_iter = head\n pointer_double_iter = head\n while pointer_double_iter.next and pointer_double_iter.next.next:\n pointer_iter = pointer_iter.next\n pointer_double_iter = pointer_double_iter.next.next\n # pointer to the second array \n second_pointer = pointer_iter.next\n # finish the first array\n pointer_iter.next = None\n\n pointer_1 = self.sortList(head)\n pointer_2 = self.sortList(second_pointer)\n\n # pointer to the first element\n if pointer_1.val < pointer_2.val:\n pointer_init = pointer_1\n pointer_1 = pointer_1.next\n else:\n pointer_init = pointer_2\n pointer_2 = pointer_2.next\n current_pointer = pointer_init\n\n\n # concatenation\n while pointer_1 and pointer_2:\n if pointer_1.val < pointer_2.val:\n current_pointer.next = pointer_1\n current_pointer = current_pointer.next\n pointer_1 = pointer_1.next\n else:\n current_pointer.next = pointer_2\n current_pointer = current_pointer.next\n pointer_2 = pointer_2.next\n\n if not pointer_1:\n current_pointer.next = pointer_2\n if not pointer_2:\n current_pointer.next = pointer_1\n\n return pointer_init","runtime":"253"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None: return None\n if head.next is None: return head\n\n # find middle of list\n slow = head\n fast = head\n while fast.next is not None and fast.next.next is not None:\n slow = slow.next\n fast = fast.next.next\n\n # split into two halves and sort them\n rhead = slow.next\n slow.next = None\n head = self.sortList(head)\n other = self.sortList(rhead)\n\n if head.val > other.val:\n head, other = other, head\n\n # merge other into head\n hcurr = head\n while hcurr.next is not None and other is not None:\n if hcurr.next.val > other.val:\n hnext = hcurr.next\n hcurr.next = other\n other = other.next\n hcurr.next.next = hnext\n hcurr = hcurr.next\n\n # if other is empty, we're done;\n # otherwise we reached the end of the main list and need to\n # append other\n if other is not None:\n hcurr.next = other\n\n return head\n","runtime":"253"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n #if length is less than or eqaul to one\n if not head or not head.next:\n return head\n \n #spilt ll in half\n slow=fast=head\n fast=fast.next\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n #Store the mid\n mid=slow.next\n #set slow next to None to get 2 seperate halfs\n slow.next=None\n\n #recursively sort left and right halfs of linked list\n left=self.sortList(head)\n right=self.sortList(mid)\n\n #merge 2 sorted hafs of the linked list\n dummy=ListNode(0)\n curr=dummy\n while left and right:\n if left.val<right.val:\n curr.next=left\n left=left.next\n else:\n curr.next=right\n right=right.next\n curr=curr.next\n #append remaining nodes of left or right\n curr.next=left or right\n return dummy.next\n","runtime":"259"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n #mergesort\n def merge(self,first:Optional[ListNode],second:Optional[ListNode])-> Optional[ListNode]:\n final = ListNode()\n head = final\n while first and second:\n if first.val<=second.val:\n final.next = first\n final = final.next\n first = first.next\n else:\n final.next = second\n final = final.next\n second = second.next\n if first:\n final.next = first\n else:\n final.next = second\n final = final.next\n return head.next\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n def mergeSort(arr,low,high):\n if high==low:\n return arr[low]\n mid = int((high+low)/2)\n h = mergeSort(arr,low,mid)\n a = mergeSort(arr,mid+1,high)\n return self.merge(h,a)\n t = []\n traverse = head\n while traverse:\n prev = traverse\n traverse = traverse.next\n prev.next = None\n t.append(prev)\n return mergeSort(t,0,len(t)-1)\n\n \n ","runtime":"259"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n def merge_sort(node):\n # Base case: if the list is empty or has only one node, it's already sorted\n if not node or not node.next:\n return node\n \n # Use two pointers to find the middle of the list\n slow, fast = node, node.next\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n \n # Split the list into two halves\n right_half = slow.next\n slow.next = None\n \n # Recursively sort both halves\n left = merge_sort(node)\n right = merge_sort(right_half)\n \n # Merge the sorted halves\n dummy = ListNode()\n curr = dummy\n \n while left and right:\n if left.val < right.val:\n curr.next = left\n left = left.next\n else:\n curr.next = right\n right = right.next\n curr = curr.next\n # Append the remaining nodes of the left or right half to the end of the sorted list\n curr.next = left or right\n \n return dummy.next\n \n return merge_sort(head)","runtime":"265"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n tortoise, hare = head, head.next\n\n while hare and hare.next:\n tortoise = tortoise.next\n hare = hare.next.next\n\n middle = tortoise.next\n tortoise.next = None\n \n left = self.sortList(head)\n right = self.sortList(middle)\n\n dummy = ListNode(0)\n p = dummy\n\n while left and right:\n if left.val < right.val:\n p.next = left\n left = left.next\n else:\n p.next = right\n right = right.next\n p = p.next\n \n p.next = left or right\n return dummy.next\n ","runtime":"271"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n mid = slow.next\n slow.next = None\n\n left = self.sortList(head)\n right = self.sortList(mid)\n\n dummy = ListNode()\n c = dummy\n\n while left and right:\n if left.val < right.val:\n c.next = left\n left = left.next\n else:\n c.next = right\n right = right.next\n c = c.next\n\n c.next = left or right\n\n return dummy.next","runtime":"271"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n mid = slow.next\n slow.next = None\n return self.merge(self.sortList(head), self.sortList(mid))\n \n def merge(self, l1, l2):\n dummy = ListNode()\n cur = dummy\n while l1 and l2:\n if l1.val < l2.val:\n cur.next = l1\n l1 = l1.next\n else:\n cur.next = l2\n l2 = l2.next\n cur = cur.next\n cur.next = l1 or l2\n return dummy.next\n \n\n ","runtime":"277"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n \n slow, fast = head, head.next\n while fast and fast.next:\n slow, fast = slow.next, fast.next.next\n mid = slow.next\n slow.next = None\n\n small = self.sortList(head)\n large = self.sortList(mid)\n\n dummy = ListNode()\n cur1, cur2, cur = small, large, dummy\n while cur1 and cur2:\n if cur1.val < cur2.val:\n cur.next = cur1\n cur1 = cur1.next\n else:\n cur.next = cur2\n cur2 = cur2.next\n cur = cur.next\n cur.next = cur1 or cur2\n return dummy.next\n\n\n# from collections import defaultdict\n# class Solution:\n# def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n# d = defaultdict(list)\n# cur = head\n# while cur:\n# d[cur.val].append(cur)\n# cur = cur.next\n# new_head, cur = None, None\n# for value, nodes in sorted(d.items()):\n# for node in nodes:\n# if not cur:\n# new_head, cur = node, node\n# else:\n# cur.next = node\n# cur = cur.next\n# if cur:\n# cur.next = None\n# return new_head\n","runtime":"277"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # merge sort\n # base case: if length <= 1 denotes sorted list\n if not head or not head.next:\n return head\n\n # split list into 2 halfs with slow and fast pointer to find mid\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n mid = slow.next\n slow.next = None # cut the list into 2 halves\n\n # recursively sort left and right halves\n left = self.sortList(head)\n right = self.sortList(mid)\n\n # merge 2 halves\n dummy = ListNode(0)\n curr = dummy\n while left and right:\n if left.val < right.val:\n curr.next = left\n left = left.next # move down left list\n else:\n curr.next = right\n right = right.next\n curr = curr.next\n \n # append remaining nodes\n curr.next = left or right\n\n return dummy.next","runtime":"283"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n temp = head\n if head is None or head.next is None:\n return head\n slow = head\n fast = head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n mid = slow.next\n slow.next = None\n left = self.sortList(head)\n right = self.sortList(mid)\n\n dummy = ListNode(0)\n curr = dummy\n \n while left and right:\n if left.val <= right.val:\n curr.next = left\n left = left.next\n else:\n curr.next = right\n right= right.next\n curr = curr.next\n if left:\n curr.next = left\n else:\n curr.next = right\n return dummy.next\n\n\n ","runtime":"283"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n slow, fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n mid = slow.next\n slow.next = None\n\n left = self.sortList(head)\n right = self.sortList(mid)\n\n dummy = ListNode(0)\n curr = dummy\n while left and right:\n if left.val < right.val:\n curr.next = left\n left = left.next\n else:\n curr.next = right\n right = right.next\n\n curr = curr.next\n curr.next = left or right\n return dummy.next\n\n\n\n\n\n\n ","runtime":"288"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n if not head or not head.next:\n return head\n\n left = head \n mid = self.getMid(head)\n right = mid.next \n mid.next = None\n\n sorted_left = self.sortList(left)\n sorted_right = self.sortList(right)\n return self.merge(sorted_left, sorted_right)\n \n\n def merge(self, left, right): \n curr = dummy = ListNode()\n while left and right:\n if left.val <= right.val:\n curr.next = left \n left = left.next \n else:\n curr.next = right \n right = right.next \n curr = curr.next \n \n if left:\n curr.next = left \n \n if right:\n curr.next = right \n \n return dummy.next\n\n\n def getMid(self, head):\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow","runtime":"288"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n mid = self.getMiddle(head)\n left = head\n right = mid.next\n mid.next = None\n\n left_sorted = self.sortList(left)\n right_sorted = self.sortList(right)\n\n sorted_list = self.merge(left_sorted, right_sorted)\n return sorted_list\n\n def getMiddle(self, head: ListNode) -> ListNode:\n slow = head\n fast = head.next\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n return slow\n\n\n def merge(self, l1: ListNode, l2: ListNode) -> ListNode:\n dummy = ListNode(0)\n tail = dummy\n \n while l1 and l2:\n if l1.val < l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n\n # Attach the remaining nodes\n tail.next = l1 if l1 else l2\n\n return dummy.next\n","runtime":"294"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n right = slow.next\n slow.next = None\n\n left = self.sortList(head)\n right = self.sortList(right)\n\n return self.merge(left, right)\n\n def merge(self, l1, l2):\n if not l1 or not l2:\n return l1 or l2\n\n if l1.val < l2.val:\n l1.next = self.merge(l1.next, l2)\n return l1\n else:\n l2.next = self.merge(l1, l2.next)\n return l2\n ","runtime":"294"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def mergeTwoSort(self,left,right):\n new_node=ListNode(-1)\n new_head=new_node\n while left and right:\n if left.val<=right.val:\n new_head.next=left\n left=left.next\n else:\n new_head.next=right\n right=right.next\n new_head=new_head.next\n if left:\n new_head.next=left\n else:\n new_head.next=right\n return new_node.next\n\n def findMiddle(self,head):\n if head is None or head.next is None:\n return head\n slow=fast=head\n prev=None\n while fast and fast.next:\n prev=slow\n slow=slow.next\n fast=fast.next.next\n prev.next=None\n return slow\n\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return head\n mid=self.findMiddle(head)\n left=self.sortList(head)\n right=self.sortList(mid)\n return self.mergeTwoSort(left,right)","runtime":"300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def find_middle(self, head):\n slow, fast = head, head\n while fast and fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n\n def merge_list(self, l1, l2):\n dummy = ListNode()\n tail = dummy\n\n while l1 and l2:\n if l1.val < l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n \n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n \n return dummy.next\n\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # base condition\n if not head or not head.next:\n return head\n\n # find the middle value\n middle = self.find_middle(head)\n middle_to_next = middle.next\n middle.next = None\n\n #Find left and rights\n left = self.sortList(head)\n right = self.sortList(middle_to_next)\n\n sorted_list = self.merge_list(left, right)\n return sorted_list","runtime":"300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # We will go about this in the form of Merge sort first\n if head is None or head.next is None:\n return head\n start = head\n mid = self.getMid(head)\n tmp = mid.next\n mid.next = None # cut things at the mid\n mid = tmp\n\n arr1 = self.sortList(start)\n arr2 = self.sortList(mid)\n return self.merge(arr1, arr2)\n\n \n def getMid(self, arr):\n \"\"\"This will give us the mid point\"\"\"\n slow = arr\n fast = arr.next\n while fast and fast.next: \n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(self, arr1, arr2):\n head = ListNode()\n ptr = head # this is a test. \n # make a list by starting with hail. initializing the head with that. \n while arr1 and arr2:\n if arr1.val < arr2.val:\n ptr.next = arr1\n arr1 = arr1.next\n else:\n ptr.next = arr2\n arr2 = arr2.next\n ptr = ptr.next\n \n if arr1:\n ptr.next = arr1\n \n if arr2:\n ptr.next = arr2\n \n return head.next\n","runtime":"306"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n # find middle of list\n dummy = ListNode(0, head)\n slow, fast = dummy, head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n midpoint = slow.next\n slow.next = None\n list1, list2 = self.sortList(head), self.sortList(midpoint)\n return self.merge(list1, list2)\n\n def merge(self, l1, l2):\n if not l1 and l2:\n return l2\n if l1 and not l2:\n return l1\n dummy = ListNode(0)\n current = dummy\n while l1 and l2:\n if l1.val <= l2.val:\n current.next = l1\n l1 = l1.next\n else:\n current.next = l2\n l2 = l2.next\n current = current.next\n if l1:\n current.next = l1\n elif l2:\n current.next = l2\n return dummy.next\n\n\n\n","runtime":"306"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n (left,right) = self.split(head)\n temp = right.next\n right.next = None\n right = temp\n left = self.sortList(left)\n right = self.sortList(right)\n return self.merge(left,right)\n\n def split(self,head):\n tortoise,hare = head,head.next\n while hare and hare.next:\n tortoise = tortoise.next\n hare = hare.next.next\n return (head, tortoise)\n\n def merge(self, a,b):\n tail = dummy = ListNode()\n while a and b:\n if a.val < b.val:\n tail.next = a\n a = a.next\n else:\n tail.next = b\n b = b.next\n tail=tail.next\n if a:\n tail.next = a\n if b:\n tail.next = b\n return dummy.next\n\n\n\n\n\n\n\n\n\n\n ","runtime":"312"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def getMiddle(self,head):\n fast,slow=head,head\n while fast.next and fast.next.next:\n slow=slow.next\n fast=fast.next.next\n return slow\n\n def mergeTwoLists(self, list1: ListNode, list2: ListNode) -> ListNode:\n dummy = node = ListNode()\n\n while list1 and list2:\n if list1.val < list2.val:\n node.next = list1\n list1 = list1.next\n else:\n node.next = list2\n list2 = list2.next\n node = node.next\n\n node.next = list1 or list2\n\n return dummy.next\n\n def divide(self,head):\n if not head.next:\n return head\n \n middle=self.getMiddle(head) \n right=middle.next\n middle.next=None\n left=self.divide(head)\n right=self.divide(right)\n\n return self.mergeTwoLists(left,right)\n\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return head\n\n return self.divide(head)\n","runtime":"312"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n def findMiddle(head):\n # Use slow and fast pointers to find the middle of the linked list\n slow = head\n fast = head\n prev = None\n \n while fast and fast.next:\n prev = slow\n slow = slow.next\n fast = fast.next.next\n \n # Disconnect the first half from the second half\n if prev:\n prev.next = None\n\n return slow\n # Step 1: Split the list into two halves\n mid = findMiddle(head)\n \n # Step 2: Recursively sort both halves\n left = self.sortList(head)\n right = self.sortList(mid)\n def mergeTwoLists(l1, l2):\n # Create a dummy node to form the sorted list\n dummy = ListNode()\n tail = dummy\n\n # Merge the two lists\n while l1 and l2:\n if l1.val < l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n\n # Append any remaining elements from either list\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n\n return dummy.next\n # Step 3: Merge the sorted halves\n return mergeTwoLists(left, right)","runtime":"318"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n def getMiddle(head):\n slow, fast = head, head.next\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n return slow\n\n \n def merge(left, right):\n dummy = ListNode(None)\n temp = dummy\n while left and right:\n if left.val < right.val:\n temp.next = left\n temp = left\n left = left.next\n\n else:\n temp.next = right\n temp = right\n right = right.next\n\n if (left): temp.next = left\n else: temp.next = right\n return dummy.next\n\n \n\n if head is None or head.next is None:\n return head\n \n mid = getMiddle(head)\n left = head \n right = mid.next\n mid.next = None\n\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left, right)\n ","runtime":"318"},{"code":"# merge sort\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n # Helper function to find the middle of the linked list\n def get_middle(node):\n slow, fast = node, node\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n\n # Helper function to merge two sorted linked lists\n def merge(l1, l2):\n dummy = ListNode()\n tail = dummy\n\n while l1 and l2:\n if l1.val < l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n\n return dummy.next\n\n # Get the middle of the list to split it\n mid = get_middle(head)\n right = mid.next\n mid.next = None\n\n # Recursively sort both halves\n left_sorted = self.sortList(head)\n right_sorted = self.sortList(right)\n\n # Merge the sorted halves\n return merge(left_sorted, right_sorted)","runtime":"324"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n \n # Step 1: Find the middle of the list\n middle = self.findMiddle(head)\n right = middle.next\n middle.next = None\n left = head\n\n # Step 2: Recursively sort both halves\n left = self.sortList(left)\n right = self.sortList(right)\n\n # Step 3: Merge both sorted halves\n return self.mergeTwoSortedLists(left, right)\n\n def mergeTwoSortedLists(self, list1, list2):\n dummy = ListNode(-1)\n temp = dummy\n\n # Merge the two lists by comparing nodes\n while list1 and list2:\n if list1.val <= list2.val:\n temp.next = list1\n list1 = list1.next\n else:\n temp.next = list2\n list2 = list2.next\n temp = temp.next\n \n # Attach the remaining part of the lists\n if list1:\n temp.next = list1\n else:\n temp.next = list2\n \n return dummy.next\n\n def findMiddle(self, head):\n # Slow and fast pointer to find the middle of the list\n slow, fast = head, head\n while fast and fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n","runtime":"324"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: return\n \n def mid(head):\n slow, fast = head, head.next\n while fast and fast.next:\n slow, fast = slow.next, fast.next.next\n return slow\n \n def merge(l, r):\n dummy = ListNode(0)\n cur = dummy\n while l and r:\n if l.val < r.val:\n cur.next = l\n l = l.next\n else:\n cur.next = r\n r = r.next\n cur = cur.next\n if l:\n cur.next = l\n if r:\n cur.next = r\n return dummy.next\n\n if not (head and head.next):\n return head\n m = mid(head)\n l, r = head, m.next\n m.next = None\n l, r = self.sortList(l), self.sortList(r)\n return merge(l, r)\n","runtime":"330"},{"code":"class Solution:\n def sortList(self, head: ListNode) -> ListNode:\n def split(head: ListNode, k: int) -> ListNode:\n while k > 1 and head:\n head = head.next\n k -= 1\n rest = head.next if head else None\n if head:\n head.next = None\n return rest\n\n def merge(l1: ListNode, l2: ListNode) -> tuple:\n dummy = ListNode(0)\n tail = dummy\n\n while l1 and l2:\n if l1.val > l2.val:\n l1, l2 = l2, l1\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n tail.next = l1 if l1 else l2\n while tail.next:\n tail = tail.next\n\n return dummy.next, tail\n\n length = 0\n curr = head\n while curr:\n length += 1\n curr = curr.next\n\n dummy = ListNode(0, head)\n\n k = 1\n while k < length:\n curr = dummy.next\n tail = dummy\n while curr:\n l = curr\n r = split(l, k)\n curr = split(r, k)\n mergedHead, mergedTail = merge(l, r)\n tail.next = mergedHead\n tail = mergedTail\n k *= 2\n\n return dummy.next","runtime":"330"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n \n # Step 1: Find the middle of the list\n def find_middle(head):\n slow, fast = head, head\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n # Step 2: Split the list into two halves\n def split(head):\n middle = find_middle(head)\n second_half = middle.next\n middle.next = None\n return head, second_half\n \n # Step 4: Merge two sorted lists\n def merge(list1, list2):\n dummy = ListNode(0)\n tail = dummy\n while list1 and list2:\n if list1.val < list2.val:\n tail.next = list1\n list1 = list1.next\n else:\n tail.next = list2\n list2 = list2.next\n tail = tail.next\n if list1:\n tail.next = list1\n if list2:\n tail.next = list2\n return dummy.next\n \n # Step 3: Recursively sort each half\n left, right = split(head)\n left = self.sortList(left)\n right = self.sortList(right)\n \n return merge(left, right)","runtime":"336"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def sortList(self, head: ListNode) -> ListNode:\n def split(head: ListNode, k: int) -> ListNode:\n while k > 1 and head:\n head = head.next\n k -= 1\n rest = head.next if head else None\n if head:\n head.next = None\n return rest\n\n def merge(l1: ListNode, l2: ListNode) -> tuple:\n dummy = ListNode(0)\n tail = dummy\n\n while l1 and l2:\n if l1.val > l2.val:\n l1, l2 = l2, l1\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n tail.next = l1 if l1 else l2\n while tail.next:\n tail = tail.next\n\n return dummy.next, tail\n\n length = 0\n curr = head\n while curr:\n length += 1\n curr = curr.next\n\n dummy = ListNode(0, head)\n\n k = 1\n while k < length:\n curr = dummy.next\n tail = dummy\n while curr:\n l = curr\n r = split(l, k)\n curr = split(r, k)\n mergedHead, mergedTail = merge(l, r)\n tail.next = mergedHead\n tail = mergedTail\n k *= 2\n\n return dummy.next","runtime":"336"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n \n # Find count\n ptr = head.next\n n = 2\n while ptr.next:\n n += 1\n ptr = ptr.next\n \n # Break at midpoint\n ctr = 1\n ptr = head\n while ctr != n//2:\n ctr += 1\n ptr = ptr.next\n mid = ptr.next\n ptr.next = None\n \n # Recursively sort left and right\n left = self.sortList(head)\n right = self.sortList(mid)\n \n # Merge and return\n newHead = ListNode()\n newTrack = newHead\n while left and right:\n if left.val < right.val:\n newTrack.next = left\n left = left.next\n else:\n newTrack.next = right\n right = right.next\n newTrack = newTrack.next\n \n if left:\n newTrack.next = left\n elif right:\n newTrack.next = right\n \n return newHead.next\n \n ","runtime":"342"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n # Known:\n\n # Bubble sort\n # Insertion Sort\n # Merge Sort\n # Selection Sort\n\n def divide(head):\n dummy = ListNode(-1, head)\n slow = fast = dummy\n\n while slow and fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n\n right = slow.next\n slow.next = None\n\n return head, right\n\n def MergeSort(head):\n\n if head and head.next:\n\n l, r = divide(head)\n\n l = MergeSort(l)\n r = MergeSort(r)\n\n # print(l)\n # print(r)\n # print(\".\", head)\n\n i = l\n j = r\n\n dummy = ListNode(-1)\n k = dummy\n\n while i and j:\n if i.val < j.val:\n k.next = i\n i = i.next\n else:\n k.next = j\n j = j.next\n\n k = k.next\n\n if i:\n k.next = i\n\n if j:\n k.next = j\n\n return dummy.next\n\n return head\n\n return MergeSort(head)","runtime":"342"},{"code":"class ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\nclass Solution:\n def sortList(self, head: ListNode) -> ListNode:\n # Base case: if head is None or a single node, return head\n if not head or not head.next:\n return head\n\n # Function to split the list into two halves\n def split(head: ListNode) -> (ListNode, ListNode):\n slow, fast = head, head\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n mid = slow.next\n slow.next = None\n return head, mid\n\n # Function to merge two sorted lists\n def merge(left: ListNode, right: ListNode) -> ListNode:\n dummy = ListNode(0)\n current = dummy\n while left and right:\n if left.val < right.val:\n current.next = left\n left = left.next\n else:\n current.next = right\n right = right.next\n current = current.next\n current.next = left if left else right\n return dummy.next\n\n # Split the list into two halves\n left, right = split(head)\n\n # Recursively sort each half\n left = self.sortList(left)\n right = self.sortList(right)\n\n # Merge the sorted halves\n return merge(left, right)\n","runtime":"348"},{"code":"class ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\nclass Solution:\n def sortList(self, head: ListNode) -> ListNode:\n if not head or not head.next:\n return head\n \n # Split the linked list into two halves\n def split(head: ListNode) -> (ListNode, ListNode):\n slow, fast = head, head\n prev = None\n while fast and fast.next:\n prev = slow\n slow = slow.next\n fast = fast.next.next\n if prev:\n prev.next = None\n return head, slow\n \n # Merge two sorted linked lists\n def merge(left: ListNode, right: ListNode) -> ListNode:\n dummy = ListNode()\n current = dummy\n while left and right:\n if left.val < right.val:\n current.next = left\n left = left.next\n else:\n current.next = right\n right = right.next\n current = current.next\n if left:\n current.next = left\n if right:\n current.next = right\n return dummy.next\n \n # Recursively sort the linked list\n left, right = split(head)\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left, right)\n","runtime":"348"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n \n mid = self.getmidnode(head)\n leftlist = self.sortList(head)\n rightlist = self.sortList(mid)\n return self.mergetwolists(leftlist,rightlist)\n \n def mergetwolists(self,l1,l2):\n if not l1:\n return l2\n if not l2:\n return l1\n \n while l1 and l2:\n if l1.val <= l2.val:\n l1.next = self.mergetwolists(l1.next,l2)\n return l1\n else:\n l2.next = self.mergetwolists(l1,l2.next)\n return l2\n \n def getmidnode(self,head):\n if not head:\n return None\n prev = None\n slow = head\n fast = head\n while fast and fast.next:\n prev = slow\n slow = slow.next\n fast = fast.next.next\n prev.next = None\n return slow","runtime":"354"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def mergeTwoLists(l1: ListNode, l2: ListNode) -> ListNode:\n dummy = ListNode()\n tail = dummy\n \n while l1 and l2:\n if l1.val < l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n \n # Append the remaining nodes from either l1 or l2.\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n \n return dummy.next\n\n def getMiddle(head: ListNode) -> ListNode:\n slow, fast = head, head\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n\n\n # Base case: if the list is empty or contains a single element, it's already sorted.\n if not head or not head.next:\n return head\n\n # Step 1: Split the list into two halves using the slow-fast pointer technique.\n mid = getMiddle(head)\n left = head\n right = mid.next\n mid.next = None # Cut the list into two parts\n \n # Step 2: Recursively sort both halves.\n left_sorted = self.sortList(left)\n right_sorted = self.sortList(right)\n \n # Step 3: Merge the two sorted halves.\n return mergeTwoLists(left_sorted, right_sorted)","runtime":"354"},{"code":"class Solution:\n def merge(self, h1: Optional[ListNode], h2: Optional[ListNode]):\n p = dummy = ListNode()\n while h1 and h2:\n if h1.val < h2.val:\n p.next = h1\n h1 = h1.next\n else:\n p.next = h2\n h2 = h2.next\n p = p.next\n p.next = h1 or h2\n return dummy.next\n\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n n = 0\n p = head\n while p:\n p = p.next\n n += 1\n dummy = ListNode(0, head)\n sub_len = 1\n while sub_len < n:\n prev, cur = dummy, dummy.next\n while cur:\n h1 = cur\n t = sub_len - 1\n while t and cur.next:\n cur = cur.next\n t -= 1\n h2 = cur.next\n cur.next = None\n cur = h2\n t = sub_len - 1\n while t and cur and cur.next:\n cur = cur.next\n t -= 1\n next_part = None\n if cur:\n next_part = cur.next\n cur.next = None\n prev.next = self.merge(h1, h2)\n while prev.next:\n prev = prev.next\n cur = next_part\n sub_len <<= 1\n\n return dummy.next","runtime":"360"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n\n \"\"\"\n APPROACH 1: Top-down merge sort\n \"\"\"\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n def checkLL(node: ListNode) -> None:\n elems = []\n while node:\n elems.append(node.val)\n node = node.next\n print(elems)\n\n def getMidAndEnd(node: ListNode) -> List[ListNode]:\n # For finding tail, we'll use\n # fast if size is odd, fastPrev if size is even\n slow, fast, fastPrev = node, node.next, node\n\n while fast and fast.next:\n slow, fast, fastPrev = slow.next, fast.next.next, fastPrev.next.next\n\n mid = slow\n tail = fast if fast else fastPrev\n return [mid, tail]\n\n def mergeSort(node: Optional[ListNode]) -> Optional[ListNode]:\n if not node:\n return None\n elif not node.next:\n return node\n\n # Step 1: First find middle split point using Slow/fast approach\n mid, tail = getMidAndEnd(node)\n\n # Step 2: Next actually split LLs\n midNext, mid.next = mid.next, None\n\n # print(f'Split: {checkLL(node)} === {checkLL(midNext)}')\n\n # Step 3: Recurse..\n ll1Head = mergeSort(node)\n ll2Head = mergeSort(midNext)\n\n # Step 4: Sort while merging\n # We'll use tempHead as reference to new temporary list\n tempHead = ListNode(val=0, next=None)\n tempPtr = tempHead\n\n while ll1Head and ll2Head:\n if ll1Head.val <= ll2Head.val:\n tempPtr.next, ll1Head = ll1Head, ll1Head.next\n else:\n tempPtr.next, ll2Head = ll2Head, ll2Head.next\n tempPtr = tempPtr.next\n # detach node added to temp list from l1/l2\n tempPtr.next = None\n\n # depending on which LL remains, attach it to temp\n tempPtr.next = ll1Head if ll1Head else ll2Head\n\n return tempHead.next\n\n return mergeSort(head)\n\n","runtime":"360"},{"code":"import heapq\n\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n if head and not head.next:\n return head\n\n mid = head\n fast = head\n while fast and fast.next:\n mid = mid.next\n fast = fast.next.next\n \n node_before_mid = head\n while node_before_mid and node_before_mid.next != mid:\n node_before_mid = node_before_mid.next\n if node_before_mid:\n node_before_mid.next = None\n\n left = self.sortList(head)\n right = self.sortList(mid)\n\n new_head = None\n prev = None\n while left and right:\n if left.val < right.val:\n if not prev:\n new_head = left\n else:\n prev.next = left\n prev = left\n left = left.next\n else:\n if not prev:\n new_head = right\n else:\n prev.next = right\n prev = right\n right = right.next\n \n while left:\n if not prev:\n new_head = left\n else:\n prev.next = left\n prev = left\n left = left.next\n while right:\n if not prev:\n new_head = right\n else:\n prev.next = right\n prev = right\n right = right.next\n\n return new_head\n\n \n\n\"\"\"\nif not head:\n return None\n\n nodes = []\n node = head\n idx = 0\n while node:\n next_node = node.next\n node.next = None\n nodes.append((node.val, idx, node))\n node = next_node\n idx += 1\n\n heapq.heapify(nodes)\n \n new_head = nodes[0][2]\n prev_node = None\n while nodes:\n node = heapq.heappop(nodes)[2]\n if prev_node:\n prev_node.next = node\n prev_node = node\n return new_head\n\"\"\"","runtime":"365"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n\n if not head.next:\n return head\n\n i = 0\n node = head\n divider = head\n while node.next is not None:\n i += 1\n node = node.next\n\n if i % 2 == 0:\n divider = divider.next\n\n second_head = divider.next\n divider.next = None\n\n sorted_first_half = self.sortList(head)\n sorted_second_half = self.sortList(second_head)\n\n new_head = None\n if sorted_first_half.val < sorted_second_half.val:\n new_head = sorted_first_half\n sorted_first_half = sorted_first_half.next\n else:\n new_head = sorted_second_half\n sorted_second_half = sorted_second_half.next\n node = new_head\n\n while not (sorted_first_half is None and sorted_second_half is None):\n if sorted_first_half and (sorted_second_half is None or sorted_first_half.val < sorted_second_half.val):\n node.next = sorted_first_half\n sorted_first_half = sorted_first_half.next\n else:\n node.next = sorted_second_half\n sorted_second_half = sorted_second_half.next\n\n node = node.next\n\n return new_head\n","runtime":"365"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or head.next is None:\n return head\n\n mid = divide(head)\n print(mid.val)\n\n left = self.sortList(head)\n right = self.sortList(mid)\n\n return merge(left, right)\n\n\ndef merge(head1: Optional[ListNode], head2: Optional[ListNode]) -> Optional[ListNode]:\n new_head = ListNode(val=-1)\n tail = new_head\n\n while head1 and head2:\n if head1.val <= head2.val:\n tail.next = head1\n head1 = head1.next\n else:\n tail.next = head2\n head2 = head2.next\n tail = tail.next\n\n tail.next = head1 if head1 else head2\n\n return new_head.next\n\n\ndef divide(head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return\n\n prev_slow, slow, fast = head, head, head\n\n while fast and fast.next:\n fast = fast.next.next\n prev_slow = slow\n slow = slow.next\n\n prev_slow.next = None\n # print(head.val, slow.val)\n return slow\n\n \n ","runtime":"371"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # O(1) space solution\n if not head or not head.next:\n return head\n \n def size(head):\n curr = head\n length = 0\n while curr:\n length +=1\n curr = curr.next\n return length\n\n def split(node,size):\n # Split the list after 'size' nodes\n for _ in range(size-1):\n if not node:\n return None\n node = node.next\n if not node:\n return None\n second = node.next\n node.next = None\n return second\n\n def merge(left,right):\n dummy = ListNode(0)\n cur = dummy\n while left and right:\n if left.val < right.val:\n cur.next = left\n left = left.next\n else:\n cur.next = right\n right = right.next\n cur = cur.next\n \n #adding remaining node\n cur.next = left if left else right\n return dummy.next\n\n\n dummy = ListNode(0)\n dummy.next = head\n lenght = size(head)\n size = 1\n\n while size < lenght:\n curr = dummy.next\n tail = dummy\n while curr:\n left = curr\n right = split(left,size)\n curr = split(right,size)\n tail.next = merge(left,right)\n while tail.next:\n tail = tail.next\n size *= 2\n\n return dummy.next","runtime":"371"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n res = []\n curr = head\n while curr:\n res.append(curr.val)\n curr = curr.next\n \n def merge_sort(list1):\n n = len(list1)\n\n if n <= 1:\n return list1\n mid = n // 2\n left = merge_sort(list1[:mid])\n right = merge_sort(list1[mid:])\n return merge(left, right)\n def merge(left, right):\n arr = []\n i = j = 0\n while i < len(left) and j < len(right):\n if left[i] < right[j]:\n arr.append(left[i])\n i += 1\n else:\n arr.append(right[j])\n j += 1\n arr.extend(left[i:])\n arr.extend(right[j:])\n\n return arr\n\n sort = merge_sort(res)\n\n dummy = ListNode()\n cur = dummy\n\n for val in sort:\n cur.next = ListNode(val)\n cur = cur.next\n return dummy.next","runtime":"377"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def split_list(head):\n fast=head\n slow=head\n while fast.next and fast.next.next:\n fast=fast.next.next\n slow=slow.next\n tmp=slow.next\n slow.next=None\n return head, tmp\n \n def merge_sort(head):\n if not head or not head.next:\n return head\n list1, list2 = split_list(head)\n list1=merge_sort(list1)\n list2=merge_sort(list2)\n #print(list1, list2)\n dummy=ListNode(-2)\n tmp=dummy\n while list1!=None and list2!=None:\n if list1.val <= list2.val:\n tmp.next=list1\n list1 = list1.next\n else:\n tmp.next=list2\n list2 = list2.next\n tmp = tmp.next\n while list1:\n tmp.next=list1\n list1 = list1.next\n tmp = tmp.next\n while list2:\n tmp.next=list2\n list2 = list2.next\n tmp = tmp.next\n return dummy.next\n\n head=merge_sort(head)\n return head\n\n ","runtime":"377"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def getMidPt(self, head):\n fast = head\n slow = head\n while fast.next != None and fast.next.next !=None:\n slow = slow.next\n fast = fast.next.next\n return slow\n def mergeSort(self, left_list, right_list):\n header = None\n if left_list == None:\n return right_list\n if right_list == None:\n return left_list\n if left_list.val < right_list.val:\n left_list.next = self.mergeSort(left_list.next, right_list)\n header = left_list\n else:\n right_list.next = self.mergeSort(left_list, right_list.next)\n header = right_list\n return header\n\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head == None or head.next == None:\n return head\n \n \n midpt = self.getMidPt(head)\n left_list = head\n right_list = midpt.next\n midpt.next = None\n\n left_sorted = self.sortList(left_list)\n right_sorted = self.sortList(right_list)\n\n return self.mergeSort(left_sorted, right_sorted)\n\n\n \n","runtime":"383"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n # Base Conditions\n if head == None:\n return None\n\n list_len = 0\n count_elem = head\n\n while count_elem != None:\n list_len += 1\n count_elem = count_elem.next\n\n # Call recursive function with lenght term, this way we don't have to get the length each time\n return self.sortListRec(head, list_len)\n\n def sortListRec(self, head: Optional[ListNode], length: int) -> Optional[ListNode]:\n\n if length < 2:\n head.next = None\n return head\n \n # Swap elements if necessary\n if length == 2:\n if head.val > head.next.val:\n\n temp = head\n head = head.next\n head.next = temp\n \n head.next.next = None\n return head\n\n half_len = length // 2\n \n middle_elem = head\n\n for i in range(half_len):\n middle_elem = middle_elem.next\n\n sorted_left = self.sortListRec(head, half_len)\n sorted_right = self.sortListRec(middle_elem, length - half_len)\n\n first = ListNode(0, None)\n tmp = first\n\n while sorted_left != None or sorted_right != None:\n if sorted_left == None:\n # print(sorted_right.val)\n tmp.next = sorted_right\n sorted_right = sorted_right.next\n elif sorted_right == None:\n #print(sorted_left.val)\n tmp.next = sorted_left\n sorted_left = sorted_left.next\n\n elif sorted_left.val <= sorted_right.val:\n #print(sorted_left.val)\n tmp.next = sorted_left\n sorted_left = sorted_left.next\n else:\n #print(sorted_right.val)\n tmp.next = sorted_right\n sorted_right = sorted_right.next\n tmp = tmp.next\n\n tmp.next = None\n\n return first.next\n\n\n ","runtime":"383"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n curr = head\n nodes = []\n while curr:\n nodes.append(curr)\n curr = curr.next\n def merge(arr1, arr2):\n index1, index2 = 0, 0\n merged_array = []\n while index1 < len(arr1) and index2 < len(arr2):\n if arr1[index1].val < arr2[index2].val:\n merged_array.append(arr1[index1])\n index1 += 1\n else:\n merged_array.append(arr2[index2])\n index2 += 1\n if index1 == len(arr1):\n while index2 < len(arr2):\n merged_array.append(arr2[index2])\n index2 += 1\n elif index2 == len(arr2):\n while index1 < len(arr1):\n merged_array.append(arr1[index1])\n index1 += 1\n return merged_array\n\n def mergesort(arr):\n if len(arr) == 1:\n return arr\n left = mergesort(arr[:len(arr) // 2])\n right = mergesort(arr[len(arr) // 2:])\n return merge(left, right)\n \n nodes = mergesort(nodes)\n head = nodes[0]\n for i in range(len(nodes) - 1):\n nodes[i].next = nodes[i + 1]\n nodes[-1].next = None\n return head","runtime":"389"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def findmiddle(self, head):\n if head is None or head.next is None:\n return head\n slow = head\n fast = head.next\n while fast!=None and fast.next!=None:\n slow = slow.next\n fast = fast.next.next\n return slow\n\n def merge(self, head1, head2):\n t1= head1\n t2 = head2\n dnode = ListNode(-1)\n temp = dnode\n while t1!=None and t2!=None:\n if t1.val > t2.val:\n temp.next = t2\n t2= t2.next\n else:\n temp.next = t1\n t1= t1.next\n temp = temp.next\n if t1!=None:\n temp.next = t1\n if t2!=None: \n temp.next = t2\n\n return dnode.next\n\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head == None or head.next == None:\n return head\n left = head\n middle = self.findmiddle(head)\n right = middle.next\n middle.next = None\n left = self.sortList(left)\n right = self.sortList(right)\n return self.merge(left, right)\n","runtime":"389"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def mid(head):\n slow=head\n fast=head.next\n while (fast!=None) and (fast.next!=None):\n slow=slow.next\n fast=fast.next.next\n return slow\n def merge(first, second):\n t1=first\n t2=second\n dnode=ListNode(-1)\n temp=dnode\n while (t1 is not None) and (t2 is not None):\n if t1.val<t2.val:\n temp.next=t1\n temp=t1\n t1=t1.next\n else:\n temp.next=t2\n temp=t2\n t2=t2.next\n if t1 is not None:\n temp.next=t1\n if t2 is not None:\n temp.next=t2\n return dnode.next\n\n if head==None or head.next==None:\n return head\n middle=mid(head)\n left=head\n right=middle.next\n middle.next=None\n left=self.sortList(left)\n right=self.sortList(right)\n return merge(left,right)","runtime":"395"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n curr = head\n nodes = []\n while curr:\n nodes.append(curr)\n curr = curr.next\n def merge(arr1, arr2):\n index1, index2 = 0, 0\n merged_array = []\n while index1 < len(arr1) and index2 < len(arr2):\n if arr1[index1].val < arr2[index2].val:\n merged_array.append(arr1[index1])\n index1 += 1\n else:\n merged_array.append(arr2[index2])\n index2 += 1\n if index1 == len(arr1):\n while index2 < len(arr2):\n merged_array.append(arr2[index2])\n index2 += 1\n elif index2 == len(arr2):\n while index1 < len(arr1):\n merged_array.append(arr1[index1])\n index1 += 1\n return merged_array\n\n def mergesort(arr):\n if len(arr) == 1:\n return arr\n left = mergesort(arr[:len(arr) // 2])\n right = mergesort(arr[len(arr) // 2:])\n return merge(left, right)\n \n nodes = mergesort(nodes)\n head = nodes[0]\n for i in range(len(nodes) - 1):\n nodes[i].next = nodes[i + 1]\n nodes[-1].next = None\n return head","runtime":"395"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n def findMiddle(head):\n slow = head\n fast = head.next\n while fast != None and fast.next != None:\n slow = slow.next\n fast = fast.next.next\n return slow\n\n def merge2(lefthead,righthead):\n temp1 = lefthead\n temp2 = righthead\n dummy = ListNode(-1)\n temp = dummy\n while temp1 != None and temp2 != None:\n\n if temp1.val <= temp2.val:\n temp.next = temp1\n temp1 = temp1.next\n temp = temp.next\n else:\n temp.next = temp2\n temp2 = temp2.next\n temp = temp.next\n\n if temp1 == None:\n temp.next = temp2\n if temp2 == None:\n temp.next = temp1\n \n return dummy.next\n\n def mergeSort(head):\n if head == None or head.next == None:\n return head\n middle = findMiddle(head)\n lefthead = head\n righthead = middle.next\n middle.next = None\n lefthead = mergeSort(lefthead)\n righthead = mergeSort(righthead)\n return (merge2(lefthead,righthead))\n \n\n return (mergeSort(head))\n","runtime":"401"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n dummy = ListNode(0, head)\n n = self.count(head)\n intv = 1\n\n while intv < n:\n cur_start = dummy.next\n tail = dummy\n while cur_start:\n l2 = self.split(cur_start, intv)\n rest = self.split(l2, intv)\n tail.next = self.merge(cur_start, l2)\n cur_start = rest\n\n while tail.next:\n tail = tail.next\n \n intv *= 2\n \n return dummy.next\n \n def count(self, head):\n cur = head\n n = 0\n while cur:\n n += 1\n cur = cur.next\n \n return n\n \n def split(self, head, k):\n pre = None\n cur = head\n\n for _ in range(k):\n if not cur:\n break\n pre = cur\n cur = cur.next\n \n if pre:\n pre.next = None\n return cur\n \n def merge(self, l1, l2):\n if not l1 and not l2:\n return None\n \n if not l1 or not l2:\n return l1 if l1 else l2\n \n dummy = ListNode()\n cur = dummy\n while l1 and l2:\n if l1.val < l2.val:\n cur.next = l1\n l1 = l1.next\n else:\n cur.next = l2\n l2 = l2.next\n \n cur = cur.next\n \n cur.next = l1 if l1 else l2\n return dummy.next\n ","runtime":"401"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def merge(head1, head2):\n resultHead = ListNode(0)\n cur = resultHead\n while head1 != None or head2 != None:\n if head1 == None:\n cur.next = head2\n head2 = None\n elif head2 == None:\n cur.next = head1\n head1 = None\n else:\n if head1.val < head2.val:\n cur.next = head1\n cur = head1\n head1 = head1.next \n else:\n cur.next = head2\n cur = head2\n head2 = head2.next\n \n return resultHead.next\n\n\n def findOneBeforeMiddle(head):\n fast = head\n slow = head\n prev = None\n while fast and fast.next:\n prev = slow\n\n fast = fast.next.next\n slow = slow.next\n \n return prev\n \n if not head or not head.next:\n return head\n\n prev = findOneBeforeMiddle(head)\n if prev != None:\n middle = prev.next\n prev.next = None\n\n return merge(self.sortList(head), self.sortList(middle))\n \n\n ","runtime":"407"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n # convert linked list to list\n res = []\n current = head\n\n while current is not None:\n res.append(current.val)\n current = current.next\n\n # using merge sort \n def mergesort(res):\n\n if len(res) <= 1:\n return res\n \n middle = len(res) // 2\n left_half = res[:middle]\n right_half = res[middle:]\n\n left_half = mergesort(left_half)\n right_half = mergesort(right_half)\n\n left = 0\n right = 0\n check_pointer = 0\n\n while left < len(left_half) and right < len(right_half):\n\n if left_half[left] < right_half[right]:\n res[check_pointer] = left_half[left]\n left += 1\n check_pointer += 1\n else:\n res[check_pointer] = right_half[right]\n right += 1\n check_pointer += 1\n \n while left < len(left_half):\n res[check_pointer] = left_half[left]\n left += 1\n check_pointer += 1\n \n while right < len(right_half):\n res[check_pointer] = right_half[right]\n right += 1\n check_pointer += 1\n \n return res\n \n # convert list to linked list \n dummy = ListNode()\n current = dummy\n\n for i in mergesort(res): # direct use the function\n current.next = ListNode(i)\n current = current.next\n \n return dummy.next\n\n \n \n\n\n\n ","runtime":"407"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n # def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def append(self, new_value):\n\n # Allocate new node\n new_node = Node(new_value)\n\n # if head is None, initialize it to new node\n if self.head is None:\n self.head = new_node\n return\n curr_node = self.head\n while curr_node.next is not None:\n curr_node = curr_node.next\n\n # Append the new node at the end\n # of the linked list\n curr_node.next = new_node\n\n def sortedMerge(self, a, b):\n result = None\n\n # Base cases\n if a == None:\n return b\n if b == None:\n return a\n\n # pick either a or b and recur..\n if a.val <= b.val:\n result = a\n result.next = self.sortedMerge(a.next, b)\n else:\n result = b\n result.next = self.sortedMerge(a, b.next)\n return result\n\n def sortList(self, h: Optional[ListNode]) -> Optional[ListNode]:\n\n # Base case if head is None\n if h == None or h.next == None:\n return h\n\n # get the middle of the list\n middle = self.getMiddle(h)\n nexttomiddle = middle.next\n\n # set the next of middle node to None\n middle.next = None\n\n # Apply mergeSort on left list\n left = self.sortList(h)\n\n # Apply mergeSort on right list\n right = self.sortList(nexttomiddle)\n\n # Merge the left and right lists\n sortedlist = self.sortedMerge(left, right)\n return sortedlist\n\n # Utility function to get the middle\n # of the linked list\n def getMiddle(self, head):\n if (head == None):\n return head\n\n slow = head\n fast = head\n\n while (fast.next != None and\n fast.next.next != None):\n slow = slow.next\n fast = fast.next.next\n\n return slow","runtime":"413"},{"code":"# # Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \"\"\"\n Merge sort is an obvious solution. There is no need to copy the lists though. Can just maintain pointers\n \"\"\"\n\n def sort_list_helper(head: Optional[ListNode], length_to_sort: int) -> Optional[ListNode]:\n if length_to_sort <= 1:\n return head\n \n middle = (length_to_sort // 2)\n left, right = head, head\n\n right_idx = 0\n while right_idx < middle:\n right = right.next\n right_idx += 1\n\n left_ptr = left\n while left_ptr.next != right:\n left_ptr = left_ptr.next\n left_ptr.next = None\n\n sorted_left = sort_list_helper(left, middle)\n sorted_right = sort_list_helper(right, length_to_sort - middle)\n left_idx, right_idx = 0, 0\n\n if sorted_left.val <= sorted_right.val:\n curr = sorted_left\n sorted_left = sorted_left.next\n else:\n curr = sorted_right\n sorted_right = sorted_right.next\n head = curr\n\n while sorted_left != None or sorted_right != None:\n if sorted_right == None or (sorted_left and sorted_left.val <= sorted_right.val):\n curr.next = sorted_left\n curr = curr.next\n sorted_left = sorted_left.next\n else:\n curr.next = sorted_right\n curr = curr.next\n sorted_right = sorted_right.next\n\n return head\n\n length = self.list_length(head) \n return sort_list_helper(head, length)\n \n def list_length(self, head: ListNode):\n ptr = head\n length = 0\n while ptr:\n length += 1\n ptr = ptr.next\n return length\n \n ","runtime":"413"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n list=[]\n while head:\n list.append(head.val)\n head=head.next\n if len(list)==0:\n return\n def sort(list):\n if len(list)>1:\n mid=len(list)//2\n left_array=list[:mid]\n right_array=list[mid:]\n \n sort(left_array)\n sort(right_array)\n i=j=k=0\n while i<len(left_array) and j<len(right_array):\n if left_array[i]<right_array[j]:\n list[k]=left_array[i]\n i=i+1\n else:\n list[k]=right_array[j]\n j=j+1\n k=k+1\n while i<len(left_array):\n list[k]=left_array[i]\n i=i+1\n k=k+1\n while j<len(right_array):\n list[k]=right_array[j]\n j=j+1\n k=k+1\n\n sort(list)\n head=ListNode(list[0])\n head1=head\n for i in range(1,len(list)):\n head.next=ListNode(list[i])\n head=head.next\n return head1\n \n","runtime":"419"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n return self.mergesort(head)\n\n def get_length(self, head):\n length = 0\n while head:\n length += 1\n head = head.next\n return length \n\n def mergesort(self, head):\n length = self.get_length(head)\n if length <= 1:\n return head\n\n prev = None \n right_head = head\n for _ in range(length // 2):\n prev = right_head\n right_head = right_head.next\n if prev:\n prev.next = None\n\n left_head = head\n left_head = self.mergesort(left_head)\n right_head = self.mergesort(right_head)\n return self.merge(left_head, right_head)\n \n\n def merge(self, left_half, right_half):\n dummy = ListNode()\n prev = dummy\n while left_half or right_half:\n if not right_half or (left_half and left_half.val < right_half.val):\n prev.next = left_half\n prev = left_half\n left_half = left_half.next\n else:\n prev.next = right_half\n prev = right_half\n right_half = right_half.next\n return dummy.next","runtime":"419"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n mergeSize = 1\n\n length, current = 0, head\n while current != None:\n length += 1\n current = current.next\n\n def merge(current):\n nonlocal mergeSize\n left, right = current.next, current.next\n for _ in range(mergeSize):\n if not right: break\n right = right.next\n\n rightStart, rightCount = right, 0\n\n while (left != rightStart) or (rightCount < mergeSize and right != None):\n if (rightCount >= mergeSize or right == None) or (left != rightStart and left.val <= right.val):\n current.next = left\n left, current = left.next, current.next\n else:\n current.next = right\n right, current, rightCount = right.next, current.next, rightCount + 1\n\n current.next = right\n return current\n\n dummyHead = ListNode(0)\n dummyHead.next = head\n\n while mergeSize < length:\n current = dummyHead\n while current.next:\n current = merge(current)\n mergeSize *= 2\n\n return dummyHead.next","runtime":"425"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n length = 0\n cur = head\n while cur:\n length += 1\n cur = cur.next\n \n if length <= 1:\n return head\n middle_node = self.get_middle_node(head) \n print(f\"middle node: {middle_node.val}\")\n cur = middle_node.next\n middle_node.next = None\n middle_node = cur\n\n left = self.sortList(head)\n right = self.sortList(middle_node)\n\n return self.merge(left, right)\n\n\n def merge(self, left, right):\n if not left:\n return right\n if not right:\n return left\n if left.val < right.val:\n left.next = self.merge(left.next, right)\n return left\n else:\n right.next = self.merge(left, right.next)\n return right\n\n def get_middle_node(self, head):\n slow = fast = head\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n\n","runtime":"425"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head == None or head.next == None:\n return head\n\n def half(h1):\n s = h1\n f = h1.next\n while f != None and f.next != None:\n s = s.next\n f = f.next.next\n lpart = h1\n rpart = s.next\n s.next = None\n return lpart , rpart\n\n def merge(left , right):\n ret = None\n res = None\n p = left\n q = right\n while p != None and q != None:\n if p.val <= q.val:\n if res == None:\n ret = p\n res = p\n else:\n res.next = p\n res = res.next\n p = p.next\n else:\n if res == None:\n ret = q\n res = q\n else:\n res.next = q\n res = res.next\n q = q.next\n\n while p != None:\n res.next = p\n p = p.next\n res = res.next\n \n while q != None:\n res.next = q\n q = q.next\n res = res.next\n\n return ret\n\n def mergesort(root):\n if root == None or root.next == None:\n return root\n l , r = half(root)\n leftHead = mergesort(l)\n rightHead= mergesort(r)\n return merge(leftHead , rightHead)\n \n return mergesort(head)\n","runtime":"431"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n n = 0\n curr = head\n while curr != None:\n curr = curr.next\n n += 1\n step = 1\n updateHead = True\n while step < n:\n l1 = head\n r1 = self.findEnd(l1, step)\n l2 = r1.next\n r2 = self.findEnd(l2, step)\n nextL1 = r2.next\n r1.next = None\n r2.next = None\n (start, end) = self.merge(l1,r1,l2,r2)\n head = start\n lastEnd = end\n while nextL1 != None:\n l1 = nextL1\n r1 = self.findEnd(l1, step)\n l2 = r1.next\n if l2 == None:\n lastEnd.next = l1\n break\n r2 = self.findEnd(l2, step)\n nextL1 = r2.next\n r1.next = None\n r2.next = None\n (start, end) = self.merge(l1,r1,l2,r2)\n lastEnd.next = start\n lastEnd = end\n step *= 2\n return head\n\n return head\n \n def findEnd(self, start, k):\n end = start\n while end.next != None:\n k -= 1\n if k != 0:\n end = end.next\n else:\n break\n return end\n \n def merge(self, l1, r1, l2, r2):\n if l1.val > l2.val:\n head = l2\n l2 = l2.next\n else:\n head = l1\n l1 = l1.next\n curr = head\n while l1 != None and l2 != None:\n if l1.val > l2.val:\n curr.next = l2\n l2 = l2.next\n else:\n curr.next = l1\n l1 = l1.next\n curr = curr.next\n if l1 == None and l2 != None:\n curr.next = l2\n return (head, r2)\n else:\n curr.next = l1\n return (head, r1)\n \n ","runtime":"431"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n return self.helpSort(head)[0]\n\n def getRandomPivot(self, head):\n length = 1\n cur = head\n while cur.next:\n cur = cur.next\n length += 1\n randind = random.randrange(length)\n cur = head\n for _ in range(randind):\n cur = cur.next\n return cur.val\n\n def helpSort(self, head): #head, tail\n if not head or not head.next:\n return head, head\n \n ahead = ListNode()\n atail = ahead\n bhead = ListNode()\n btail = bhead\n chead = ListNode()\n ctail = chead\n\n pivot = self.getRandomPivot(head)\n\n cur = head\n while cur:\n if cur.val < pivot:\n atail.next = cur\n atail = atail.next\n elif cur.val == pivot:\n btail.next = cur\n btail = btail.next\n else:\n ctail.next = cur\n ctail = ctail.next\n cur = cur.next\n atail.next = None\n btail.next = None\n ctail.next = None\n ahead = ahead.next\n bhead = bhead.next\n chead = chead.next\n\n x, xtail = self.helpSort(ahead)\n y, ytail = self.helpSort(chead)\n\n if x and bhead:\n xtail.next = bhead\n if bhead and y:\n btail.next = y\n rethead = None\n rettail = None\n for parthead, parttail in [(y, ytail), (bhead, btail), (x, xtail)]:\n if parthead:\n rethead = parthead\n if not rettail:\n rettail = parttail\n return rethead, rettail","runtime":"437"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # merge sort\n # devide and conqur\n # find mid \n # 4 2 | 1 3\n # 4 | 2, 1 | 3\n # 2 4 1 3 \n # 1 2 3 4\n # nlogn time and space n/2+n/4....+1=n\n \n\n if head==None or head.next==None:\n return head\n\n #at lead two elements\n left,right=self.findmid(head)\n \n #merge sort: returh the new head\n left=self.sortList(left)\n right=self.sortList(right)\n\n new_head=self.merge(left,right)\n return new_head\n\n def findmid(self,head):\n # 1 2 3 \n # s\n # f\n # f.next!=None f.next.next!=None\n # return head, s.next\n\n s=head\n f=head\n\n while f.next!=None and f.next.next!=None:\n s=s.next\n f=f.next.next\n\n right=s.next\n s.next=None\n \n left=head\n return left,right\n\n \n def merge(self,list1,list2):\n #base case: list1==None and list2==None \n if list1==None:\n return list2\n if list2==None:\n return list1\n\n dummy=ListNode(float(\"inf\"))\n cur=dummy\n point1=list1\n point2=list2\n\n while point1!=None and point2!=None:\n if point1.val<=point2.val:\n cur.next=point1\n point1=point1.next\n cur=cur.next\n else:\n cur.next=point2\n point2=point2.next\n cur=cur.next\n\n if point1!=None:\n cur.next=point1\n if point2!=None:\n cur.next=point2\n\n return dummy.next\n \n \n ","runtime":"437"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom typing import Tuple\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return None\n if head.next is None:\n return head\n \n dummy1 = ListNode()\n l1 = dummy1\n dummy2 = ListNode()\n l2 = dummy2\n\n p = head\n first = 1\n while p:\n q = p.next\n if first:\n l1.next = p\n l1 = p\n else:\n l2.next = p\n l2 = p\n p = q\n first = 1 - first\n\n # def prin(h):\n # p = []\n # while h:\n # p.append(h.val)\n # h = h.next\n # print(p)\n\n # prin(dummy1.next)\n # prin(dummy2.next)\n\n l1.next = l2.next = None\n\n dummy1 = self.sortList(dummy1.next)\n dummy2 = self.sortList(dummy2.next)\n\n # prin(dummy1)\n # prin(dummy2)\n\n dummy = ListNode()\n last = dummy\n\n p1 = dummy1\n p2 = dummy2\n\n while p1 and p2:\n if p1.val < p2.val:\n last.next = p1\n last = p1\n p1 = p1.next\n else:\n last.next = p2\n last = p2\n p2 = p2.next\n \n if p1:\n last.next = p1\n if p2:\n last.next = p2\n \n return dummy.next\n\n \n\n def sortList1(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n def sort(head: Optional[ListNode]) -> Tuple[Optional[ListNode], Optional[ListNode]]:\n if head is None:\n return (None, None)\n dummy_le = ListNode()\n dummy_gt = ListNode()\n le = dummy_le\n gt = dummy_gt\n\n first = head\n p = head.next\n\n while p:\n if p.val <= first.val:\n le.next = p\n le = p\n else:\n gt.next =p\n gt = p\n p = p.next\n \n le.next = None\n gt.next = None\n first.next = None\n\n (le_head, le_tail) = sort(dummy_le.next)\n (gt_head, gt_tail) = sort(dummy_gt.next)\n\n if le_head is not None:\n le_tail.next = first\n first.next = gt_head\n if gt_tail is not None:\n return (le_head, gt_tail)\n else:\n return (le_head, first)\n else:\n first.next = gt_head\n if gt_tail is not None:\n return (first, gt_tail)\n else:\n return (first, first)\n \n return sort(head)[0]\n ","runtime":"443"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n return self.helpSort(head)[0]\n\n def getRandomPivot(self, head):\n length = 1\n cur = head\n while cur.next:\n cur = cur.next\n length += 1\n randind = random.randrange(length)\n cur = head\n for _ in range(randind):\n cur = cur.next\n return cur.val\n\n def helpSort(self, head): #head, tail\n if not head or not head.next:\n return head, head\n \n ahead = ListNode()\n atail = ahead\n bhead = ListNode()\n btail = bhead\n chead = ListNode()\n ctail = chead\n\n pivot = self.getRandomPivot(head)\n\n cur = head\n while cur:\n if cur.val < pivot:\n atail.next = cur\n atail = atail.next\n elif cur.val == pivot:\n btail.next = cur\n btail = btail.next\n else:\n ctail.next = cur\n ctail = ctail.next\n cur = cur.next\n atail.next = None\n btail.next = None\n ctail.next = None\n ahead = ahead.next\n bhead = bhead.next\n chead = chead.next\n\n x, xtail = self.helpSort(ahead)\n y, ytail = self.helpSort(chead)\n\n if x and bhead:\n xtail.next = bhead\n if bhead and y:\n btail.next = y\n rethead = None\n rettail = None\n for parthead, parttail in [(x, xtail), (bhead, btail), (y, ytail)]:\n if parthead:\n rettail = parttail\n if not rethead:\n rethead = parthead\n return rethead, rettail","runtime":"443"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n return self.helpSort(head)[0]\n\n def getRandomPivot(self, head):\n length = 1\n cur = head\n while cur.next:\n cur = cur.next\n length += 1\n randind = random.randrange(length)\n cur = head\n for _ in range(randind):\n cur = cur.next\n return cur.val\n\n def helpSort(self, head): #head, tail\n if not head or not head.next:\n return head, head\n \n ahead = ListNode()\n atail = ahead\n bhead = ListNode()\n btail = bhead\n chead = ListNode()\n ctail = chead\n\n pivot = self.getRandomPivot(head)\n\n cur = head\n while cur:\n if cur.val < pivot:\n atail.next = cur\n atail = atail.next\n elif cur.val == pivot:\n btail.next = cur\n btail = btail.next\n else:\n ctail.next = cur\n ctail = ctail.next\n cur = cur.next\n atail.next = None\n btail.next = None\n ctail.next = None\n ahead = ahead.next\n bhead = bhead.next\n chead = chead.next\n\n x, xtail = self.helpSort(ahead)\n y, ytail = self.helpSort(chead)\n\n if x and bhead:\n xtail.next = bhead\n if bhead and y:\n btail.next = y\n rethead = None\n rettail = None\n for parthead, parttail in [(y, ytail), (bhead, btail), (x, xtail)]:\n if parthead:\n rethead = parthead\n if not rettail:\n rettail = parttail\n return rethead, rettail","runtime":"460"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is not None:\n print(head.val)\n total_num = 0\n left_head = head\n if head is None:\n return None\n while head is not None:\n total_num += 1\n head = head.next\n \n if total_num >= 2:\n half_num = total_num // 2\n \n right_head = left_head\n for i in range(half_num-1):\n right_head = right_head.next\n \n current_head = right_head\n right_head = current_head.next\n current_head.next = None\n else:\n return left_head\n \n \n if right_head is not None:\n print('right',right_head.val)\n\n left_sorted = self.sortList(left_head)\n right_sorted = self.sortList(right_head)\n\n head = None\n \n while left_sorted is not None and right_sorted is not None:\n if left_sorted.val <= right_sorted.val:\n if head is None:\n head = left_sorted\n result = head\n else:\n head.next = left_sorted\n head = left_sorted\n left_sorted = left_sorted.next\n else:\n if head is None:\n head = right_sorted\n result = head\n else:\n head.next = right_sorted\n head = right_sorted\n right_sorted = right_sorted.next\n \n if left_sorted is not None:\n if head is None:\n head = left_sorted\n result = head\n else:\n head.next = left_sorted \n else:\n if head is None:\n head = right_sorted\n result = head\n else:\n head.next = right_sorted\n\n\n \n \n return result\n\n\n \n ","runtime":"460"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, node: Optional[ListNode]) -> Optional[ListNode]:\n if not node or not node.next:\n return node\n if not node.next.next:\n if node.val>node.next.val:\n temp = node.next\n node.next,temp.next,node = None,node,node.next\n return node\n slow = node\n fast = node.next\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n right = self.sortList(slow.next)\n slow.next = None\n left = self.sortList(node)\n dummy = ListNode()\n temp = dummy\n while left and right:\n if left.val<right.val:\n temp.next = ListNode(left.val)\n left = left.next\n else:\n temp.next = ListNode(right.val)\n right = right.next\n temp = temp.next\n if left:\n temp.next=left\n elif right:\n temp.next = right\n return dummy.next ","runtime":"466"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def findMid(self, node):\n f = s = node\n while (f.next and f.next.next):\n f = f.next.next\n s = s.next\n return s\n\n def mergeSort(self, node):\n if(node is None or node.next is None): return node\n \n mid = self.findMid(node) #Find the mid\n nextNode = mid.next #Get the start of second half \n mid.next = None #Break at mid\n \n firstHalf = self.mergeSort(node)\n secondHalf = self.mergeSort(nextNode)\n \n return self.merge(firstHalf, secondHalf)\n\n def merge(self,n1,n2):\n tmp = cur = ListNode()\n while n1 or n2:\n v1 = n1.val if n1 else float('inf')\n v2 = n2.val if n2 else float('inf')\n if v1<v2:\n cur.next = n1\n n1 = n1.next\n else:\n cur.next = n2\n n2 = n2.next\n cur = cur.next\n \n return tmp.next\n\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n return self.mergeSort(head)\n\n \n ","runtime":"466"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def merge(left, right):\n cur = ListNode()\n start = cur\n while left or right:\n left_val = left.val if left else float('inf')\n right_val = right.val if right else float('inf')\n if left_val > right_val:\n cur.next = right\n right = right.next\n else:\n cur.next = left\n left = left.next\n cur = cur.next\n cur.next = None\n return start.next\n\n\n def inner(node, list_len):\n if list_len == 1:\n node.next = None\n return node\n \n cur = node\n for i in range(list_len // 2):\n cur = cur.next\n\n left = inner(node, list_len // 2)\n right = inner(cur, list_len - list_len // 2)\n return merge(left, right)\n\n if not head:\n return head\n n = 0\n cur = head\n while cur:\n n += 1\n cur = cur.next\n # divide and conqure\n return inner(head, n)","runtime":"472"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n mid = self.findMidandDisconnect(head)\n return self.mergeSortedList(self.sortList(head), self.sortList(mid))\n\n\n def findMidandDisconnect(self, head):\n if not head or not head.next:\n return head\n\n count, p = 0, head\n while p:\n count += 1\n p = p.next\n p = head\n\n for i in range(count//2):\n if i == (count//2)-1:\n temp = p.next\n p.next = None\n p = temp\n else:\n p = p.next\n \n return p\n\n def mergeSortedList(self, p1, p2):\n sentinel = ListNode()\n head, a, b = sentinel, p1, p2\n\n while a or b:\n if not a or (b and b.val < a.val):\n head.next = b\n head, b = head.next, b.next\n elif not b or (a and a.val <= b.val):\n head.next = a\n head, a = head.next, a.next\n return sentinel.next\n","runtime":"472"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return head\n slow=head\n fast=head\n while fast.next and fast.next.next:\n slow=slow.next\n fast=fast.next.next\n mid=slow.next\n slow.next=None\n left=self.sortList(head)\n right=self.sortList(mid)\n merged=ListNode()\n temp=merged\n while left and right:\n if left.val<right.val:\n temp.next=ListNode(left.val)\n left=left.next\n else:\n temp.next=ListNode(right.val)\n right=right.next\n temp=temp.next\n if left: temp.next=left\n if right: temp.next=right\n return merged.next","runtime":"478"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n def merge_sort_list(head):\n if not head or not head.next:\n return head\n\n left = left_tail = ListNode()\n right = right_tail = ListNode()\n\n use_right = False\n curr = head\n while curr:\n temp = curr\n curr = curr.next\n\n if use_right:\n right_tail.next = temp\n right_tail = right_tail.next\n else:\n left_tail.next = temp\n left_tail = left_tail.next\n \n use_right = not use_right\n right_tail.next = None\n left_tail.next = None\n \n # need base case\n left = merge_sort_list(left.next)\n right = merge_sort_list(right.next)\n\n res = res_tail = ListNode()\n \n cleft = left\n cright = right\n while cleft or cright:\n if not cleft:\n res_tail.next = cright\n res_tail = res_tail.next\n cright = cright.next\n elif not cright:\n res_tail.next = cleft\n res_tail = res_tail.next\n cleft = cleft.next\n elif cright.val < cleft.val:\n res_tail.next = cright\n res_tail = res_tail.next\n cright = cright.next\n else:\n res_tail.next = cleft\n res_tail = res_tail.next\n cleft = cleft.next\n res_tail.next = None\n return res.next\n\n return merge_sort_list(head)\n ","runtime":"478"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return head\n def merge(head, slow):\n l = head\n r = slow\n temp = []\n while l and r and l != slow:\n if l.val < r.val:\n temp.append(l.val)\n l = l.next\n else:\n temp.append(r.val)\n r = r.next\n while l and l != slow:\n temp.append(l.val)\n l = l.next\n while r:\n temp.append(r.val)\n r = r.next\n cur = head\n i = 0\n while cur:\n cur.val = temp[i]\n i += 1\n cur = cur.next\n\n def sort(head):\n if head.next:\n slow = head\n fast = head\n before = ListNode(next = slow)\n while fast and fast.next:\n before = slow\n slow = slow.next\n fast = fast.next.next\n before.next = None\n sort(head)\n sort(slow)\n before.next = slow\n merge(head, slow)\n \n sort(head)\n return head","runtime":"484"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return head\n current = head\n even = None\n odd = None\n even_head = None\n odd_head = None\n parity = 0\n while current is not None:\n if parity == 0:\n if even is None:\n even = current\n even_head = even\n else:\n even.next = current\n even = even.next\n else:\n if odd is None:\n odd = current\n odd_head = odd\n else:\n odd.next = current\n odd = odd.next\n current = current.next\n parity = 1 - parity\n if even is not None:\n even.next = None\n if odd is not None:\n odd.next = None\n even_head = self.sortList(even_head)\n odd_head = self.sortList(odd_head)\n return self.mergeTwoLists(even_head, odd_head)\n\n def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:\n if list1 is None:\n return list2\n if list2 is None:\n return list1\n if list1.val <= list2.val:\n head = list1\n list1 = list1.next\n on_1 = True\n else:\n head = list2\n list2 = list2.next\n on_1 = False\n current = head\n while list1 is not None and list2 is not None:\n if list1.val <= list2.val and on_1:\n current = list1\n list1 = list1.next\n elif list1.val > list2.val and on_1:\n current.next = list2\n list2 = list2.next\n current = current.next\n on_1 = False\n elif list1.val <= list2.val and not on_1:\n current.next = list1\n list1 = list1.next\n current = current.next\n on_1 = True\n else:\n current = list2\n list2 = list2.next\n if list1 is not None:\n current.next = list1\n if list2 is not None:\n current.next = list2\n return head","runtime":"484"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution: \n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # merge sort with fast and slow ptr\n \n def get_mid_node(self, head):\n # base case is guaranteed\n slow_ptr = head\n fast_ptr = slow_ptr.next\n while fast_ptr != None and fast_ptr.next != None:\n slow_ptr = slow_ptr.next\n fast_ptr = fast_ptr.next\n if fast_ptr == None:\n return slow_ptr, fast_ptr\n fast_ptr = fast_ptr.next\n return slow_ptr\n \n def merge(left, right):\n merged_list_pre = ListNode()\n merged_list_ptr = merged_list_pre\n left_ptr = left\n right_ptr = right\n # the two list are already sorted\n while (left_ptr != None) or (right_ptr != None):\n if right_ptr == None:\n merged_list_ptr.next = left_ptr\n left_ptr = left_ptr.next\n elif left_ptr == None:\n merged_list_ptr.next = right_ptr\n right_ptr = right_ptr.next\n elif left_ptr.val < right_ptr.val:\n merged_list_ptr.next = left_ptr\n left_ptr = left_ptr.next\n else:\n merged_list_ptr.next = right_ptr\n right_ptr = right_ptr.next\n merged_list_ptr = merged_list_ptr.next\n merged_list_ptr.next = None\n return merged_list_pre.next\n \n def merge_sort(head):\n #print_list(head)\n # base case\n if head == None or head.next == None:\n return head\n mid = get_mid_node(self, head)\n # break the list\n right_head = mid.next\n mid.next = None\n # recursive step \n left = merge_sort(head)\n right = merge_sort(right_head)\n # merge\n return merge(left, right)\n\n # def print_list(head):\n # if head == None:\n # print(\"None\")\n # while head != None:\n # print(head.val, end =\" \") \n # head = head.next\n # print()\n \n return merge_sort(head)\n \n \n \n ","runtime":"490"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def getMid(head):\n slow = head\n fast = head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1, l2):\n head = tail = ListNode()\n while l1 or l2:\n val1 = l1.val if l1 else float(\"inf\")\n val2 = l2.val if l2 else float(\"inf\")\n if val1 > val2:\n tail.next = l2\n l2 = l2.next\n else:\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n return head.next\n if not head or not head.next:\n return head\n left = head\n right = getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left, right)\n\n","runtime":"490"},{"code":"from queue import PriorityQueue\n\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n root = None\n heap = PriorityQueue()\n while head != None:\n heap.put(head.val)\n head = head.next\n\n while heap.empty() == False:\n v = heap.get()\n if root == None:\n root = ListNode(v)\n cur = root\n else:\n cur.next = ListNode(v)\n cur = cur.next\n\n return root\n","runtime":"496"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def mergeSort(node, length):\n # base case\n if length == 0: return None\n if length == 1: return node\n\n # 1. break a list to two parts\n length1 = length // 2\n length2 = length - length1\n curr = node\n for _ in range(length // 2 - 1):\n curr = curr.next\n node1 = node\n node2 = curr.next\n curr.next = None # break connection between node1 and node2\n\n # 2. sort each parts\n node1 = mergeSort(node1, length1)\n node2 = mergeSort(node2, length2)\n\n # 3. merge results\n dummy = node = ListNode()\n while node1 and node2:\n if node1.val < node2.val:\n node.next = ListNode(node1.val)\n node1 = node1.next\n else:\n node.next = ListNode(node2.val)\n node2 = node2.next\n node = node.next\n\n node.next = node1 if node1 else node2 # add remaining list \n\n return dummy.next\n \n curr = head\n length = 0\n while curr:\n length += 1\n curr = curr.next\n \n return mergeSort(head, length)","runtime":"496"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n return self.mergeSort(head)\n \n def mergeSort(self, head):\n if not head or not head.next:\n return head\n \n slow, fast = head, head.next\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n left_head, right_head = head, slow.next\n slow.next = None\n return self.merge(self.mergeSort(left_head), self.mergeSort(right_head))\n\n def merge(self, left, right):\n dummy = ListNode()\n cur = dummy\n while left and right:\n if left.val < right.val:\n cur.next = ListNode(left.val)\n left = left.next\n else:\n cur.next = ListNode(right.val)\n right = right.next\n cur = cur.next\n if left:\n cur.next = left\n elif right:\n cur.next = right\n return dummy.next\n","runtime":"502"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def mergeSort(node, length):\n # base case\n if length == 0: return None\n if length == 1: return node\n\n # 1. break a list to two parts\n length1 = length // 2\n length2 = length - length1\n curr = node\n for _ in range(length // 2 - 1):\n curr = curr.next\n node1 = node\n node2 = curr.next\n curr.next = None\n\n # 2. sort each parts\n node1 = mergeSort(node1, length1)\n node2 = mergeSort(node2, length2)\n\n # 3. merge results\n dummy = node = ListNode()\n while node1 and node2:\n if node1.val < node2.val:\n node.next = ListNode(node1.val)\n node1 = node1.next\n else:\n node.next = ListNode(node2.val)\n node2 = node2.next\n node = node.next\n\n node.next = node1 if node1 else node2 \n\n return dummy.next\n \n curr = head\n length = 0\n while curr:\n length += 1\n curr = curr.next\n \n return mergeSort(head, length)","runtime":"502"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return head\n slow=head\n fast=head.next\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n mid=slow.next\n slow.next=None\n left=self.sortList(head)\n right=self.sortList(mid)\n merged=ListNode()\n temp=merged\n while left and right:\n if left.val<right.val:\n temp.next=ListNode(left.val)\n left=left.next\n else:\n temp.next=ListNode(right.val)\n right=right.next\n temp=temp.next\n if left: temp.next=left\n if right: temp.next=right\n return merged.next","runtime":"508"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n return self.quickSort(head)\n\n def quickSort(self, head):\n if head is None or head.next is None:\n return head\n\n pivot = self.randomPivot(head)\n lesser = lesserDummy = ListNode()\n equal = equalDummy = ListNode()\n greater = greaterDummy = ListNode()\n while head:\n if head.val < pivot.val:\n lesser.next = head\n lesser = lesser.next\n elif head.val == pivot.val:\n equal.next = head\n equal = equal.next\n else:\n greater.next = head\n greater = greater.next\n head = head.next\n\n lesser.next = equal.next = greater.next = None\n left = self.quickSort(lesserDummy.next)\n mid = equalDummy.next\n right = self.quickSort(greaterDummy.next)\n return self.concat(self.concat(left, mid), right)\n\n def getLength(self, head):\n cnt = 0\n while head:\n cnt += 1\n head = head.next\n return cnt\n\n def randomPivot(self, head):\n pivotIndex = random.randint(0, self.getLength(head) - 1)\n for i in range(pivotIndex):\n head = head.next\n return head\n\n def concat(self, head1, head2):\n dummyHead = tail = ListNode()\n tail.next = head1\n while tail.next:\n tail = tail.next\n tail.next = head2\n return dummyHead.next","runtime":"508"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n # Time complexity = O(n) + O(nlogn) + O(n) --> ll to arr, sort, arr to ll\n # Space complexity = O(n) --> arr\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n temp = head\n arr = []\n while temp is not None:\n arr.append(temp.val)\n temp = temp.next\n\n self.mergeSort(arr, 0, len(arr)-1)\n temp = head\n for i in range(len(arr)):\n temp.val = arr[i]\n temp = temp.next\n\n return head\n\n def merge(self, arr, l, m, r):\n n1 = m - l + 1\n n2 = r - m\n left = [arr[l+i] for i in range(n1)]\n right = [arr[m + 1 + i] for i in range(n2)]\n i = j = 0\n k = l\n\n while i < n1 and j < n2:\n if left[i] < right[j]:\n arr[k] = left[i]\n i += 1\n else:\n arr[k] = right[j]\n j += 1\n k += 1\n\n while i < n1:\n arr[k] = left[i]\n i += 1\n k += 1\n\n while j < n2:\n arr[k] = right[j]\n j += 1\n k += 1\n\n def mergeSort(self, arr, l, r):\n if l < r:\n mid = (l+r)//2\n self.mergeSort(arr, l, mid)\n self.mergeSort(arr, mid+1, r)\n self.merge(arr, l, mid, r)","runtime":"514"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None:\n return None\n data = []\n node = head\n while node:\n idx = bisect_left(data, node.val)\n data.insert(idx, node.val)\n node = node.next\n \n nodes = [ListNode(data[0])] \n for i in range(1, len(data)):\n node = ListNode(data[i])\n nodes[i-1].next = node\n nodes.append(node)\n \n return nodes[0]\n\n \n ","runtime":"514"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # Step 1: Extract values from the linked list and store them in an array\n values = []\n current = head\n while current:\n values.append(current.val)\n current = current.next\n \n # Step 2: Apply heap sort on the array\n self.heap_sort(values)\n \n # Step 3: Reconstruct the linked list with sorted values\n current = head\n for val in values:\n current.val = val\n current = current.next\n \n return head\n\n def heapify(self, arr, n, i):\n # Helper function to heapify a subtree rooted with node i\n largest = i # Initialize largest as root\n left = 2 * i + 1 # left = 2*i + 1\n right = 2 * i + 2 # right = 2*i + 2\n\n # If left child is larger than root\n if left < n and arr[left] > arr[largest]:\n largest = left\n\n # If right child is larger than largest so far\n if right < n and arr[right] > arr[largest]:\n largest = right\n\n # If largest is not root\n if largest != i:\n arr[i], arr[largest] = arr[largest], arr[i] # swap\n\n # Recursively heapify the affected subtree\n self.heapify(arr, n, largest)\n\n def heap_sort(self, arr):\n n = len(arr)\n\n # Build a maxheap.\n for i in range(n // 2 - 1, -1, -1):\n self.heapify(arr, n, i)\n\n # One by one extract elements\n for i in range(n-1, 0, -1):\n arr[i], arr[0] = arr[0], arr[i] # swap\n self.heapify(arr, i, 0)","runtime":"520"},{"code":"class Solution:\n @staticmethod\n def merge(node1: ListNode, node2: ListNode) -> ListNode:\n last = dummy = ListNode()\n \n while node1 is not None or node2 is not None:\n n1 = node1.val if node1 else float(\"inf\")\n n2 = node2.val if node2 else float(\"inf\")\n \n if n1 == n2 == float(\"inf\"):\n break\n elif n1 < n2:\n smallest = node1\n node1 = node1.next\n else:\n smallest = node2\n node2 = node2.next\n \n smallest.next = None\n last.next = smallest\n last = smallest\n \n return dummy.next\n \n \n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n \n slow, fast = head, head.next\n\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n \n mid = slow\n \n after_mid = mid.next\n mid.next = None\n mid = after_mid\n\n head = self.sortList(head)\n mid = self.sortList(mid)\n \n return self.merge(head, mid)\n","runtime":"520"}],"string":"[\n {\n \"code\": \"with open(\\\"user.out\\\", \\\"w\\\") as Solution:\\n for head in map(loads, stdin):\\n Solution.write(f\\\"{sorted(head)}\\\\n\\\".replace(\\\" \\\",\\\"\\\"))\\nexit()\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"f = open('user.out','w')\\nfor arr in map(loads, stdin):\\n print(str(sorted(arr)).replace(' ',''), file=f)\\nexit(0)\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"f = open('user.out','w')\\nfor arr in map(loads, stdin):\\n print(str(sorted(arr)).replace(' ',''), file=f)\\nexit(0)\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"f = open('user.out','w')\\nfor arr in map(loads, stdin):\\n print(str(sorted(arr)).replace(' ',''), file=f)\\nexit(0)\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n curr = head\\n l =[]\\n while curr:\\n l.append(curr.val)\\n curr = curr.next\\n l.sort()\\n curr = head\\n for i in l:\\n curr.val = i\\n curr = curr.next\\n return head\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n l = []\\n cur = head\\n while cur:\\n l.append(cur.val)\\n cur = cur.next\\n l.sort()\\n cur = head\\n for num in l:\\n cur.val = num\\n cur = cur.next\\n return head\\n\\n \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # Step 0\\n if not head:\\n return head\\n\\n node = head\\n sorted_list = []\\n\\n # Step 1: \\n while node:\\n sorted_list.append(node.val)\\n node = node.next\\n\\n # Step 2:\\n sorted_list.sort()\\n\\n # Step 3: \\n node = head\\n for val in sorted_list:\\n node.val = val\\n node = node.next\\n\\n return head\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n values = []\\n current = head\\n while current:\\n values.append(current.val)\\n current = current.next\\n values.sort()\\n current = head\\n for value in values:\\n current.val = value\\n current = current.next\\n \\n return head\\n\",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n values = []\\n curr = head\\n while curr:\\n values.append(curr.val)\\n curr = curr.next\\n \\n values = sorted(values, reverse = True)\\n\\n curr = head\\n while curr:\\n curr.val = values.pop()\\n curr = curr.next\\n \\n return head\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n if not head or not head.next:\\n return head\\n \\n sortedL=[]\\n curr=head\\n while curr:\\n sortedL.append(curr.val)\\n curr=curr.next\\n \\n # sort the list\\n sortedL.sort()\\n\\n # create a new linked list based on sorted value\\n curr=head\\n for val in sortedL:\\n curr.val=val\\n curr=curr.next\\n return head\\n\\n\\n \\n \",\n \"runtime\": \"99\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n list2=[]\\n k=head\\n while k:\\n list2.append(k.val)\\n k=k.next\\n \\n list2.sort()\\n\\n k=head\\n i=0\\n while k:\\n k.val = list2[i]\\n i=i+1\\n k = k.next\\n\\n return head\",\n \"runtime\": \"99\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n arr, itr = [], head # take an array to store all the extracted values\\n while itr: # iterate and copy\\n arr.append(itr.val) \\n itr = itr.next\\n arr.sort() # sort it\\n itr, i = head, 0 # take i to traverse the array along with linked list\\n\\t\\t\\t\\t\\n while itr: # fill the sorted values\\n itr.val = arr[i] \\n i += 1\\n itr = itr.next\\n return head\",\n \"runtime\": \"105\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n arr, itr = [], head\\n while itr:\\n arr.append(itr.val)\\n itr = itr.next\\n arr.sort()\\n itr, i = head, 0\\n while itr:\\n itr.val = arr[i]\\n i += 1\\n itr = itr.next\\n return head\",\n \"runtime\": \"105\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n curr = head\\n valList = list()\\n while curr:\\n valList.append(curr.val)\\n curr = curr.next\\n \\n curr = head\\n valList.sort(reverse=True)\\n while curr:\\n curr.val = valList.pop()\\n curr = curr.next\\n return head\\n\",\n \"runtime\": \"111\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n values = []\\n curr = head\\n while curr:\\n values.append(curr.val)\\n curr = curr.next\\n \\n values = sorted(values, reverse = True)\\n\\n curr = head\\n while curr:\\n curr.val = values.pop()\\n curr = curr.next\\n \\n return head\",\n \"runtime\": \"111\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n arr = []\\n temp = head\\n temp2 = head\\n while temp:\\n arr.append(temp.val)\\n temp = temp.next\\n arr.sort()\\n i = 0\\n while temp2:\\n temp2.val = arr[i]\\n i += 1\\n temp2 = temp2.next\\n return head\\n\\n \",\n \"runtime\": \"117\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n arr=[]\\n temp=head\\n while(temp!=None):\\n arr.append(temp.val)\\n temp=temp.next\\n arr.sort()\\n temp=head\\n i=0\\n while(temp!=None):\\n temp.val=arr[i]\\n i+=1\\n temp=temp.next\\n return(head)\\n \",\n \"runtime\": \"117\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n \\n nums = []\\n node = head\\n while node:\\n nums.append(node.val)\\n node = node.next\\n \\n nums.sort()\\n node = head\\n for num in nums:\\n node.val = num\\n node = node.next\\n \\n return head\",\n \"runtime\": \"123\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n l=[]\\n temp=head\\n while temp is not None:\\n l.append(temp.val)\\n temp=temp.next\\n i=0\\n l=sorted(l)\\n current=head\\n while current is not None:\\n current.val=l[i]\\n i=i+1\\n current=current.next\\n return head\\n\\n \\n \",\n \"runtime\": \"123\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n k=[]\\n node=head\\n while node:\\n k.append(node.val)\\n node=node.next\\n k.sort()\\n \\n node=head\\n for i in k:\\n node.val=i\\n node=node.next\\n return head\\n \",\n \"runtime\": \"128\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n allElements = []\\n \\n temp = head\\n temp2 = head\\n if head == None:\\n return head\\n while temp != None:\\n allElements.append(temp.val)\\n temp = temp.next\\n \\n allElements.sort()\\n for i in range(0, len(allElements)):\\n temp2.val = allElements[i]\\n temp2 = temp2.next\\n \\n return head\\n \",\n \"runtime\": \"128\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n l = []\\n while head:\\n l.append(head)\\n head = head.next\\n \\n l.sort(key=lambda x: x.val, reverse=True)\\n \\n dummy = ListNode()\\n curr = dummy\\n while l:\\n curr.next = l.pop()\\n curr = curr.next\\n \\n curr.next = None\\n return dummy.next\",\n \"runtime\": \"134\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n nodes_arr = []\\n\\n curr = head\\n while curr:\\n nodes_arr.append(curr)\\n curr = curr.next\\n\\n nodes_arr.sort(key=lambda node: node.val)\\n\\n for i in range(len(nodes_arr) - 1):\\n nodes_arr[i].next = nodes_arr[i + 1]\\n \\n nodes_arr[-1].next = None\\n\\n return nodes_arr[0]\\n\",\n \"runtime\": \"134\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nimport heapq\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n heap = []\\n curr = head\\n\\n while curr:\\n heapq.heappush(heap,curr.val)\\n curr = curr.next\\n\\n curr= head\\n while curr:\\n pop = heapq.heappop(heap)\\n curr.val = pop\\n curr = curr.next\\n \\n return head\\n \",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n cur=head\\n l=[]\\n while cur:\\n l.append(cur.val)\\n cur=cur.next\\n l.sort()\\n cur=head\\n i=0\\n while cur:\\n cur.val=l[i]\\n i+=1\\n cur=cur.next\\n return head\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nimport heapq\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n heap = []\\n curr = head\\n\\n while curr:\\n heapq.heappush(heap,curr.val)\\n curr = curr.next\\n \\n curr = head\\n while curr:\\n pop = heapq.heappop(heap)\\n curr.val = pop\\n curr = curr.next\\n \\n return head\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n l = []\\n node = head\\n while node:\\n l.append(node.val)\\n node = node.next\\n l.sort()\\n ret = ListNode()\\n node = ret\\n for n in l:\\n node.next = ListNode(n)\\n node = node.next\\n return ret.next\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\\"\\\"\\\"\\n 1. use a hashtable to store all the nodes, space complexity: O(n) \\n 2. there could be duplocated keys\\n \\\"\\\"\\\"\\n\\n if not head:\\n return head\\n\\n\\n store = defaultdict(list) # key: the val, value: the node list\\n\\n curr = head \\n while curr:\\n store[curr.val].append(curr)\\n curr = curr.next\\n \\n keys = list(store.keys())\\n keys.sort()\\n\\n # note store[keys[i]] should be a list \\n dummy_node = ListNode()\\n new_curr = dummy_node\\n for i in range(len(keys)):\\n for node in store[keys[i]]:\\n new_curr.next = node \\n new_curr = node\\n\\n\\n new_curr.next = None \\n return dummy_node.next\",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nimport heapq\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n heap=[]\\n curr=head\\n while curr:\\n heapq.heappush(heap,curr.val)\\n curr=curr.next\\n curr=head\\n while curr:\\n pop=heapq.heappop(heap)\\n curr.val=pop\\n curr=curr.next\\n return head\\n \",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n elems = []\\n\\n curr = head\\n while curr:\\n elems.append(curr.val)\\n curr = curr.next\\n elems.sort()\\n\\n dummyHead = ListNode(0)\\n prev = dummyHead\\n\\n for elem in elems:\\n new = ListNode(elem)\\n prev.next = new\\n prev = prev.next\\n return dummyHead.next\",\n \"runtime\": \"158\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nimport heapq\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n heap = []\\n curr = head\\n\\n while curr:\\n heapq.heappush(heap,curr.val)\\n curr = curr.next\\n\\n curr= head\\n while curr:\\n pop = heapq.heappop(heap)\\n curr.val = pop\\n curr = curr.next\\n \\n return head\",\n \"runtime\": \"158\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n heap = []\\n curr = head\\n\\n while curr:\\n heapq.heappush(heap, curr.val)\\n curr = curr.next\\n\\n curr = head\\n while curr:\\n val = heapq.heappop(heap)\\n curr.val = val\\n curr = curr.next\\n\\n \\n return head\\n\\n \",\n \"runtime\": \"164\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n values = []\\n while head:\\n values.append(head.val)\\n head = head.next\\n values = sorted(values)\\n head = None\\n p = head\\n for x in values[::-1]:\\n head = ListNode(x, p)\\n p = head\\n # ListNode()\\n ## my solution, get nodes, sort\\n return head\",\n \"runtime\": \"164\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nimport heapq\\n\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n heap = []\\n curr = head\\n\\n while curr:\\n heapq.heappush(heap, curr.val)\\n curr = curr.next\\n \\n curr = head\\n while curr:\\n pop = heapq.heappop(heap)\\n curr.val = pop\\n curr= curr.next\\n return head\\n\\n \\n\\n\\n\\n\\n \",\n \"runtime\": \"170\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n arr = []\\n temp = head\\n while temp is not None:\\n arr.append(temp.val)\\n temp = temp.next\\n arr.sort()\\n print(arr)\\n temp = head\\n for i in arr:\\n print(i)\\n temp.val = i\\n temp = temp.next\\n return head\\n # temp = head\\n # if head is None or head.next is None:\\n # return head\\n # slow = head\\n # fast = head.next\\n # while fast and fast.next:\\n # slow = slow.next\\n # fast = fast.next.next\\n # mid = slow.next\\n # slow.next = None\\n # left = self.sortList(head)\\n # right = self.sortList(mid)\\n\\n # dummy = ListNode(0)\\n # curr = dummy\\n \\n # while left and right:\\n # if left.val <= right.val:\\n # curr.next = left\\n # left = left.next\\n # else:\\n # curr.next = right\\n # right= right.next\\n # curr = curr.next\\n # if left:\\n # curr.next = left\\n # else:\\n # curr.next = right\\n # return dummy.next\\n\\n\\n \",\n \"runtime\": \"170\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: return None\\n nums = []\\n dummy = head\\n while dummy != None:\\n nums.append(dummy.val)\\n dummy = dummy.next\\n nums.sort()\\n head1 = ListNode()\\n dummy1 = head1\\n for i in range(len(nums)):\\n dummy1.next = ListNode(nums[i])\\n dummy1 = dummy1.next\\n return head1.next\",\n \"runtime\": \"176\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return None\\n arr = []\\n while head:\\n arr.append(head.val)\\n head = head.next\\n arr.sort()\\n print(arr)\\n\\n h = ListNode(arr[0])\\n hh = h\\n for i in range(1,len(arr)):\\n a = ListNode(arr[i])\\n h.next = a\\n h = h.next\\n return hh\\n \\n \",\n \"runtime\": \"176\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom collections import defaultdict\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n d = defaultdict(list)\\n cur = head\\n while cur:\\n d[cur.val].append(cur)\\n cur = cur.next\\n new_head, cur = None, None\\n for value, nodes in sorted(d.items()):\\n for node in nodes:\\n if not cur:\\n new_head, cur = node, node\\n else:\\n cur.next = node\\n cur = cur.next\\n if cur:\\n cur.next = None\\n return new_head\\n\",\n \"runtime\": \"182\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n li=[]\\n if not head:return head\\n while head:\\n li.append(head.val)\\n head=head.next\\n li.sort()\\n header=ListNode(li[0])\\n head=header\\n for i in range(1,len(li)):\\n node=ListNode(li[i])\\n head.next=node\\n head=node\\n return header\",\n \"runtime\": \"182\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n nums = []\\n tmp_head = head\\n while tmp_head:\\n nums.append(tmp_head.val)\\n tmp_head = tmp_head.next\\n nums.sort(reverse=True)\\n if len(nums) <= 0:\\n return head\\n \\n head = ListNode(val=nums.pop())\\n return self.build_list(nums, head)\\n\\n def build_list(self, nums, head):\\n if len(nums) == 0:\\n return head\\n \\n next_element = nums.pop()\\n head.next = ListNode(val=next_element)\\n self.build_list(nums, head.next)\\n return head\\n\\n\\n \\n\\n \",\n \"runtime\": \"188\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return head\\n hashmap = {}\\n nums = []\\n cur = head\\n while cur:\\n nums.append((cur.val, cur))\\n hashmap[(cur.val, cur)] = cur\\n cur = cur.next\\n nums.sort(key=lambda x: x[0])\\n hashmap[nums[len(nums)-1]].next = None\\n for i in range(len(nums)-2, -1, -1):\\n hashmap[nums[i]].next = hashmap[nums[i+1]]\\n \\n return head if head is None else hashmap[nums[0]]\",\n \"runtime\": \"188\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n \\\"\\\"\\\"\\n Time Complexity: O(N log N)\\n Space Complexity: O(1)\\n \\\"\\\"\\\"\\n \\n dummy = ListNode()\\n res = dummy\\n\\n min_heap = []\\n \\n if not head:\\n return head\\n \\n curr = head\\n\\n while curr:\\n heapq.heappush(min_heap, curr.val)\\n curr = curr.next\\n \\n while min_heap:\\n next_node = ListNode(heapq.heappop(min_heap))\\n res.next = next_node\\n res = next_node\\n \\n return dummy.next\",\n \"runtime\": \"194\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def mergeLists(self, left, right):\\n head = tail = None\\n while left or right:\\n if left and right:\\n if right.val < left.val:\\n nxt = right\\n right = right.next\\n else:\\n nxt = left\\n left = left.next\\n if tail:\\n tail.next = nxt\\n tail = nxt\\n else:\\n head = tail = nxt\\n else:\\n nxt = left or right\\n if tail:\\n tail.next = nxt\\n else:\\n head = tail = nxt\\n break\\n \\n return head\\n\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n i = head\\n stack = []\\n while i:\\n heappush(stack, i.val)\\n i = i.next\\n head = tail = ListNode(heappop(stack))\\n while stack:\\n tail.next = ListNode(heappop(stack))\\n tail = tail.next\\n tail.next = None\\n return head\\n\\n \",\n \"runtime\": \"194\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n curr = head\\n heap = []\\n while curr:\\n heapq.heappush(heap , curr.val)\\n curr = curr.next\\n dummy = ListNode(0)\\n curr = dummy\\n while heap:\\n temp = heapq.heappop(heap)\\n curr.next = ListNode(temp)\\n curr = curr.next\\n return dummy.next\\n\\n \",\n \"runtime\": \"200\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n store = []\\n curr = head\\n while curr:\\n store.append(curr.val)\\n curr = curr.next\\n store.sort()\\n dummyNode = ListNode(0)\\n temp = dummyNode\\n \\n for i in store:\\n x = ListNode(val = i)\\n temp.next = x\\n temp = x\\n return dummyNode.next\",\n \"runtime\": \"200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n heap = []\\n\\n cur = head\\n while cur:\\n heapq.heappush(heap, cur.val)\\n cur = cur.next\\n \\n res = ListNode()\\n cur = res\\n while heap:\\n val = heapq.heappop(heap)\\n cur.next = ListNode(val)\\n cur = cur.next\\n\\n return res.next\",\n \"runtime\": \"206\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom heapq import heappush\\n\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return head\\n\\n heap = []\\n node = head\\n\\n while node is not None:\\n heappush(heap, node.val)\\n node = node.next\\n\\n vals = []\\n while heap:\\n vals.append(heapq.heappop(heap))\\n\\n head = ListNode(vals[0])\\n node = head\\n\\n for val in vals[1:]:\\n next_node = ListNode(val)\\n node.next = next_node\\n node = next_node\\n\\n return head\",\n \"runtime\": \"206\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n l = []\\n while head:\\n heapq.heappush(l,head.val)\\n head = head.next\\n \\n head_val = heapq.heappop(l)\\n head = ListNode(head_val)\\n tmp = head\\n while l:\\n val = heapq.heappop(l)\\n node = ListNode(val)\\n tmp.next = node\\n tmp = tmp.next\\n return head\",\n \"runtime\": \"211\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom heapq import *\\n\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n if not head or not head.next:\\n return head\\n \\n min_heap = []\\n cur = head\\n while cur:\\n heappush(min_heap,cur.val)\\n cur = cur.next\\n \\n dummy = newHead = ListNode()\\n while min_heap:\\n n = heappop(min_heap)\\n newHead.next = ListNode(n)\\n newHead = newHead.next\\n return dummy.next\",\n \"runtime\": \"211\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n curr = head\\n minHeap = []\\n while curr is not None:\\n heapq.heappush(minHeap, (curr.val))\\n curr = curr.next\\n result = ListNode()\\n curr = result\\n while len(minHeap) > 0:\\n curr.next = ListNode(heapq.heappop(minHeap))\\n curr = curr.next\\n return result.next\",\n \"runtime\": \"217\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return head\\n \\n array = []\\n curr = head\\n while curr:\\n array.append((curr.val, ListNode(curr.val)))\\n curr = curr.next\\n\\n array.sort(key=lambda row: row[0], reverse=True)\\n dummy = ListNode()\\n curr = dummy\\n for _ in range(len(array)):\\n val, node = array.pop()\\n curr.next = node\\n curr = curr.next\\n \\n return dummy.next\",\n \"runtime\": \"217\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom heapq import heappush, heappop\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n heap = []\\n dummy = ListNode()\\n index = 0\\n while head:\\n heappush(heap, (head.val, index, head))\\n head = head.next\\n index += 1\\n \\n current = dummy\\n while heap:\\n val, index, node = heappop(heap)\\n current.next = node\\n current = current.next\\n current.next = None\\n return dummy.next\\n \",\n \"runtime\": \"223\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # use min_heap to sort the list\\n min_heap = []\\n\\n p = head\\n dummy_node = ListNode(-1)\\n index = 0\\n\\n while p:\\n heappush(min_heap, (p.val, index, p))\\n p = p.next\\n index += 1\\n \\n p = dummy_node\\n while min_heap:\\n _, _, curr_node = heappop(min_heap)\\n p.next = curr_node\\n p = p.next\\n \\n p.next = None\\n return dummy_node.next \",\n \"runtime\": \"223\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nimport heapq\\n\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n h = []\\n node = head\\n while(node):\\n h.append((node.val,id(node), node))\\n node = node.next\\n #print(h)\\n heapq.heapify(h)\\n root = ListNode(val=float(\\\"inf\\\"))\\n node = root\\n while(h):\\n _,_, ans = heapq.heappop(h)\\n node.next = ans\\n node = node.next\\n node.next = None\\n return root.next\",\n \"runtime\": \"229\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return head\\n sorted_head = self.mergeSort(head)\\n return sorted_head\\n\\n def mergeSort(self,head):\\n if head.next == None:\\n return head\\n\\n #find the midpoint and split\\n slow = head\\n fast = head.next\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n #recursivly call mergesort\\n right = self.mergeSort(slow.next)\\n slow.next = None\\n left= self.mergeSort(head)\\n\\n #order\\n right_curr = right\\n left_curr = left\\n sorted_head = None\\n if left_curr.val < right_curr.val:\\n sorted_head = left_curr\\n left_curr = left_curr.next\\n else:\\n sorted_head = right_curr\\n right_curr = right_curr.next\\n sorted_end = sorted_head\\n while right_curr is not None and left_curr is not None:\\n if left_curr.val < right_curr.val:\\n sorted_end.next = left_curr\\n left_curr = left_curr.next\\n else:\\n sorted_end.next = right_curr\\n right_curr = right_curr.next\\n sorted_end = sorted_end.next\\n\\n if right_curr:\\n sorted_end.next = right_curr\\n else:\\n sorted_end.next = left_curr\\n\\n return sorted_head\\n\\n\\n\\n \\n \\n\\n \\n def swap(self, node_1, node_2):\\n #print(\\\"swapping\\\")\\n temp = node_1.val\\n node_1.val = node_2.val\\n node_2.val = temp\\n\\n def bubblesort(self, head):\\n if head is None:\\n return head\\n swap = True #init\\n while swap:\\n curr = head\\n swap = False\\n # print(f\\\"Resetting Curr {curr}\\\")\\n while curr.next is not None:\\n if curr.val > curr.next.val:\\n #print(head)\\n self.swap(curr, curr.next)\\n swap = True\\n # print(f\\\"swapped: {head}\\\")\\n curr = curr.next\\n \\n return head\\n\\n\\n \\n\\n \\n \",\n \"runtime\": \"229\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return None\\n\\n heap = []\\n\\n current_node = head\\n i = 0\\n while current_node:\\n heapq.heappush(heap, (current_node.val, i, current_node))\\n i += 1\\n current_node = current_node.next\\n\\n current_node = heapq.heappop(heap)[2]\\n head = current_node\\n\\n while len(heap) > 0:\\n next_node = heapq.heappop(heap)[2]\\n current_node.next = next_node\\n current_node = next_node\\n current_node.next = None\\n\\n return head\\n\\n \",\n \"runtime\": \"235\"\n },\n {\n \"code\": \"from heapq import heapify, heappush, heappop\\n\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n h = []\\n heapify(h)\\n\\n if head == None:\\n return head\\n\\n cur = head\\n \\n while cur != None:\\n heappush(h, cur.val)\\n cur = cur.next\\n \\n head = prev = None\\n while len(h) > 0:\\n node = ListNode(val=heappop(h), next=None)\\n if prev:\\n prev.next = node\\n prev = node\\n if head == None:\\n head = node\\n return head\",\n \"runtime\": \"235\"\n },\n {\n \"code\": \"import heapq\\n\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n node_heap = []\\n\\n curr = head\\n while curr:\\n heapq.heappush(node_heap, (curr.val, id(curr), curr))\\n curr = curr.next\\n \\n _, _, new_head = heapq.heappop(node_heap)\\n curr = new_head\\n \\n while node_heap:\\n _, _, curr.next = heapq.heappop(node_heap)\\n curr = curr.next\\n \\n curr.next = None\\n return new_head\\n \\n\",\n \"runtime\": \"241\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n node_map = defaultdict(list)\\n curr = head\\n dummyHead = ListNode(0)\\n while curr:\\n node_map[curr.val].append(curr)\\n curr = curr.next\\n \\n curr = dummyHead\\n # n log n\\n for key, value in sorted(node_map.items()):\\n for node in value:\\n curr.next = ListNode(node.val)\\n curr = curr.next\\n\\n return dummyHead.next\",\n \"runtime\": \"241\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n sz = 0\\n h = head\\n while h:\\n h = h.next\\n sz += 1\\n \\n def mergesort(sz, h):\\n if sz == 0: return None\\n if sz == 1: return h\\n if sz == 2:\\n if h.val > h.next.val:\\n tmp = h.next\\n h.next = None\\n tmp.next = h\\n h = tmp\\n return h\\n mid = sz // 2\\n k = h\\n for _ in range(mid - 1):\\n k = k.next\\n k.next, k = None, k.next\\n h1, h2 = mergesort(mid, h), mergesort(sz - mid, k)\\n res = dummy = ListNode(-1)\\n while h1 and h2:\\n if h1.val < h2.val:\\n dummy.next = h1\\n h1 = h1.next\\n else:\\n dummy.next = h2\\n h2 = h2.next\\n dummy = dummy.next\\n if h1: dummy.next = h1\\n if h2: dummy.next = h2\\n return res.next\\n\\n return mergesort(sz, head)\\n\\n \",\n \"runtime\": \"247\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return head\\n \\n count = 0\\n ptr = head\\n while ptr:\\n ptr = ptr.next\\n count += 1\\n \\n self.prehead = ListNode()\\n\\n return self.sort(head, count)[0]\\n \\n def sort(self, head: ListNode, count: int) -> (ListNode, ListNode):\\n if count == 1:\\n ans = (head, head.next)\\n head.next = None\\n return ans\\n \\n (left, right) = self.sort(head, (count+1)//2)\\n (left_2, right) = self.sort(right, count - (count+1)//2)\\n return (self.merge(left, left_2), right)\\n \\n def merge(self, head_1:ListNode, head_2:ListNode) -> ListNode:\\n self.prehead.next = None\\n head = self.prehead\\n while head_1 and head_2:\\n if head_1.val <= head_2.val:\\n head.next = head_1\\n head = head_1\\n head_1 = head_1.next\\n else:\\n head.next = head_2\\n head = head_2\\n head_2 = head_2.next\\n \\n head.next = head_1 if head_1 else head_2\\n return self.prehead.next\",\n \"runtime\": \"247\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n DEBUG = False\\n\\n # if not head:\\n # return None\\n\\n # node_pointers = [head]\\n # while node_pointers[-1].next:\\n # node_pointers.append(node_pointers[-1].next)\\n\\n # if DEBUG:\\n # for node in node_pointers:\\n # print(f'{node.val}, ')\\n # print(f'\\\\n')\\n\\n # def sort_values(array):\\n # if DEBUG:\\n # for node in array:\\n # print(f'{node.val}, ')\\n # print(f'\\\\n')\\n\\n # n = len(array)\\n # if n < 2:\\n # return array\\n\\n # m = n // 2\\n # sub_array_1 = sort_values(array[:m])\\n # sub_array_2 = sort_values(array[m:])\\n\\n # # concatenation\\n # i_1 = 0\\n # i_2 = 0\\n # output = []\\n # while i_1 < m and i_2 < n - m:\\n # if sub_array_1[i_1].val <= sub_array_2[i_2].val:\\n # output += [sub_array_1[i_1]]\\n # i_1 += 1\\n # else:\\n # output += [sub_array_2[i_2]]\\n # i_2 += 1\\n # if i_1 < len(sub_array_1):\\n # output += sub_array_1[i_1:]\\n # if i_2 < len(sub_array_2):\\n # output += sub_array_2[i_2:]\\n\\n # return output\\n\\n # node_pointers = sort_values(node_pointers)\\n # for i in range(len(node_pointers) - 1):\\n # node_pointers[i].next = node_pointers[i + 1]\\n # node_pointers[-1].next = None\\n\\n # return node_pointers[0]\\n\\n\\n if not head:\\n return head\\n\\n if not head.next:\\n return head\\n\\n # find the pointer to the middle node\\n pointer_iter = head\\n pointer_double_iter = head\\n while pointer_double_iter.next and pointer_double_iter.next.next:\\n pointer_iter = pointer_iter.next\\n pointer_double_iter = pointer_double_iter.next.next\\n # pointer to the second array \\n second_pointer = pointer_iter.next\\n # finish the first array\\n pointer_iter.next = None\\n\\n pointer_1 = self.sortList(head)\\n pointer_2 = self.sortList(second_pointer)\\n\\n # pointer to the first element\\n if pointer_1.val < pointer_2.val:\\n pointer_init = pointer_1\\n pointer_1 = pointer_1.next\\n else:\\n pointer_init = pointer_2\\n pointer_2 = pointer_2.next\\n current_pointer = pointer_init\\n\\n\\n # concatenation\\n while pointer_1 and pointer_2:\\n if pointer_1.val < pointer_2.val:\\n current_pointer.next = pointer_1\\n current_pointer = current_pointer.next\\n pointer_1 = pointer_1.next\\n else:\\n current_pointer.next = pointer_2\\n current_pointer = current_pointer.next\\n pointer_2 = pointer_2.next\\n\\n if not pointer_1:\\n current_pointer.next = pointer_2\\n if not pointer_2:\\n current_pointer.next = pointer_1\\n\\n return pointer_init\",\n \"runtime\": \"253\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None: return None\\n if head.next is None: return head\\n\\n # find middle of list\\n slow = head\\n fast = head\\n while fast.next is not None and fast.next.next is not None:\\n slow = slow.next\\n fast = fast.next.next\\n\\n # split into two halves and sort them\\n rhead = slow.next\\n slow.next = None\\n head = self.sortList(head)\\n other = self.sortList(rhead)\\n\\n if head.val > other.val:\\n head, other = other, head\\n\\n # merge other into head\\n hcurr = head\\n while hcurr.next is not None and other is not None:\\n if hcurr.next.val > other.val:\\n hnext = hcurr.next\\n hcurr.next = other\\n other = other.next\\n hcurr.next.next = hnext\\n hcurr = hcurr.next\\n\\n # if other is empty, we're done;\\n # otherwise we reached the end of the main list and need to\\n # append other\\n if other is not None:\\n hcurr.next = other\\n\\n return head\\n\",\n \"runtime\": \"253\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n #if length is less than or eqaul to one\\n if not head or not head.next:\\n return head\\n \\n #spilt ll in half\\n slow=fast=head\\n fast=fast.next\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n #Store the mid\\n mid=slow.next\\n #set slow next to None to get 2 seperate halfs\\n slow.next=None\\n\\n #recursively sort left and right halfs of linked list\\n left=self.sortList(head)\\n right=self.sortList(mid)\\n\\n #merge 2 sorted hafs of the linked list\\n dummy=ListNode(0)\\n curr=dummy\\n while left and right:\\n if left.val<right.val:\\n curr.next=left\\n left=left.next\\n else:\\n curr.next=right\\n right=right.next\\n curr=curr.next\\n #append remaining nodes of left or right\\n curr.next=left or right\\n return dummy.next\\n\",\n \"runtime\": \"259\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n #mergesort\\n def merge(self,first:Optional[ListNode],second:Optional[ListNode])-> Optional[ListNode]:\\n final = ListNode()\\n head = final\\n while first and second:\\n if first.val<=second.val:\\n final.next = first\\n final = final.next\\n first = first.next\\n else:\\n final.next = second\\n final = final.next\\n second = second.next\\n if first:\\n final.next = first\\n else:\\n final.next = second\\n final = final.next\\n return head.next\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n def mergeSort(arr,low,high):\\n if high==low:\\n return arr[low]\\n mid = int((high+low)/2)\\n h = mergeSort(arr,low,mid)\\n a = mergeSort(arr,mid+1,high)\\n return self.merge(h,a)\\n t = []\\n traverse = head\\n while traverse:\\n prev = traverse\\n traverse = traverse.next\\n prev.next = None\\n t.append(prev)\\n return mergeSort(t,0,len(t)-1)\\n\\n \\n \",\n \"runtime\": \"259\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n def merge_sort(node):\\n # Base case: if the list is empty or has only one node, it's already sorted\\n if not node or not node.next:\\n return node\\n \\n # Use two pointers to find the middle of the list\\n slow, fast = node, node.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n \\n # Split the list into two halves\\n right_half = slow.next\\n slow.next = None\\n \\n # Recursively sort both halves\\n left = merge_sort(node)\\n right = merge_sort(right_half)\\n \\n # Merge the sorted halves\\n dummy = ListNode()\\n curr = dummy\\n \\n while left and right:\\n if left.val < right.val:\\n curr.next = left\\n left = left.next\\n else:\\n curr.next = right\\n right = right.next\\n curr = curr.next\\n # Append the remaining nodes of the left or right half to the end of the sorted list\\n curr.next = left or right\\n \\n return dummy.next\\n \\n return merge_sort(head)\",\n \"runtime\": \"265\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n tortoise, hare = head, head.next\\n\\n while hare and hare.next:\\n tortoise = tortoise.next\\n hare = hare.next.next\\n\\n middle = tortoise.next\\n tortoise.next = None\\n \\n left = self.sortList(head)\\n right = self.sortList(middle)\\n\\n dummy = ListNode(0)\\n p = dummy\\n\\n while left and right:\\n if left.val < right.val:\\n p.next = left\\n left = left.next\\n else:\\n p.next = right\\n right = right.next\\n p = p.next\\n \\n p.next = left or right\\n return dummy.next\\n \",\n \"runtime\": \"271\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n mid = slow.next\\n slow.next = None\\n\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n\\n dummy = ListNode()\\n c = dummy\\n\\n while left and right:\\n if left.val < right.val:\\n c.next = left\\n left = left.next\\n else:\\n c.next = right\\n right = right.next\\n c = c.next\\n\\n c.next = left or right\\n\\n return dummy.next\",\n \"runtime\": \"271\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n mid = slow.next\\n slow.next = None\\n return self.merge(self.sortList(head), self.sortList(mid))\\n \\n def merge(self, l1, l2):\\n dummy = ListNode()\\n cur = dummy\\n while l1 and l2:\\n if l1.val < l2.val:\\n cur.next = l1\\n l1 = l1.next\\n else:\\n cur.next = l2\\n l2 = l2.next\\n cur = cur.next\\n cur.next = l1 or l2\\n return dummy.next\\n \\n\\n \",\n \"runtime\": \"277\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n \\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow, fast = slow.next, fast.next.next\\n mid = slow.next\\n slow.next = None\\n\\n small = self.sortList(head)\\n large = self.sortList(mid)\\n\\n dummy = ListNode()\\n cur1, cur2, cur = small, large, dummy\\n while cur1 and cur2:\\n if cur1.val < cur2.val:\\n cur.next = cur1\\n cur1 = cur1.next\\n else:\\n cur.next = cur2\\n cur2 = cur2.next\\n cur = cur.next\\n cur.next = cur1 or cur2\\n return dummy.next\\n\\n\\n# from collections import defaultdict\\n# class Solution:\\n# def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n# d = defaultdict(list)\\n# cur = head\\n# while cur:\\n# d[cur.val].append(cur)\\n# cur = cur.next\\n# new_head, cur = None, None\\n# for value, nodes in sorted(d.items()):\\n# for node in nodes:\\n# if not cur:\\n# new_head, cur = node, node\\n# else:\\n# cur.next = node\\n# cur = cur.next\\n# if cur:\\n# cur.next = None\\n# return new_head\\n\",\n \"runtime\": \"277\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # merge sort\\n # base case: if length <= 1 denotes sorted list\\n if not head or not head.next:\\n return head\\n\\n # split list into 2 halfs with slow and fast pointer to find mid\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n mid = slow.next\\n slow.next = None # cut the list into 2 halves\\n\\n # recursively sort left and right halves\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n\\n # merge 2 halves\\n dummy = ListNode(0)\\n curr = dummy\\n while left and right:\\n if left.val < right.val:\\n curr.next = left\\n left = left.next # move down left list\\n else:\\n curr.next = right\\n right = right.next\\n curr = curr.next\\n \\n # append remaining nodes\\n curr.next = left or right\\n\\n return dummy.next\",\n \"runtime\": \"283\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n temp = head\\n if head is None or head.next is None:\\n return head\\n slow = head\\n fast = head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n mid = slow.next\\n slow.next = None\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n\\n dummy = ListNode(0)\\n curr = dummy\\n \\n while left and right:\\n if left.val <= right.val:\\n curr.next = left\\n left = left.next\\n else:\\n curr.next = right\\n right= right.next\\n curr = curr.next\\n if left:\\n curr.next = left\\n else:\\n curr.next = right\\n return dummy.next\\n\\n\\n \",\n \"runtime\": \"283\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n slow, fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n mid = slow.next\\n slow.next = None\\n\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n\\n dummy = ListNode(0)\\n curr = dummy\\n while left and right:\\n if left.val < right.val:\\n curr.next = left\\n left = left.next\\n else:\\n curr.next = right\\n right = right.next\\n\\n curr = curr.next\\n curr.next = left or right\\n return dummy.next\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"288\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n if not head or not head.next:\\n return head\\n\\n left = head \\n mid = self.getMid(head)\\n right = mid.next \\n mid.next = None\\n\\n sorted_left = self.sortList(left)\\n sorted_right = self.sortList(right)\\n return self.merge(sorted_left, sorted_right)\\n \\n\\n def merge(self, left, right): \\n curr = dummy = ListNode()\\n while left and right:\\n if left.val <= right.val:\\n curr.next = left \\n left = left.next \\n else:\\n curr.next = right \\n right = right.next \\n curr = curr.next \\n \\n if left:\\n curr.next = left \\n \\n if right:\\n curr.next = right \\n \\n return dummy.next\\n\\n\\n def getMid(self, head):\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\",\n \"runtime\": \"288\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n mid = self.getMiddle(head)\\n left = head\\n right = mid.next\\n mid.next = None\\n\\n left_sorted = self.sortList(left)\\n right_sorted = self.sortList(right)\\n\\n sorted_list = self.merge(left_sorted, right_sorted)\\n return sorted_list\\n\\n def getMiddle(self, head: ListNode) -> ListNode:\\n slow = head\\n fast = head.next\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n return slow\\n\\n\\n def merge(self, l1: ListNode, l2: ListNode) -> ListNode:\\n dummy = ListNode(0)\\n tail = dummy\\n \\n while l1 and l2:\\n if l1.val < l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n\\n # Attach the remaining nodes\\n tail.next = l1 if l1 else l2\\n\\n return dummy.next\\n\",\n \"runtime\": \"294\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n right = slow.next\\n slow.next = None\\n\\n left = self.sortList(head)\\n right = self.sortList(right)\\n\\n return self.merge(left, right)\\n\\n def merge(self, l1, l2):\\n if not l1 or not l2:\\n return l1 or l2\\n\\n if l1.val < l2.val:\\n l1.next = self.merge(l1.next, l2)\\n return l1\\n else:\\n l2.next = self.merge(l1, l2.next)\\n return l2\\n \",\n \"runtime\": \"294\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def mergeTwoSort(self,left,right):\\n new_node=ListNode(-1)\\n new_head=new_node\\n while left and right:\\n if left.val<=right.val:\\n new_head.next=left\\n left=left.next\\n else:\\n new_head.next=right\\n right=right.next\\n new_head=new_head.next\\n if left:\\n new_head.next=left\\n else:\\n new_head.next=right\\n return new_node.next\\n\\n def findMiddle(self,head):\\n if head is None or head.next is None:\\n return head\\n slow=fast=head\\n prev=None\\n while fast and fast.next:\\n prev=slow\\n slow=slow.next\\n fast=fast.next.next\\n prev.next=None\\n return slow\\n\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return head\\n mid=self.findMiddle(head)\\n left=self.sortList(head)\\n right=self.sortList(mid)\\n return self.mergeTwoSort(left,right)\",\n \"runtime\": \"300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def find_middle(self, head):\\n slow, fast = head, head\\n while fast and fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n\\n def merge_list(self, l1, l2):\\n dummy = ListNode()\\n tail = dummy\\n\\n while l1 and l2:\\n if l1.val < l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n \\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n \\n return dummy.next\\n\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # base condition\\n if not head or not head.next:\\n return head\\n\\n # find the middle value\\n middle = self.find_middle(head)\\n middle_to_next = middle.next\\n middle.next = None\\n\\n #Find left and rights\\n left = self.sortList(head)\\n right = self.sortList(middle_to_next)\\n\\n sorted_list = self.merge_list(left, right)\\n return sorted_list\",\n \"runtime\": \"300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # We will go about this in the form of Merge sort first\\n if head is None or head.next is None:\\n return head\\n start = head\\n mid = self.getMid(head)\\n tmp = mid.next\\n mid.next = None # cut things at the mid\\n mid = tmp\\n\\n arr1 = self.sortList(start)\\n arr2 = self.sortList(mid)\\n return self.merge(arr1, arr2)\\n\\n \\n def getMid(self, arr):\\n \\\"\\\"\\\"This will give us the mid point\\\"\\\"\\\"\\n slow = arr\\n fast = arr.next\\n while fast and fast.next: \\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(self, arr1, arr2):\\n head = ListNode()\\n ptr = head # this is a test. \\n # make a list by starting with hail. initializing the head with that. \\n while arr1 and arr2:\\n if arr1.val < arr2.val:\\n ptr.next = arr1\\n arr1 = arr1.next\\n else:\\n ptr.next = arr2\\n arr2 = arr2.next\\n ptr = ptr.next\\n \\n if arr1:\\n ptr.next = arr1\\n \\n if arr2:\\n ptr.next = arr2\\n \\n return head.next\\n\",\n \"runtime\": \"306\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n # find middle of list\\n dummy = ListNode(0, head)\\n slow, fast = dummy, head\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n midpoint = slow.next\\n slow.next = None\\n list1, list2 = self.sortList(head), self.sortList(midpoint)\\n return self.merge(list1, list2)\\n\\n def merge(self, l1, l2):\\n if not l1 and l2:\\n return l2\\n if l1 and not l2:\\n return l1\\n dummy = ListNode(0)\\n current = dummy\\n while l1 and l2:\\n if l1.val <= l2.val:\\n current.next = l1\\n l1 = l1.next\\n else:\\n current.next = l2\\n l2 = l2.next\\n current = current.next\\n if l1:\\n current.next = l1\\n elif l2:\\n current.next = l2\\n return dummy.next\\n\\n\\n\\n\",\n \"runtime\": \"306\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n (left,right) = self.split(head)\\n temp = right.next\\n right.next = None\\n right = temp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return self.merge(left,right)\\n\\n def split(self,head):\\n tortoise,hare = head,head.next\\n while hare and hare.next:\\n tortoise = tortoise.next\\n hare = hare.next.next\\n return (head, tortoise)\\n\\n def merge(self, a,b):\\n tail = dummy = ListNode()\\n while a and b:\\n if a.val < b.val:\\n tail.next = a\\n a = a.next\\n else:\\n tail.next = b\\n b = b.next\\n tail=tail.next\\n if a:\\n tail.next = a\\n if b:\\n tail.next = b\\n return dummy.next\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"312\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def getMiddle(self,head):\\n fast,slow=head,head\\n while fast.next and fast.next.next:\\n slow=slow.next\\n fast=fast.next.next\\n return slow\\n\\n def mergeTwoLists(self, list1: ListNode, list2: ListNode) -> ListNode:\\n dummy = node = ListNode()\\n\\n while list1 and list2:\\n if list1.val < list2.val:\\n node.next = list1\\n list1 = list1.next\\n else:\\n node.next = list2\\n list2 = list2.next\\n node = node.next\\n\\n node.next = list1 or list2\\n\\n return dummy.next\\n\\n def divide(self,head):\\n if not head.next:\\n return head\\n \\n middle=self.getMiddle(head) \\n right=middle.next\\n middle.next=None\\n left=self.divide(head)\\n right=self.divide(right)\\n\\n return self.mergeTwoLists(left,right)\\n\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return head\\n\\n return self.divide(head)\\n\",\n \"runtime\": \"312\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n def findMiddle(head):\\n # Use slow and fast pointers to find the middle of the linked list\\n slow = head\\n fast = head\\n prev = None\\n \\n while fast and fast.next:\\n prev = slow\\n slow = slow.next\\n fast = fast.next.next\\n \\n # Disconnect the first half from the second half\\n if prev:\\n prev.next = None\\n\\n return slow\\n # Step 1: Split the list into two halves\\n mid = findMiddle(head)\\n \\n # Step 2: Recursively sort both halves\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n def mergeTwoLists(l1, l2):\\n # Create a dummy node to form the sorted list\\n dummy = ListNode()\\n tail = dummy\\n\\n # Merge the two lists\\n while l1 and l2:\\n if l1.val < l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n\\n # Append any remaining elements from either list\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n\\n return dummy.next\\n # Step 3: Merge the sorted halves\\n return mergeTwoLists(left, right)\",\n \"runtime\": \"318\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n def getMiddle(head):\\n slow, fast = head, head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n return slow\\n\\n \\n def merge(left, right):\\n dummy = ListNode(None)\\n temp = dummy\\n while left and right:\\n if left.val < right.val:\\n temp.next = left\\n temp = left\\n left = left.next\\n\\n else:\\n temp.next = right\\n temp = right\\n right = right.next\\n\\n if (left): temp.next = left\\n else: temp.next = right\\n return dummy.next\\n\\n \\n\\n if head is None or head.next is None:\\n return head\\n \\n mid = getMiddle(head)\\n left = head \\n right = mid.next\\n mid.next = None\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left, right)\\n \",\n \"runtime\": \"318\"\n },\n {\n \"code\": \"# merge sort\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n # Helper function to find the middle of the linked list\\n def get_middle(node):\\n slow, fast = node, node\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n\\n # Helper function to merge two sorted linked lists\\n def merge(l1, l2):\\n dummy = ListNode()\\n tail = dummy\\n\\n while l1 and l2:\\n if l1.val < l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n\\n return dummy.next\\n\\n # Get the middle of the list to split it\\n mid = get_middle(head)\\n right = mid.next\\n mid.next = None\\n\\n # Recursively sort both halves\\n left_sorted = self.sortList(head)\\n right_sorted = self.sortList(right)\\n\\n # Merge the sorted halves\\n return merge(left_sorted, right_sorted)\",\n \"runtime\": \"324\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n \\n # Step 1: Find the middle of the list\\n middle = self.findMiddle(head)\\n right = middle.next\\n middle.next = None\\n left = head\\n\\n # Step 2: Recursively sort both halves\\n left = self.sortList(left)\\n right = self.sortList(right)\\n\\n # Step 3: Merge both sorted halves\\n return self.mergeTwoSortedLists(left, right)\\n\\n def mergeTwoSortedLists(self, list1, list2):\\n dummy = ListNode(-1)\\n temp = dummy\\n\\n # Merge the two lists by comparing nodes\\n while list1 and list2:\\n if list1.val <= list2.val:\\n temp.next = list1\\n list1 = list1.next\\n else:\\n temp.next = list2\\n list2 = list2.next\\n temp = temp.next\\n \\n # Attach the remaining part of the lists\\n if list1:\\n temp.next = list1\\n else:\\n temp.next = list2\\n \\n return dummy.next\\n\\n def findMiddle(self, head):\\n # Slow and fast pointer to find the middle of the list\\n slow, fast = head, head\\n while fast and fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n\",\n \"runtime\": \"324\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: return\\n \\n def mid(head):\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow, fast = slow.next, fast.next.next\\n return slow\\n \\n def merge(l, r):\\n dummy = ListNode(0)\\n cur = dummy\\n while l and r:\\n if l.val < r.val:\\n cur.next = l\\n l = l.next\\n else:\\n cur.next = r\\n r = r.next\\n cur = cur.next\\n if l:\\n cur.next = l\\n if r:\\n cur.next = r\\n return dummy.next\\n\\n if not (head and head.next):\\n return head\\n m = mid(head)\\n l, r = head, m.next\\n m.next = None\\n l, r = self.sortList(l), self.sortList(r)\\n return merge(l, r)\\n\",\n \"runtime\": \"330\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: ListNode) -> ListNode:\\n def split(head: ListNode, k: int) -> ListNode:\\n while k > 1 and head:\\n head = head.next\\n k -= 1\\n rest = head.next if head else None\\n if head:\\n head.next = None\\n return rest\\n\\n def merge(l1: ListNode, l2: ListNode) -> tuple:\\n dummy = ListNode(0)\\n tail = dummy\\n\\n while l1 and l2:\\n if l1.val > l2.val:\\n l1, l2 = l2, l1\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n tail.next = l1 if l1 else l2\\n while tail.next:\\n tail = tail.next\\n\\n return dummy.next, tail\\n\\n length = 0\\n curr = head\\n while curr:\\n length += 1\\n curr = curr.next\\n\\n dummy = ListNode(0, head)\\n\\n k = 1\\n while k < length:\\n curr = dummy.next\\n tail = dummy\\n while curr:\\n l = curr\\n r = split(l, k)\\n curr = split(r, k)\\n mergedHead, mergedTail = merge(l, r)\\n tail.next = mergedHead\\n tail = mergedTail\\n k *= 2\\n\\n return dummy.next\",\n \"runtime\": \"330\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n \\n # Step 1: Find the middle of the list\\n def find_middle(head):\\n slow, fast = head, head\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n # Step 2: Split the list into two halves\\n def split(head):\\n middle = find_middle(head)\\n second_half = middle.next\\n middle.next = None\\n return head, second_half\\n \\n # Step 4: Merge two sorted lists\\n def merge(list1, list2):\\n dummy = ListNode(0)\\n tail = dummy\\n while list1 and list2:\\n if list1.val < list2.val:\\n tail.next = list1\\n list1 = list1.next\\n else:\\n tail.next = list2\\n list2 = list2.next\\n tail = tail.next\\n if list1:\\n tail.next = list1\\n if list2:\\n tail.next = list2\\n return dummy.next\\n \\n # Step 3: Recursively sort each half\\n left, right = split(head)\\n left = self.sortList(left)\\n right = self.sortList(right)\\n \\n return merge(left, right)\",\n \"runtime\": \"336\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def sortList(self, head: ListNode) -> ListNode:\\n def split(head: ListNode, k: int) -> ListNode:\\n while k > 1 and head:\\n head = head.next\\n k -= 1\\n rest = head.next if head else None\\n if head:\\n head.next = None\\n return rest\\n\\n def merge(l1: ListNode, l2: ListNode) -> tuple:\\n dummy = ListNode(0)\\n tail = dummy\\n\\n while l1 and l2:\\n if l1.val > l2.val:\\n l1, l2 = l2, l1\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n tail.next = l1 if l1 else l2\\n while tail.next:\\n tail = tail.next\\n\\n return dummy.next, tail\\n\\n length = 0\\n curr = head\\n while curr:\\n length += 1\\n curr = curr.next\\n\\n dummy = ListNode(0, head)\\n\\n k = 1\\n while k < length:\\n curr = dummy.next\\n tail = dummy\\n while curr:\\n l = curr\\n r = split(l, k)\\n curr = split(r, k)\\n mergedHead, mergedTail = merge(l, r)\\n tail.next = mergedHead\\n tail = mergedTail\\n k *= 2\\n\\n return dummy.next\",\n \"runtime\": \"336\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n \\n # Find count\\n ptr = head.next\\n n = 2\\n while ptr.next:\\n n += 1\\n ptr = ptr.next\\n \\n # Break at midpoint\\n ctr = 1\\n ptr = head\\n while ctr != n//2:\\n ctr += 1\\n ptr = ptr.next\\n mid = ptr.next\\n ptr.next = None\\n \\n # Recursively sort left and right\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n \\n # Merge and return\\n newHead = ListNode()\\n newTrack = newHead\\n while left and right:\\n if left.val < right.val:\\n newTrack.next = left\\n left = left.next\\n else:\\n newTrack.next = right\\n right = right.next\\n newTrack = newTrack.next\\n \\n if left:\\n newTrack.next = left\\n elif right:\\n newTrack.next = right\\n \\n return newHead.next\\n \\n \",\n \"runtime\": \"342\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n # Known:\\n\\n # Bubble sort\\n # Insertion Sort\\n # Merge Sort\\n # Selection Sort\\n\\n def divide(head):\\n dummy = ListNode(-1, head)\\n slow = fast = dummy\\n\\n while slow and fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n\\n right = slow.next\\n slow.next = None\\n\\n return head, right\\n\\n def MergeSort(head):\\n\\n if head and head.next:\\n\\n l, r = divide(head)\\n\\n l = MergeSort(l)\\n r = MergeSort(r)\\n\\n # print(l)\\n # print(r)\\n # print(\\\".\\\", head)\\n\\n i = l\\n j = r\\n\\n dummy = ListNode(-1)\\n k = dummy\\n\\n while i and j:\\n if i.val < j.val:\\n k.next = i\\n i = i.next\\n else:\\n k.next = j\\n j = j.next\\n\\n k = k.next\\n\\n if i:\\n k.next = i\\n\\n if j:\\n k.next = j\\n\\n return dummy.next\\n\\n return head\\n\\n return MergeSort(head)\",\n \"runtime\": \"342\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\nclass Solution:\\n def sortList(self, head: ListNode) -> ListNode:\\n # Base case: if head is None or a single node, return head\\n if not head or not head.next:\\n return head\\n\\n # Function to split the list into two halves\\n def split(head: ListNode) -> (ListNode, ListNode):\\n slow, fast = head, head\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n mid = slow.next\\n slow.next = None\\n return head, mid\\n\\n # Function to merge two sorted lists\\n def merge(left: ListNode, right: ListNode) -> ListNode:\\n dummy = ListNode(0)\\n current = dummy\\n while left and right:\\n if left.val < right.val:\\n current.next = left\\n left = left.next\\n else:\\n current.next = right\\n right = right.next\\n current = current.next\\n current.next = left if left else right\\n return dummy.next\\n\\n # Split the list into two halves\\n left, right = split(head)\\n\\n # Recursively sort each half\\n left = self.sortList(left)\\n right = self.sortList(right)\\n\\n # Merge the sorted halves\\n return merge(left, right)\\n\",\n \"runtime\": \"348\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\nclass Solution:\\n def sortList(self, head: ListNode) -> ListNode:\\n if not head or not head.next:\\n return head\\n \\n # Split the linked list into two halves\\n def split(head: ListNode) -> (ListNode, ListNode):\\n slow, fast = head, head\\n prev = None\\n while fast and fast.next:\\n prev = slow\\n slow = slow.next\\n fast = fast.next.next\\n if prev:\\n prev.next = None\\n return head, slow\\n \\n # Merge two sorted linked lists\\n def merge(left: ListNode, right: ListNode) -> ListNode:\\n dummy = ListNode()\\n current = dummy\\n while left and right:\\n if left.val < right.val:\\n current.next = left\\n left = left.next\\n else:\\n current.next = right\\n right = right.next\\n current = current.next\\n if left:\\n current.next = left\\n if right:\\n current.next = right\\n return dummy.next\\n \\n # Recursively sort the linked list\\n left, right = split(head)\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left, right)\\n\",\n \"runtime\": \"348\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n \\n mid = self.getmidnode(head)\\n leftlist = self.sortList(head)\\n rightlist = self.sortList(mid)\\n return self.mergetwolists(leftlist,rightlist)\\n \\n def mergetwolists(self,l1,l2):\\n if not l1:\\n return l2\\n if not l2:\\n return l1\\n \\n while l1 and l2:\\n if l1.val <= l2.val:\\n l1.next = self.mergetwolists(l1.next,l2)\\n return l1\\n else:\\n l2.next = self.mergetwolists(l1,l2.next)\\n return l2\\n \\n def getmidnode(self,head):\\n if not head:\\n return None\\n prev = None\\n slow = head\\n fast = head\\n while fast and fast.next:\\n prev = slow\\n slow = slow.next\\n fast = fast.next.next\\n prev.next = None\\n return slow\",\n \"runtime\": \"354\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def mergeTwoLists(l1: ListNode, l2: ListNode) -> ListNode:\\n dummy = ListNode()\\n tail = dummy\\n \\n while l1 and l2:\\n if l1.val < l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n \\n # Append the remaining nodes from either l1 or l2.\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n \\n return dummy.next\\n\\n def getMiddle(head: ListNode) -> ListNode:\\n slow, fast = head, head\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n\\n\\n # Base case: if the list is empty or contains a single element, it's already sorted.\\n if not head or not head.next:\\n return head\\n\\n # Step 1: Split the list into two halves using the slow-fast pointer technique.\\n mid = getMiddle(head)\\n left = head\\n right = mid.next\\n mid.next = None # Cut the list into two parts\\n \\n # Step 2: Recursively sort both halves.\\n left_sorted = self.sortList(left)\\n right_sorted = self.sortList(right)\\n \\n # Step 3: Merge the two sorted halves.\\n return mergeTwoLists(left_sorted, right_sorted)\",\n \"runtime\": \"354\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, h1: Optional[ListNode], h2: Optional[ListNode]):\\n p = dummy = ListNode()\\n while h1 and h2:\\n if h1.val < h2.val:\\n p.next = h1\\n h1 = h1.next\\n else:\\n p.next = h2\\n h2 = h2.next\\n p = p.next\\n p.next = h1 or h2\\n return dummy.next\\n\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n n = 0\\n p = head\\n while p:\\n p = p.next\\n n += 1\\n dummy = ListNode(0, head)\\n sub_len = 1\\n while sub_len < n:\\n prev, cur = dummy, dummy.next\\n while cur:\\n h1 = cur\\n t = sub_len - 1\\n while t and cur.next:\\n cur = cur.next\\n t -= 1\\n h2 = cur.next\\n cur.next = None\\n cur = h2\\n t = sub_len - 1\\n while t and cur and cur.next:\\n cur = cur.next\\n t -= 1\\n next_part = None\\n if cur:\\n next_part = cur.next\\n cur.next = None\\n prev.next = self.merge(h1, h2)\\n while prev.next:\\n prev = prev.next\\n cur = next_part\\n sub_len <<= 1\\n\\n return dummy.next\",\n \"runtime\": \"360\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n\\n \\\"\\\"\\\"\\n APPROACH 1: Top-down merge sort\\n \\\"\\\"\\\"\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n def checkLL(node: ListNode) -> None:\\n elems = []\\n while node:\\n elems.append(node.val)\\n node = node.next\\n print(elems)\\n\\n def getMidAndEnd(node: ListNode) -> List[ListNode]:\\n # For finding tail, we'll use\\n # fast if size is odd, fastPrev if size is even\\n slow, fast, fastPrev = node, node.next, node\\n\\n while fast and fast.next:\\n slow, fast, fastPrev = slow.next, fast.next.next, fastPrev.next.next\\n\\n mid = slow\\n tail = fast if fast else fastPrev\\n return [mid, tail]\\n\\n def mergeSort(node: Optional[ListNode]) -> Optional[ListNode]:\\n if not node:\\n return None\\n elif not node.next:\\n return node\\n\\n # Step 1: First find middle split point using Slow/fast approach\\n mid, tail = getMidAndEnd(node)\\n\\n # Step 2: Next actually split LLs\\n midNext, mid.next = mid.next, None\\n\\n # print(f'Split: {checkLL(node)} === {checkLL(midNext)}')\\n\\n # Step 3: Recurse..\\n ll1Head = mergeSort(node)\\n ll2Head = mergeSort(midNext)\\n\\n # Step 4: Sort while merging\\n # We'll use tempHead as reference to new temporary list\\n tempHead = ListNode(val=0, next=None)\\n tempPtr = tempHead\\n\\n while ll1Head and ll2Head:\\n if ll1Head.val <= ll2Head.val:\\n tempPtr.next, ll1Head = ll1Head, ll1Head.next\\n else:\\n tempPtr.next, ll2Head = ll2Head, ll2Head.next\\n tempPtr = tempPtr.next\\n # detach node added to temp list from l1/l2\\n tempPtr.next = None\\n\\n # depending on which LL remains, attach it to temp\\n tempPtr.next = ll1Head if ll1Head else ll2Head\\n\\n return tempHead.next\\n\\n return mergeSort(head)\\n\\n\",\n \"runtime\": \"360\"\n },\n {\n \"code\": \"import heapq\\n\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n if head and not head.next:\\n return head\\n\\n mid = head\\n fast = head\\n while fast and fast.next:\\n mid = mid.next\\n fast = fast.next.next\\n \\n node_before_mid = head\\n while node_before_mid and node_before_mid.next != mid:\\n node_before_mid = node_before_mid.next\\n if node_before_mid:\\n node_before_mid.next = None\\n\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n\\n new_head = None\\n prev = None\\n while left and right:\\n if left.val < right.val:\\n if not prev:\\n new_head = left\\n else:\\n prev.next = left\\n prev = left\\n left = left.next\\n else:\\n if not prev:\\n new_head = right\\n else:\\n prev.next = right\\n prev = right\\n right = right.next\\n \\n while left:\\n if not prev:\\n new_head = left\\n else:\\n prev.next = left\\n prev = left\\n left = left.next\\n while right:\\n if not prev:\\n new_head = right\\n else:\\n prev.next = right\\n prev = right\\n right = right.next\\n\\n return new_head\\n\\n \\n\\n\\\"\\\"\\\"\\nif not head:\\n return None\\n\\n nodes = []\\n node = head\\n idx = 0\\n while node:\\n next_node = node.next\\n node.next = None\\n nodes.append((node.val, idx, node))\\n node = next_node\\n idx += 1\\n\\n heapq.heapify(nodes)\\n \\n new_head = nodes[0][2]\\n prev_node = None\\n while nodes:\\n node = heapq.heappop(nodes)[2]\\n if prev_node:\\n prev_node.next = node\\n prev_node = node\\n return new_head\\n\\\"\\\"\\\"\",\n \"runtime\": \"365\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n\\n if not head.next:\\n return head\\n\\n i = 0\\n node = head\\n divider = head\\n while node.next is not None:\\n i += 1\\n node = node.next\\n\\n if i % 2 == 0:\\n divider = divider.next\\n\\n second_head = divider.next\\n divider.next = None\\n\\n sorted_first_half = self.sortList(head)\\n sorted_second_half = self.sortList(second_head)\\n\\n new_head = None\\n if sorted_first_half.val < sorted_second_half.val:\\n new_head = sorted_first_half\\n sorted_first_half = sorted_first_half.next\\n else:\\n new_head = sorted_second_half\\n sorted_second_half = sorted_second_half.next\\n node = new_head\\n\\n while not (sorted_first_half is None and sorted_second_half is None):\\n if sorted_first_half and (sorted_second_half is None or sorted_first_half.val < sorted_second_half.val):\\n node.next = sorted_first_half\\n sorted_first_half = sorted_first_half.next\\n else:\\n node.next = sorted_second_half\\n sorted_second_half = sorted_second_half.next\\n\\n node = node.next\\n\\n return new_head\\n\",\n \"runtime\": \"365\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or head.next is None:\\n return head\\n\\n mid = divide(head)\\n print(mid.val)\\n\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n\\n return merge(left, right)\\n\\n\\ndef merge(head1: Optional[ListNode], head2: Optional[ListNode]) -> Optional[ListNode]:\\n new_head = ListNode(val=-1)\\n tail = new_head\\n\\n while head1 and head2:\\n if head1.val <= head2.val:\\n tail.next = head1\\n head1 = head1.next\\n else:\\n tail.next = head2\\n head2 = head2.next\\n tail = tail.next\\n\\n tail.next = head1 if head1 else head2\\n\\n return new_head.next\\n\\n\\ndef divide(head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return\\n\\n prev_slow, slow, fast = head, head, head\\n\\n while fast and fast.next:\\n fast = fast.next.next\\n prev_slow = slow\\n slow = slow.next\\n\\n prev_slow.next = None\\n # print(head.val, slow.val)\\n return slow\\n\\n \\n \",\n \"runtime\": \"371\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # O(1) space solution\\n if not head or not head.next:\\n return head\\n \\n def size(head):\\n curr = head\\n length = 0\\n while curr:\\n length +=1\\n curr = curr.next\\n return length\\n\\n def split(node,size):\\n # Split the list after 'size' nodes\\n for _ in range(size-1):\\n if not node:\\n return None\\n node = node.next\\n if not node:\\n return None\\n second = node.next\\n node.next = None\\n return second\\n\\n def merge(left,right):\\n dummy = ListNode(0)\\n cur = dummy\\n while left and right:\\n if left.val < right.val:\\n cur.next = left\\n left = left.next\\n else:\\n cur.next = right\\n right = right.next\\n cur = cur.next\\n \\n #adding remaining node\\n cur.next = left if left else right\\n return dummy.next\\n\\n\\n dummy = ListNode(0)\\n dummy.next = head\\n lenght = size(head)\\n size = 1\\n\\n while size < lenght:\\n curr = dummy.next\\n tail = dummy\\n while curr:\\n left = curr\\n right = split(left,size)\\n curr = split(right,size)\\n tail.next = merge(left,right)\\n while tail.next:\\n tail = tail.next\\n size *= 2\\n\\n return dummy.next\",\n \"runtime\": \"371\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n res = []\\n curr = head\\n while curr:\\n res.append(curr.val)\\n curr = curr.next\\n \\n def merge_sort(list1):\\n n = len(list1)\\n\\n if n <= 1:\\n return list1\\n mid = n // 2\\n left = merge_sort(list1[:mid])\\n right = merge_sort(list1[mid:])\\n return merge(left, right)\\n def merge(left, right):\\n arr = []\\n i = j = 0\\n while i < len(left) and j < len(right):\\n if left[i] < right[j]:\\n arr.append(left[i])\\n i += 1\\n else:\\n arr.append(right[j])\\n j += 1\\n arr.extend(left[i:])\\n arr.extend(right[j:])\\n\\n return arr\\n\\n sort = merge_sort(res)\\n\\n dummy = ListNode()\\n cur = dummy\\n\\n for val in sort:\\n cur.next = ListNode(val)\\n cur = cur.next\\n return dummy.next\",\n \"runtime\": \"377\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def split_list(head):\\n fast=head\\n slow=head\\n while fast.next and fast.next.next:\\n fast=fast.next.next\\n slow=slow.next\\n tmp=slow.next\\n slow.next=None\\n return head, tmp\\n \\n def merge_sort(head):\\n if not head or not head.next:\\n return head\\n list1, list2 = split_list(head)\\n list1=merge_sort(list1)\\n list2=merge_sort(list2)\\n #print(list1, list2)\\n dummy=ListNode(-2)\\n tmp=dummy\\n while list1!=None and list2!=None:\\n if list1.val <= list2.val:\\n tmp.next=list1\\n list1 = list1.next\\n else:\\n tmp.next=list2\\n list2 = list2.next\\n tmp = tmp.next\\n while list1:\\n tmp.next=list1\\n list1 = list1.next\\n tmp = tmp.next\\n while list2:\\n tmp.next=list2\\n list2 = list2.next\\n tmp = tmp.next\\n return dummy.next\\n\\n head=merge_sort(head)\\n return head\\n\\n \",\n \"runtime\": \"377\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def getMidPt(self, head):\\n fast = head\\n slow = head\\n while fast.next != None and fast.next.next !=None:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def mergeSort(self, left_list, right_list):\\n header = None\\n if left_list == None:\\n return right_list\\n if right_list == None:\\n return left_list\\n if left_list.val < right_list.val:\\n left_list.next = self.mergeSort(left_list.next, right_list)\\n header = left_list\\n else:\\n right_list.next = self.mergeSort(left_list, right_list.next)\\n header = right_list\\n return header\\n\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head == None or head.next == None:\\n return head\\n \\n \\n midpt = self.getMidPt(head)\\n left_list = head\\n right_list = midpt.next\\n midpt.next = None\\n\\n left_sorted = self.sortList(left_list)\\n right_sorted = self.sortList(right_list)\\n\\n return self.mergeSort(left_sorted, right_sorted)\\n\\n\\n \\n\",\n \"runtime\": \"383\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n # Base Conditions\\n if head == None:\\n return None\\n\\n list_len = 0\\n count_elem = head\\n\\n while count_elem != None:\\n list_len += 1\\n count_elem = count_elem.next\\n\\n # Call recursive function with lenght term, this way we don't have to get the length each time\\n return self.sortListRec(head, list_len)\\n\\n def sortListRec(self, head: Optional[ListNode], length: int) -> Optional[ListNode]:\\n\\n if length < 2:\\n head.next = None\\n return head\\n \\n # Swap elements if necessary\\n if length == 2:\\n if head.val > head.next.val:\\n\\n temp = head\\n head = head.next\\n head.next = temp\\n \\n head.next.next = None\\n return head\\n\\n half_len = length // 2\\n \\n middle_elem = head\\n\\n for i in range(half_len):\\n middle_elem = middle_elem.next\\n\\n sorted_left = self.sortListRec(head, half_len)\\n sorted_right = self.sortListRec(middle_elem, length - half_len)\\n\\n first = ListNode(0, None)\\n tmp = first\\n\\n while sorted_left != None or sorted_right != None:\\n if sorted_left == None:\\n # print(sorted_right.val)\\n tmp.next = sorted_right\\n sorted_right = sorted_right.next\\n elif sorted_right == None:\\n #print(sorted_left.val)\\n tmp.next = sorted_left\\n sorted_left = sorted_left.next\\n\\n elif sorted_left.val <= sorted_right.val:\\n #print(sorted_left.val)\\n tmp.next = sorted_left\\n sorted_left = sorted_left.next\\n else:\\n #print(sorted_right.val)\\n tmp.next = sorted_right\\n sorted_right = sorted_right.next\\n tmp = tmp.next\\n\\n tmp.next = None\\n\\n return first.next\\n\\n\\n \",\n \"runtime\": \"383\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n curr = head\\n nodes = []\\n while curr:\\n nodes.append(curr)\\n curr = curr.next\\n def merge(arr1, arr2):\\n index1, index2 = 0, 0\\n merged_array = []\\n while index1 < len(arr1) and index2 < len(arr2):\\n if arr1[index1].val < arr2[index2].val:\\n merged_array.append(arr1[index1])\\n index1 += 1\\n else:\\n merged_array.append(arr2[index2])\\n index2 += 1\\n if index1 == len(arr1):\\n while index2 < len(arr2):\\n merged_array.append(arr2[index2])\\n index2 += 1\\n elif index2 == len(arr2):\\n while index1 < len(arr1):\\n merged_array.append(arr1[index1])\\n index1 += 1\\n return merged_array\\n\\n def mergesort(arr):\\n if len(arr) == 1:\\n return arr\\n left = mergesort(arr[:len(arr) // 2])\\n right = mergesort(arr[len(arr) // 2:])\\n return merge(left, right)\\n \\n nodes = mergesort(nodes)\\n head = nodes[0]\\n for i in range(len(nodes) - 1):\\n nodes[i].next = nodes[i + 1]\\n nodes[-1].next = None\\n return head\",\n \"runtime\": \"389\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def findmiddle(self, head):\\n if head is None or head.next is None:\\n return head\\n slow = head\\n fast = head.next\\n while fast!=None and fast.next!=None:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n\\n def merge(self, head1, head2):\\n t1= head1\\n t2 = head2\\n dnode = ListNode(-1)\\n temp = dnode\\n while t1!=None and t2!=None:\\n if t1.val > t2.val:\\n temp.next = t2\\n t2= t2.next\\n else:\\n temp.next = t1\\n t1= t1.next\\n temp = temp.next\\n if t1!=None:\\n temp.next = t1\\n if t2!=None: \\n temp.next = t2\\n\\n return dnode.next\\n\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head == None or head.next == None:\\n return head\\n left = head\\n middle = self.findmiddle(head)\\n right = middle.next\\n middle.next = None\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return self.merge(left, right)\\n\",\n \"runtime\": \"389\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def mid(head):\\n slow=head\\n fast=head.next\\n while (fast!=None) and (fast.next!=None):\\n slow=slow.next\\n fast=fast.next.next\\n return slow\\n def merge(first, second):\\n t1=first\\n t2=second\\n dnode=ListNode(-1)\\n temp=dnode\\n while (t1 is not None) and (t2 is not None):\\n if t1.val<t2.val:\\n temp.next=t1\\n temp=t1\\n t1=t1.next\\n else:\\n temp.next=t2\\n temp=t2\\n t2=t2.next\\n if t1 is not None:\\n temp.next=t1\\n if t2 is not None:\\n temp.next=t2\\n return dnode.next\\n\\n if head==None or head.next==None:\\n return head\\n middle=mid(head)\\n left=head\\n right=middle.next\\n middle.next=None\\n left=self.sortList(left)\\n right=self.sortList(right)\\n return merge(left,right)\",\n \"runtime\": \"395\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n curr = head\\n nodes = []\\n while curr:\\n nodes.append(curr)\\n curr = curr.next\\n def merge(arr1, arr2):\\n index1, index2 = 0, 0\\n merged_array = []\\n while index1 < len(arr1) and index2 < len(arr2):\\n if arr1[index1].val < arr2[index2].val:\\n merged_array.append(arr1[index1])\\n index1 += 1\\n else:\\n merged_array.append(arr2[index2])\\n index2 += 1\\n if index1 == len(arr1):\\n while index2 < len(arr2):\\n merged_array.append(arr2[index2])\\n index2 += 1\\n elif index2 == len(arr2):\\n while index1 < len(arr1):\\n merged_array.append(arr1[index1])\\n index1 += 1\\n return merged_array\\n\\n def mergesort(arr):\\n if len(arr) == 1:\\n return arr\\n left = mergesort(arr[:len(arr) // 2])\\n right = mergesort(arr[len(arr) // 2:])\\n return merge(left, right)\\n \\n nodes = mergesort(nodes)\\n head = nodes[0]\\n for i in range(len(nodes) - 1):\\n nodes[i].next = nodes[i + 1]\\n nodes[-1].next = None\\n return head\",\n \"runtime\": \"395\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n def findMiddle(head):\\n slow = head\\n fast = head.next\\n while fast != None and fast.next != None:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n\\n def merge2(lefthead,righthead):\\n temp1 = lefthead\\n temp2 = righthead\\n dummy = ListNode(-1)\\n temp = dummy\\n while temp1 != None and temp2 != None:\\n\\n if temp1.val <= temp2.val:\\n temp.next = temp1\\n temp1 = temp1.next\\n temp = temp.next\\n else:\\n temp.next = temp2\\n temp2 = temp2.next\\n temp = temp.next\\n\\n if temp1 == None:\\n temp.next = temp2\\n if temp2 == None:\\n temp.next = temp1\\n \\n return dummy.next\\n\\n def mergeSort(head):\\n if head == None or head.next == None:\\n return head\\n middle = findMiddle(head)\\n lefthead = head\\n righthead = middle.next\\n middle.next = None\\n lefthead = mergeSort(lefthead)\\n righthead = mergeSort(righthead)\\n return (merge2(lefthead,righthead))\\n \\n\\n return (mergeSort(head))\\n\",\n \"runtime\": \"401\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n dummy = ListNode(0, head)\\n n = self.count(head)\\n intv = 1\\n\\n while intv < n:\\n cur_start = dummy.next\\n tail = dummy\\n while cur_start:\\n l2 = self.split(cur_start, intv)\\n rest = self.split(l2, intv)\\n tail.next = self.merge(cur_start, l2)\\n cur_start = rest\\n\\n while tail.next:\\n tail = tail.next\\n \\n intv *= 2\\n \\n return dummy.next\\n \\n def count(self, head):\\n cur = head\\n n = 0\\n while cur:\\n n += 1\\n cur = cur.next\\n \\n return n\\n \\n def split(self, head, k):\\n pre = None\\n cur = head\\n\\n for _ in range(k):\\n if not cur:\\n break\\n pre = cur\\n cur = cur.next\\n \\n if pre:\\n pre.next = None\\n return cur\\n \\n def merge(self, l1, l2):\\n if not l1 and not l2:\\n return None\\n \\n if not l1 or not l2:\\n return l1 if l1 else l2\\n \\n dummy = ListNode()\\n cur = dummy\\n while l1 and l2:\\n if l1.val < l2.val:\\n cur.next = l1\\n l1 = l1.next\\n else:\\n cur.next = l2\\n l2 = l2.next\\n \\n cur = cur.next\\n \\n cur.next = l1 if l1 else l2\\n return dummy.next\\n \",\n \"runtime\": \"401\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def merge(head1, head2):\\n resultHead = ListNode(0)\\n cur = resultHead\\n while head1 != None or head2 != None:\\n if head1 == None:\\n cur.next = head2\\n head2 = None\\n elif head2 == None:\\n cur.next = head1\\n head1 = None\\n else:\\n if head1.val < head2.val:\\n cur.next = head1\\n cur = head1\\n head1 = head1.next \\n else:\\n cur.next = head2\\n cur = head2\\n head2 = head2.next\\n \\n return resultHead.next\\n\\n\\n def findOneBeforeMiddle(head):\\n fast = head\\n slow = head\\n prev = None\\n while fast and fast.next:\\n prev = slow\\n\\n fast = fast.next.next\\n slow = slow.next\\n \\n return prev\\n \\n if not head or not head.next:\\n return head\\n\\n prev = findOneBeforeMiddle(head)\\n if prev != None:\\n middle = prev.next\\n prev.next = None\\n\\n return merge(self.sortList(head), self.sortList(middle))\\n \\n\\n \",\n \"runtime\": \"407\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n # convert linked list to list\\n res = []\\n current = head\\n\\n while current is not None:\\n res.append(current.val)\\n current = current.next\\n\\n # using merge sort \\n def mergesort(res):\\n\\n if len(res) <= 1:\\n return res\\n \\n middle = len(res) // 2\\n left_half = res[:middle]\\n right_half = res[middle:]\\n\\n left_half = mergesort(left_half)\\n right_half = mergesort(right_half)\\n\\n left = 0\\n right = 0\\n check_pointer = 0\\n\\n while left < len(left_half) and right < len(right_half):\\n\\n if left_half[left] < right_half[right]:\\n res[check_pointer] = left_half[left]\\n left += 1\\n check_pointer += 1\\n else:\\n res[check_pointer] = right_half[right]\\n right += 1\\n check_pointer += 1\\n \\n while left < len(left_half):\\n res[check_pointer] = left_half[left]\\n left += 1\\n check_pointer += 1\\n \\n while right < len(right_half):\\n res[check_pointer] = right_half[right]\\n right += 1\\n check_pointer += 1\\n \\n return res\\n \\n # convert list to linked list \\n dummy = ListNode()\\n current = dummy\\n\\n for i in mergesort(res): # direct use the function\\n current.next = ListNode(i)\\n current = current.next\\n \\n return dummy.next\\n\\n \\n \\n\\n\\n\\n \",\n \"runtime\": \"407\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n # def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def append(self, new_value):\\n\\n # Allocate new node\\n new_node = Node(new_value)\\n\\n # if head is None, initialize it to new node\\n if self.head is None:\\n self.head = new_node\\n return\\n curr_node = self.head\\n while curr_node.next is not None:\\n curr_node = curr_node.next\\n\\n # Append the new node at the end\\n # of the linked list\\n curr_node.next = new_node\\n\\n def sortedMerge(self, a, b):\\n result = None\\n\\n # Base cases\\n if a == None:\\n return b\\n if b == None:\\n return a\\n\\n # pick either a or b and recur..\\n if a.val <= b.val:\\n result = a\\n result.next = self.sortedMerge(a.next, b)\\n else:\\n result = b\\n result.next = self.sortedMerge(a, b.next)\\n return result\\n\\n def sortList(self, h: Optional[ListNode]) -> Optional[ListNode]:\\n\\n # Base case if head is None\\n if h == None or h.next == None:\\n return h\\n\\n # get the middle of the list\\n middle = self.getMiddle(h)\\n nexttomiddle = middle.next\\n\\n # set the next of middle node to None\\n middle.next = None\\n\\n # Apply mergeSort on left list\\n left = self.sortList(h)\\n\\n # Apply mergeSort on right list\\n right = self.sortList(nexttomiddle)\\n\\n # Merge the left and right lists\\n sortedlist = self.sortedMerge(left, right)\\n return sortedlist\\n\\n # Utility function to get the middle\\n # of the linked list\\n def getMiddle(self, head):\\n if (head == None):\\n return head\\n\\n slow = head\\n fast = head\\n\\n while (fast.next != None and\\n fast.next.next != None):\\n slow = slow.next\\n fast = fast.next.next\\n\\n return slow\",\n \"runtime\": \"413\"\n },\n {\n \"code\": \"# # Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\\"\\\"\\\"\\n Merge sort is an obvious solution. There is no need to copy the lists though. Can just maintain pointers\\n \\\"\\\"\\\"\\n\\n def sort_list_helper(head: Optional[ListNode], length_to_sort: int) -> Optional[ListNode]:\\n if length_to_sort <= 1:\\n return head\\n \\n middle = (length_to_sort // 2)\\n left, right = head, head\\n\\n right_idx = 0\\n while right_idx < middle:\\n right = right.next\\n right_idx += 1\\n\\n left_ptr = left\\n while left_ptr.next != right:\\n left_ptr = left_ptr.next\\n left_ptr.next = None\\n\\n sorted_left = sort_list_helper(left, middle)\\n sorted_right = sort_list_helper(right, length_to_sort - middle)\\n left_idx, right_idx = 0, 0\\n\\n if sorted_left.val <= sorted_right.val:\\n curr = sorted_left\\n sorted_left = sorted_left.next\\n else:\\n curr = sorted_right\\n sorted_right = sorted_right.next\\n head = curr\\n\\n while sorted_left != None or sorted_right != None:\\n if sorted_right == None or (sorted_left and sorted_left.val <= sorted_right.val):\\n curr.next = sorted_left\\n curr = curr.next\\n sorted_left = sorted_left.next\\n else:\\n curr.next = sorted_right\\n curr = curr.next\\n sorted_right = sorted_right.next\\n\\n return head\\n\\n length = self.list_length(head) \\n return sort_list_helper(head, length)\\n \\n def list_length(self, head: ListNode):\\n ptr = head\\n length = 0\\n while ptr:\\n length += 1\\n ptr = ptr.next\\n return length\\n \\n \",\n \"runtime\": \"413\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n list=[]\\n while head:\\n list.append(head.val)\\n head=head.next\\n if len(list)==0:\\n return\\n def sort(list):\\n if len(list)>1:\\n mid=len(list)//2\\n left_array=list[:mid]\\n right_array=list[mid:]\\n \\n sort(left_array)\\n sort(right_array)\\n i=j=k=0\\n while i<len(left_array) and j<len(right_array):\\n if left_array[i]<right_array[j]:\\n list[k]=left_array[i]\\n i=i+1\\n else:\\n list[k]=right_array[j]\\n j=j+1\\n k=k+1\\n while i<len(left_array):\\n list[k]=left_array[i]\\n i=i+1\\n k=k+1\\n while j<len(right_array):\\n list[k]=right_array[j]\\n j=j+1\\n k=k+1\\n\\n sort(list)\\n head=ListNode(list[0])\\n head1=head\\n for i in range(1,len(list)):\\n head.next=ListNode(list[i])\\n head=head.next\\n return head1\\n \\n\",\n \"runtime\": \"419\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n return self.mergesort(head)\\n\\n def get_length(self, head):\\n length = 0\\n while head:\\n length += 1\\n head = head.next\\n return length \\n\\n def mergesort(self, head):\\n length = self.get_length(head)\\n if length <= 1:\\n return head\\n\\n prev = None \\n right_head = head\\n for _ in range(length // 2):\\n prev = right_head\\n right_head = right_head.next\\n if prev:\\n prev.next = None\\n\\n left_head = head\\n left_head = self.mergesort(left_head)\\n right_head = self.mergesort(right_head)\\n return self.merge(left_head, right_head)\\n \\n\\n def merge(self, left_half, right_half):\\n dummy = ListNode()\\n prev = dummy\\n while left_half or right_half:\\n if not right_half or (left_half and left_half.val < right_half.val):\\n prev.next = left_half\\n prev = left_half\\n left_half = left_half.next\\n else:\\n prev.next = right_half\\n prev = right_half\\n right_half = right_half.next\\n return dummy.next\",\n \"runtime\": \"419\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n mergeSize = 1\\n\\n length, current = 0, head\\n while current != None:\\n length += 1\\n current = current.next\\n\\n def merge(current):\\n nonlocal mergeSize\\n left, right = current.next, current.next\\n for _ in range(mergeSize):\\n if not right: break\\n right = right.next\\n\\n rightStart, rightCount = right, 0\\n\\n while (left != rightStart) or (rightCount < mergeSize and right != None):\\n if (rightCount >= mergeSize or right == None) or (left != rightStart and left.val <= right.val):\\n current.next = left\\n left, current = left.next, current.next\\n else:\\n current.next = right\\n right, current, rightCount = right.next, current.next, rightCount + 1\\n\\n current.next = right\\n return current\\n\\n dummyHead = ListNode(0)\\n dummyHead.next = head\\n\\n while mergeSize < length:\\n current = dummyHead\\n while current.next:\\n current = merge(current)\\n mergeSize *= 2\\n\\n return dummyHead.next\",\n \"runtime\": \"425\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n length = 0\\n cur = head\\n while cur:\\n length += 1\\n cur = cur.next\\n \\n if length <= 1:\\n return head\\n middle_node = self.get_middle_node(head) \\n print(f\\\"middle node: {middle_node.val}\\\")\\n cur = middle_node.next\\n middle_node.next = None\\n middle_node = cur\\n\\n left = self.sortList(head)\\n right = self.sortList(middle_node)\\n\\n return self.merge(left, right)\\n\\n\\n def merge(self, left, right):\\n if not left:\\n return right\\n if not right:\\n return left\\n if left.val < right.val:\\n left.next = self.merge(left.next, right)\\n return left\\n else:\\n right.next = self.merge(left, right.next)\\n return right\\n\\n def get_middle_node(self, head):\\n slow = fast = head\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n\\n\",\n \"runtime\": \"425\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head == None or head.next == None:\\n return head\\n\\n def half(h1):\\n s = h1\\n f = h1.next\\n while f != None and f.next != None:\\n s = s.next\\n f = f.next.next\\n lpart = h1\\n rpart = s.next\\n s.next = None\\n return lpart , rpart\\n\\n def merge(left , right):\\n ret = None\\n res = None\\n p = left\\n q = right\\n while p != None and q != None:\\n if p.val <= q.val:\\n if res == None:\\n ret = p\\n res = p\\n else:\\n res.next = p\\n res = res.next\\n p = p.next\\n else:\\n if res == None:\\n ret = q\\n res = q\\n else:\\n res.next = q\\n res = res.next\\n q = q.next\\n\\n while p != None:\\n res.next = p\\n p = p.next\\n res = res.next\\n \\n while q != None:\\n res.next = q\\n q = q.next\\n res = res.next\\n\\n return ret\\n\\n def mergesort(root):\\n if root == None or root.next == None:\\n return root\\n l , r = half(root)\\n leftHead = mergesort(l)\\n rightHead= mergesort(r)\\n return merge(leftHead , rightHead)\\n \\n return mergesort(head)\\n\",\n \"runtime\": \"431\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n n = 0\\n curr = head\\n while curr != None:\\n curr = curr.next\\n n += 1\\n step = 1\\n updateHead = True\\n while step < n:\\n l1 = head\\n r1 = self.findEnd(l1, step)\\n l2 = r1.next\\n r2 = self.findEnd(l2, step)\\n nextL1 = r2.next\\n r1.next = None\\n r2.next = None\\n (start, end) = self.merge(l1,r1,l2,r2)\\n head = start\\n lastEnd = end\\n while nextL1 != None:\\n l1 = nextL1\\n r1 = self.findEnd(l1, step)\\n l2 = r1.next\\n if l2 == None:\\n lastEnd.next = l1\\n break\\n r2 = self.findEnd(l2, step)\\n nextL1 = r2.next\\n r1.next = None\\n r2.next = None\\n (start, end) = self.merge(l1,r1,l2,r2)\\n lastEnd.next = start\\n lastEnd = end\\n step *= 2\\n return head\\n\\n return head\\n \\n def findEnd(self, start, k):\\n end = start\\n while end.next != None:\\n k -= 1\\n if k != 0:\\n end = end.next\\n else:\\n break\\n return end\\n \\n def merge(self, l1, r1, l2, r2):\\n if l1.val > l2.val:\\n head = l2\\n l2 = l2.next\\n else:\\n head = l1\\n l1 = l1.next\\n curr = head\\n while l1 != None and l2 != None:\\n if l1.val > l2.val:\\n curr.next = l2\\n l2 = l2.next\\n else:\\n curr.next = l1\\n l1 = l1.next\\n curr = curr.next\\n if l1 == None and l2 != None:\\n curr.next = l2\\n return (head, r2)\\n else:\\n curr.next = l1\\n return (head, r1)\\n \\n \",\n \"runtime\": \"431\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n return self.helpSort(head)[0]\\n\\n def getRandomPivot(self, head):\\n length = 1\\n cur = head\\n while cur.next:\\n cur = cur.next\\n length += 1\\n randind = random.randrange(length)\\n cur = head\\n for _ in range(randind):\\n cur = cur.next\\n return cur.val\\n\\n def helpSort(self, head): #head, tail\\n if not head or not head.next:\\n return head, head\\n \\n ahead = ListNode()\\n atail = ahead\\n bhead = ListNode()\\n btail = bhead\\n chead = ListNode()\\n ctail = chead\\n\\n pivot = self.getRandomPivot(head)\\n\\n cur = head\\n while cur:\\n if cur.val < pivot:\\n atail.next = cur\\n atail = atail.next\\n elif cur.val == pivot:\\n btail.next = cur\\n btail = btail.next\\n else:\\n ctail.next = cur\\n ctail = ctail.next\\n cur = cur.next\\n atail.next = None\\n btail.next = None\\n ctail.next = None\\n ahead = ahead.next\\n bhead = bhead.next\\n chead = chead.next\\n\\n x, xtail = self.helpSort(ahead)\\n y, ytail = self.helpSort(chead)\\n\\n if x and bhead:\\n xtail.next = bhead\\n if bhead and y:\\n btail.next = y\\n rethead = None\\n rettail = None\\n for parthead, parttail in [(y, ytail), (bhead, btail), (x, xtail)]:\\n if parthead:\\n rethead = parthead\\n if not rettail:\\n rettail = parttail\\n return rethead, rettail\",\n \"runtime\": \"437\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # merge sort\\n # devide and conqur\\n # find mid \\n # 4 2 | 1 3\\n # 4 | 2, 1 | 3\\n # 2 4 1 3 \\n # 1 2 3 4\\n # nlogn time and space n/2+n/4....+1=n\\n \\n\\n if head==None or head.next==None:\\n return head\\n\\n #at lead two elements\\n left,right=self.findmid(head)\\n \\n #merge sort: returh the new head\\n left=self.sortList(left)\\n right=self.sortList(right)\\n\\n new_head=self.merge(left,right)\\n return new_head\\n\\n def findmid(self,head):\\n # 1 2 3 \\n # s\\n # f\\n # f.next!=None f.next.next!=None\\n # return head, s.next\\n\\n s=head\\n f=head\\n\\n while f.next!=None and f.next.next!=None:\\n s=s.next\\n f=f.next.next\\n\\n right=s.next\\n s.next=None\\n \\n left=head\\n return left,right\\n\\n \\n def merge(self,list1,list2):\\n #base case: list1==None and list2==None \\n if list1==None:\\n return list2\\n if list2==None:\\n return list1\\n\\n dummy=ListNode(float(\\\"inf\\\"))\\n cur=dummy\\n point1=list1\\n point2=list2\\n\\n while point1!=None and point2!=None:\\n if point1.val<=point2.val:\\n cur.next=point1\\n point1=point1.next\\n cur=cur.next\\n else:\\n cur.next=point2\\n point2=point2.next\\n cur=cur.next\\n\\n if point1!=None:\\n cur.next=point1\\n if point2!=None:\\n cur.next=point2\\n\\n return dummy.next\\n \\n \\n \",\n \"runtime\": \"437\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom typing import Tuple\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return None\\n if head.next is None:\\n return head\\n \\n dummy1 = ListNode()\\n l1 = dummy1\\n dummy2 = ListNode()\\n l2 = dummy2\\n\\n p = head\\n first = 1\\n while p:\\n q = p.next\\n if first:\\n l1.next = p\\n l1 = p\\n else:\\n l2.next = p\\n l2 = p\\n p = q\\n first = 1 - first\\n\\n # def prin(h):\\n # p = []\\n # while h:\\n # p.append(h.val)\\n # h = h.next\\n # print(p)\\n\\n # prin(dummy1.next)\\n # prin(dummy2.next)\\n\\n l1.next = l2.next = None\\n\\n dummy1 = self.sortList(dummy1.next)\\n dummy2 = self.sortList(dummy2.next)\\n\\n # prin(dummy1)\\n # prin(dummy2)\\n\\n dummy = ListNode()\\n last = dummy\\n\\n p1 = dummy1\\n p2 = dummy2\\n\\n while p1 and p2:\\n if p1.val < p2.val:\\n last.next = p1\\n last = p1\\n p1 = p1.next\\n else:\\n last.next = p2\\n last = p2\\n p2 = p2.next\\n \\n if p1:\\n last.next = p1\\n if p2:\\n last.next = p2\\n \\n return dummy.next\\n\\n \\n\\n def sortList1(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n def sort(head: Optional[ListNode]) -> Tuple[Optional[ListNode], Optional[ListNode]]:\\n if head is None:\\n return (None, None)\\n dummy_le = ListNode()\\n dummy_gt = ListNode()\\n le = dummy_le\\n gt = dummy_gt\\n\\n first = head\\n p = head.next\\n\\n while p:\\n if p.val <= first.val:\\n le.next = p\\n le = p\\n else:\\n gt.next =p\\n gt = p\\n p = p.next\\n \\n le.next = None\\n gt.next = None\\n first.next = None\\n\\n (le_head, le_tail) = sort(dummy_le.next)\\n (gt_head, gt_tail) = sort(dummy_gt.next)\\n\\n if le_head is not None:\\n le_tail.next = first\\n first.next = gt_head\\n if gt_tail is not None:\\n return (le_head, gt_tail)\\n else:\\n return (le_head, first)\\n else:\\n first.next = gt_head\\n if gt_tail is not None:\\n return (first, gt_tail)\\n else:\\n return (first, first)\\n \\n return sort(head)[0]\\n \",\n \"runtime\": \"443\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n return self.helpSort(head)[0]\\n\\n def getRandomPivot(self, head):\\n length = 1\\n cur = head\\n while cur.next:\\n cur = cur.next\\n length += 1\\n randind = random.randrange(length)\\n cur = head\\n for _ in range(randind):\\n cur = cur.next\\n return cur.val\\n\\n def helpSort(self, head): #head, tail\\n if not head or not head.next:\\n return head, head\\n \\n ahead = ListNode()\\n atail = ahead\\n bhead = ListNode()\\n btail = bhead\\n chead = ListNode()\\n ctail = chead\\n\\n pivot = self.getRandomPivot(head)\\n\\n cur = head\\n while cur:\\n if cur.val < pivot:\\n atail.next = cur\\n atail = atail.next\\n elif cur.val == pivot:\\n btail.next = cur\\n btail = btail.next\\n else:\\n ctail.next = cur\\n ctail = ctail.next\\n cur = cur.next\\n atail.next = None\\n btail.next = None\\n ctail.next = None\\n ahead = ahead.next\\n bhead = bhead.next\\n chead = chead.next\\n\\n x, xtail = self.helpSort(ahead)\\n y, ytail = self.helpSort(chead)\\n\\n if x and bhead:\\n xtail.next = bhead\\n if bhead and y:\\n btail.next = y\\n rethead = None\\n rettail = None\\n for parthead, parttail in [(x, xtail), (bhead, btail), (y, ytail)]:\\n if parthead:\\n rettail = parttail\\n if not rethead:\\n rethead = parthead\\n return rethead, rettail\",\n \"runtime\": \"443\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n return self.helpSort(head)[0]\\n\\n def getRandomPivot(self, head):\\n length = 1\\n cur = head\\n while cur.next:\\n cur = cur.next\\n length += 1\\n randind = random.randrange(length)\\n cur = head\\n for _ in range(randind):\\n cur = cur.next\\n return cur.val\\n\\n def helpSort(self, head): #head, tail\\n if not head or not head.next:\\n return head, head\\n \\n ahead = ListNode()\\n atail = ahead\\n bhead = ListNode()\\n btail = bhead\\n chead = ListNode()\\n ctail = chead\\n\\n pivot = self.getRandomPivot(head)\\n\\n cur = head\\n while cur:\\n if cur.val < pivot:\\n atail.next = cur\\n atail = atail.next\\n elif cur.val == pivot:\\n btail.next = cur\\n btail = btail.next\\n else:\\n ctail.next = cur\\n ctail = ctail.next\\n cur = cur.next\\n atail.next = None\\n btail.next = None\\n ctail.next = None\\n ahead = ahead.next\\n bhead = bhead.next\\n chead = chead.next\\n\\n x, xtail = self.helpSort(ahead)\\n y, ytail = self.helpSort(chead)\\n\\n if x and bhead:\\n xtail.next = bhead\\n if bhead and y:\\n btail.next = y\\n rethead = None\\n rettail = None\\n for parthead, parttail in [(y, ytail), (bhead, btail), (x, xtail)]:\\n if parthead:\\n rethead = parthead\\n if not rettail:\\n rettail = parttail\\n return rethead, rettail\",\n \"runtime\": \"460\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is not None:\\n print(head.val)\\n total_num = 0\\n left_head = head\\n if head is None:\\n return None\\n while head is not None:\\n total_num += 1\\n head = head.next\\n \\n if total_num >= 2:\\n half_num = total_num // 2\\n \\n right_head = left_head\\n for i in range(half_num-1):\\n right_head = right_head.next\\n \\n current_head = right_head\\n right_head = current_head.next\\n current_head.next = None\\n else:\\n return left_head\\n \\n \\n if right_head is not None:\\n print('right',right_head.val)\\n\\n left_sorted = self.sortList(left_head)\\n right_sorted = self.sortList(right_head)\\n\\n head = None\\n \\n while left_sorted is not None and right_sorted is not None:\\n if left_sorted.val <= right_sorted.val:\\n if head is None:\\n head = left_sorted\\n result = head\\n else:\\n head.next = left_sorted\\n head = left_sorted\\n left_sorted = left_sorted.next\\n else:\\n if head is None:\\n head = right_sorted\\n result = head\\n else:\\n head.next = right_sorted\\n head = right_sorted\\n right_sorted = right_sorted.next\\n \\n if left_sorted is not None:\\n if head is None:\\n head = left_sorted\\n result = head\\n else:\\n head.next = left_sorted \\n else:\\n if head is None:\\n head = right_sorted\\n result = head\\n else:\\n head.next = right_sorted\\n\\n\\n \\n \\n return result\\n\\n\\n \\n \",\n \"runtime\": \"460\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, node: Optional[ListNode]) -> Optional[ListNode]:\\n if not node or not node.next:\\n return node\\n if not node.next.next:\\n if node.val>node.next.val:\\n temp = node.next\\n node.next,temp.next,node = None,node,node.next\\n return node\\n slow = node\\n fast = node.next\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n right = self.sortList(slow.next)\\n slow.next = None\\n left = self.sortList(node)\\n dummy = ListNode()\\n temp = dummy\\n while left and right:\\n if left.val<right.val:\\n temp.next = ListNode(left.val)\\n left = left.next\\n else:\\n temp.next = ListNode(right.val)\\n right = right.next\\n temp = temp.next\\n if left:\\n temp.next=left\\n elif right:\\n temp.next = right\\n return dummy.next \",\n \"runtime\": \"466\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def findMid(self, node):\\n f = s = node\\n while (f.next and f.next.next):\\n f = f.next.next\\n s = s.next\\n return s\\n\\n def mergeSort(self, node):\\n if(node is None or node.next is None): return node\\n \\n mid = self.findMid(node) #Find the mid\\n nextNode = mid.next #Get the start of second half \\n mid.next = None #Break at mid\\n \\n firstHalf = self.mergeSort(node)\\n secondHalf = self.mergeSort(nextNode)\\n \\n return self.merge(firstHalf, secondHalf)\\n\\n def merge(self,n1,n2):\\n tmp = cur = ListNode()\\n while n1 or n2:\\n v1 = n1.val if n1 else float('inf')\\n v2 = n2.val if n2 else float('inf')\\n if v1<v2:\\n cur.next = n1\\n n1 = n1.next\\n else:\\n cur.next = n2\\n n2 = n2.next\\n cur = cur.next\\n \\n return tmp.next\\n\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n return self.mergeSort(head)\\n\\n \\n \",\n \"runtime\": \"466\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def merge(left, right):\\n cur = ListNode()\\n start = cur\\n while left or right:\\n left_val = left.val if left else float('inf')\\n right_val = right.val if right else float('inf')\\n if left_val > right_val:\\n cur.next = right\\n right = right.next\\n else:\\n cur.next = left\\n left = left.next\\n cur = cur.next\\n cur.next = None\\n return start.next\\n\\n\\n def inner(node, list_len):\\n if list_len == 1:\\n node.next = None\\n return node\\n \\n cur = node\\n for i in range(list_len // 2):\\n cur = cur.next\\n\\n left = inner(node, list_len // 2)\\n right = inner(cur, list_len - list_len // 2)\\n return merge(left, right)\\n\\n if not head:\\n return head\\n n = 0\\n cur = head\\n while cur:\\n n += 1\\n cur = cur.next\\n # divide and conqure\\n return inner(head, n)\",\n \"runtime\": \"472\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n mid = self.findMidandDisconnect(head)\\n return self.mergeSortedList(self.sortList(head), self.sortList(mid))\\n\\n\\n def findMidandDisconnect(self, head):\\n if not head or not head.next:\\n return head\\n\\n count, p = 0, head\\n while p:\\n count += 1\\n p = p.next\\n p = head\\n\\n for i in range(count//2):\\n if i == (count//2)-1:\\n temp = p.next\\n p.next = None\\n p = temp\\n else:\\n p = p.next\\n \\n return p\\n\\n def mergeSortedList(self, p1, p2):\\n sentinel = ListNode()\\n head, a, b = sentinel, p1, p2\\n\\n while a or b:\\n if not a or (b and b.val < a.val):\\n head.next = b\\n head, b = head.next, b.next\\n elif not b or (a and a.val <= b.val):\\n head.next = a\\n head, a = head.next, a.next\\n return sentinel.next\\n\",\n \"runtime\": \"472\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return head\\n slow=head\\n fast=head\\n while fast.next and fast.next.next:\\n slow=slow.next\\n fast=fast.next.next\\n mid=slow.next\\n slow.next=None\\n left=self.sortList(head)\\n right=self.sortList(mid)\\n merged=ListNode()\\n temp=merged\\n while left and right:\\n if left.val<right.val:\\n temp.next=ListNode(left.val)\\n left=left.next\\n else:\\n temp.next=ListNode(right.val)\\n right=right.next\\n temp=temp.next\\n if left: temp.next=left\\n if right: temp.next=right\\n return merged.next\",\n \"runtime\": \"478\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n def merge_sort_list(head):\\n if not head or not head.next:\\n return head\\n\\n left = left_tail = ListNode()\\n right = right_tail = ListNode()\\n\\n use_right = False\\n curr = head\\n while curr:\\n temp = curr\\n curr = curr.next\\n\\n if use_right:\\n right_tail.next = temp\\n right_tail = right_tail.next\\n else:\\n left_tail.next = temp\\n left_tail = left_tail.next\\n \\n use_right = not use_right\\n right_tail.next = None\\n left_tail.next = None\\n \\n # need base case\\n left = merge_sort_list(left.next)\\n right = merge_sort_list(right.next)\\n\\n res = res_tail = ListNode()\\n \\n cleft = left\\n cright = right\\n while cleft or cright:\\n if not cleft:\\n res_tail.next = cright\\n res_tail = res_tail.next\\n cright = cright.next\\n elif not cright:\\n res_tail.next = cleft\\n res_tail = res_tail.next\\n cleft = cleft.next\\n elif cright.val < cleft.val:\\n res_tail.next = cright\\n res_tail = res_tail.next\\n cright = cright.next\\n else:\\n res_tail.next = cleft\\n res_tail = res_tail.next\\n cleft = cleft.next\\n res_tail.next = None\\n return res.next\\n\\n return merge_sort_list(head)\\n \",\n \"runtime\": \"478\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return head\\n def merge(head, slow):\\n l = head\\n r = slow\\n temp = []\\n while l and r and l != slow:\\n if l.val < r.val:\\n temp.append(l.val)\\n l = l.next\\n else:\\n temp.append(r.val)\\n r = r.next\\n while l and l != slow:\\n temp.append(l.val)\\n l = l.next\\n while r:\\n temp.append(r.val)\\n r = r.next\\n cur = head\\n i = 0\\n while cur:\\n cur.val = temp[i]\\n i += 1\\n cur = cur.next\\n\\n def sort(head):\\n if head.next:\\n slow = head\\n fast = head\\n before = ListNode(next = slow)\\n while fast and fast.next:\\n before = slow\\n slow = slow.next\\n fast = fast.next.next\\n before.next = None\\n sort(head)\\n sort(slow)\\n before.next = slow\\n merge(head, slow)\\n \\n sort(head)\\n return head\",\n \"runtime\": \"484\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return head\\n current = head\\n even = None\\n odd = None\\n even_head = None\\n odd_head = None\\n parity = 0\\n while current is not None:\\n if parity == 0:\\n if even is None:\\n even = current\\n even_head = even\\n else:\\n even.next = current\\n even = even.next\\n else:\\n if odd is None:\\n odd = current\\n odd_head = odd\\n else:\\n odd.next = current\\n odd = odd.next\\n current = current.next\\n parity = 1 - parity\\n if even is not None:\\n even.next = None\\n if odd is not None:\\n odd.next = None\\n even_head = self.sortList(even_head)\\n odd_head = self.sortList(odd_head)\\n return self.mergeTwoLists(even_head, odd_head)\\n\\n def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:\\n if list1 is None:\\n return list2\\n if list2 is None:\\n return list1\\n if list1.val <= list2.val:\\n head = list1\\n list1 = list1.next\\n on_1 = True\\n else:\\n head = list2\\n list2 = list2.next\\n on_1 = False\\n current = head\\n while list1 is not None and list2 is not None:\\n if list1.val <= list2.val and on_1:\\n current = list1\\n list1 = list1.next\\n elif list1.val > list2.val and on_1:\\n current.next = list2\\n list2 = list2.next\\n current = current.next\\n on_1 = False\\n elif list1.val <= list2.val and not on_1:\\n current.next = list1\\n list1 = list1.next\\n current = current.next\\n on_1 = True\\n else:\\n current = list2\\n list2 = list2.next\\n if list1 is not None:\\n current.next = list1\\n if list2 is not None:\\n current.next = list2\\n return head\",\n \"runtime\": \"484\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution: \\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # merge sort with fast and slow ptr\\n \\n def get_mid_node(self, head):\\n # base case is guaranteed\\n slow_ptr = head\\n fast_ptr = slow_ptr.next\\n while fast_ptr != None and fast_ptr.next != None:\\n slow_ptr = slow_ptr.next\\n fast_ptr = fast_ptr.next\\n if fast_ptr == None:\\n return slow_ptr, fast_ptr\\n fast_ptr = fast_ptr.next\\n return slow_ptr\\n \\n def merge(left, right):\\n merged_list_pre = ListNode()\\n merged_list_ptr = merged_list_pre\\n left_ptr = left\\n right_ptr = right\\n # the two list are already sorted\\n while (left_ptr != None) or (right_ptr != None):\\n if right_ptr == None:\\n merged_list_ptr.next = left_ptr\\n left_ptr = left_ptr.next\\n elif left_ptr == None:\\n merged_list_ptr.next = right_ptr\\n right_ptr = right_ptr.next\\n elif left_ptr.val < right_ptr.val:\\n merged_list_ptr.next = left_ptr\\n left_ptr = left_ptr.next\\n else:\\n merged_list_ptr.next = right_ptr\\n right_ptr = right_ptr.next\\n merged_list_ptr = merged_list_ptr.next\\n merged_list_ptr.next = None\\n return merged_list_pre.next\\n \\n def merge_sort(head):\\n #print_list(head)\\n # base case\\n if head == None or head.next == None:\\n return head\\n mid = get_mid_node(self, head)\\n # break the list\\n right_head = mid.next\\n mid.next = None\\n # recursive step \\n left = merge_sort(head)\\n right = merge_sort(right_head)\\n # merge\\n return merge(left, right)\\n\\n # def print_list(head):\\n # if head == None:\\n # print(\\\"None\\\")\\n # while head != None:\\n # print(head.val, end =\\\" \\\") \\n # head = head.next\\n # print()\\n \\n return merge_sort(head)\\n \\n \\n \\n \",\n \"runtime\": \"490\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def getMid(head):\\n slow = head\\n fast = head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1, l2):\\n head = tail = ListNode()\\n while l1 or l2:\\n val1 = l1.val if l1 else float(\\\"inf\\\")\\n val2 = l2.val if l2 else float(\\\"inf\\\")\\n if val1 > val2:\\n tail.next = l2\\n l2 = l2.next\\n else:\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n return head.next\\n if not head or not head.next:\\n return head\\n left = head\\n right = getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left, right)\\n\\n\",\n \"runtime\": \"490\"\n },\n {\n \"code\": \"from queue import PriorityQueue\\n\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n root = None\\n heap = PriorityQueue()\\n while head != None:\\n heap.put(head.val)\\n head = head.next\\n\\n while heap.empty() == False:\\n v = heap.get()\\n if root == None:\\n root = ListNode(v)\\n cur = root\\n else:\\n cur.next = ListNode(v)\\n cur = cur.next\\n\\n return root\\n\",\n \"runtime\": \"496\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def mergeSort(node, length):\\n # base case\\n if length == 0: return None\\n if length == 1: return node\\n\\n # 1. break a list to two parts\\n length1 = length // 2\\n length2 = length - length1\\n curr = node\\n for _ in range(length // 2 - 1):\\n curr = curr.next\\n node1 = node\\n node2 = curr.next\\n curr.next = None # break connection between node1 and node2\\n\\n # 2. sort each parts\\n node1 = mergeSort(node1, length1)\\n node2 = mergeSort(node2, length2)\\n\\n # 3. merge results\\n dummy = node = ListNode()\\n while node1 and node2:\\n if node1.val < node2.val:\\n node.next = ListNode(node1.val)\\n node1 = node1.next\\n else:\\n node.next = ListNode(node2.val)\\n node2 = node2.next\\n node = node.next\\n\\n node.next = node1 if node1 else node2 # add remaining list \\n\\n return dummy.next\\n \\n curr = head\\n length = 0\\n while curr:\\n length += 1\\n curr = curr.next\\n \\n return mergeSort(head, length)\",\n \"runtime\": \"496\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n return self.mergeSort(head)\\n \\n def mergeSort(self, head):\\n if not head or not head.next:\\n return head\\n \\n slow, fast = head, head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n left_head, right_head = head, slow.next\\n slow.next = None\\n return self.merge(self.mergeSort(left_head), self.mergeSort(right_head))\\n\\n def merge(self, left, right):\\n dummy = ListNode()\\n cur = dummy\\n while left and right:\\n if left.val < right.val:\\n cur.next = ListNode(left.val)\\n left = left.next\\n else:\\n cur.next = ListNode(right.val)\\n right = right.next\\n cur = cur.next\\n if left:\\n cur.next = left\\n elif right:\\n cur.next = right\\n return dummy.next\\n\",\n \"runtime\": \"502\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def mergeSort(node, length):\\n # base case\\n if length == 0: return None\\n if length == 1: return node\\n\\n # 1. break a list to two parts\\n length1 = length // 2\\n length2 = length - length1\\n curr = node\\n for _ in range(length // 2 - 1):\\n curr = curr.next\\n node1 = node\\n node2 = curr.next\\n curr.next = None\\n\\n # 2. sort each parts\\n node1 = mergeSort(node1, length1)\\n node2 = mergeSort(node2, length2)\\n\\n # 3. merge results\\n dummy = node = ListNode()\\n while node1 and node2:\\n if node1.val < node2.val:\\n node.next = ListNode(node1.val)\\n node1 = node1.next\\n else:\\n node.next = ListNode(node2.val)\\n node2 = node2.next\\n node = node.next\\n\\n node.next = node1 if node1 else node2 \\n\\n return dummy.next\\n \\n curr = head\\n length = 0\\n while curr:\\n length += 1\\n curr = curr.next\\n \\n return mergeSort(head, length)\",\n \"runtime\": \"502\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return head\\n slow=head\\n fast=head.next\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n mid=slow.next\\n slow.next=None\\n left=self.sortList(head)\\n right=self.sortList(mid)\\n merged=ListNode()\\n temp=merged\\n while left and right:\\n if left.val<right.val:\\n temp.next=ListNode(left.val)\\n left=left.next\\n else:\\n temp.next=ListNode(right.val)\\n right=right.next\\n temp=temp.next\\n if left: temp.next=left\\n if right: temp.next=right\\n return merged.next\",\n \"runtime\": \"508\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n return self.quickSort(head)\\n\\n def quickSort(self, head):\\n if head is None or head.next is None:\\n return head\\n\\n pivot = self.randomPivot(head)\\n lesser = lesserDummy = ListNode()\\n equal = equalDummy = ListNode()\\n greater = greaterDummy = ListNode()\\n while head:\\n if head.val < pivot.val:\\n lesser.next = head\\n lesser = lesser.next\\n elif head.val == pivot.val:\\n equal.next = head\\n equal = equal.next\\n else:\\n greater.next = head\\n greater = greater.next\\n head = head.next\\n\\n lesser.next = equal.next = greater.next = None\\n left = self.quickSort(lesserDummy.next)\\n mid = equalDummy.next\\n right = self.quickSort(greaterDummy.next)\\n return self.concat(self.concat(left, mid), right)\\n\\n def getLength(self, head):\\n cnt = 0\\n while head:\\n cnt += 1\\n head = head.next\\n return cnt\\n\\n def randomPivot(self, head):\\n pivotIndex = random.randint(0, self.getLength(head) - 1)\\n for i in range(pivotIndex):\\n head = head.next\\n return head\\n\\n def concat(self, head1, head2):\\n dummyHead = tail = ListNode()\\n tail.next = head1\\n while tail.next:\\n tail = tail.next\\n tail.next = head2\\n return dummyHead.next\",\n \"runtime\": \"508\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n # Time complexity = O(n) + O(nlogn) + O(n) --> ll to arr, sort, arr to ll\\n # Space complexity = O(n) --> arr\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n temp = head\\n arr = []\\n while temp is not None:\\n arr.append(temp.val)\\n temp = temp.next\\n\\n self.mergeSort(arr, 0, len(arr)-1)\\n temp = head\\n for i in range(len(arr)):\\n temp.val = arr[i]\\n temp = temp.next\\n\\n return head\\n\\n def merge(self, arr, l, m, r):\\n n1 = m - l + 1\\n n2 = r - m\\n left = [arr[l+i] for i in range(n1)]\\n right = [arr[m + 1 + i] for i in range(n2)]\\n i = j = 0\\n k = l\\n\\n while i < n1 and j < n2:\\n if left[i] < right[j]:\\n arr[k] = left[i]\\n i += 1\\n else:\\n arr[k] = right[j]\\n j += 1\\n k += 1\\n\\n while i < n1:\\n arr[k] = left[i]\\n i += 1\\n k += 1\\n\\n while j < n2:\\n arr[k] = right[j]\\n j += 1\\n k += 1\\n\\n def mergeSort(self, arr, l, r):\\n if l < r:\\n mid = (l+r)//2\\n self.mergeSort(arr, l, mid)\\n self.mergeSort(arr, mid+1, r)\\n self.merge(arr, l, mid, r)\",\n \"runtime\": \"514\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None:\\n return None\\n data = []\\n node = head\\n while node:\\n idx = bisect_left(data, node.val)\\n data.insert(idx, node.val)\\n node = node.next\\n \\n nodes = [ListNode(data[0])] \\n for i in range(1, len(data)):\\n node = ListNode(data[i])\\n nodes[i-1].next = node\\n nodes.append(node)\\n \\n return nodes[0]\\n\\n \\n \",\n \"runtime\": \"514\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # Step 1: Extract values from the linked list and store them in an array\\n values = []\\n current = head\\n while current:\\n values.append(current.val)\\n current = current.next\\n \\n # Step 2: Apply heap sort on the array\\n self.heap_sort(values)\\n \\n # Step 3: Reconstruct the linked list with sorted values\\n current = head\\n for val in values:\\n current.val = val\\n current = current.next\\n \\n return head\\n\\n def heapify(self, arr, n, i):\\n # Helper function to heapify a subtree rooted with node i\\n largest = i # Initialize largest as root\\n left = 2 * i + 1 # left = 2*i + 1\\n right = 2 * i + 2 # right = 2*i + 2\\n\\n # If left child is larger than root\\n if left < n and arr[left] > arr[largest]:\\n largest = left\\n\\n # If right child is larger than largest so far\\n if right < n and arr[right] > arr[largest]:\\n largest = right\\n\\n # If largest is not root\\n if largest != i:\\n arr[i], arr[largest] = arr[largest], arr[i] # swap\\n\\n # Recursively heapify the affected subtree\\n self.heapify(arr, n, largest)\\n\\n def heap_sort(self, arr):\\n n = len(arr)\\n\\n # Build a maxheap.\\n for i in range(n // 2 - 1, -1, -1):\\n self.heapify(arr, n, i)\\n\\n # One by one extract elements\\n for i in range(n-1, 0, -1):\\n arr[i], arr[0] = arr[0], arr[i] # swap\\n self.heapify(arr, i, 0)\",\n \"runtime\": \"520\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def merge(node1: ListNode, node2: ListNode) -> ListNode:\\n last = dummy = ListNode()\\n \\n while node1 is not None or node2 is not None:\\n n1 = node1.val if node1 else float(\\\"inf\\\")\\n n2 = node2.val if node2 else float(\\\"inf\\\")\\n \\n if n1 == n2 == float(\\\"inf\\\"):\\n break\\n elif n1 < n2:\\n smallest = node1\\n node1 = node1.next\\n else:\\n smallest = node2\\n node2 = node2.next\\n \\n smallest.next = None\\n last.next = smallest\\n last = smallest\\n \\n return dummy.next\\n \\n \\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n \\n slow, fast = head, head.next\\n\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n \\n mid = slow\\n \\n after_mid = mid.next\\n mid.next = None\\n mid = after_mid\\n\\n head = self.sortList(head)\\n mid = self.sortList(mid)\\n \\n return self.merge(head, mid)\\n\",\n \"runtime\": \"520\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":148,"string":"148"},"mm_list":{"kind":"list like","value":[{"code":"f = open('user.out','w')\nfor arr in map(loads, stdin):\n print(str(sorted(arr)).replace(' ',''), file=f)\nexit(0)","memory":"20900"},{"code":"f = open('user.out','w')\nfor arr in map(loads, stdin):\n print(str(sorted(arr)).replace(' ',''), file=f)\nexit(0)","memory":"21000"},{"code":"with open('user.out','w') as f:\n for arr in map(loads, stdin):\n f.write(str(sorted(arr)).replace(' ','')+'\\n')\nexit(0)","memory":"21100"},{"code":"with open(\"user.out\", \"w\") as Solution:\n for head in map(loads, stdin):\n Solution.write(f\"{sorted(head)}\\n\".replace(\" \",\"\"))\nexit()","memory":"21200"},{"code":"f=open(\"user.out\",'w')\nwhile True:\n try:\n n=input()\n if len(n)==2:\n print('[]',file=f)\n continue\n arr=list(map(int,n[1:-1].split(',')))\n arr=[str(i) for i in sorted(arr)]\n print('['+','.join(arr)+']',file=f)\n except:\n f.close()\n exit(0)","memory":"26200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n l=[]\n temp=head\n while(temp):\n l.append(temp.val)\n temp=temp.next\n l.sort()\n x=str(l)\n x=x.replace(\"[\",\"\")\n x=x.replace(\"]\",\"\")\n x=x.replace(\" \",\"\")\n return ListNode(x)\n \n \n \n \n\n ","memory":"30600"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n # Split the list into two halves\n def split_list(head):\n slow, fast = head, head\n while fast and fast.next:\n prev = slow\n slow = slow.next\n fast = fast.next.next\n prev.next = None # Split the list into two halves\n return head, slow\n\n # Merge two sorted linked lists\n def merge_sorted_lists(l1, l2):\n dummy = ListNode()\n cur = dummy\n\n while l1 and l2:\n if l1.val < l2.val:\n cur.next = l1\n l1 = l1.next\n else:\n cur.next = l2\n l2 = l2.next\n cur = cur.next\n\n cur.next = l1 if l1 else l2\n return dummy.next\n\n # Recursive merge sort implementation\n def merge_sort(head):\n if not head or not head.next:\n return head\n\n # Split list into two halves\n left, right = split_list(head)\n\n # Recursively sort both halves\n left = merge_sort(left)\n right = merge_sort(right)\n\n # Merge the two sorted halves\n return merge_sorted_lists(left, right)\n\n # Start the merge sort\n return merge_sort(head)\n","memory":"31200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next :\n return head\n \n mid = self.getMid(head)\n right = self.sortList(mid.next)\n mid.next = None\n left = self.sortList(head)\n\n return self.merge(left, right)\n\n def getMid(self, head : ListNode) -> ListNode:\n slow = head\n fast = head\n\n while fast.next and fast.next.next :\n slow = slow.next\n fast = fast.next.next\n\n return slow\n\n def merge(self, left, right) :\n dummy = ListNode()\n tail = dummy\n\n while left and right :\n if left.val < right.val :\n tail.next = left\n left = left.next\n else :\n tail.next = right\n right = right.next\n tail = tail.next\n\n if left :\n tail.next = left\n if right :\n tail.next = right\n\n return dummy.next\n\n\n","memory":"31500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n\n def get_med(head):\n slow=fast=head\n while fast and fast.next and fast.next.next:\n slow=slow.next\n fast=fast.next.next\n return slow\n \n \n \n def merge_sort(head):\n \n if (not head) or (not head.next):\n return head\n\n head1=head\n med=get_med(head)\n head2=med.next\n med.next=None\n\n head1=merge_sort(head1)\n head2=merge_sort(head2)\n\n head=tail=ListNode()\n heads=[head1, head2]\n\n while heads[0] or heads[1]:\n val1=heads[0].val if heads[0] else 10**10\n val2=heads[1].val if heads[1] else 10**10\n min_idx=val1>val2\n tail.next=heads[min_idx]\n heads[min_idx]=heads[min_idx].next\n tail=tail.next\n \n return head.next\n\n return merge_sort(head)\n\n\n # def getMed(head):\n # if (head==None) or (head.next==None):\n # return head\n # slow,fast=head,head.next\n # while slow.next and fast.next:\n # slow=slow.next\n # fast=fast.next.next\n # return slow\n\n # def mergeSort(head):\n # if (head==None) or (head.next==None):\n # return head\n # left,right=head,getMed(head)\n # tmp=right\n # right=right.next\n # tmp.next=None\n # left,right=mergeSort(left),mergeSort(right)\n\n # res=tail=ListNode()\n # while left and right:\n # if left.val<=right.val:\n # tail.next=left\n # left=left.next\n # else:\n # tail.next=right\n # right=right.next\n # tail=tail.next\n # if left:\n # tail.next=left\n # if right:\n # tail.next=right\n # return res.next\n \n # return mergeSort(head)\n\n\n\n ","memory":"31600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n \n \n \n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def mergelist(list1, list2):\n dummy=ListNode(-1)\n temp=dummy\n while(list1 is not None and list2 is not None):\n if(list1.val<list2.val):\n temp.next=list1\n list1=list1.next\n else:\n temp.next=list2\n list2=list2.next\n temp=temp.next\n if list1 is not None:\n temp.next=list1\n else:\n temp.next=list2\n\n return dummy.next\n def findmiddle(head):\n slow=head\n fast=head.next\n while(fast and fast.next):\n slow=slow.next\n fast=fast.next.next\n return slow\n\n\n if not head or not head.next:\n return head\n \n middle=findmiddle(head) \n\n right=middle.next\n middle.next=None\n left=head\n\n left=self.sortList(left)\n right=self.sortList(right)\n\n return mergelist(left,right) ","memory":"31700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n n = 0\n cur_v = head\n while cur_v:\n n += 1\n cur_v = cur_v.next\n if n == 0:\n return head\n\n def merge(pv, v, i, k, j):\n left_head, right_head = v, v\n for _ in range(i, k):\n right_head = right_head.next\n new_head = None\n\n took_left, took_right = 0, 0\n full_left, full_right = k - i, j - k\n cur_v = pv\n for _ in range(i, j):\n takel, taker = False, False\n # print(left_head, right_head, full_left, full_right)\n if took_left < full_left and took_right < full_right:\n if left_head.val < right_head.val:\n takel = True\n else:\n taker = True\n # print(takel, taker)\n if takel or (not taker and took_left < full_left):\n took_left += 1\n if cur_v is not None:\n cur_v.next = left_head\n cur_v = cur_v.next\n else:\n cur_v = left_head\n new_head = cur_v\n left_head = left_head.next\n else:\n took_right += 1\n if cur_v is not None:\n cur_v.next = right_head\n cur_v = cur_v.next\n else:\n cur_v = right_head\n new_head = cur_v\n right_head = right_head.next\n cur_v.next = right_head\n # print(cur_v, cur_v.next, new_head)\n return cur_v, right_head, new_head\n \n w = 1\n while w < n:\n i = 0\n cur_v = head\n last_v = None\n while i < n - 1:\n j = min(n, i + 2 * w)\n k = min(n, i + w)\n if j != k:\n p_v, cur_v, new_head = merge(last_v, cur_v, i, k, j)\n # if last_v is not None:\n # last_v.next = new_head\n # else:\n if i == 0:\n head = new_head\n last_v = p_v\n i += 2 * w\n w *= 2\n return head","memory":"31800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not (head and head.next):\n return head\n slow, fast = head, head.next\n while fast and fast.next:\n fast, slow = fast.next.next, slow.next\n mid = slow.next\n slow.next = None\n mid = self.sortList(mid)\n head = self.sortList(head)\n\n slow = fast = ListNode(0)\n while head and mid:\n if head.val < mid.val:\n fast.next, head = head, head.next\n else:\n fast.next, mid = mid, mid.next\n fast = fast.next\n \n fast.next = head if head else mid\n return slow.next\n","memory":"31900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def _split(head): \n # print(\"_split=\", head if head else None)\n if not head:\n return None, None\n head1, head2 = head, head\n ptr_slow, ptr_fast = head1, head1.next\n if not ptr_fast:\n return head, None\n if not ptr_fast.next:\n head.next = None\n return head, ptr_fast\n ptr_fast = ptr_fast.next\n while ptr_fast and ptr_fast.next:\n ptr_fast = ptr_fast.next.next\n ptr_slow = ptr_slow.next\n head2 = ptr_slow.next\n ptr_slow.next = None # terminate head1\n # print(\"split head1 = \", head1 if head1 else None)\n # print(\"split head2 = \", head2 if head2 else None)\n return head1, head2\n def _merge(head1, head2):\n if head1.val < head2.val:\n head = head1\n head1 = head1.next \n else:\n head = head2\n head2 = head2.next\n ptr = head\n while head1 and head2:\n if head1.val < head2.val:\n ptr.next = head1\n head1 = head1.next \n else:\n ptr.next = head2\n head2 = head2.next\n ptr = ptr.next\n if head1:\n ptr.next = head1\n if head2:\n ptr.next = head2\n # print(\"merged\", head)\n return head\n head1, head2 = _split(head)\n if not head1:\n return head2\n if not head2:\n return head1\n return _merge(self.sortList(head1), self.sortList(head2))\n","memory":"31900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def getMid(head):\n slow = fast = head\n prev = None\n while fast and fast.next:\n prev = slow\n slow = slow.next\n fast = fast.next.next\n if prev:\n prev.next = None\n return slow\n\n def mergeSort(head):\n # Base case: if the list is empty or has only one node\n if not head or not head.next:\n return head\n mid = getMid(head) \n h1 = mergeSort(head)\n h2 = mergeSort(mid)\n cur = dummy = ListNode(-1)\n while h1 and h2:\n if h1.val < h2.val:\n cur.next = h1 \n h1 = h1.next \n else:\n cur.next = h2 \n h2 = h2.next \n cur = cur.next \n if h1:\n cur.next = h1 \n elif h2:\n cur.next = h2 \n return dummy.next \n return mergeSort(head)","memory":"32000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nimport heapq\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n heap=[]\n curr=head\n while curr is not None:\n heapq.heappush(heap,curr.val)\n curr=curr.next\n curr=head\n while curr is not None:\n pop=heapq.heappop(heap)\n curr.val=pop\n curr=curr.next\n return head","memory":"32100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n arr=[]\n temp=head\n while(temp!=None):\n arr.append(temp.val)\n temp=temp.next\n arr.sort()\n temp=head\n i=0\n while(temp!=None):\n temp.val=arr[i]\n i+=1\n temp=temp.next\n return(head)\n ","memory":"32200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n arr = []\n temp = head\n temp2 = head\n while temp:\n arr.append(temp.val)\n temp = temp.next\n arr.sort()\n i = 0\n while temp2:\n temp2.val = arr[i]\n i += 1\n temp2 = temp2.next\n return head\n\n ","memory":"32200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n ptr=head\n l=[]\n while ptr:\n l.append(ptr.val)\n ptr=ptr.next\n l.sort()\n i=0\n ptr=head\n while ptr:\n ptr.val=l[i]\n i+=1\n ptr=ptr.next\n return head","memory":"32299"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n fast = slow = head\n while fast.next.next:\n fast = fast.next.next\n slow = slow.next\n if not fast.next:\n break\n start = slow.next\n slow.next = None\n l, r = self.sortList(head), self.sortList(start)\n # print(f\"l is {l}\")\n # print(f\"r is {r}\")\n \n return self.merge(l, r)\n\n def merge(self, l, r):\n if not l or not r:\n return l or r\n head = tmp = ListNode(0)\n while l and r:\n if l.val<=r.val:\n tmp.next = l\n l = l.next\n else:\n tmp.next = r\n r = r.next\n tmp = tmp.next\n if l:\n tmp.next = l\n if r:\n tmp.next = r\n return head.next","memory":"32299"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def merge(self,l1,l2):\n head=start=ListNode()\n while l1 and l2:\n if l1.val<l2.val:\n head.next=l1\n l1=l1.next\n else:\n head.next=l2\n l2=l2.next\n head=head.next\n if l1:\n head.next=l1\n if l2:\n head.next=l2\n return start.next\n \n def getMiddle(self,l1):\n slow=l1\n fast=l1.next\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n return slow\n \n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or head.next==None:\n return head\n mid=self.getMiddle(head)\n rp=mid.next\n mid.next=None\n left=self.sortList(head)\n right=self.sortList(rp)\n return self.merge(left,right)\n \n \n \n\n ","memory":"32400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n l=[]\n temp=head\n while temp is not None:\n l.append(temp.val)\n temp=temp.next\n i=0\n l=sorted(l)\n current=head\n while current is not None:\n current.val=l[i]\n i=i+1\n current=current.next\n return head\n\n \n ","memory":"32400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n curr = head\n valList = list()\n while curr:\n valList.append(curr.val)\n curr = curr.next\n \n curr = head\n valList.sort(reverse=True)\n while curr:\n curr.val = valList.pop()\n curr = curr.next\n return head\n","memory":"32500"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None: return head\n else:\n M = self.find_mid(head)\n head2 = M.next\n M.next = None\n L, R = self.sortList(head), self.sortList(head2)\n return self.merge(L, R)\n\n def find_mid(self, head):\n slow, fast = head, head.next\n while fast and fast.next:\n slow = slow.next\n fast = (fast.next).next\n return slow\n\n def merge(self, l1, l2):\n dummy = ListNode()\n last = dummy\n while l1 and l2:\n if l1.val < l2.val:\n last.next = l1\n l1 = l1.next\n else:\n last.next = l2\n l2 = l2.next\n last = last.next\n last.next = l1 if l1 else l2\n return dummy.next","memory":"32500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n if not head or not head.next:\n return head \n\n mid = self.get_mid(head)\n left = self.sortList(head)\n right = self.sortList(mid)\n\n return self.merge(left, right)\n \n def merge(self, l1, l2):\n\n if not l1: return l2\n if not l2: return l1\n dh = ListNode(0)\n curr = dh\n\n while l1 and l2:\n if l1.val < l2.val:\n curr.next = l1\n l1 = l1.next\n else:\n curr.next = l2\n l2 = l2.next\n curr = curr.next\n \n curr.next = l1 if l1 else l2\n\n return dh.next\n\n def get_mid(self, root):\n mid_prev = None\n while root and root.next:\n mid_prev = root if not mid_prev else mid_prev.next\n root = root.next.next\n \n mid = mid_prev.next\n mid_prev.next = None\n return mid # head of the half","memory":"32600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n\n\n def divide(self,head):\n slow,fast=head,head.next\n while fast and fast.next:\n slow=slow.next\n fast=fast.next.next\n return slow\n \n def Merge(self,l,r):\n temp=ans=ListNode()\n while l and r:\n if l.val<=r.val:\n temp.next=l\n l=l.next\n else:\n temp.next=r\n r=r.next\n temp=temp.next\n if l:\n temp.next=l\n if r:\n temp.next=r\n return ans.next\n \n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n left=head\n right=self.divide(head)\n temp=right.next\n right.next=None\n right=temp\n left=self.sortList(left)\n right=self.sortList(right)\n return self.Merge(left,right)\n ","memory":"32600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n dummyhead = ListNode(0, head)\n fast, slow = dummyhead, dummyhead\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n \n first = head\n second = slow.next\n slow.next = None\n\n sorted_first = self.sortList(first)\n sorted_second = self.sortList(second)\n\n # merge\n result_dummyhead = ListNode()\n prev = result_dummyhead\n while sorted_first and sorted_second:\n l1 = sorted_first.val \n l2 = sorted_second.val\n \n if l1 <= l2:\n prev.next = ListNode(l1)\n prev = prev.next\n sorted_first = sorted_first.next\n else:\n prev.next = ListNode(l2)\n prev = prev.next\n sorted_second = sorted_second.next\n \n prev.next = sorted_first if sorted_first else sorted_second\n\n return result_dummyhead.next\n\n \n\n\n\n","memory":"32700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nfrom queue import PriorityQueue\n\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n ret = head\n copy = head\n\n q = PriorityQueue()\n\n while head:\n q.put(head.val)\n head = head.next\n \n while copy:\n copy.val = q.get()\n copy = copy.next\n\n return ret","memory":"32800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n def dq(head, tail):\n\n if head == tail:\n return \n\n\n curr = head\n largeList = True\n for i in range(1000):\n if curr == tail:\n largeList = False\n break\n else:\n curr = curr.next\n \n curr=head\n if largeList:\n randstep = randrange(0, 500) \n for i in range(randstep):\n curr = curr.next\n \n curr.val, tail.val = (tail.val, curr.val)\n\n\n\n # ll=[]\n # pt = head\n # print(\"Before while, head.val = \", head.val, \", tail.val = \", tail.val)\n\n # while pt!=None and pt != tail:\n # ll.append(pt.val)\n # pt = pt.next\n # ll.append(pt.val)\n # print(\" before swap, list = \", ll)\n\n fast = head\n prev = None\n slow = head\n\n while fast != tail:\n if fast.val < tail.val:\n # print(\" before swap, slow.val = \", slow.val, \"fast.val = \", fast.val )\n slow.val, fast.val = (fast.val, slow.val)\n # print(\" after swap, slow.val = \", slow.val, \"fast.val = \", fast.val )\n prev = slow\n slow = slow.next\n\n fast = fast.next\n\n if slow != tail:\n slow.val, tail.val = (tail.val, slow.val)\n\n # ll=[]\n # pt = head\n # while pt!=None and pt != tail:\n # ll.append(pt.val)\n # pt = pt.next\n # ll.append(pt.val)\n # print(\" after swap, list = \", ll)\n \n # print(\"Before recursion 1, head.val = \", head.val, \", prev.val = \", prev.val, \"slow.val = \", slow.val, \"tail.val = \", tail.val) \n if head != slow:\n dq(head, prev)\n # print(\"Before recursion 2, head.val = \", head.val, \", prev.val = \", prev.val, \"slow.val = \", slow.val, \"tail.val = \", tail.val) \n if slow != tail:\n dq(slow.next, tail) \n\n\n if head == None or head.next == None:\n return head\n \n curr = head\n tail = None\n \n while curr != None:\n tail = curr\n curr = curr.next\n \n dq(head, tail)\n\n return head","memory":"32900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n values = []\n curr = head\n while curr:\n values.append(curr.val)\n curr = curr.next\n \n values = sorted(values, reverse = True)\n\n curr = head\n while curr:\n curr.val = values.pop()\n curr = curr.next\n \n return head","memory":"33000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n cur=head\n array=[]\n def merge_sort(array):\n if len(array)<=1:\n return array\n mid=len(array)//2\n left=merge_sort(array[:mid])\n right=merge_sort(array[mid:])\n return merge(left,right)\n\n def merge(left,right):\n i,j=0,0\n A=[]\n while i<len(left) and j<len(right):\n if left[i]<=right[j]:\n A.append(left[i])\n i+=1\n else:\n A.append(right[j])\n j+=1\n while i<len(left):\n A.append(left[i])\n i+=1\n\n while j<len(right):\n A.append(right[j])\n j+=1\n return A\n \n while cur:\n array.append(cur.val)\n cur=cur.next\n \n array=merge_sort(array)\n cur=head\n k=0\n while cur:\n cur.val=array[k]\n cur=cur.next\n k+=1\n return head\n\n \n\n \n\n\n\n\n\n ","memory":"33100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n \n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n fast = fast.next.next\n slow= slow.next\n return slow\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merger(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val>l2.val:\n tail.next = l2\n l2 = l2.next\n else:\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n \n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merger(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(l1,l2):\n dummy = ListNode(0)\n tail = dummy\n while l1 and l2:\n if l1.val >l2.val:\n tail.next = l2\n l2 = l2.next\n else:\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next \n\n\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l2.val>l1.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n \n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n return slow\n \n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next \n\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n return slow\n \n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n \n if l2:\n tail.next = l2\n return dummy.next\n \n \n \n\n \n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def sort(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val>l2.val:\n tail.next = l2\n l2 = l2.next\n else:\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return sort(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n\n def getMid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2 : \n tail.next = l2\n return dummy.next\n\n\n left = head\n right = getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n if not head or not head.next:return head\n def getMid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val <l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n tail = tail.next\n if l2:\n tail.next = l2\n tail = tail.next\n return dummy.next\n\n \n\n left = head\n right = getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n\n return merge(left,right)\n\n \n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n\n left = head\n right = self.getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return self.merge(left,right)\n \n def getMid(self,head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(self,list1,list2):\n dummy = ListNode()\n tail = dummy\n while list1 and list2:\n if list1.val<list2.val:\n tail.next = list1\n list1 = list1.next\n else:\n tail.next = list2\n list2 = list2.next\n if list1:\n tail.next = list1\n if list2:\n tail.next = list2\n return dummy.next\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getMid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n tail = tail.next\n if l2:\n tail.next = l2\n tail = tail.next\n return dummy.next\n left = head\n right = getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n \n left = head\n right = self.getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return self.merge(left,right)\n\n def getmid(self,head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(self,l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head:\n return None\n myList = []\n while head:\n myList.append(head.val)\n head = head.next\n myList.sort()\n newHead = point = ListNode(0)\n for i in range(len(myList)):\n point.next = ListNode(myList[i])\n point = point.next\n return newHead.next\n \n \n \n \n \n \"\"\"\n if not head or not head.next:\n return head\n mid = self.midpoint(head)\n left = self.sortList(head)\n right = self.sortList(mid)\n return self.merge(left,right)\n \n def midpoint(self,head):\n slow,fast = head,head\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n mid = slow.next\n slow.next = None\n return mid\n \n def merge(self , left ,right):\n dummy = ListNode()\n cur = dummy\n while left and right:\n if left.val<right.val:\n cur.next = left\n left = left.next\n cur = cur.next\n else:\n cur.next = right\n right = right.next\n cur = cur.next\n cur.next = left or right\n return dummy.next\"\"\"\n \n ","memory":"33300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n \n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n fast = fast.next.next\n slow= slow.next\n return slow\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merger(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val>l2.val:\n tail.next = l2\n l2 = l2.next\n else:\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n \n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merger(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(l1,l2):\n dummy = ListNode(0)\n tail = dummy\n while l1 and l2:\n if l1.val >l2.val:\n tail.next = l2\n l2 = l2.next\n else:\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next \n\n\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l2.val>l1.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n \n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n return slow\n \n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next \n\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n return slow\n \n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n \n if l2:\n tail.next = l2\n return dummy.next\n \n \n \n\n \n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def sort(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val>l2.val:\n tail.next = l2\n l2 = l2.next\n else:\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return sort(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n\n def getMid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2 : \n tail.next = l2\n return dummy.next\n\n\n left = head\n right = getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n if not head or not head.next:return head\n def getMid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val <l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n tail = tail.next\n if l2:\n tail.next = l2\n tail = tail.next\n return dummy.next\n\n \n\n left = head\n right = getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n\n return merge(left,right)\n\n \n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n\n left = head\n right = self.getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return self.merge(left,right)\n \n def getMid(self,head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(self,list1,list2):\n dummy = ListNode()\n tail = dummy\n while list1 and list2:\n if list1.val<list2.val:\n tail.next = list1\n list1 = list1.next\n else:\n tail.next = list2\n list2 = list2.next\n if list1:\n tail.next = list1\n if list2:\n tail.next = list2\n return dummy.next\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getMid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n tail = tail.next\n if l2:\n tail.next = l2\n tail = tail.next\n return dummy.next\n left = head\n right = getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n \n left = head\n right = self.getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return self.merge(left,right)\n\n def getmid(self,head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(self,l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head:\n return None\n myList = []\n while head:\n myList.append(head.val)\n head = head.next\n myList.sort()\n newHead = point = ListNode(0)\n for i in range(len(myList)):\n point.next = ListNode(myList[i])\n point = point.next\n return newHead.next\n \n \n \n \n \n \"\"\"\n if not head or not head.next:\n return head\n mid = self.midpoint(head)\n left = self.sortList(head)\n right = self.sortList(mid)\n return self.merge(left,right)\n \n def midpoint(self,head):\n slow,fast = head,head\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n mid = slow.next\n slow.next = None\n return mid\n \n def merge(self , left ,right):\n dummy = ListNode()\n cur = dummy\n while left and right:\n if left.val<right.val:\n cur.next = left\n left = left.next\n cur = cur.next\n else:\n cur.next = right\n right = right.next\n cur = cur.next\n cur.next = left or right\n return dummy.next\"\"\"\n \n ","memory":"33300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(list1,list2):\n dummy = ListNode()\n tail = dummy\n while list1 and list2:\n if list1.val<list2.val:\n tail.next = list1\n list1 = list1.next\n else:\n tail.next = list2\n list2 = list2.next\n tail = tail.next\n if list1:\n tail.next = list1\n if list2:\n tail.next = list2\n return dummy.next\n \n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n \n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n fast = fast.next.next\n slow= slow.next\n return slow\n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n def mid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merger(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val>l2.val:\n tail.next = l2\n l2 = l2.next\n else:\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n \n left = head\n right = mid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merger(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(l1,l2):\n dummy = ListNode(0)\n tail = dummy\n while l1 and l2:\n if l1.val >l2.val:\n tail.next = l2\n l2 = l2.next\n else:\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next \n\n\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l2.val>l1.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n \n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n return slow\n \n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next \n\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n fast = fast.next.next\n slow = slow.next\n return slow\n \n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n \n if l2:\n tail.next = l2\n return dummy.next\n \n \n \n\n \n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getmid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def sort(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val>l2.val:\n tail.next = l2\n l2 = l2.next\n else:\n tail.next = l1\n l1 = l1.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n left = head\n right = getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return sort(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n\n def getMid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2 : \n tail.next = l2\n return dummy.next\n\n\n left = head\n right = getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n if not head or not head.next:return head\n def getMid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val <l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n tail = tail.next\n if l2:\n tail.next = l2\n tail = tail.next\n return dummy.next\n\n \n\n left = head\n right = getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n\n return merge(left,right)\n\n \n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n\n left = head\n right = self.getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return self.merge(left,right)\n \n def getMid(self,head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(self,list1,list2):\n dummy = ListNode()\n tail = dummy\n while list1 and list2:\n if list1.val<list2.val:\n tail.next = list1\n list1 = list1.next\n else:\n tail.next = list2\n list2 = list2.next\n if list1:\n tail.next = list1\n if list2:\n tail.next = list2\n return dummy.next\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:return head\n def getMid(head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n def merge(l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n tail = tail.next\n if l2:\n tail.next = l2\n tail = tail.next\n return dummy.next\n left = head\n right = getMid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return merge(left,right)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head or not head.next:\n return head\n \n left = head\n right = self.getmid(head)\n tmp = right.next\n right.next = None\n right = tmp\n\n left = self.sortList(left)\n right = self.sortList(right)\n return self.merge(left,right)\n\n def getmid(self,head):\n slow,fast = head,head.next\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n return slow\n \n def merge(self,l1,l2):\n dummy = ListNode()\n tail = dummy\n while l1 and l2:\n if l1.val<l2.val:\n tail.next = l1\n l1 = l1.next\n else:\n tail.next = l2\n l2 = l2.next\n tail = tail.next\n if l1:\n tail.next = l1\n if l2:\n tail.next = l2\n return dummy.next\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n if not head:\n return None\n myList = []\n while head:\n myList.append(head.val)\n head = head.next\n myList.sort()\n newHead = point = ListNode(0)\n for i in range(len(myList)):\n point.next = ListNode(myList[i])\n point = point.next\n return newHead.next\n \n \n \n \n \n \"\"\"\n if not head or not head.next:\n return head\n mid = self.midpoint(head)\n left = self.sortList(head)\n right = self.sortList(mid)\n return self.merge(left,right)\n \n def midpoint(self,head):\n slow,fast = head,head\n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n mid = slow.next\n slow.next = None\n return mid\n \n def merge(self , left ,right):\n dummy = ListNode()\n cur = dummy\n while left and right:\n if left.val<right.val:\n cur.next = left\n left = left.next\n cur = cur.next\n else:\n cur.next = right\n right = right.next\n cur = cur.next\n cur.next = left or right\n return dummy.next\"\"\"\n \n ","memory":"33400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head==None or head.next==None:\n return head\n \n p = head\n arr=[]\n while(p!=None):\n arr.append(p.val)\n p=p.next\n \n #print(arr)\n\n def merge(left, right):\n result = []\n i = j = 0\n\n while i < len(left) and j < len(right):\n if left[i] < right[j]:\n result.append(left[i])\n i += 1\n else:\n result.append(right[j])\n j += 1\n\n result.extend(left[i:])\n result.extend(right[j:])\n\n return result\n \n def mergeSort(arr):\n if len(arr) <= 1:\n return arr\n\n mid = len(arr) // 2\n leftHalf = arr[:mid]\n rightHalf = arr[mid:]\n\n sortedLeft = mergeSort(leftHalf)\n sortedRight = mergeSort(rightHalf)\n\n return merge(sortedLeft, sortedRight)\n\n ans= mergeSort(arr)\n p=head\n while(p!=None):\n p.val=ans.pop(0)\n p=p.next\n \n return head","memory":"34100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n list1, list2 = self.divideList(head)\n self.printList(list1)\n self.printList(list2)\n\n if list2:\n return self.mergeList(self.sortList(list1), self.sortList(list2))\n \n return list1\n\n def divideList(self, head):\n if not head or not head.next: \n return head, None\n\n tortoise = head \n hare = head\n prev = head\n\n while hare and hare.next:\n prev = tortoise\n tortoise = tortoise.next\n hare = hare.next.next\n \n prev.next = None\n\n return (head, tortoise)\n \n def mergeList(self, head1, head2):\n dummyNode = ListNode()\n merged = dummyNode\n\n while head1 and head2:\n if head1.val < head2.val:\n merged.next = head1\n head1 = head1.next \n else:\n merged.next = head2\n head2 = head2.next\n\n merged = merged.next\n\n while head1:\n merged.next = head1\n head1 = head1.next \n merged = merged.next\n\n while head2:\n merged.next = head2\n head2 = head2.next \n merged = merged.next\n\n return dummyNode.next\n \n def printList(self, head):\n res = []\n while head:\n res.append(str(head.val))\n head = head.next\n print(\" \".join(res))","memory":"34200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n def merge(root):\n if not root:\n return root\n if not root.next:\n return root \n\n p, s, f = None, root, root\n while f and f.next:\n p = s\n s = s.next\n f = f.next.next\n\n p.next = None\n left = merge(root)\n right = merge(s)\n\n dummy = TreeNode(0)\n tail = dummy \n while left and right:\n if left.val <= right.val:\n new = TreeNode(left.val)\n tail.next = new\n tail = tail.next\n left = left.next\n else:\n new = TreeNode(right.val)\n tail.next = new\n tail = tail.next\n right = right.next\n\n if left:\n tail.next = left\n \n if right:\n tail.next = right\n\n return dummy.next \n\n\n return merge(head) ","memory":"34400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n # def merge(head):\n if not head:\n return head\n if not head.next:\n return head \n\n p, s, f = None, head, head\n while f and f.next:\n p = s\n s = s.next\n f = f.next.next\n\n p.next = None\n left = self.sortList(head)\n right = self.sortList(s)\n\n dummy = TreeNode(0)\n tail = dummy \n while left and right:\n if left.val <= right.val:\n new = TreeNode(left.val)\n tail.next = new\n tail = tail.next\n left = left.next\n else:\n new = TreeNode(right.val)\n tail.next = new\n tail = tail.next\n right = right.next\n\n if left:\n tail.next = left\n \n if right:\n tail.next = right\n\n return dummy.next \n\n\n # return merge(head) ","memory":"34600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \n # def merge(head):\n if not head or not head.next:\n return head \n\n # split nodes into two halfs\n p, s, f = None, head, head\n while f and f.next:\n p = s\n s = s.next\n f = f.next.next\n\n p.next = None\n leftList = self.sortList(head)\n rightList = self.sortList(s)\n\n # merging\n tail = dummy = TreeNode(0) \n while leftList and rightList:\n if leftList.val <= rightList.val:\n new = TreeNode(leftList.val)\n tail.next = new\n tail = tail.next\n leftList = leftList.next\n else:\n new = TreeNode(rightList.val)\n tail.next = new\n tail = tail.next\n rightList = rightList.next\n\n if leftList:\n tail.next = leftList\n \n if rightList:\n tail.next = rightList\n\n return dummy.next \n\n\n # return merge(head) ","memory":"34700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n ns = []\n while head is not None:\n ns.append((head.val, head))\n head = head.next\n ns[-1][1].next = None\n ns = sorted(ns, key = lambda cn: cn[0])\n for ci in range(1, len(ns)): ns[ci - 1][1].next = ns[ci][1]\n return ns[0][1] if ns else None","memory":"35200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n node_set = []\n while head:\n node_set.append((head.val, head))\n next_node= head.next\n head.next = None\n head = next_node\n \n node_set.sort(key = lambda x : x[0])\n\n for i in range(1,len(node_set)):\n node_set[i-1][1].next = node_set[i][1]\n \n return node_set[0][1]","memory":"35300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n h = []\n curr = head\n while curr:\n h.append((curr.val, curr))\n curr = curr.next\n \n h = sorted(h, key = lambda x: x[0])\n\n curr = rs = None\n \n for _, tmp in h:\n if not rs:\n rs = curr = tmp\n else:\n curr.next = tmp\n curr = curr.next\n curr.next = None\n\n return rs ","memory":"35400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n \"\"\"\n easy way:\n put each node (val, node) in a list\n sort\n update next pointers for each node\n \"\"\"\n nodes = []\n curr = head\n while curr:\n nodes.append((curr.val, curr))\n curr = curr.next\n \n nodes.sort(key=lambda node: node[0])\n dummy = prev = ListNode(0)\n \n for (_, node) in nodes:\n prev.next = node\n prev = node\n \n prev.next = None\n \n return dummy.next","memory":"35500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None: return None\n pylist = []\n node = head\n while node is not None:\n pylist.append((node.val, node))\n node = node.next\n pass\n pylist.sort(reverse=True, key=(lambda val_node: val_node[0]))\n\n head_val, head = pylist.pop() # The list guaranteed not to be empty\n node = head\n while len(pylist) > 0:\n val, next_node = pylist.pop()\n node.next = next_node\n node = next_node\n pass\n node.next = None\n\n return head","memory":"35600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n sorted_arr = []\n if head is None: return head\n\n while head is not None:\n sorted_arr.append((head.val, head))\n head = head.next \n\n print(\"len list:\", len(sorted_arr))\n for val, n in sorted_arr: print(val)\n\n sorted_arr = sorted(sorted_arr, key=lambda x: x[0])\n\n for i, (val, node) in enumerate(sorted_arr[:-1]):\n node.next = sorted_arr[i+1][1]\n \n sorted_arr[-1][1].next = None\n\n return sorted_arr[0][1]","memory":"35700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return head\n point = head\n arr = []\n while point is not None:\n arr.append([point, point.val])\n point = point.next\n arr.sort(key = lambda x: x[1])\n # print(arr)\n for ind, item in enumerate(arr):\n val, _ = item\n if ind == len(arr) - 1:\n val.next = None\n else:\n val.next = arr[ind + 1][0]\n return arr[0][0]\n\n \n \n","memory":"36100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n curr = head\n node_list = []\n\n if curr == None:\n return None\n \n while (curr):\n node_list.append([curr.val, curr])\n curr = curr.next\n \n node_list = sorted(node_list,key=lambda node: node[0])\n\n curr = node_list[0][1]\n for i in range(1, len(node_list)):\n curr.next = node_list[i][1]\n curr = node_list[i][1]\n \n node_list[-1][1].next = None\n\n return node_list[0][1]\n","memory":"36200"},{"code":"class Solution:\n def sortList(self, head):\n node = head\n lst = []\n\n if not head:\n return None\n\n while node:\n # print(node.val)\n lst.append([node.val, node])\n node = node.next\n\n lst = sorted(lst, key=lambda x: x[0])\n # print(lst)\n\n head = lst[0][1]\n prev = head\n for i in range(1, len(lst)):\n node = lst[i][1]\n node.next = None\n\n prev.next = node\n prev = node\n\n # print(head)\n return head\n ","memory":"36300"},{"code":"class Solution:\n def sortList(self, head):\n node = head\n lst = []\n if not head:\n return None\n\n while node:\n lst.append([node.val, node])\n node = node.next\n\n lst = sorted(lst, key=lambda x: x[0])\n\n head = lst[0][1]\n prev = head\n for i in range(1, len(lst)):\n node = lst[i][1]\n node.next = None\n\n prev.next = node\n prev = node\n\n return head\n ","memory":"36300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n lst = []\n cur = head\n while cur != None:\n lst.append([cur.val, cur])\n cur = cur.next\n \n lst = sorted(lst, key=lambda x: x[0])\n\n new_head = ListNode()\n cur = new_head\n for item in lst:\n item[1].next = None\n cur.next = item[1]\n cur = cur.next\n \n return new_head.next\n ","memory":"36400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n self.node_map = {}\n i = 0\n curr = head\n while curr:\n self.node_map[i] = curr\n curr = curr.next\n i += 1\n return self.__sortList(head, 0, i)\n \n def __sortList(self, head, i, j):\n if not head or not head.next:\n return head\n left, right = self.__split(i, j)\n left = self.sortList(left)\n right = self.sortList(right)\n merged = ListNode()\n curr = merged\n while left and right:\n if left.val < right.val:\n curr.next = left\n left = left.next\n else:\n curr.next = right\n right = right.next\n curr = curr.next\n if left:\n curr.next = left\n elif right:\n curr.next = right\n return merged.next\n \n\n def __split(self, i, j):\n left = self.node_map[i]\n m = (i + j + 1) // 2\n right = self.node_map[m]\n self.node_map[m-1].next = None\n return left, right","memory":"36500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n self.node_map = {}\n i = 0\n curr = head\n while curr:\n self.node_map[i] = curr\n curr = curr.next\n i += 1\n return self.__sortList(head, 0, i)\n \n def __sortList(self, head, i, j):\n if not head or not head.next:\n return head\n left, right = self.__split(i, j)\n left = self.sortList(left)\n right = self.sortList(right)\n merged = ListNode()\n curr = merged\n while left and right:\n if left.val < right.val:\n curr.next = left\n left = left.next\n else:\n curr.next = right\n right = right.next\n curr = curr.next\n if left:\n curr.next = left\n elif right:\n curr.next = right\n return merged.next\n \n\n def __split(self, i, j):\n left = self.node_map[i]\n m = (i + j + 1) // 2\n right = self.node_map[m]\n self.node_map[m-1].next = None\n return left, right","memory":"36600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n nodes = []\n\n cur = head\n i = 0\n while cur:\n nodes.append((cur.val, i, cur))\n cur = cur.next\n i += 1\n nodes.sort()\n\n cur = ListNode()\n root = cur\n for i in range(len(nodes)):\n _, _, node = nodes[i]\n\n cur.next = node\n cur = cur.next\n \n cur.next = None\n return root.next","memory":"36800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:\n\n r = ListNode()\n copy = r\n\n while list1 != None and list2 != None :\n if(list1.val <= list2.val):\n copy.next = ListNode(val = list1.val)\n copy = copy.next\n list1 = list1.next\n else:\n copy.next = ListNode(val = list2.val)\n copy = copy.next\n list2 = list2.next\n\n while list1 != None:\n copy.next = ListNode(val = list1.val)\n copy = copy.next\n list1 = list1.next\n \n while list2 != None:\n copy.next = ListNode(val = list2.val)\n copy = copy.next\n list2 = list2.next\n\n return r.next\n\n def merge(self,listH):\n\n head = listH\n head2 = listH\n before = None\n while head2 != None:\n before = head\n head = head.next \n head2 = head2.next\n if(head2 != None):\n head2 = head2.next\n \n second = before.next\n if(second == None):\n return listH\n \n before.next = None\n\n l = self.merge(listH)\n r = self.merge(second)\n\n return self.mergeTwoLists(l,r) \n\n \n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if(head == None):\n return None\n \n return self.merge(head)","memory":"36900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: return\n cur = head\n arr = []\n while cur:\n arr.append(cur.val)\n cur = cur.next\n arr.sort()\n newTree = ListNode(0)\n cur = newTree\n for i in arr:\n newTree.next = ListNode(i)\n newTree = newTree.next\n return cur.next\n\n ","memory":"37000"},{"code":"import heapq\n\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n\n nodes = []\n node = head\n idx = 0\n while node:\n next_node = node.next\n node.next = None\n nodes.append((node.val, idx, node))\n node = next_node\n idx += 1\n\n heapq.heapify(nodes)\n \n new_head = nodes[0][2]\n prev_node = None\n while nodes:\n node = heapq.heappop(nodes)[2]\n if prev_node:\n prev_node.next = node\n prev_node = node\n return new_head","memory":"37100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n # base case\n if not head or not head.next:\n return head\n # Divide: slow and fast to find the middle point of the list\n slow = head\n fast = head \n while fast.next and fast.next.next:\n slow = slow.next\n fast = fast.next.next\n head1 = head\n head2 = slow.next\n slow.next = None\n head1 = self.sortList(head1)\n head2 = self.sortList(head2)\n # merge:\n return self.merge(head1,head2)\n\n\n def merge(self,head1,head2):\n # merge two sublists one by one\n if not head1:\n return head2\n if not head2:\n return head1\n head = ListNode(0)\n tmp = head\n while head1 and head2:\n if head1.val < head2.val:\n tmp.next = ListNode(head1.val)\n head1 = head1.next\n else:\n tmp.next = ListNode(head2.val)\n head2 = head2.next\n tmp = tmp.next\n if not head1:\n tmp.next = head2\n if not head2:\n tmp.next = head1\n return head.next","memory":"37200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n split = []\n \n node = head\n while node:\n split.append([node])\n node = node.next\n \n if len(split) < 2:\n return head\n \n ordered_nodes = self.merge(split)\n\n\n for i in range(len(ordered_nodes) - 1):\n ordered_nodes[i].next = ordered_nodes[i + 1]\n ordered_nodes[-1].next = None\n\n return ordered_nodes[0]\n\n def merge(self, next_split):\n split = []\n \n while len(next_split) > 1:\n split = next_split\n next_split = []\n\n while split:\n left = split.pop()\n if not split:\n next_split.append(left)\n continue\n right = split.pop()\n\n new_seq = []\n\n while left and right:\n if left[0].val < right[0].val:\n new_seq.append(left.pop(0))\n else:\n new_seq.append(right.pop(0))\n if left:\n new_seq.extend(left)\n elif right:\n new_seq.extend(right)\n \n next_split.append(new_seq)\n \n return next_split[0]\n ","memory":"37200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n\n curr = head\n arr = []\n \n\n while curr:\n val = curr.val\n arr.append(val)\n \n curr = curr.next\n sorted_arr = sorted(arr)\n\n dummy = ListNode(0)\n curr = dummy\n\n for num in sorted_arr:\n curr.next = ListNode(num)\n\n curr = curr.next\n\n\n print(sorted_arr)\n\n return dummy.next\n\n \n ","memory":"37300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head:\n return None\n \n elems = []\n\n curr = head\n while curr:\n elems.append(curr.val)\n curr = curr.next\n elems.sort()\n\n dummyHead = ListNode(0)\n prev = dummyHead\n\n for elem in elems:\n new = ListNode(elem)\n prev.next = new\n prev = prev.next\n return dummyHead.next","memory":"37300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head: return None\n nums = []\n dummy = head\n while dummy != None:\n nums.append(dummy.val)\n dummy = dummy.next\n nums.sort()\n head1 = ListNode()\n dummy1 = head1\n for i in range(len(nums)):\n dummy1.next = ListNode(nums[i])\n dummy1 = dummy1.next\n return head1.next","memory":"37400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n def construct(arr):\n if len(arr)==0:\n return None\n head=ListNode(arr[0])\n temp=head\n for i in range(1,len(arr)):\n temp.next=ListNode(arr[i])\n temp=temp.next\n return head\n arr=[]\n temp=head\n while temp!=None:\n arr.append(temp.val)\n temp=temp.next\n arr.sort()\n return construct(arr)\n\n ","memory":"37400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n l = []\n current = head\n while current:\n l.append(current.val)\n current = current.next\n \n l.sort()\n \n start = ListNode()\n current = start\n for i in l:\n new = ListNode(val=i)\n current.next = new\n current = current.next\n \n return start.next","memory":"37500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head.next is None:\n return head\n list1 = []\n while head:\n list1.append(head.val)\n head = head.next\n list1.sort()\n dummy = tail = ListNode(0)\n for val in list1:\n node = ListNode(val)\n dummy.next = node\n dummy = dummy.next\n return tail.next\n ","memory":"37500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if head is None or head is []:\n return head \n \n extra = []\n current = head\n\n while current:\n extra.append(current.val)\n current = current.next\n \n extra.sort()\n\n newHead = ListNode(extra[0])\n current = newHead\n\n for val in extra[1:]:\n current.next = ListNode(val)\n current = current.next\n \n return newHead\n\n ","memory":"37600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n intermediate = []\n while head != None:\n intermediate.append(head.val)\n head = head.next\n intermediate.sort(reverse=True)\n \n node = None\n for i in intermediate:\n node = ListNode(i, node)\n return node","memory":"37700"},{"code":"class Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n if not head or not head.next:\n return head\n\n # Extract the elements from the linked list\n elements = []\n current = head\n while current:\n elements.append(current.val)\n current = current.next\n\n # Sort the elements\n elements.sort()\n\n # Create a new sorted linked list\n sorted_head = ListNode(elements[0])\n current = sorted_head\n for val in elements[1:]:\n current.next = new_node = ListNode(val)\n current = new_node\n\n return sorted_head","memory":"37800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n storage = []\n while head:\n storage.append(head.val)\n head = head.next\n \n storage.sort()\n\n if not storage:\n return None\n\n head = ListNode(storage[0]) # Create the head node\n current = head # Pointer to track the current node\n\n # Loop through the remaining values and create the linked list\n for value in storage[1:]:\n current.next = ListNode(value)\n current = current.next # Move the pointer to the new node\n\n return head","memory":"37800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n lst = list()\n while head:\n lst.append(head.val)\n head = head.next\n \n lst = sorted(lst)\n head = None\n cursor = None\n while lst:\n if not head:\n head = ListNode(lst.pop(0))\n cursor = head\n else:\n cursor.next = ListNode(lst.pop(0))\n cursor = cursor.next\n \n return head\n \n\n","memory":"37900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\n values = []\n while head:\n values.append(head.val)\n head = head.next\n values = sorted(values)\n head = None\n p = head\n for x in values[::-1]:\n head = ListNode(x, p)\n p = head\n # ListNode()\n ## my solution, get nodes, sort\n return head","memory":"37900"}],"string":"[\n {\n \"code\": \"f = open('user.out','w')\\nfor arr in map(loads, stdin):\\n print(str(sorted(arr)).replace(' ',''), file=f)\\nexit(0)\",\n \"memory\": \"20900\"\n },\n {\n \"code\": \"f = open('user.out','w')\\nfor arr in map(loads, stdin):\\n print(str(sorted(arr)).replace(' ',''), file=f)\\nexit(0)\",\n \"memory\": \"21000\"\n },\n {\n \"code\": \"with open('user.out','w') as f:\\n for arr in map(loads, stdin):\\n f.write(str(sorted(arr)).replace(' ','')+'\\\\n')\\nexit(0)\",\n \"memory\": \"21100\"\n },\n {\n \"code\": \"with open(\\\"user.out\\\", \\\"w\\\") as Solution:\\n for head in map(loads, stdin):\\n Solution.write(f\\\"{sorted(head)}\\\\n\\\".replace(\\\" \\\",\\\"\\\"))\\nexit()\",\n \"memory\": \"21200\"\n },\n {\n \"code\": \"f=open(\\\"user.out\\\",'w')\\nwhile True:\\n try:\\n n=input()\\n if len(n)==2:\\n print('[]',file=f)\\n continue\\n arr=list(map(int,n[1:-1].split(',')))\\n arr=[str(i) for i in sorted(arr)]\\n print('['+','.join(arr)+']',file=f)\\n except:\\n f.close()\\n exit(0)\",\n \"memory\": \"26200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n l=[]\\n temp=head\\n while(temp):\\n l.append(temp.val)\\n temp=temp.next\\n l.sort()\\n x=str(l)\\n x=x.replace(\\\"[\\\",\\\"\\\")\\n x=x.replace(\\\"]\\\",\\\"\\\")\\n x=x.replace(\\\" \\\",\\\"\\\")\\n return ListNode(x)\\n \\n \\n \\n \\n\\n \",\n \"memory\": \"30600\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n # Split the list into two halves\\n def split_list(head):\\n slow, fast = head, head\\n while fast and fast.next:\\n prev = slow\\n slow = slow.next\\n fast = fast.next.next\\n prev.next = None # Split the list into two halves\\n return head, slow\\n\\n # Merge two sorted linked lists\\n def merge_sorted_lists(l1, l2):\\n dummy = ListNode()\\n cur = dummy\\n\\n while l1 and l2:\\n if l1.val < l2.val:\\n cur.next = l1\\n l1 = l1.next\\n else:\\n cur.next = l2\\n l2 = l2.next\\n cur = cur.next\\n\\n cur.next = l1 if l1 else l2\\n return dummy.next\\n\\n # Recursive merge sort implementation\\n def merge_sort(head):\\n if not head or not head.next:\\n return head\\n\\n # Split list into two halves\\n left, right = split_list(head)\\n\\n # Recursively sort both halves\\n left = merge_sort(left)\\n right = merge_sort(right)\\n\\n # Merge the two sorted halves\\n return merge_sorted_lists(left, right)\\n\\n # Start the merge sort\\n return merge_sort(head)\\n\",\n \"memory\": \"31200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next :\\n return head\\n \\n mid = self.getMid(head)\\n right = self.sortList(mid.next)\\n mid.next = None\\n left = self.sortList(head)\\n\\n return self.merge(left, right)\\n\\n def getMid(self, head : ListNode) -> ListNode:\\n slow = head\\n fast = head\\n\\n while fast.next and fast.next.next :\\n slow = slow.next\\n fast = fast.next.next\\n\\n return slow\\n\\n def merge(self, left, right) :\\n dummy = ListNode()\\n tail = dummy\\n\\n while left and right :\\n if left.val < right.val :\\n tail.next = left\\n left = left.next\\n else :\\n tail.next = right\\n right = right.next\\n tail = tail.next\\n\\n if left :\\n tail.next = left\\n if right :\\n tail.next = right\\n\\n return dummy.next\\n\\n\\n\",\n \"memory\": \"31500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n\\n def get_med(head):\\n slow=fast=head\\n while fast and fast.next and fast.next.next:\\n slow=slow.next\\n fast=fast.next.next\\n return slow\\n \\n \\n \\n def merge_sort(head):\\n \\n if (not head) or (not head.next):\\n return head\\n\\n head1=head\\n med=get_med(head)\\n head2=med.next\\n med.next=None\\n\\n head1=merge_sort(head1)\\n head2=merge_sort(head2)\\n\\n head=tail=ListNode()\\n heads=[head1, head2]\\n\\n while heads[0] or heads[1]:\\n val1=heads[0].val if heads[0] else 10**10\\n val2=heads[1].val if heads[1] else 10**10\\n min_idx=val1>val2\\n tail.next=heads[min_idx]\\n heads[min_idx]=heads[min_idx].next\\n tail=tail.next\\n \\n return head.next\\n\\n return merge_sort(head)\\n\\n\\n # def getMed(head):\\n # if (head==None) or (head.next==None):\\n # return head\\n # slow,fast=head,head.next\\n # while slow.next and fast.next:\\n # slow=slow.next\\n # fast=fast.next.next\\n # return slow\\n\\n # def mergeSort(head):\\n # if (head==None) or (head.next==None):\\n # return head\\n # left,right=head,getMed(head)\\n # tmp=right\\n # right=right.next\\n # tmp.next=None\\n # left,right=mergeSort(left),mergeSort(right)\\n\\n # res=tail=ListNode()\\n # while left and right:\\n # if left.val<=right.val:\\n # tail.next=left\\n # left=left.next\\n # else:\\n # tail.next=right\\n # right=right.next\\n # tail=tail.next\\n # if left:\\n # tail.next=left\\n # if right:\\n # tail.next=right\\n # return res.next\\n \\n # return mergeSort(head)\\n\\n\\n\\n \",\n \"memory\": \"31600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n \\n \\n \\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def mergelist(list1, list2):\\n dummy=ListNode(-1)\\n temp=dummy\\n while(list1 is not None and list2 is not None):\\n if(list1.val<list2.val):\\n temp.next=list1\\n list1=list1.next\\n else:\\n temp.next=list2\\n list2=list2.next\\n temp=temp.next\\n if list1 is not None:\\n temp.next=list1\\n else:\\n temp.next=list2\\n\\n return dummy.next\\n def findmiddle(head):\\n slow=head\\n fast=head.next\\n while(fast and fast.next):\\n slow=slow.next\\n fast=fast.next.next\\n return slow\\n\\n\\n if not head or not head.next:\\n return head\\n \\n middle=findmiddle(head) \\n\\n right=middle.next\\n middle.next=None\\n left=head\\n\\n left=self.sortList(left)\\n right=self.sortList(right)\\n\\n return mergelist(left,right) \",\n \"memory\": \"31700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n n = 0\\n cur_v = head\\n while cur_v:\\n n += 1\\n cur_v = cur_v.next\\n if n == 0:\\n return head\\n\\n def merge(pv, v, i, k, j):\\n left_head, right_head = v, v\\n for _ in range(i, k):\\n right_head = right_head.next\\n new_head = None\\n\\n took_left, took_right = 0, 0\\n full_left, full_right = k - i, j - k\\n cur_v = pv\\n for _ in range(i, j):\\n takel, taker = False, False\\n # print(left_head, right_head, full_left, full_right)\\n if took_left < full_left and took_right < full_right:\\n if left_head.val < right_head.val:\\n takel = True\\n else:\\n taker = True\\n # print(takel, taker)\\n if takel or (not taker and took_left < full_left):\\n took_left += 1\\n if cur_v is not None:\\n cur_v.next = left_head\\n cur_v = cur_v.next\\n else:\\n cur_v = left_head\\n new_head = cur_v\\n left_head = left_head.next\\n else:\\n took_right += 1\\n if cur_v is not None:\\n cur_v.next = right_head\\n cur_v = cur_v.next\\n else:\\n cur_v = right_head\\n new_head = cur_v\\n right_head = right_head.next\\n cur_v.next = right_head\\n # print(cur_v, cur_v.next, new_head)\\n return cur_v, right_head, new_head\\n \\n w = 1\\n while w < n:\\n i = 0\\n cur_v = head\\n last_v = None\\n while i < n - 1:\\n j = min(n, i + 2 * w)\\n k = min(n, i + w)\\n if j != k:\\n p_v, cur_v, new_head = merge(last_v, cur_v, i, k, j)\\n # if last_v is not None:\\n # last_v.next = new_head\\n # else:\\n if i == 0:\\n head = new_head\\n last_v = p_v\\n i += 2 * w\\n w *= 2\\n return head\",\n \"memory\": \"31800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not (head and head.next):\\n return head\\n slow, fast = head, head.next\\n while fast and fast.next:\\n fast, slow = fast.next.next, slow.next\\n mid = slow.next\\n slow.next = None\\n mid = self.sortList(mid)\\n head = self.sortList(head)\\n\\n slow = fast = ListNode(0)\\n while head and mid:\\n if head.val < mid.val:\\n fast.next, head = head, head.next\\n else:\\n fast.next, mid = mid, mid.next\\n fast = fast.next\\n \\n fast.next = head if head else mid\\n return slow.next\\n\",\n \"memory\": \"31900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def _split(head): \\n # print(\\\"_split=\\\", head if head else None)\\n if not head:\\n return None, None\\n head1, head2 = head, head\\n ptr_slow, ptr_fast = head1, head1.next\\n if not ptr_fast:\\n return head, None\\n if not ptr_fast.next:\\n head.next = None\\n return head, ptr_fast\\n ptr_fast = ptr_fast.next\\n while ptr_fast and ptr_fast.next:\\n ptr_fast = ptr_fast.next.next\\n ptr_slow = ptr_slow.next\\n head2 = ptr_slow.next\\n ptr_slow.next = None # terminate head1\\n # print(\\\"split head1 = \\\", head1 if head1 else None)\\n # print(\\\"split head2 = \\\", head2 if head2 else None)\\n return head1, head2\\n def _merge(head1, head2):\\n if head1.val < head2.val:\\n head = head1\\n head1 = head1.next \\n else:\\n head = head2\\n head2 = head2.next\\n ptr = head\\n while head1 and head2:\\n if head1.val < head2.val:\\n ptr.next = head1\\n head1 = head1.next \\n else:\\n ptr.next = head2\\n head2 = head2.next\\n ptr = ptr.next\\n if head1:\\n ptr.next = head1\\n if head2:\\n ptr.next = head2\\n # print(\\\"merged\\\", head)\\n return head\\n head1, head2 = _split(head)\\n if not head1:\\n return head2\\n if not head2:\\n return head1\\n return _merge(self.sortList(head1), self.sortList(head2))\\n\",\n \"memory\": \"31900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def getMid(head):\\n slow = fast = head\\n prev = None\\n while fast and fast.next:\\n prev = slow\\n slow = slow.next\\n fast = fast.next.next\\n if prev:\\n prev.next = None\\n return slow\\n\\n def mergeSort(head):\\n # Base case: if the list is empty or has only one node\\n if not head or not head.next:\\n return head\\n mid = getMid(head) \\n h1 = mergeSort(head)\\n h2 = mergeSort(mid)\\n cur = dummy = ListNode(-1)\\n while h1 and h2:\\n if h1.val < h2.val:\\n cur.next = h1 \\n h1 = h1.next \\n else:\\n cur.next = h2 \\n h2 = h2.next \\n cur = cur.next \\n if h1:\\n cur.next = h1 \\n elif h2:\\n cur.next = h2 \\n return dummy.next \\n return mergeSort(head)\",\n \"memory\": \"32000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nimport heapq\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n heap=[]\\n curr=head\\n while curr is not None:\\n heapq.heappush(heap,curr.val)\\n curr=curr.next\\n curr=head\\n while curr is not None:\\n pop=heapq.heappop(heap)\\n curr.val=pop\\n curr=curr.next\\n return head\",\n \"memory\": \"32100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n arr=[]\\n temp=head\\n while(temp!=None):\\n arr.append(temp.val)\\n temp=temp.next\\n arr.sort()\\n temp=head\\n i=0\\n while(temp!=None):\\n temp.val=arr[i]\\n i+=1\\n temp=temp.next\\n return(head)\\n \",\n \"memory\": \"32200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n arr = []\\n temp = head\\n temp2 = head\\n while temp:\\n arr.append(temp.val)\\n temp = temp.next\\n arr.sort()\\n i = 0\\n while temp2:\\n temp2.val = arr[i]\\n i += 1\\n temp2 = temp2.next\\n return head\\n\\n \",\n \"memory\": \"32200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n ptr=head\\n l=[]\\n while ptr:\\n l.append(ptr.val)\\n ptr=ptr.next\\n l.sort()\\n i=0\\n ptr=head\\n while ptr:\\n ptr.val=l[i]\\n i+=1\\n ptr=ptr.next\\n return head\",\n \"memory\": \"32299\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n fast = slow = head\\n while fast.next.next:\\n fast = fast.next.next\\n slow = slow.next\\n if not fast.next:\\n break\\n start = slow.next\\n slow.next = None\\n l, r = self.sortList(head), self.sortList(start)\\n # print(f\\\"l is {l}\\\")\\n # print(f\\\"r is {r}\\\")\\n \\n return self.merge(l, r)\\n\\n def merge(self, l, r):\\n if not l or not r:\\n return l or r\\n head = tmp = ListNode(0)\\n while l and r:\\n if l.val<=r.val:\\n tmp.next = l\\n l = l.next\\n else:\\n tmp.next = r\\n r = r.next\\n tmp = tmp.next\\n if l:\\n tmp.next = l\\n if r:\\n tmp.next = r\\n return head.next\",\n \"memory\": \"32299\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def merge(self,l1,l2):\\n head=start=ListNode()\\n while l1 and l2:\\n if l1.val<l2.val:\\n head.next=l1\\n l1=l1.next\\n else:\\n head.next=l2\\n l2=l2.next\\n head=head.next\\n if l1:\\n head.next=l1\\n if l2:\\n head.next=l2\\n return start.next\\n \\n def getMiddle(self,l1):\\n slow=l1\\n fast=l1.next\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n return slow\\n \\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or head.next==None:\\n return head\\n mid=self.getMiddle(head)\\n rp=mid.next\\n mid.next=None\\n left=self.sortList(head)\\n right=self.sortList(rp)\\n return self.merge(left,right)\\n \\n \\n \\n\\n \",\n \"memory\": \"32400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n l=[]\\n temp=head\\n while temp is not None:\\n l.append(temp.val)\\n temp=temp.next\\n i=0\\n l=sorted(l)\\n current=head\\n while current is not None:\\n current.val=l[i]\\n i=i+1\\n current=current.next\\n return head\\n\\n \\n \",\n \"memory\": \"32400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n curr = head\\n valList = list()\\n while curr:\\n valList.append(curr.val)\\n curr = curr.next\\n \\n curr = head\\n valList.sort(reverse=True)\\n while curr:\\n curr.val = valList.pop()\\n curr = curr.next\\n return head\\n\",\n \"memory\": \"32500\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None: return head\\n else:\\n M = self.find_mid(head)\\n head2 = M.next\\n M.next = None\\n L, R = self.sortList(head), self.sortList(head2)\\n return self.merge(L, R)\\n\\n def find_mid(self, head):\\n slow, fast = head, head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = (fast.next).next\\n return slow\\n\\n def merge(self, l1, l2):\\n dummy = ListNode()\\n last = dummy\\n while l1 and l2:\\n if l1.val < l2.val:\\n last.next = l1\\n l1 = l1.next\\n else:\\n last.next = l2\\n l2 = l2.next\\n last = last.next\\n last.next = l1 if l1 else l2\\n return dummy.next\",\n \"memory\": \"32500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n if not head or not head.next:\\n return head \\n\\n mid = self.get_mid(head)\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n\\n return self.merge(left, right)\\n \\n def merge(self, l1, l2):\\n\\n if not l1: return l2\\n if not l2: return l1\\n dh = ListNode(0)\\n curr = dh\\n\\n while l1 and l2:\\n if l1.val < l2.val:\\n curr.next = l1\\n l1 = l1.next\\n else:\\n curr.next = l2\\n l2 = l2.next\\n curr = curr.next\\n \\n curr.next = l1 if l1 else l2\\n\\n return dh.next\\n\\n def get_mid(self, root):\\n mid_prev = None\\n while root and root.next:\\n mid_prev = root if not mid_prev else mid_prev.next\\n root = root.next.next\\n \\n mid = mid_prev.next\\n mid_prev.next = None\\n return mid # head of the half\",\n \"memory\": \"32600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n\\n\\n def divide(self,head):\\n slow,fast=head,head.next\\n while fast and fast.next:\\n slow=slow.next\\n fast=fast.next.next\\n return slow\\n \\n def Merge(self,l,r):\\n temp=ans=ListNode()\\n while l and r:\\n if l.val<=r.val:\\n temp.next=l\\n l=l.next\\n else:\\n temp.next=r\\n r=r.next\\n temp=temp.next\\n if l:\\n temp.next=l\\n if r:\\n temp.next=r\\n return ans.next\\n \\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n left=head\\n right=self.divide(head)\\n temp=right.next\\n right.next=None\\n right=temp\\n left=self.sortList(left)\\n right=self.sortList(right)\\n return self.Merge(left,right)\\n \",\n \"memory\": \"32600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n dummyhead = ListNode(0, head)\\n fast, slow = dummyhead, dummyhead\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n \\n first = head\\n second = slow.next\\n slow.next = None\\n\\n sorted_first = self.sortList(first)\\n sorted_second = self.sortList(second)\\n\\n # merge\\n result_dummyhead = ListNode()\\n prev = result_dummyhead\\n while sorted_first and sorted_second:\\n l1 = sorted_first.val \\n l2 = sorted_second.val\\n \\n if l1 <= l2:\\n prev.next = ListNode(l1)\\n prev = prev.next\\n sorted_first = sorted_first.next\\n else:\\n prev.next = ListNode(l2)\\n prev = prev.next\\n sorted_second = sorted_second.next\\n \\n prev.next = sorted_first if sorted_first else sorted_second\\n\\n return result_dummyhead.next\\n\\n \\n\\n\\n\\n\",\n \"memory\": \"32700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nfrom queue import PriorityQueue\\n\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n ret = head\\n copy = head\\n\\n q = PriorityQueue()\\n\\n while head:\\n q.put(head.val)\\n head = head.next\\n \\n while copy:\\n copy.val = q.get()\\n copy = copy.next\\n\\n return ret\",\n \"memory\": \"32800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\n\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n def dq(head, tail):\\n\\n if head == tail:\\n return \\n\\n\\n curr = head\\n largeList = True\\n for i in range(1000):\\n if curr == tail:\\n largeList = False\\n break\\n else:\\n curr = curr.next\\n \\n curr=head\\n if largeList:\\n randstep = randrange(0, 500) \\n for i in range(randstep):\\n curr = curr.next\\n \\n curr.val, tail.val = (tail.val, curr.val)\\n\\n\\n\\n # ll=[]\\n # pt = head\\n # print(\\\"Before while, head.val = \\\", head.val, \\\", tail.val = \\\", tail.val)\\n\\n # while pt!=None and pt != tail:\\n # ll.append(pt.val)\\n # pt = pt.next\\n # ll.append(pt.val)\\n # print(\\\" before swap, list = \\\", ll)\\n\\n fast = head\\n prev = None\\n slow = head\\n\\n while fast != tail:\\n if fast.val < tail.val:\\n # print(\\\" before swap, slow.val = \\\", slow.val, \\\"fast.val = \\\", fast.val )\\n slow.val, fast.val = (fast.val, slow.val)\\n # print(\\\" after swap, slow.val = \\\", slow.val, \\\"fast.val = \\\", fast.val )\\n prev = slow\\n slow = slow.next\\n\\n fast = fast.next\\n\\n if slow != tail:\\n slow.val, tail.val = (tail.val, slow.val)\\n\\n # ll=[]\\n # pt = head\\n # while pt!=None and pt != tail:\\n # ll.append(pt.val)\\n # pt = pt.next\\n # ll.append(pt.val)\\n # print(\\\" after swap, list = \\\", ll)\\n \\n # print(\\\"Before recursion 1, head.val = \\\", head.val, \\\", prev.val = \\\", prev.val, \\\"slow.val = \\\", slow.val, \\\"tail.val = \\\", tail.val) \\n if head != slow:\\n dq(head, prev)\\n # print(\\\"Before recursion 2, head.val = \\\", head.val, \\\", prev.val = \\\", prev.val, \\\"slow.val = \\\", slow.val, \\\"tail.val = \\\", tail.val) \\n if slow != tail:\\n dq(slow.next, tail) \\n\\n\\n if head == None or head.next == None:\\n return head\\n \\n curr = head\\n tail = None\\n \\n while curr != None:\\n tail = curr\\n curr = curr.next\\n \\n dq(head, tail)\\n\\n return head\",\n \"memory\": \"32900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n values = []\\n curr = head\\n while curr:\\n values.append(curr.val)\\n curr = curr.next\\n \\n values = sorted(values, reverse = True)\\n\\n curr = head\\n while curr:\\n curr.val = values.pop()\\n curr = curr.next\\n \\n return head\",\n \"memory\": \"33000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n cur=head\\n array=[]\\n def merge_sort(array):\\n if len(array)<=1:\\n return array\\n mid=len(array)//2\\n left=merge_sort(array[:mid])\\n right=merge_sort(array[mid:])\\n return merge(left,right)\\n\\n def merge(left,right):\\n i,j=0,0\\n A=[]\\n while i<len(left) and j<len(right):\\n if left[i]<=right[j]:\\n A.append(left[i])\\n i+=1\\n else:\\n A.append(right[j])\\n j+=1\\n while i<len(left):\\n A.append(left[i])\\n i+=1\\n\\n while j<len(right):\\n A.append(right[j])\\n j+=1\\n return A\\n \\n while cur:\\n array.append(cur.val)\\n cur=cur.next\\n \\n array=merge_sort(array)\\n cur=head\\n k=0\\n while cur:\\n cur.val=array[k]\\n cur=cur.next\\n k+=1\\n return head\\n\\n \\n\\n \\n\\n\\n\\n\\n\\n \",\n \"memory\": \"33100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow= slow.next\\n return slow\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merger(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val>l2.val:\\n tail.next = l2\\n l2 = l2.next\\n else:\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n \\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merger(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(l1,l2):\\n dummy = ListNode(0)\\n tail = dummy\\n while l1 and l2:\\n if l1.val >l2.val:\\n tail.next = l2\\n l2 = l2.next\\n else:\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next \\n\\n\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l2.val>l1.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n \\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n return slow\\n \\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next \\n\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n return slow\\n \\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n \\n if l2:\\n tail.next = l2\\n return dummy.next\\n \\n \\n \\n\\n \\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def sort(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val>l2.val:\\n tail.next = l2\\n l2 = l2.next\\n else:\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return sort(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n\\n def getMid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2 : \\n tail.next = l2\\n return dummy.next\\n\\n\\n left = head\\n right = getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n if not head or not head.next:return head\\n def getMid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val <l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n tail = tail.next\\n if l2:\\n tail.next = l2\\n tail = tail.next\\n return dummy.next\\n\\n \\n\\n left = head\\n right = getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n\\n return merge(left,right)\\n\\n \\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n\\n left = head\\n right = self.getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return self.merge(left,right)\\n \\n def getMid(self,head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(self,list1,list2):\\n dummy = ListNode()\\n tail = dummy\\n while list1 and list2:\\n if list1.val<list2.val:\\n tail.next = list1\\n list1 = list1.next\\n else:\\n tail.next = list2\\n list2 = list2.next\\n if list1:\\n tail.next = list1\\n if list2:\\n tail.next = list2\\n return dummy.next\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getMid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n tail = tail.next\\n if l2:\\n tail.next = l2\\n tail = tail.next\\n return dummy.next\\n left = head\\n right = getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n \\n left = head\\n right = self.getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return self.merge(left,right)\\n\\n def getmid(self,head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(self,l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head:\\n return None\\n myList = []\\n while head:\\n myList.append(head.val)\\n head = head.next\\n myList.sort()\\n newHead = point = ListNode(0)\\n for i in range(len(myList)):\\n point.next = ListNode(myList[i])\\n point = point.next\\n return newHead.next\\n \\n \\n \\n \\n \\n \\\"\\\"\\\"\\n if not head or not head.next:\\n return head\\n mid = self.midpoint(head)\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n return self.merge(left,right)\\n \\n def midpoint(self,head):\\n slow,fast = head,head\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n mid = slow.next\\n slow.next = None\\n return mid\\n \\n def merge(self , left ,right):\\n dummy = ListNode()\\n cur = dummy\\n while left and right:\\n if left.val<right.val:\\n cur.next = left\\n left = left.next\\n cur = cur.next\\n else:\\n cur.next = right\\n right = right.next\\n cur = cur.next\\n cur.next = left or right\\n return dummy.next\\\"\\\"\\\"\\n \\n \",\n \"memory\": \"33300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow= slow.next\\n return slow\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merger(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val>l2.val:\\n tail.next = l2\\n l2 = l2.next\\n else:\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n \\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merger(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(l1,l2):\\n dummy = ListNode(0)\\n tail = dummy\\n while l1 and l2:\\n if l1.val >l2.val:\\n tail.next = l2\\n l2 = l2.next\\n else:\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next \\n\\n\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l2.val>l1.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n \\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n return slow\\n \\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next \\n\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n return slow\\n \\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n \\n if l2:\\n tail.next = l2\\n return dummy.next\\n \\n \\n \\n\\n \\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def sort(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val>l2.val:\\n tail.next = l2\\n l2 = l2.next\\n else:\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return sort(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n\\n def getMid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2 : \\n tail.next = l2\\n return dummy.next\\n\\n\\n left = head\\n right = getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n if not head or not head.next:return head\\n def getMid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val <l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n tail = tail.next\\n if l2:\\n tail.next = l2\\n tail = tail.next\\n return dummy.next\\n\\n \\n\\n left = head\\n right = getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n\\n return merge(left,right)\\n\\n \\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n\\n left = head\\n right = self.getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return self.merge(left,right)\\n \\n def getMid(self,head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(self,list1,list2):\\n dummy = ListNode()\\n tail = dummy\\n while list1 and list2:\\n if list1.val<list2.val:\\n tail.next = list1\\n list1 = list1.next\\n else:\\n tail.next = list2\\n list2 = list2.next\\n if list1:\\n tail.next = list1\\n if list2:\\n tail.next = list2\\n return dummy.next\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getMid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n tail = tail.next\\n if l2:\\n tail.next = l2\\n tail = tail.next\\n return dummy.next\\n left = head\\n right = getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n \\n left = head\\n right = self.getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return self.merge(left,right)\\n\\n def getmid(self,head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(self,l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head:\\n return None\\n myList = []\\n while head:\\n myList.append(head.val)\\n head = head.next\\n myList.sort()\\n newHead = point = ListNode(0)\\n for i in range(len(myList)):\\n point.next = ListNode(myList[i])\\n point = point.next\\n return newHead.next\\n \\n \\n \\n \\n \\n \\\"\\\"\\\"\\n if not head or not head.next:\\n return head\\n mid = self.midpoint(head)\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n return self.merge(left,right)\\n \\n def midpoint(self,head):\\n slow,fast = head,head\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n mid = slow.next\\n slow.next = None\\n return mid\\n \\n def merge(self , left ,right):\\n dummy = ListNode()\\n cur = dummy\\n while left and right:\\n if left.val<right.val:\\n cur.next = left\\n left = left.next\\n cur = cur.next\\n else:\\n cur.next = right\\n right = right.next\\n cur = cur.next\\n cur.next = left or right\\n return dummy.next\\\"\\\"\\\"\\n \\n \",\n \"memory\": \"33300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(list1,list2):\\n dummy = ListNode()\\n tail = dummy\\n while list1 and list2:\\n if list1.val<list2.val:\\n tail.next = list1\\n list1 = list1.next\\n else:\\n tail.next = list2\\n list2 = list2.next\\n tail = tail.next\\n if list1:\\n tail.next = list1\\n if list2:\\n tail.next = list2\\n return dummy.next\\n \\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow= slow.next\\n return slow\\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n def mid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merger(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val>l2.val:\\n tail.next = l2\\n l2 = l2.next\\n else:\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n \\n left = head\\n right = mid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merger(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(l1,l2):\\n dummy = ListNode(0)\\n tail = dummy\\n while l1 and l2:\\n if l1.val >l2.val:\\n tail.next = l2\\n l2 = l2.next\\n else:\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next \\n\\n\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l2.val>l1.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n \\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n return slow\\n \\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next \\n\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n fast = fast.next.next\\n slow = slow.next\\n return slow\\n \\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n \\n if l2:\\n tail.next = l2\\n return dummy.next\\n \\n \\n \\n\\n \\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getmid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def sort(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val>l2.val:\\n tail.next = l2\\n l2 = l2.next\\n else:\\n tail.next = l1\\n l1 = l1.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n left = head\\n right = getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return sort(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n\\n def getMid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2 : \\n tail.next = l2\\n return dummy.next\\n\\n\\n left = head\\n right = getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n if not head or not head.next:return head\\n def getMid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val <l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n tail = tail.next\\n if l2:\\n tail.next = l2\\n tail = tail.next\\n return dummy.next\\n\\n \\n\\n left = head\\n right = getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n\\n return merge(left,right)\\n\\n \\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n\\n left = head\\n right = self.getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return self.merge(left,right)\\n \\n def getMid(self,head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(self,list1,list2):\\n dummy = ListNode()\\n tail = dummy\\n while list1 and list2:\\n if list1.val<list2.val:\\n tail.next = list1\\n list1 = list1.next\\n else:\\n tail.next = list2\\n list2 = list2.next\\n if list1:\\n tail.next = list1\\n if list2:\\n tail.next = list2\\n return dummy.next\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:return head\\n def getMid(head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n def merge(l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n tail = tail.next\\n if l2:\\n tail.next = l2\\n tail = tail.next\\n return dummy.next\\n left = head\\n right = getMid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return merge(left,right)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head or not head.next:\\n return head\\n \\n left = head\\n right = self.getmid(head)\\n tmp = right.next\\n right.next = None\\n right = tmp\\n\\n left = self.sortList(left)\\n right = self.sortList(right)\\n return self.merge(left,right)\\n\\n def getmid(self,head):\\n slow,fast = head,head.next\\n while fast and fast.next:\\n slow = slow.next\\n fast = fast.next.next\\n return slow\\n \\n def merge(self,l1,l2):\\n dummy = ListNode()\\n tail = dummy\\n while l1 and l2:\\n if l1.val<l2.val:\\n tail.next = l1\\n l1 = l1.next\\n else:\\n tail.next = l2\\n l2 = l2.next\\n tail = tail.next\\n if l1:\\n tail.next = l1\\n if l2:\\n tail.next = l2\\n return dummy.next\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n if not head:\\n return None\\n myList = []\\n while head:\\n myList.append(head.val)\\n head = head.next\\n myList.sort()\\n newHead = point = ListNode(0)\\n for i in range(len(myList)):\\n point.next = ListNode(myList[i])\\n point = point.next\\n return newHead.next\\n \\n \\n \\n \\n \\n \\\"\\\"\\\"\\n if not head or not head.next:\\n return head\\n mid = self.midpoint(head)\\n left = self.sortList(head)\\n right = self.sortList(mid)\\n return self.merge(left,right)\\n \\n def midpoint(self,head):\\n slow,fast = head,head\\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n mid = slow.next\\n slow.next = None\\n return mid\\n \\n def merge(self , left ,right):\\n dummy = ListNode()\\n cur = dummy\\n while left and right:\\n if left.val<right.val:\\n cur.next = left\\n left = left.next\\n cur = cur.next\\n else:\\n cur.next = right\\n right = right.next\\n cur = cur.next\\n cur.next = left or right\\n return dummy.next\\\"\\\"\\\"\\n \\n \",\n \"memory\": \"33400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head==None or head.next==None:\\n return head\\n \\n p = head\\n arr=[]\\n while(p!=None):\\n arr.append(p.val)\\n p=p.next\\n \\n #print(arr)\\n\\n def merge(left, right):\\n result = []\\n i = j = 0\\n\\n while i < len(left) and j < len(right):\\n if left[i] < right[j]:\\n result.append(left[i])\\n i += 1\\n else:\\n result.append(right[j])\\n j += 1\\n\\n result.extend(left[i:])\\n result.extend(right[j:])\\n\\n return result\\n \\n def mergeSort(arr):\\n if len(arr) <= 1:\\n return arr\\n\\n mid = len(arr) // 2\\n leftHalf = arr[:mid]\\n rightHalf = arr[mid:]\\n\\n sortedLeft = mergeSort(leftHalf)\\n sortedRight = mergeSort(rightHalf)\\n\\n return merge(sortedLeft, sortedRight)\\n\\n ans= mergeSort(arr)\\n p=head\\n while(p!=None):\\n p.val=ans.pop(0)\\n p=p.next\\n \\n return head\",\n \"memory\": \"34100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n list1, list2 = self.divideList(head)\\n self.printList(list1)\\n self.printList(list2)\\n\\n if list2:\\n return self.mergeList(self.sortList(list1), self.sortList(list2))\\n \\n return list1\\n\\n def divideList(self, head):\\n if not head or not head.next: \\n return head, None\\n\\n tortoise = head \\n hare = head\\n prev = head\\n\\n while hare and hare.next:\\n prev = tortoise\\n tortoise = tortoise.next\\n hare = hare.next.next\\n \\n prev.next = None\\n\\n return (head, tortoise)\\n \\n def mergeList(self, head1, head2):\\n dummyNode = ListNode()\\n merged = dummyNode\\n\\n while head1 and head2:\\n if head1.val < head2.val:\\n merged.next = head1\\n head1 = head1.next \\n else:\\n merged.next = head2\\n head2 = head2.next\\n\\n merged = merged.next\\n\\n while head1:\\n merged.next = head1\\n head1 = head1.next \\n merged = merged.next\\n\\n while head2:\\n merged.next = head2\\n head2 = head2.next \\n merged = merged.next\\n\\n return dummyNode.next\\n \\n def printList(self, head):\\n res = []\\n while head:\\n res.append(str(head.val))\\n head = head.next\\n print(\\\" \\\".join(res))\",\n \"memory\": \"34200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n def merge(root):\\n if not root:\\n return root\\n if not root.next:\\n return root \\n\\n p, s, f = None, root, root\\n while f and f.next:\\n p = s\\n s = s.next\\n f = f.next.next\\n\\n p.next = None\\n left = merge(root)\\n right = merge(s)\\n\\n dummy = TreeNode(0)\\n tail = dummy \\n while left and right:\\n if left.val <= right.val:\\n new = TreeNode(left.val)\\n tail.next = new\\n tail = tail.next\\n left = left.next\\n else:\\n new = TreeNode(right.val)\\n tail.next = new\\n tail = tail.next\\n right = right.next\\n\\n if left:\\n tail.next = left\\n \\n if right:\\n tail.next = right\\n\\n return dummy.next \\n\\n\\n return merge(head) \",\n \"memory\": \"34400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n # def merge(head):\\n if not head:\\n return head\\n if not head.next:\\n return head \\n\\n p, s, f = None, head, head\\n while f and f.next:\\n p = s\\n s = s.next\\n f = f.next.next\\n\\n p.next = None\\n left = self.sortList(head)\\n right = self.sortList(s)\\n\\n dummy = TreeNode(0)\\n tail = dummy \\n while left and right:\\n if left.val <= right.val:\\n new = TreeNode(left.val)\\n tail.next = new\\n tail = tail.next\\n left = left.next\\n else:\\n new = TreeNode(right.val)\\n tail.next = new\\n tail = tail.next\\n right = right.next\\n\\n if left:\\n tail.next = left\\n \\n if right:\\n tail.next = right\\n\\n return dummy.next \\n\\n\\n # return merge(head) \",\n \"memory\": \"34600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\n # def merge(head):\\n if not head or not head.next:\\n return head \\n\\n # split nodes into two halfs\\n p, s, f = None, head, head\\n while f and f.next:\\n p = s\\n s = s.next\\n f = f.next.next\\n\\n p.next = None\\n leftList = self.sortList(head)\\n rightList = self.sortList(s)\\n\\n # merging\\n tail = dummy = TreeNode(0) \\n while leftList and rightList:\\n if leftList.val <= rightList.val:\\n new = TreeNode(leftList.val)\\n tail.next = new\\n tail = tail.next\\n leftList = leftList.next\\n else:\\n new = TreeNode(rightList.val)\\n tail.next = new\\n tail = tail.next\\n rightList = rightList.next\\n\\n if leftList:\\n tail.next = leftList\\n \\n if rightList:\\n tail.next = rightList\\n\\n return dummy.next \\n\\n\\n # return merge(head) \",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n ns = []\\n while head is not None:\\n ns.append((head.val, head))\\n head = head.next\\n ns[-1][1].next = None\\n ns = sorted(ns, key = lambda cn: cn[0])\\n for ci in range(1, len(ns)): ns[ci - 1][1].next = ns[ci][1]\\n return ns[0][1] if ns else None\",\n \"memory\": \"35200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n node_set = []\\n while head:\\n node_set.append((head.val, head))\\n next_node= head.next\\n head.next = None\\n head = next_node\\n \\n node_set.sort(key = lambda x : x[0])\\n\\n for i in range(1,len(node_set)):\\n node_set[i-1][1].next = node_set[i][1]\\n \\n return node_set[0][1]\",\n \"memory\": \"35300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n h = []\\n curr = head\\n while curr:\\n h.append((curr.val, curr))\\n curr = curr.next\\n \\n h = sorted(h, key = lambda x: x[0])\\n\\n curr = rs = None\\n \\n for _, tmp in h:\\n if not rs:\\n rs = curr = tmp\\n else:\\n curr.next = tmp\\n curr = curr.next\\n curr.next = None\\n\\n return rs \",\n \"memory\": \"35400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n \\\"\\\"\\\"\\n easy way:\\n put each node (val, node) in a list\\n sort\\n update next pointers for each node\\n \\\"\\\"\\\"\\n nodes = []\\n curr = head\\n while curr:\\n nodes.append((curr.val, curr))\\n curr = curr.next\\n \\n nodes.sort(key=lambda node: node[0])\\n dummy = prev = ListNode(0)\\n \\n for (_, node) in nodes:\\n prev.next = node\\n prev = node\\n \\n prev.next = None\\n \\n return dummy.next\",\n \"memory\": \"35500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None: return None\\n pylist = []\\n node = head\\n while node is not None:\\n pylist.append((node.val, node))\\n node = node.next\\n pass\\n pylist.sort(reverse=True, key=(lambda val_node: val_node[0]))\\n\\n head_val, head = pylist.pop() # The list guaranteed not to be empty\\n node = head\\n while len(pylist) > 0:\\n val, next_node = pylist.pop()\\n node.next = next_node\\n node = next_node\\n pass\\n node.next = None\\n\\n return head\",\n \"memory\": \"35600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n sorted_arr = []\\n if head is None: return head\\n\\n while head is not None:\\n sorted_arr.append((head.val, head))\\n head = head.next \\n\\n print(\\\"len list:\\\", len(sorted_arr))\\n for val, n in sorted_arr: print(val)\\n\\n sorted_arr = sorted(sorted_arr, key=lambda x: x[0])\\n\\n for i, (val, node) in enumerate(sorted_arr[:-1]):\\n node.next = sorted_arr[i+1][1]\\n \\n sorted_arr[-1][1].next = None\\n\\n return sorted_arr[0][1]\",\n \"memory\": \"35700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return head\\n point = head\\n arr = []\\n while point is not None:\\n arr.append([point, point.val])\\n point = point.next\\n arr.sort(key = lambda x: x[1])\\n # print(arr)\\n for ind, item in enumerate(arr):\\n val, _ = item\\n if ind == len(arr) - 1:\\n val.next = None\\n else:\\n val.next = arr[ind + 1][0]\\n return arr[0][0]\\n\\n \\n \\n\",\n \"memory\": \"36100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n curr = head\\n node_list = []\\n\\n if curr == None:\\n return None\\n \\n while (curr):\\n node_list.append([curr.val, curr])\\n curr = curr.next\\n \\n node_list = sorted(node_list,key=lambda node: node[0])\\n\\n curr = node_list[0][1]\\n for i in range(1, len(node_list)):\\n curr.next = node_list[i][1]\\n curr = node_list[i][1]\\n \\n node_list[-1][1].next = None\\n\\n return node_list[0][1]\\n\",\n \"memory\": \"36200\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head):\\n node = head\\n lst = []\\n\\n if not head:\\n return None\\n\\n while node:\\n # print(node.val)\\n lst.append([node.val, node])\\n node = node.next\\n\\n lst = sorted(lst, key=lambda x: x[0])\\n # print(lst)\\n\\n head = lst[0][1]\\n prev = head\\n for i in range(1, len(lst)):\\n node = lst[i][1]\\n node.next = None\\n\\n prev.next = node\\n prev = node\\n\\n # print(head)\\n return head\\n \",\n \"memory\": \"36300\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head):\\n node = head\\n lst = []\\n if not head:\\n return None\\n\\n while node:\\n lst.append([node.val, node])\\n node = node.next\\n\\n lst = sorted(lst, key=lambda x: x[0])\\n\\n head = lst[0][1]\\n prev = head\\n for i in range(1, len(lst)):\\n node = lst[i][1]\\n node.next = None\\n\\n prev.next = node\\n prev = node\\n\\n return head\\n \",\n \"memory\": \"36300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n lst = []\\n cur = head\\n while cur != None:\\n lst.append([cur.val, cur])\\n cur = cur.next\\n \\n lst = sorted(lst, key=lambda x: x[0])\\n\\n new_head = ListNode()\\n cur = new_head\\n for item in lst:\\n item[1].next = None\\n cur.next = item[1]\\n cur = cur.next\\n \\n return new_head.next\\n \",\n \"memory\": \"36400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n self.node_map = {}\\n i = 0\\n curr = head\\n while curr:\\n self.node_map[i] = curr\\n curr = curr.next\\n i += 1\\n return self.__sortList(head, 0, i)\\n \\n def __sortList(self, head, i, j):\\n if not head or not head.next:\\n return head\\n left, right = self.__split(i, j)\\n left = self.sortList(left)\\n right = self.sortList(right)\\n merged = ListNode()\\n curr = merged\\n while left and right:\\n if left.val < right.val:\\n curr.next = left\\n left = left.next\\n else:\\n curr.next = right\\n right = right.next\\n curr = curr.next\\n if left:\\n curr.next = left\\n elif right:\\n curr.next = right\\n return merged.next\\n \\n\\n def __split(self, i, j):\\n left = self.node_map[i]\\n m = (i + j + 1) // 2\\n right = self.node_map[m]\\n self.node_map[m-1].next = None\\n return left, right\",\n \"memory\": \"36500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n self.node_map = {}\\n i = 0\\n curr = head\\n while curr:\\n self.node_map[i] = curr\\n curr = curr.next\\n i += 1\\n return self.__sortList(head, 0, i)\\n \\n def __sortList(self, head, i, j):\\n if not head or not head.next:\\n return head\\n left, right = self.__split(i, j)\\n left = self.sortList(left)\\n right = self.sortList(right)\\n merged = ListNode()\\n curr = merged\\n while left and right:\\n if left.val < right.val:\\n curr.next = left\\n left = left.next\\n else:\\n curr.next = right\\n right = right.next\\n curr = curr.next\\n if left:\\n curr.next = left\\n elif right:\\n curr.next = right\\n return merged.next\\n \\n\\n def __split(self, i, j):\\n left = self.node_map[i]\\n m = (i + j + 1) // 2\\n right = self.node_map[m]\\n self.node_map[m-1].next = None\\n return left, right\",\n \"memory\": \"36600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n nodes = []\\n\\n cur = head\\n i = 0\\n while cur:\\n nodes.append((cur.val, i, cur))\\n cur = cur.next\\n i += 1\\n nodes.sort()\\n\\n cur = ListNode()\\n root = cur\\n for i in range(len(nodes)):\\n _, _, node = nodes[i]\\n\\n cur.next = node\\n cur = cur.next\\n \\n cur.next = None\\n return root.next\",\n \"memory\": \"36800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:\\n\\n r = ListNode()\\n copy = r\\n\\n while list1 != None and list2 != None :\\n if(list1.val <= list2.val):\\n copy.next = ListNode(val = list1.val)\\n copy = copy.next\\n list1 = list1.next\\n else:\\n copy.next = ListNode(val = list2.val)\\n copy = copy.next\\n list2 = list2.next\\n\\n while list1 != None:\\n copy.next = ListNode(val = list1.val)\\n copy = copy.next\\n list1 = list1.next\\n \\n while list2 != None:\\n copy.next = ListNode(val = list2.val)\\n copy = copy.next\\n list2 = list2.next\\n\\n return r.next\\n\\n def merge(self,listH):\\n\\n head = listH\\n head2 = listH\\n before = None\\n while head2 != None:\\n before = head\\n head = head.next \\n head2 = head2.next\\n if(head2 != None):\\n head2 = head2.next\\n \\n second = before.next\\n if(second == None):\\n return listH\\n \\n before.next = None\\n\\n l = self.merge(listH)\\n r = self.merge(second)\\n\\n return self.mergeTwoLists(l,r) \\n\\n \\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if(head == None):\\n return None\\n \\n return self.merge(head)\",\n \"memory\": \"36900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: return\\n cur = head\\n arr = []\\n while cur:\\n arr.append(cur.val)\\n cur = cur.next\\n arr.sort()\\n newTree = ListNode(0)\\n cur = newTree\\n for i in arr:\\n newTree.next = ListNode(i)\\n newTree = newTree.next\\n return cur.next\\n\\n \",\n \"memory\": \"37000\"\n },\n {\n \"code\": \"import heapq\\n\\n# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n\\n nodes = []\\n node = head\\n idx = 0\\n while node:\\n next_node = node.next\\n node.next = None\\n nodes.append((node.val, idx, node))\\n node = next_node\\n idx += 1\\n\\n heapq.heapify(nodes)\\n \\n new_head = nodes[0][2]\\n prev_node = None\\n while nodes:\\n node = heapq.heappop(nodes)[2]\\n if prev_node:\\n prev_node.next = node\\n prev_node = node\\n return new_head\",\n \"memory\": \"37100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n # base case\\n if not head or not head.next:\\n return head\\n # Divide: slow and fast to find the middle point of the list\\n slow = head\\n fast = head \\n while fast.next and fast.next.next:\\n slow = slow.next\\n fast = fast.next.next\\n head1 = head\\n head2 = slow.next\\n slow.next = None\\n head1 = self.sortList(head1)\\n head2 = self.sortList(head2)\\n # merge:\\n return self.merge(head1,head2)\\n\\n\\n def merge(self,head1,head2):\\n # merge two sublists one by one\\n if not head1:\\n return head2\\n if not head2:\\n return head1\\n head = ListNode(0)\\n tmp = head\\n while head1 and head2:\\n if head1.val < head2.val:\\n tmp.next = ListNode(head1.val)\\n head1 = head1.next\\n else:\\n tmp.next = ListNode(head2.val)\\n head2 = head2.next\\n tmp = tmp.next\\n if not head1:\\n tmp.next = head2\\n if not head2:\\n tmp.next = head1\\n return head.next\",\n \"memory\": \"37200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n split = []\\n \\n node = head\\n while node:\\n split.append([node])\\n node = node.next\\n \\n if len(split) < 2:\\n return head\\n \\n ordered_nodes = self.merge(split)\\n\\n\\n for i in range(len(ordered_nodes) - 1):\\n ordered_nodes[i].next = ordered_nodes[i + 1]\\n ordered_nodes[-1].next = None\\n\\n return ordered_nodes[0]\\n\\n def merge(self, next_split):\\n split = []\\n \\n while len(next_split) > 1:\\n split = next_split\\n next_split = []\\n\\n while split:\\n left = split.pop()\\n if not split:\\n next_split.append(left)\\n continue\\n right = split.pop()\\n\\n new_seq = []\\n\\n while left and right:\\n if left[0].val < right[0].val:\\n new_seq.append(left.pop(0))\\n else:\\n new_seq.append(right.pop(0))\\n if left:\\n new_seq.extend(left)\\n elif right:\\n new_seq.extend(right)\\n \\n next_split.append(new_seq)\\n \\n return next_split[0]\\n \",\n \"memory\": \"37200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n\\n curr = head\\n arr = []\\n \\n\\n while curr:\\n val = curr.val\\n arr.append(val)\\n \\n curr = curr.next\\n sorted_arr = sorted(arr)\\n\\n dummy = ListNode(0)\\n curr = dummy\\n\\n for num in sorted_arr:\\n curr.next = ListNode(num)\\n\\n curr = curr.next\\n\\n\\n print(sorted_arr)\\n\\n return dummy.next\\n\\n \\n \",\n \"memory\": \"37300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head:\\n return None\\n \\n elems = []\\n\\n curr = head\\n while curr:\\n elems.append(curr.val)\\n curr = curr.next\\n elems.sort()\\n\\n dummyHead = ListNode(0)\\n prev = dummyHead\\n\\n for elem in elems:\\n new = ListNode(elem)\\n prev.next = new\\n prev = prev.next\\n return dummyHead.next\",\n \"memory\": \"37300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head: return None\\n nums = []\\n dummy = head\\n while dummy != None:\\n nums.append(dummy.val)\\n dummy = dummy.next\\n nums.sort()\\n head1 = ListNode()\\n dummy1 = head1\\n for i in range(len(nums)):\\n dummy1.next = ListNode(nums[i])\\n dummy1 = dummy1.next\\n return head1.next\",\n \"memory\": \"37400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n def construct(arr):\\n if len(arr)==0:\\n return None\\n head=ListNode(arr[0])\\n temp=head\\n for i in range(1,len(arr)):\\n temp.next=ListNode(arr[i])\\n temp=temp.next\\n return head\\n arr=[]\\n temp=head\\n while temp!=None:\\n arr.append(temp.val)\\n temp=temp.next\\n arr.sort()\\n return construct(arr)\\n\\n \",\n \"memory\": \"37400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n l = []\\n current = head\\n while current:\\n l.append(current.val)\\n current = current.next\\n \\n l.sort()\\n \\n start = ListNode()\\n current = start\\n for i in l:\\n new = ListNode(val=i)\\n current.next = new\\n current = current.next\\n \\n return start.next\",\n \"memory\": \"37500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head.next is None:\\n return head\\n list1 = []\\n while head:\\n list1.append(head.val)\\n head = head.next\\n list1.sort()\\n dummy = tail = ListNode(0)\\n for val in list1:\\n node = ListNode(val)\\n dummy.next = node\\n dummy = dummy.next\\n return tail.next\\n \",\n \"memory\": \"37500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if head is None or head is []:\\n return head \\n \\n extra = []\\n current = head\\n\\n while current:\\n extra.append(current.val)\\n current = current.next\\n \\n extra.sort()\\n\\n newHead = ListNode(extra[0])\\n current = newHead\\n\\n for val in extra[1:]:\\n current.next = ListNode(val)\\n current = current.next\\n \\n return newHead\\n\\n \",\n \"memory\": \"37600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n intermediate = []\\n while head != None:\\n intermediate.append(head.val)\\n head = head.next\\n intermediate.sort(reverse=True)\\n \\n node = None\\n for i in intermediate:\\n node = ListNode(i, node)\\n return node\",\n \"memory\": \"37700\"\n },\n {\n \"code\": \"class Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n if not head or not head.next:\\n return head\\n\\n # Extract the elements from the linked list\\n elements = []\\n current = head\\n while current:\\n elements.append(current.val)\\n current = current.next\\n\\n # Sort the elements\\n elements.sort()\\n\\n # Create a new sorted linked list\\n sorted_head = ListNode(elements[0])\\n current = sorted_head\\n for val in elements[1:]:\\n current.next = new_node = ListNode(val)\\n current = new_node\\n\\n return sorted_head\",\n \"memory\": \"37800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n storage = []\\n while head:\\n storage.append(head.val)\\n head = head.next\\n \\n storage.sort()\\n\\n if not storage:\\n return None\\n\\n head = ListNode(storage[0]) # Create the head node\\n current = head # Pointer to track the current node\\n\\n # Loop through the remaining values and create the linked list\\n for value in storage[1:]:\\n current.next = ListNode(value)\\n current = current.next # Move the pointer to the new node\\n\\n return head\",\n \"memory\": \"37800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n lst = list()\\n while head:\\n lst.append(head.val)\\n head = head.next\\n \\n lst = sorted(lst)\\n head = None\\n cursor = None\\n while lst:\\n if not head:\\n head = ListNode(lst.pop(0))\\n cursor = head\\n else:\\n cursor.next = ListNode(lst.pop(0))\\n cursor = cursor.next\\n \\n return head\\n \\n\\n\",\n \"memory\": \"37900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, val=0, next=None):\\n# self.val = val\\n# self.next = next\\nclass Solution:\\n def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:\\n values = []\\n while head:\\n values.append(head.val)\\n head = head.next\\n values = sorted(values)\\n head = None\\n p = head\\n for x in values[::-1]:\\n head = ListNode(x, p)\\n p = head\\n # ListNode()\\n ## my solution, get nodes, sort\\n return head\",\n \"memory\": \"37900\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":69,"string":"69"}}},{"rowIdx":53,"cells":{"question_id":{"kind":"number","value":149,"string":"149"},"name":{"kind":"string","value":"max-points-on-a-line"},"content":{"kind":"string","value":"<p>Given an array of <code>points</code> where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a point on the <strong>X-Y</strong> plane, return <em>the maximum number of points that lie on the same straight line</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/02/25/plane1.jpg\" style=\"width: 300px; height: 294px;\" />\n<pre>\n<strong>Input:</strong> points = [[1,1],[2,2],[3,3]]\n<strong>Output:</strong> 3\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/02/25/plane2.jpg\" style=\"width: 300px; height: 294px;\" />\n<pre>\n<strong>Input:</strong> points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]\n<strong>Output:</strong> 4\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= points.length <= 300</code></li>\n\t<li><code>points[i].length == 2</code></li>\n\t<li><code>-10<sup>4</sup> <= x<sub>i</sub>, y<sub>i</sub> <= 10<sup>4</sup></code></li>\n\t<li>All the <code>points</code> are <strong>unique</strong>.</li>\n</ul>\n"},"acRate":{"kind":"number","value":27.520810324781436,"string":"27.52081"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","hash-table","math","geometry"],"string":"[\n \"array\",\n \"hash-table\",\n \"math\",\n \"geometry\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"48\", 13.637699999999999], [\"70\", 37.489999999999995], [\"92\", 18.772100000000002], [\"114\", 7.198999999999999], [\"136\", 3.3143], [\"158\", 1.6299], [\"179\", 1.3582999999999996], [\"201\", 1.1137000000000001], [\"223\", 0.8424], [\"245\", 0.7609], [\"267\", 0.3807], [\"289\", 0.2718], [\"310\", 0.3262], [\"332\", 0.1631], [\"354\", 0.08159999999999999], [\"376\", 0.0544], [\"398\", 0.299], [\"420\", 0.13599999999999998], [\"441\", 0.2176], [\"463\", 0.2718], [\"485\", 0.19039999999999999], [\"507\", 0.10869999999999999], [\"529\", 0.1359], [\"551\", 0.10869999999999999], [\"573\", 0.6248], [\"594\", 0.3805], [\"616\", 0.16319999999999998], [\"638\", 0.1631], [\"660\", 0.1631], [\"682\", 0.08159999999999999], [\"704\", 0.1359], [\"725\", 0.1903], [\"747\", 0.0272], [\"769\", 0.13599999999999998], [\"791\", 0.0272], [\"813\", 0.08159999999999999], [\"835\", 0.13599999999999998], [\"856\", 0.0544], [\"878\", 0.0544], [\"900\", 0.0544], [\"922\", 0.0544], [\"944\", 0.1088], [\"966\", 0.1358], [\"987\", 0.08159999999999999], [\"1009\", 0.1631], [\"1031\", 0.3533], [\"1053\", 0.21749999999999997], [\"1075\", 0.2718], [\"1097\", 0.1088], [\"1118\", 0.0544], [\"1140\", 0.0544], [\"1162\", 0.0543], [\"1184\", 0.21739999999999998], [\"1206\", 0.0272], [\"1228\", 0.1631], [\"1249\", 0.0544], [\"1271\", 0.1088], [\"1293\", 0.0272], [\"1315\", 0.08159999999999999], [\"1337\", 0.0272], [\"1359\", 0.1088], [\"1381\", 0.0544], [\"1402\", 0.0544], [\"1424\", 0.0544], [\"1446\", 0.08159999999999999], [\"1468\", 0.0272], [\"1490\", 0.0272], [\"1512\", 0.08159999999999999], [\"1533\", 0.1359], [\"1555\", 0.0272], [\"1577\", 0.1088], [\"1599\", 0.13599999999999998], [\"1621\", 0.1088], [\"1643\", 0.0272], [\"1664\", 0.0544], [\"1686\", 0.08159999999999999], [\"1708\", 0.0544], [\"1730\", 0.0272], [\"1752\", 0.0272]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16354\", 25.8898], [\"16663\", 45.096500000000006], [\"16971\", 0.9508], [\"17280\", 0.0544], [\"17589\", 0.1358], [\"17898\", 0.1087], [\"18206\", 0.0272], [\"18515\", 0.0815], [\"18824\", 0.0544], [\"19133\", 0.0815], [\"19441\", 0.2717], [\"19750\", 0.2988], [\"20059\", 0.1358], [\"20368\", 0.0815], [\"20676\", 0.1358], [\"20985\", 0.0815], [\"21294\", 0.0543], [\"21603\", 0.0272], [\"21911\", 0.2173], [\"22220\", 0.1358], [\"22529\", 0.1086], [\"22838\", 0.163], [\"23146\", 0.163], [\"23455\", 0.1087], [\"23764\", 0.1087], [\"24073\", 0.35309999999999997], [\"24381\", 0.43470000000000003], [\"24690\", 1.1682], [\"24999\", 0.2717], [\"25308\", 0.1087], [\"25616\", 0.5705], [\"25925\", 1.8745], [\"26234\", 0.163], [\"26543\", 0.1901], [\"26851\", 0.2445], [\"27160\", 0.2444], [\"27469\", 0.1087], [\"27778\", 0.326], [\"28086\", 0.2716], [\"28395\", 0.1358], [\"28704\", 0.326], [\"29013\", 0.5705], [\"29321\", 0.2988], [\"29630\", 0.1902], [\"29939\", 0.2445], [\"30248\", 0.2172], [\"30556\", 0.0272], [\"30865\", 0.08159999999999999], [\"31174\", 0.1358], [\"31483\", 0.1087], [\"31791\", 0.0272], [\"32100\", 0.2173], [\"32409\", 0.1358], [\"32718\", 0.0815], [\"33026\", 0.1087], [\"33335\", 0.1087], [\"33644\", 0.1087], [\"33953\", 0.1359], [\"34261\", 0.0815], [\"34570\", 0.163], [\"34879\", 0.0272], [\"35188\", 0.1087], [\"35496\", 0.8694], [\"35805\", 1.6029], [\"36114\", 0.2716], [\"36423\", 0.0272], [\"36731\", 0.0544], [\"37040\", 0.2989], [\"37349\", 0.10869999999999999], [\"37658\", 0.0815], [\"37966\", 0.1902], [\"38275\", 0.32589999999999997], [\"38584\", 0.3532], [\"38893\", 0.0815], [\"39201\", 0.163], [\"39510\", 0.1086], [\"39819\", 0.1358], [\"40128\", 0.0272], [\"40436\", 0.5705], [\"40745\", 2.2277]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points) #amount of point\n maxP = 0 # current max points - initalize variable\n\n for i in range(n):\n X = points[i][0]\n Y = points[i][1]\n map = {} # create temperory dict for story points\n\n for j in range(i+1, n):\n dx = points[j][0] - X\n dy = points[j][1] - Y # change in x and y pos\n\n if(dx != 0): \n d = dy/dx\n if d in map:\n map[d] = map[d] + 1\n else:\n map[d] = 1 \n else:\n if 20001.0 in map:\n map[20001.0] = map[20001.0] + 1\n else:\n map[20001.0] = 1 # test case put here since I cant solve\n\n if map:\n maxP = max(maxP, max(map.values())) # return longest one by sorting it and get the max - since you have to get the value (sort by value), I don't know how to do max() with it\n\n return maxP + 1\n ","runtime":"48"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n slopes_map = {}\n for i, point1 in enumerate(points):\n for point2 in points[i+1:]:\n if point1[0] - point2[0] != 0:\n slope = (point1[1]-point2[1])/(point1[0]-point2[0])\n else:\n slope = 'inf'\n current_slope = slopes_map.get((i,slope))\n if current_slope is None:\n slopes_map[(i,slope)] = 2\n else:\n slopes_map[(i,slope)] += 1\n return max(slopes_map.values(), default = 1)","runtime":"48"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1: return 1\n \n def findslope(p1, p2):\n x1, y1 = p1[0], p1[1]\n x2, y2 = p2[0], p2[1]\n if x2-x1 == 0: return inf\n return (y2-y1)/(x2-x1)\n res = 0\n for i in range(len(points)):\n slope_dict = defaultdict(int)\n for j in range(i+1, len(points) ):\n p1 = points[i]\n p2 = points[j]\n slope = findslope(p1, p2)\n slope_dict[slope] += 1\n res = max(res, max(slope_dict.values(), default=0)+1)\n\n return res","runtime":"70"},{"code":"from collections import defaultdict\nfrom math import gcd\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n if n < 2:\n return n\n \n max_points = 1 # At least one point is there\n \n for i in range(n):\n slope_count = defaultdict(int)\n vertical_lines = 0 # Count vertical lines where dx == 0\n duplicate = 1 # Count the starting point itself\n cur_max = 0 # Current max points on the same line\n \n for j in range(i + 1, n):\n dx = points[j][0] - points[i][0]\n dy = points[j][1] - points[i][1]\n \n if dx == 0 and dy == 0: # Case of duplicate points\n duplicate += 1\n elif dx == 0: # Case of vertical line\n vertical_lines += 1\n cur_max = max(cur_max, vertical_lines)\n else:\n # Normalize the slope by using gcd\n g = gcd(dx, dy)\n dx //= g\n dy //= g\n \n # To handle consistent slope direction, ensure dx is always positive\n if dx < 0:\n dx, dy = -dx, -dy\n \n # Count points on the same slope\n slope_count[(dx, dy)] += 1\n cur_max = max(cur_max, slope_count[(dx, dy)])\n \n max_points = max(max_points, cur_max + duplicate)\n \n return max_points\n","runtime":"70"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n if n == 1: return 1\n res = 2\n for i in range(n):\n d = defaultdict(int)\n for j in range(n):\n if i != j:\n d[math.atan2(points[j][1] - points[i][1], points[j][0] - points[i][0])] += 1\n res = max(res, max(d.values()) + 1)\n return res","runtime":"92"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n res = 1\n for point in points:\n slopes = defaultdict(int)\n x1, y1 = point\n for another in points:\n if point != another:\n x2, y2 = another\n if x1 == x2:\n slope = inf\n else:\n slope = (y2-y1)/(x2-x1)\n slopes[slope] += 1\n for slope, count in slopes.items():\n res = max(res, count + 1)\n return res","runtime":"92"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n slopes = defaultdict(set)\n for i in range(len(points)):\n for j in range(i + 1, len(points)):\n if points[i][0]-points[j][0] == 0:\n slope = \"inf\"\n y_int = points[i][0]\n else:\n slope = (points[i][1]-points[j][1])/(points[i][0] - points[j][0])\n y_int = points[i][1] - (slope * points[i][0])\n slopes[(slope, y_int)].add(tuple(points[i]))\n slopes[slope, y_int].add(tuple(points[j]))\n\n if len(slopes.values()) == 0:\n return 1\n return sorted([len(i) for i in slopes.values()])[-1]","runtime":"114"},{"code":"# Hard problem. Max Points on a Line.\n# Given an array of points where points[i] = [x, y]\n# Return the maximum number of points on the same straight line\n\n# Ok, let's remember from algebra,\n# the equation of a line is:\n# y = m * x + b\n# And given two points, we can find a line between them\n\n# We notice that a point can either be on the maximum line\n# or not on the maximum line\n\n# the maximum line is the line that has the most points on it\n\n# The minimum answer is going to be 1 if points.length == 1\n# and 2 is points.length == 2\n# If the max len is 3 and points.length is 3, then all points\n# are on the same line\n\n# It might take some work to code up the function verifying\n# If a point is on line A, but it won't be that hard, I\n# was good at algebra\n\n# We have up to 300 points\n# 300^2 is a reasonable solution\n# 300^3 == 300 * 90000 == 27000000\n# which is even doable\n# One point will have up to 300 lines\n# Why don't we enumerate every line, check whether other points are on that line\n# and count for that line?\n# If there an easy way to tell if a point is on the line?\n# All we have of a point is its x and y position\n# Maybe if we plug x and y into the equation of the line,\n# and we get an equality, the point is on our line\n# I think I know what to do\n# Create every line from each point to each other point\n# check all points if they are on that line\n# bam\n\n# Maybe we could use a set of lines so that we don't\n# have to recheck\nclass Solution:\n def maxPoints(self, points: list[list[int]]) -> int:\n if len(points) <= 2: return len(points)\n def defval():\n return []\n line_set = defaultdict(defval)\n \n for i in range(len(points)):\n x1, y1 = points[i]\n #print(\"starting: {}, {}\".format(x1, y1))\n for j in range(i + 1, len(points)):\n x2, y2 = points[j]\n \n if x1 == x2:\n m = float('inf')\n b = x1\n else:\n m = (y2 - y1) / (x2 - x1)\n b = y1 - (m * x1)\n \n #print(x2, y2, m, b)\n intersects = line_set[(m,b)]\n if (x1, y1) not in intersects:\n intersects.append((x1, y1))\n if (x2, y2) not in intersects:\n intersects.append((x2, y2))\n \n #print(\"lines:\")\n max_points = 0\n for line in line_set:\n max_points = max(max_points, len(line_set[line]))\n #print(line, line_set[line])\n return max_points","runtime":"114"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 1: \n return len(points)\n greatest = 2\n \n for i in range(len(points)): \n lines = {}\n for j in range(i + 1, len(points)): \n if points[i][0] - points[j][0] == 0: \n slope = float(\"inf\")\n else:\n slope = (points[i][1] - points[j][1]) / (points[i][0] - points[j][0])\n \n if slope not in lines: \n lines[slope] = 0\n lines[slope] += 1\n greatest = max(greatest, max(lines.values()) + 1)\n \n return greatest\n \n ","runtime":"136"},{"code":"from collections import Counter\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n c = defaultdict(set)\n n = len(points)\n\n max_points = 0\n\n for i in range(n):\n x1,y1 = points[i]\n cur_line = Counter()\n\n for j in range(i+1, n):\n x2, y2 = points[j]\n dx, dy = x1-x2, y1-y2\n\n if dx == 0:\n key = f'vert_{x1}'\n elif dy == 0:\n key = f'hrznt_{y1}'\n else:\n k = (y1-y2)/(x1-x2)\n b = y1-k*x1\n\n key = f'{k}#{b}'\n\n cur_line[key] += 1\n # print(points[i], cur_line)\n\n if cur_line:\n max_points = max(max_points, max(cur_line.values()))\n\n return max_points + 1","runtime":"136"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n \n equations_to_point_set = defaultdict(set)\n \n for p1 in points:\n for p2 in points:\n if p1 == p2:\n continue\n \n x1, y1 = p1\n x2, y2 = p2\n\n if (x1 == x2):\n equations_to_point_set[(None, x1)].add((x1, y1))\n equations_to_point_set[(None, x1)].add((x2, y2))\n continue\n\n m = (y2 - y1) / (x2 - x1)\n b = y1 - (m * x1)\n \n equations_to_point_set[(m, b)].add((x1, y1))\n equations_to_point_set[(m, b)].add((x2, y2))\n\n # for (m, b), ps in equations_to_point_set.items():\n # print(f'equation: {m}x + {b}')\n # print('points: ', ps)\n # print('@@@')\n\n return max([len(ps) for ps in equations_to_point_set.values()])\n","runtime":"158"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 2:\n return len(points)\n max_points = 2\n for i in range(500):\n idx1, idx2 = random.sample(range(0, len(points)), 2)\n p1, p2 = points[idx1], points[idx2]\n m, b = self.find_line(p1[0], p1[1], p2[0], p2[1])\n num_points = 0\n for i, point in enumerate(points):\n if self.check_fitline(m, b, point[0], point[1]):\n num_points += 1\n\n max_points = max(num_points, max_points)\n\n return max_points\n\n def check_fitline(self, m, b, x, y):\n if m == float(\"inf\"):\n return b == x\n return math.isclose(m * x + b, y)\n\n def find_line(self, x1, y1, x2, y2):\n if x2 - x1 == 0:\n return float(\"inf\"), x1\n m = (y2 - y1) / (x2 - x1)\n b = y1 - m * x1\n return m, b","runtime":"158"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n results = 2\n if len(points) <= 2:\n return len(points)\n slope_map = {}\n for i in range(len(points) - 1):\n for j in range(i+1, len(points)):\n nOP = 0\n if (points[j][0] - points[i][0]) == 0:\n nOP = len([p for p in points if p[0] == points[j][0]])\n if (\"inf\", points[j][0]) in slope_map:\n slope_map[(\"inf\", points[j][0])] += 1\n else:\n slope_map[(\"inf\", points[j][0])] = 1\n else:\n a = - (points[j][1] - points[i][1]) / (points[j][0] - points[i][0])\n c = round(- points[i][0] * a - points[i][1], 3)\n print(a, c)\n if (a, c) in slope_map:\n slope_map[(a, c)] += 1\n else:\n slope_map[(a, c)] = 1\n for point in slope_map.values():\n if point > results:\n results = point\n return int((1 + math.sqrt(8*results+1) / 2 )) if results > 2 else results","runtime":"179"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lp, maxpoints = len(points), 1\n if lp ==1: return maxpoints\n slopes = [defaultdict(int) for _ in range(lp)]\n for i in range(lp):\n x1, y1 = points[i]\n for j in range(lp):\n if j != i:\n x2, y2 = points[j]\n if x1 == x2 and y1 == y2:\n slope = \"0\"\n elif x1 == x2:\n slope = str(x1) + \"v\"\n elif y1 == y2:\n slope = str(y1) + \"h\"\n elif j > i:\n slope = str(round((y2-y1) / (x2-x1), 10))\n else:\n slope = str(round((y1-y2) / (x1-x2), 10))\n slopes[i][slope] += 1\n maxpoints = max(maxpoints, slopes[i][slope])\n return maxpoints + 1","runtime":"179"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # (y2 - y1) = m(x2 - x1)\n # y = mx + B\n # map (slope, B)\n pointsOnLine = {}\n for i in range(len(points)):\n point1 = points[i]\n for j in range(i + 1, len(points)):\n point2 = points[j]\n m = self.calculateSlope(point1, point2)\n b = self.calculateB(point1, m)\n line = (m, b)\n currentSet = pointsOnLine.get(line, set())\n currentSet.add((point1[0], point1[1]))\n currentSet.add((point2[0], point2[1]))\n pointsOnLine[line] = currentSet\n\n result = 1\n for points in pointsOnLine.values():\n result = max(result, len(points))\n\n print(pointsOnLine)\n \n return result\n \n def calculateSlope(self, point1, point2):\n x1, x2 = point1[0], point2[0]\n y1, y2 = point1[1], point2[1]\n\n if (x2 - x1) == 0:\n return None\n\n m = (y2 - y1) / (x2 - x1)\n return m\n\n def calculateB(self, point, m):\n x, y = point[0], point[1]\n if m == None:\n return x\n b = y - (m * x)\n return b","runtime":"201"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if not points:\n return 0\n if len(points) == 1:\n return 1\n Hash = defaultdict(set)\n n = len(points)\n for i in range(n):\n for j in range(i+1, n):\n pointA = points[i]\n pointB = points[j]\n\n if pointA[0] == pointB[0]:\n Hash[(float('inf'), pointA[0])].add(tuple(pointA))\n Hash[(float('inf'), pointA[0])].add(tuple(pointB))\n\n else:\n gradient = (pointA[1] - pointB[1])/(pointA[0]-pointB[0])\n intercept = pointA[1]-gradient * pointA[0]\n key = (gradient, intercept)\n Hash[key].add(tuple(pointA))\n Hash[key].add(tuple(pointB))\n \n print(Hash)\n\n return max(len(v) for k, v in Hash.items())\n\n \n","runtime":"201"},{"code":"from collections import defaultdict\nclass Solution:\n # y = mx + c\n # c = y\n def maxPoints(self, points: List[List[int]]) -> int:\n points.sort(key = lambda x: (x[0], x[1]))\n count = 0\n for i in range(1, len(points)):\n x0, y0 = points[i]\n lines = defaultdict(int)\n for j in range(i):\n x1, y1 = points[j]\n slope = (y0-y1)/(x0-x1) if (x0-x1) != 0 else float('inf')\n intercept = y0-slope*(x0) if slope != float('inf') else y0\n lines[(slope, intercept)] += 1\n print(points[i], points[j], slope, intercept)\n count = max(count, lines[(slope, intercept)])\n count += 1\n # print(lines)\n return count","runtime":"223"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n options = {}\n max_a= 1\n for i in range(len(points)):\n for j in range(i+1,len(points)):\n if (points[i][0]-points[j][0]) != 0:\n a = (points[i][1]-points[j][1])/(points[i][0]-points[j][0])\n b = -(-points[i][1]+a*(points[i][0]))\n else:\n a = 'x'\n b = points[i][0]\n print(points[i],points[j])\n \n st = str(a)+\"_\"+str(b)\n if st in options:\n options[st].add(str(points[i]))\n options[st].add(str(points[j]))\n else:\n options[st] = set([str(points[i]),str(points[j])])\n for i in options.keys():\n print(options[i], i)\n max_a= max(len(options[i]), max_a)\n return max_a\n \n \n \n ","runtime":"223"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n if len(points) == 1 : \n return 1 \n\n n = len(points)\n\n slope = [[0 for i in range(n)] for j in range(n)]\n intercept = [[0 for i in range(n)] for j in range(n)] \n\n for i in range(n) : \n for j in range(n) : \n if i == j : \n slope[i][j] = None \n else : \n x1 = points[i][0]\n y1 = points[i][1]\n x2 = points[j][0]\n y2 = points[j][1]\n\n # Now calculate slope \n if x2 - x1 == 0 : \n if y2 - y1 > 0 : \n m = float('inf')\n c = x1\n else : \n m = float('-inf')\n c = x1 \n else : \n m = (y2 - y1) / (x2 - x1)\n c = y1 - m * x1\n\n slope[i][j] = m \n intercept[i][j] = c \n\n # # Print Slope \n # for i in range(n) : \n # print(slope[i])\n\n # print(\"-\" * 20)\n\n # # Print Intercept \n # for i in range(n) : \n # print(slope[i]) \n\n # print(\"-\" * 20)\n\n vals = {} \n\n for i in range(n) : \n for j in range(n) : \n if i != j : \n key = str(slope[i][j]) + \"*\" + str(intercept[i][j])\n if key not in vals.keys() : \n vals[key] = set() \n vals[key].add(i)\n vals[key].add(j)\n else : \n vals[key].add(i)\n vals[key].add(j)\n op = 0 \n for key in list(vals.keys()) : \n # print(f\"Key : {key} , Vals : {vals[key]}\")\n op = max(op, len(vals[key]))\n return op\n\n\n ","runtime":"245"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n length = len(points)\n\n if length <= 2:\n return length\n\n lines = {}\n \n for i in range(length-1):\n p1 = points[i]\n for j in range(i+1, length):\n p2 = points[j]\n m = 'inf'\n b = p1[0]\n if p2[0]-p1[0] != 0:\n m = (p2[1]-p1[1])/(p2[0]-p1[0])\n b = -p1[0] * m + p1[1]\n if (m, b) not in lines:\n lines[(m, b)] = [0, set()]\n if tuple(p1) not in lines[(m,b)][1]:\n lines[(m,b)][1].add(tuple(p1))\n lines[(m, b)][0] += 1\n if tuple(p2) not in lines[(m,b)][1]:\n lines[(m,b)][1].add(tuple(p2))\n lines[(m, b)][0] += 1\n\n print(lines)\n return max(lines.values())[0]","runtime":"245"},{"code":"from collections import defaultdict\nfrom fractions import Fraction\nfrom math import inf\n\nclass Solution:\n def getSlope(self, point: List[int], other_point: List[int]) -> Fraction:\n x1, y1 = point\n x2, y2 = other_point\n \n slope = inf if x2 == x1 else Fraction((y2 - y1), (x2 - x1))\n \n return slope\n\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n \n max_num_points_on_line = 1\n \n for i in range(0, len(points)):\n slope_map = defaultdict(set)\n for j in range(i + 1, len(points)):\n point = points[i]\n other_point = points[j]\n slope = self.getSlope(point, other_point)\n slope_map[slope].add(tuple(point))\n slope_map[slope].add(tuple(other_point))\n \n if len(slope_map[slope]) > max_num_points_on_line:\n max_num_points_on_line = len(slope_map[slope])\n \n return max_num_points_on_line","runtime":"267"},{"code":"\nimport functools\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \n if len(points) == 1:\n return 1\n\n lines = {}\n # a line has a key (slope, intercept), if slope is None, intercept is x=<value>\n # value is a set of points\n\n def addLine(x1, y1, x2, y2):\n if (x2 - x1) == 0:\n slope = None\n intercept = x1\n else:\n slope = (y2 - y1) / (x2 - x1)\n intercept = y1 - slope * x1\n if not (slope, intercept) in lines:\n lines[(slope, intercept)] = set()\n lines[(slope, intercept)].add((x1, y1))\n lines[(slope, intercept)].add((x2, y2))\n\n for i in range(len(points)):\n for j in range(i + 1, len(points)):\n addLine(points[i][0], points[i][1], points[j][0], points[j][1])\n \n print(lines)\n print(lines.values())\n\n m = \\\n functools.reduce(lambda a, x: len(x) if a < len(x) else a, lines.values(), 0)\n\n return m\n","runtime":"267"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n hashmap = defaultdict(set)\n # {(slope, intercept): set(point1, point2, point3)}\n if len(points) == 1: return 1\n elif len(points) == 2: return 2\n\n for x1, y1 in points:\n for x2, y2 in points:\n if (x2 - x1) != 0:\n slope = (y2 - y1) / (x2 - x1)\n intercept = y1 - slope * x1\n hashmap[(slope, intercept)].add((x1, y1))\n hashmap[(slope, intercept)].add((x2, y2))\n else:\n slope = None\n intercept = x1\n hashmap[(slope, intercept)].add((x1, y1))\n hashmap[(slope, intercept)].add((x2, y2))\n \n print(hashmap)\n maxcount = 1\n for key, values in hashmap.items():\n maxcount = max(maxcount, len(values))\n \n return maxcount\n\n\n\n\n","runtime":"289"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n mapping = {}\n for point in points:\n toAdd = (point[0], point[1])\n mapping[toAdd] = {}\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n pointi = (points[i][0], points[i][1])\n pointj = (points[j][0], points[j][1])\n if points[i][0]- points[j][0] == 0:\n mapping[pointi][pointj] = float(\"inf\")\n mapping[pointj][pointi] = float(\"inf\")\n else:\n mapping[pointi][pointj] = (points[i][1]-points[j][1])/(points[i][0]-points[j][0])\n mapping[pointj][pointi] = (points[i][1]-points[j][1])/(points[i][0]-points[j][0])\n \n def getFrequency(items):\n print(items)\n mapping = {}\n for i in items:\n print(i)\n if i in mapping:\n mapping[i] += 1\n else:\n mapping[i] = 1\n maximum = 0\n print(mapping)\n return getLargest(mapping.values())\n \n def getLargest(items):\n maximum = 0\n for item in items:\n maximum = max(maximum, item)\n return maximum\n\n maximums = []\n for i in range(len(points)):\n point = (points[i][0], points[i][1])\n maximum = 0\n maximums.append(getFrequency(mapping[point].values()))\n \n return getLargest(maximums) + 1\n \n \n \"\"\"\n counting = {}\n for i in range(len(points)):\n for item in mapping[points[i]].values():\n if item in counting:\n counting[item] += 1\n else:\n counting[item] = 1\n \n maximum = 0\n for i in counting.values():\n if i > maximum:\n maximum = i\n \n return int(math.sqrt(maximum+1))\n \"\"\"\n\n \n","runtime":"289"},{"code":"import fractions\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n \n max_count = 0\n\n for ax, ay in points:\n slope_counts = Counter()\n for bx, by in points:\n if (ax, ay) == (bx, by):\n continue\n slope = fractions.Fraction(by - ay, bx - ax) if bx != ax else None\n slope_counts[slope] += 1\n max_through_a = max(slope_counts.values())\n max_count = max(max_count, 1 + max_through_a)\n \n return max_count\n","runtime":"310"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # (y2 - y1) = m(x2 - x1)\n # y = mx + B\n # map (slope, B)\n pointsOnLine = {}\n for point1 in points:\n for point2 in points:\n if id(point1) != id(point2):\n m = self.calculateSlope(point1, point2)\n b = self.calculateB(point1, m)\n line = (m, b)\n currentSet = pointsOnLine.get(line, set())\n currentSet.add((point1[0], point1[1]))\n currentSet.add((point2[0], point2[1]))\n pointsOnLine[line] = currentSet\n\n result = 1\n for points in pointsOnLine.values():\n result = max(result, len(points))\n\n print(pointsOnLine)\n \n return result\n \n def calculateSlope(self, point1, point2):\n x1, x2 = point1[0], point2[0]\n y1, y2 = point1[1], point2[1]\n\n if (x2 - x1) == 0:\n return None\n\n m = (y2 - y1) / (x2 - x1)\n return m\n\n def calculateB(self, point, m):\n x, y = point[0], point[1]\n if m == None:\n return x\n b = y - (m * x)\n return b","runtime":"310"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n out = 2\n for i in range(len(points)):\n slope_map = {}\n for j in range(i + 1, len(points)):\n x, y = points[i]\n p, q = points[j]\n found = False\n for rise, run in slope_map.keys():\n if not found and rise * (x - p) == run * (y - q):\n slope_map[(rise, run)] += 1\n out = max(slope_map[(rise, run)], out)\n found = True\n if not found:\n rise, run = y - q, x - p\n slope_map[(rise, run)] = 2\n return out\n","runtime":"332"},{"code":"import numpy as np\nimport math\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n record = {}\n best = 0\n directions = [[1, 0], [0, 1], [-1, 0], [0, -1], [1, 1], [-1,-1], [-1, 1], [1, -1]]\n\n for i in range(len(points)):\n record[tuple(points[i])] = {}\n current = points[i]\n #print(\"Current is: \", current)\n for j in range(i+1, len(points)):\n other = points[j]\n difference = [current[0]-other[0], current[1]-other[1]]\n # here I'll have to convert the difference to a normalised direction vector\n current_gcd = math.gcd(difference[0], difference[1])\n difference[0] = int(difference[0]/current_gcd)\n difference[1] = int(difference[1]/current_gcd)\n if difference[0]<=0 and difference[1]<=0:\n difference[0] = difference[0]*(-1)\n difference[1] = difference[1]*(-1)\n #print(\" Difference is: \", difference)\n if difference[0]>0 and difference[1]<0:\n difference[0] = difference[0]*(-1)\n difference[1] = difference[1]*(-1)\n #print(difference, current, other)\n if tuple(difference) in record[tuple(current)].keys():\n #print(\"heya\")\n record[tuple(current)][tuple(difference)].append(tuple(other))\n best = max(best, len(record[tuple(current)][tuple(difference)]))\n else :\n record[tuple(current)][tuple(difference)] = [tuple(other)]\n best = max(1, best)\n #print('\\t\\t\\t', record)\n return best+1\n\n\n\n ","runtime":"332"},{"code":"import fractions\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 3: return len(points)\n\n line_count = Counter()\n def line(x1,y1,x2,y2):\n if x1 == x2: return (x1,inf)\n\n slope = fractions.Fraction(y2-y1,x2-x1)\n intercept = y1-slope*x1\n return (intercept,slope)\n for i in range(len(points)):\n px,py = points[i]\n for j in range(i+1,len(points)):\n qx,qy = points[j]\n line_count[line(px,py,qx,qy)] += 1\n return int(0.5*(sqrt(8*max(line_count.values())+1)+1))\n","runtime":"376"},{"code":"from collections import defaultdict\nfrom fractions import Fraction\n\nclass Solution:\n def maxPoints(self, points: list[list[int]]) -> int:\n def slope(p1, p2):\n dx = p2[0] - p1[0]\n dy = p2[1] - p1[1]\n if dx == 0: # vertical line\n return float('inf')\n if dy == 0: # horizontal line\n return 0\n return Fraction(dy, dx)\n \n if len(points) <= 2:\n return len(points)\n \n max_points = 1\n \n for i in range(len(points)):\n slopes = defaultdict(int)\n same_point_count = 1\n for j in range(len(points)):\n if i != j:\n if points[i] == points[j]:\n same_point_count += 1\n else:\n s = slope(points[i], points[j])\n slopes[s] += 1\n \n max_points = max(max_points, same_point_count + max(slopes.values(), default=0))\n \n return max_points\n","runtime":"376"},{"code":"from fractions import Fraction\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n rows = {}\n cols = {}\n wb = {}\n for i, p1 in enumerate(points[:-1]):\n x1, y1 = p1\n for x2, y2 in points[i + 1:]:\n if x1 == x2:\n if x1 in rows:\n rows[x1] += 1\n else:\n rows[x1] = 1\n continue\n if y1 == y2:\n if y1 in cols:\n cols[y1] += 1\n else:\n cols[y1] = 1\n continue\n w = Fraction(y1 - y2, x1 - x2)\n b = y1 - x1 * w\n if (w, b) in wb:\n wb[(w, b)] += 1\n else:\n wb[(w, b)] = 1\n max_row = max(rows.values()) if rows.values() else 0\n max_col = max(cols.values()) if cols.values() else 0\n max_wb = max(wb.values()) if wb.values() else 0\n max_edges = max([max_wb, max_row, max_col])\n res = int(0.5 * (1 + (1 + 8 * max_edges)**0.5))\n return res","runtime":"398"},{"code":"from collections import defaultdict\nfrom fractions import Fraction\nfrom itertools import combinations\nfrom typing import List, Dict, Tuple, Set\n\n\ndef solution(points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n\n vertical: Dict[int, Set[Tuple[int, int]]] = defaultdict(set)\n hist: Dict[Tuple[Fraction, Fraction], Set[Tuple[int, int]]] = defaultdict(set)\n for p0, p1 in combinations(points, 2):\n if p0[0] == p1[0]: # horizontal\n vertical[p0[0]].add(tuple(p0))\n vertical[p0[0]].add(tuple(p1))\n else:\n a = Fraction(p1[1] - p0[1], p1[0] - p0[0])\n b = Fraction(p0[1] * p1[0] - p0[0] * p1[1], p1[0] - p0[0])\n hist[(a, b)].add(tuple(p0))\n hist[(a, b)].add(tuple(p1))\n best = 0\n if vertical:\n best = max(map(len, vertical.values()))\n if hist:\n best = max(best, max(map(len, hist.values())))\n return best\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n return solution(points)","runtime":"398"},{"code":"from fractions import Fraction\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lines = {0:[1]}\n for i in range(len(points)):\n ax,ay = points[i]\n for j in range(i+1,len(points)):\n bx,by = points[j]\n if bx != ax:\n slope = Fraction(by-ay,bx-ax)\n intercept = ay-slope*ax\n else:\n slope = inf\n intercept = ax\n if (slope,intercept) in lines:\n lines[(slope,intercept)].add((bx,by))\n else:\n lines[(slope,intercept)] = set([(ax,ay),(bx,by)])\n return max([len(b) for b in lines.values()])\n \n\n ","runtime":"420"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n maxCount = 1\n\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n x1, y1 = points[i]\n x2, y2 = points[j]\n slope = (y2 - y1) / (x2 - x1) if x2 != x1 else None\n count = 2\n for k in range(j+1, len(points)):\n x3, y3 = points[k]\n mySlope = (y3 - y2) / (x3 - x2) if x3 != x2 else None\n if slope == mySlope:\n count += 1\n maxCount = max(count, maxCount)\n\n\n return maxCount","runtime":"420"},{"code":"import math\nfrom fractions import Fraction\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n num_pts= {}\n for n0 in range(len(points)):\n for n1 in range(n0+1, len(points)):\n if points[n1][0] == points[n0][0]:\n m = float(\"inf\")\n b = points[n1][0]\n else:\n m = Fraction(points[n1][1] - points[n0][1], points[n1][0] - points[n0][0])\n b = points[n1][1] - m * points[n1][0]\n if (m,b) not in num_pts:\n num_pts[(m,b)] = 1\n else:\n num_pts[(m,b)] += 1\n print(num_pts)\n maxval = 0\n for k, v in num_pts.items():\n if v > maxval:\n maxval = v\n return int(math.floor(math.sqrt(maxval * 2))) + 1\n","runtime":"441"},{"code":"import fractions\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n ans = 0\n for i in range(len(points)):\n cnt = defaultdict(int)\n for j in range(len(points)):\n if i == j:\n continue\n if points[i][0] != points[j][0]:\n slope = fractions.Fraction(points[i][1] - points[j][1], points[i][0] - points[j][0])\n else:\n slope = math.inf\n cnt[slope] += 1\n ans = max(ans, cnt[slope])\n return ans + 1","runtime":"441"},{"code":"class Solution:\n def maxPoints(self, points: list[list[int]]) -> int:\n n = len(points)\n ans = 1\n for i in range(n):\n x1, y1 = points[i]\n for j in range(i):\n x2, y2 = points[j]\n cnt = 2\n for k in range(j):\n x3, y3 = points[k]\n if (y2-y1)*(x3-x1) == (x2-x1)*(y3-y1): cnt += 1\n ans = max(ans, cnt)\n return ans\n","runtime":"463"},{"code":"from typing import NamedTuple, Optional\nfrom fractions import Fraction\n\nclass Line(NamedTuple):\n m: Optional[Fraction]\n b: Fraction\n\n @staticmethod \n def from_points(x1: int, y1: int, x2: int, y2: int) -> 'Line':\n if x1 == x2:\n return Line(m=None, b=x1)\n else: \n m = Fraction(y1 - y2, x1 - x2)\n b = y1 - m * x1\n return Line(m=m, b=b)\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2:\n return len(points)\n\n result = 0\n for i in range(len(points) - 1):\n lines = collections.defaultdict(int)\n for j in range(i + 1, len(points)):\n line = Line.from_points(*points[i], *points[j])\n lines[line] += 1\n result = max(result, max(lines.values()) + 1)\n return result\n \n \n\n ","runtime":"463"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n result = 2\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n x1, y1 = points[i]\n x2, y2 = points[j]\n current_result = 2\n for k in range(j+1, len(points)):\n x3, y3 = points[k]\n if (x2-x1) * (y3 - y2) == (x3 - x2) * (y2 - y1):\n current_result += 1\n result = max(result, current_result)\n return result\n\n ","runtime":"485"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n N = len(points)\n if N <= 2:\n return N\n \n def countPoints(i, a, b):\n p0 = points[i]\n if a == 0:\n return sum(p[0] == p0[0] for p in points[i + 1:])\n if b == 0:\n return sum(p[1] == p0[1] for p in points[i + 1:])\n \n count = 0\n for p in points[i + 1:]:\n dx = p[0] - p0[0]\n dy = p[1] - p0[1]\n if dx % a == 0 and dy % b == 0 and dy == dx * b // a:\n count += 1\n return count\n \n #seen = set()\n most = 0\n for i in range(N - 1):\n p1 = points[i]\n for j in range(i + 1, N):\n p2 = points[j]\n dx = p2[0] - p1[0]\n dy = p2[1] - p1[1]\n g = gcd(dx, dy)\n a = dx // g\n b = dy // g\n #if (a, b) in seen:\n # continue\n #seen.add((a, b))\n most = max(most, 2 + countPoints(j, a, b))\n return most","runtime":"485"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # each edge can be mapped to a pair (a, b)\n # where a=slope, b=bias of the unique line containing edge\n from collections import defaultdict\n import fractions\n from itertools import combinations\n \n lines = defaultdict(int)\n vert_lines = defaultdict(int)\n \n for p1, p2 in combinations(points, 2):\n x1, y1 = p1\n x2, y2 = p2\n\n if x1 == x2:\n vert_lines[x1] += 1\n else:\n a = fractions.Fraction(y2 - y1, x2 - x1)\n b = y2 - x2 * a\n lines[a, b] += 1\n\n # if line contains n points\n # lines[a,b] = (n choose 2)\n # how to extract n?\n # x = n*(n-1) / 2\n # 2x = n*(n-1)\n # 2x = n^2 - n\n # 0 = n^2 - n - 2x\n # delta = 1 + 8x\n # n = (1 + sqrt(delta) / 2)\n\n import math\n\n def comb_to_n(combs):\n delta = 1 + 8*combs\n n = (1 + math.sqrt(delta)) / 2\n n = int(n)\n return n\n\n m = 1\n for v in vert_lines.values():\n v = comb_to_n(v)\n if v > m:\n m = v\n\n for (a, b), v in lines.items():\n v = comb_to_n(v)\n if v > m:\n m = v\n\n print(lines)\n print(vert_lines)\n\n return m","runtime":"507"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n if len(points) == 2:\n return 2\n\n lineMap = defaultdict(set) # key will be (x_intercept, y_intercept, slop)\n\n def getKey(p1, p2) -> Tuple: \n deltaX = p1[0] - p2[0]\n deltaY = p1[1] - p2[1]\n y_intercept, x_intercept = 0, 0\n if deltaX == 0:\n y_intercept = float(\"inf\")\n x_intercept = p1[0]\n slope = float(\"inf\")\n elif deltaY == 0:\n x_intercept = float(\"inf\")\n y_intercept = p1[1]\n slope = 0\n else:\n slope = deltaY / deltaX\n x_intercept = p1[0] - p1[1]/slope\n y_intercept = p1[1] - slope*p1[0]\n return (x_intercept, y_intercept, slope)\n rslt = 0\n for p1 in points:\n tempMap = lineMap.copy()\n for p2 in points:\n if p1 != p2:\n key = getKey(p1, p2)\n if key not in lineMap:\n tempMap[key].add((p1[0], p1[1]))\n tempMap[key].add((p2[0], p2[1]))\n rslt = max(rslt, len(tempMap[key]))\n lineMap = tempMap\n return rslt\n\n ","runtime":"507"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # y = k*x + b\n\n N = len(points)\n if (N in [1,2]):\n #print(\"--- N=\",N)\n return N\n maxn = 0\n for i in range(0,N):\n if (N-i+2<maxn):\n #print(\"Break because N=\",N,\"; iii=\",i,\"; maxn=\",maxn)\n break\n xy1 = points[i]\n # form a pair, get [k,b] and check other items with [k,b]\n for j in range(i+1,N):\n if (N-j+2<maxn):\n #print(\"Break because N=\",N,\"; j=\",j,\"; maxn=\",maxn)\n break\n xy2 = points[j]\n\n # cases with vertical line\n only = (xy1[0] == xy2[0]) or (xy1[1] == xy2[1])\n onlyidx = 0 if (xy1[0] == xy2[0]) else 1\n\n # k = (y1-y2)/(x1-x2)\n # b = y1 - k*x1\n k = 1 if (only) else ((xy1[1] - xy2[1])/(xy1[0] - xy2[0]))\n b = xy1[1] - k*xy1[0]\n\n #print(\"cur pair:\",xy1,xy2)\n cnt = 2\n # try to form lines\n for idx in range(j+1,N):\n #print(\".. trying to append:\",points[idx])\n\n if (only):\n cnt += 1 if (points[idx][onlyidx] == xy1[onlyidx]) else 0\n else:\n x,y = points[idx][0],points[idx][1]\n cnt += 1 if (abs(y-(k*x+b)) < 1.0e-13 ) else 0\n maxn = cnt if (cnt>maxn) else maxn\n #print(\"-- maxn=\", maxn)\n return maxn\n\n ","runtime":"529"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n if n == 1:\n return 1\n elif n == 2:\n return 2\n slope = None\n out = 0\n\n for idxstart in range(n-2):\n for idx2 in range(idxstart+1, n-1):\n cnt = 2\n if points[idx2][0] == points[idxstart][0]:\n for newidx in range(idx2+1, n):\n newx, newy = points[newidx]\n if newx == points[idx2][0]:\n cnt += 1\n else:\n slope = (points[idx2][1] - points[idxstart][1]) / (points[idx2][0] - points[idxstart][0]) \n ystart = points[idxstart][1]\n xstart = points[idxstart][0]\n\n cnt = 2\n for newidx in range(idx2+1, n):\n newx, newy = points[newidx]\n yexpected = slope * (newx - xstart) + ystart\n if abs(yexpected - newy) < 0.00001:\n cnt += 1\n if cnt > out:\n out = cnt\n dprint(\"out just became\", out, \"with slope\", slope)\n\n return out\n\n\ndef dprint(*args):\n if 1 :\n print(*args)","runtime":"529"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n ans = 1\n for i in range(n):\n x1, y1 = points[i]\n for j in range(i + 1, n):\n x2, y2 = points[j]\n cnt = 2\n for k in range(j + 1, n):\n x3, y3 = points[k]\n a = (y2 - y1) * (x3 - x1)\n b = (y3 - y1) * (x2 - x1)\n cnt += a == b\n ans = max(ans, cnt)\n return ans","runtime":"551"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n ans = 1\n for i in range(n):\n x1, y1 = points[i]\n for j in range(i + 1, n):\n x2, y2 = points[j]\n cnt = 2\n for k in range(j + 1, n):\n x3, y3 = points[k]\n a = (y2 - y1) * (x3 - x1)\n b = (y3 - y1) * (x2 - x1)\n cnt += a == b\n ans = max(ans, cnt)\n return ans","runtime":"551"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n total_aligned_points = 1\n\n for i in range(n):\n x1, y1 = points[i]\n for j in range(i + 1, n):\n x2, y2 = points[j]\n cnt = 2\n for k in range(j + 1, n):\n x3, y3 = points[k]\n a = (y2 - y1) * (x3 - x1)\n b = (y3 - y1) * (x2 - x1)\n cnt += a == b\n total_aligned_points = max(total_aligned_points,cnt)\n return total_aligned_points\n ","runtime":"573"},{"code":"from fractions import Fraction\nfrom collections import Counter\nimport math\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n s=Counter()\n for i in range(len(points)):\n for j in range(i+1,len(points)):\n if (points[j][0]==points[i][0]):\n m,c=float('inf'),'inf'+str(points[j][0])\n if points[j][0]==0:\n print(points[i][0],points[i][1],points[j][0],points[j][1])\n else:\n m=Fraction(points[j][1]-points[i][1],points[j][0]-points[i][0])\n c=points[i][1]-m*(points[i][0])\n s[(m,c)] += 1\n\n ma =0 \n print(s)\n for i in s:\n if s[i]>ma:\n ma = s[i]\n return int(1 + math.sqrt(1+8*ma))//2 \n","runtime":"573"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n res = 1\n for i in range(n):\n x1, y1 = points[i]\n for j in range(i+1, n):\n x2, y2 = points[j]\n count = 2\n for k in range(j+1, n):\n x3, y3 = points[k]\n a = (y2 - y1) * (x3 - x1)\n b = (y3 - y1) * (x2 - x1)\n count += a == b\n res = max(res, count)\n return res","runtime":"594"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # y = k*x + b\n\n N = len(points)\n if (N in [1,2]):\n #print(\"--- N=\",N)\n return N\n maxn = 0\n for i in range(0,N):\n if (N-i+2<maxn):\n #print(\"Break because N=\",N,\"; iii=\",i,\"; maxn=\",maxn)\n break\n xy1 = points[i]\n # form a pair, get [k,b] and check other items with [k,b]\n for j in range(i+1,N):\n if (N-j+2<maxn):\n #print(\"Break because N=\",N,\"; j=\",j,\"; maxn=\",maxn)\n break\n xy2 = points[j]\n\n # cases with vertical line\n only = (xy1[0] == xy2[0]) or (xy1[1] == xy2[1])\n onlyidx = 0 if (xy1[0] == xy2[0]) else 1\n\n # k = (y1-y2)/(x1-x2)\n # b = y1 - k*x1\n k = 1 if (only) else ((xy1[1] - xy2[1])/(xy1[0] - xy2[0]))\n b = xy1[1] - k*xy1[0]\n\n #print(\"cur pair:\",xy1,xy2)\n cnt = 2\n # try to form lines\n for idx in range(j+1,N):\n if (N-idx+cnt<maxn):\n #print(\"Break because N=\",N,\"; j=\",j,\"; maxn=\",maxn)\n break\n\n if (only):\n cnt += 1 if (points[idx][onlyidx] == xy1[onlyidx]) else 0\n else:\n x,y = points[idx][0],points[idx][1]\n cnt += 1 if (abs(y-(k*x+b)) < 1.0e-13 ) else 0\n maxn = cnt if (cnt>maxn) else maxn\n #print(\"-- maxn=\", maxn)\n return maxn\n\n ","runtime":"594"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n ans = 1\n for i in range(n):\n x1, y1 = points[i]\n for j in range(i + 1, n):\n x2, y2 = points[j]\n cnt = 2\n for k in range(j + 1, n):\n x3, y3 = points[k]\n a = (y2 - y1) * (x3 - x1)\n b = (y3 - y1) * (x2 - x1)\n cnt += a == b\n ans = max(ans, cnt)\n return ans","runtime":"616"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n ans = min(2, len(points))\n for i in range(len(points)-2):\n p1 = points[i]\n for j in range(i+1, len(points)-1):\n p2 = points[j]\n if p2[0] - p1[0] != 0:\n angle = (p2[1] - p1[1]) / (p2[0] - p1[0])\n else:\n angle = \"line\"\n cur = 2\n for k in range(j+1, len(points)):\n p3 = points[k]\n if p3[0] - p1[0] != 0:\n angle2 = (p3[1] - p1[1]) / (p3[0] - p1[0])\n else:\n angle2 = \"line\"\n if angle == angle2:\n cur += 1\n ans = max(ans, cur)\n return ans","runtime":"616"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n def slope(p, q):\n if p[0] == q[0]:\n return inf\n \n return (p[1] - q[1]) / (p[0] - q[0])\n\n if len(points) <= 2:\n return len(points)\n \n result = 0\n for i in range(len(points)):\n p = points[i]\n for j in range(i + 1, len(points)):\n q = points[j]\n pq_slope = slope(p, q)\n count = 2\n\n for k in range(j + 1, len(points)):\n r = points[k]\n if slope(q, r) == pq_slope:\n count += 1\n \n result = max(result, count)\n \n return result\n","runtime":"638"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n res = 0\n for i in range(len(points)-1):\n x1,y1 = points[i]\n for j in range(i+1,len(points)):\n x2,y2 = points[j]\n s = 0\n x_min = min([x1,x2])\n x_max = max([x1,x2])\n y_min = min([y1,y2])\n y_max = max([y1,y2])\n for (x3,y3) in points:\n if x3 < x_min or x3 > x_max:\n continue\n if y3 < y_min or y3 > y_max:\n continue\n if x1 == x2:\n if x3 == x1:\n s += 1\n else:\n if (y2 - y1) * (x3 - x1) == (y3 - y1) * (x2 - x1):\n s += 1\n if s > res:\n res = s\n return res\n","runtime":"638"},{"code":"from typing import List\n\nclass Solution:\n def get_gradient(self, p1: List[int], p2: List[int]) -> float:\n if (p1[0] == p2[0]):\n raise Exception()\n \n return (p1[1] - p2[1]) / (p1[0] - p2[0])\n \n def maxPoints(self, points: List[List[int]]) -> int:\n if (len(points) < 2):\n return len(points)\n \n ans = 2\n\n for i in range(len(points) - 2):\n for j in range(i + 1, len(points) - 1):\n p1 = points[i]\n p2 = points[j]\n \n m0 = 0\n is_vertical = False\n\n try:\n m0 = self.get_gradient(p1, p2)\n\n except:\n is_vertical = True\n\n count = 2\n for k in range(j + 1, len(points)):\n m1 = 0\n p3 = points[k]\n\n try:\n m1 = self.get_gradient(p1, p3)\n\n if (not is_vertical and m0 == m1):\n count += 1\n\n except Exception:\n if (is_vertical):\n count += 1\n\n ans = max(ans, count)\n\n return ans","runtime":"660"},{"code":"class Solution:\n def check_line(self, a, b, c, p):\n x, y = p\n return a*x+b*y+c == 0\n\n def maxPoints(self, points: List[List[int]]) -> int:\n max_points = 1\n for i1 in range(len(points)-1):\n for i2 in range(i1+1, len(points)):\n p1, p2 = points[i1], points[i2]\n x1, y1 = p1\n x2, y2 = p2\n\n # cur_line ax+by+c=0\n a = y2-y1\n b = x1-x2\n c = y1*x2-x1*y2\n\n num_points = 2\n for i in range(i2+1, len(points)):\n if self.check_line(a, b, c, points[i]):\n num_points += 1\n\n if num_points > max_points:\n max_points = num_points\n return max_points\n","runtime":"660"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n \n if len(points) <= 2:\n return len(points)\n if len(points) == 3:\n #(y1-y2)(x1-x3)-(y1-y3)(x1-x2) = 0\n delta = (points[0][1] - points[1][1])*(points[0][0]-points[2][0]) \\\n - (points[0][1] - points[2][1])*(points[0][0]-points[1][0])\n if delta == 0:\n return 3\n else:\n return 2\n \n \n N = len(points)\n num_max = 2\n \n for i in range(N-2):\n p1 = points[i]\n for j in range(i+1, N-1):\n num = 2\n p2 = points[j]\n for k in range(j+1, N):\n p3 = points[k]\n delta = (p1[1]-p2[1])*(p1[0]-p3[0]) - (p1[1]-p3[1])*(p1[0]-p2[0])\n \n if delta == 0:\n num = num +1\n pass\n if num > num_max:\n num_max = num\n return num_max","runtime":"682"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n graph = defaultdict(list)\n\n for i in range(len(points)-1) :\n for j in range(i+1, len(points)) :\n slope = 10 ** 9\n\n if (points[j][0] - points[i][0]) != 0 :\n slope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0]) \n\n graph[(points[i][0], points[i][1])].append((points[j][0], points[j][1], slope ))\n \n # print(graph)\n def dfsUtil(p, q, dist) :\n # print(p, q, dist)\n max_len = 1\n neighbors = graph[(p, q)]\n # print(neighbors)\n\n for x, y, distance in neighbors :\n if dist == -sys.maxsize or dist == distance :\n max_len = max(max_len, 1 + dfsUtil(x, y, distance))\n\n return max_len \n\n \n max_points = 0\n for k in range(len(points)) :\n # print(points[k])\n max_points = max(max_points, dfsUtil(points[k][0], points[k][1], -sys.maxsize))\n # print(points[k], dfsUtil(points[k][0], points[k][1], -sys.maxsize))\n return max_points","runtime":"682"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n graph = defaultdict(list)\n for i in range(len(points)-1) :\n for j in range(i+1, len(points)) :\n slope = 10 ** 9\n if (points[j][0] - points[i][0]) != 0 :\n slope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0]) \n\n graph[(points[i][0], points[i][1])].append((points[j][0], points[j][1], slope ))\n \n\n def dfsUtil(p, q, dist) :\n max_len = 1\n neighbors = graph[(p, q)]\n\n for x, y, distance in neighbors :\n if dist == -sys.maxsize or dist == distance :\n max_len = max(max_len, 1 + dfsUtil(x, y, distance))\n\n return max_len \n\n \n max_points = 0\n for k in range(len(points)) :\n max_points = max(max_points, dfsUtil(points[k][0], points[k][1], -sys.maxsize))\n \n return max_points","runtime":"704"},{"code":"class Solution:\n def get_a_c(self,point1, point2):\n x1,y1 = point1\n x2,y2 = point2\n\n if x1-x2 == 0:\n return None, x1\n\n dy = y1-y2 \n dx = x1-x2\n\n a = (y1-y2) / (x1-x2)\n b = y1 - a * x1\n\n return a,b\n \n def check_in_line(self,ab, point):\n x,y = point\n a,b = ab\n if a == None:\n if x == b:\n return True\n else:\n return False\n if abs((a*x + b) - y) < 0.00001:\n return True\n else:\n return False\n\n def maxPoints(self, points: List[List[int]]) -> int:\n visited = set()\n\n max_point = 1\n\n for i in range(0,len(points)):\n for j in range(i+1, len(points)):\n ab = self.get_a_c(points[i],points[j])\n if ab not in visited:\n temp_count = 2\n for k in range(j+1, len(points)):\n if self.check_in_line(ab, points[k]):\n temp_count += 1\n if temp_count > max_point:\n max_point = temp_count\n visited.add(ab)\n \n return max_point","runtime":"704"},{"code":"import numpy as np\nclass Solution:\n def Line(self, p1: List[int], p2: List[int]) -> list[int]:\n d = 1/(p1[0] - p2[0])\n a = d*(p1[1] - p2[1])\n b = d*(-p2[0]*p1[1] + p1[0]*p2[1])\n return [a,b]\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n points = np.array(points)\n result = 0\n for i in range(len(points)):\n px , py = points[i]\n for j in range(i+1,len(points)):\n if px == points[j][0]:\n point_count = ((points[:,0]) == points[i][0]).sum()\n else :\n a, b = self.Line(points[i],points[j])\n point_count = (abs(points[:,0]*a + b - points[:,1]) <= 1e-10).sum()\n result = max(result, point_count)\n return result\n","runtime":"725"},{"code":"class Solution:\n def get_a_c(self,point1, point2):\n x1,y1 = point1\n x2,y2 = point2\n\n if x1-x2 == 0:\n return None, x1\n\n dy = y1-y2 \n dx = x1-x2\n\n a = (y1-y2) / (x1-x2)\n b = y1 - a * x1\n\n return a,b\n \n def check_in_line(self,ab, point):\n x,y = point\n a,b = ab\n if a == None:\n if x == b:\n return True\n else:\n return False\n if abs((a*x + b) - y) < 0.00001:\n return True\n else:\n return False\n\n def maxPoints(self, points: List[List[int]]) -> int:\n visited = set()\n\n max_point = 1\n\n for i in range(0,len(points)):\n for j in range(i+1, len(points)):\n ab = self.get_a_c(points[i],points[j])\n if ab not in visited:\n temp_count = 2\n for k in range(j+1, len(points)):\n if self.check_in_line(ab, points[k]):\n temp_count += 1\n if temp_count > max_point:\n max_point = temp_count\n visited.add(ab)\n \n return max_point","runtime":"725"},{"code":"class Solution:\n def aligned_2(self, x,y, q):\n if x == y :\n return True\n if (x[0]==y[0] ):\n if q == None:\n return True\n else:\n return False\n if (x[1]-y[1])/(x[0]-y[0]) == q:\n return True\n return False\n\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2:\n return len(points)\n m = 0\n for i in range(1,len(points)):\n if (points[0][0] - points[i][0]) == 0:\n q = None\n else:\n q = (points[0][1] - points[i][1])/(points[0][0] - points[i][0])\n n =2\n for j in range(i+1,len(points)):\n if self.aligned_2(points[0], points[j], q):\n n+=1\n m = max(m,n)\n return max(m, self.maxPoints(points[1:]))\n \n \n","runtime":"747"},{"code":"from typing import List\nfrom fractions import Fraction\n\nclass Solution:\n # a line can be described by y = mx + b, e.g. two numbers: m and b.\n # for each point i, compare with all other points j > i, calculate slop and intercept\n # bin the results, keep track of the max bin size.\n # very simple, O(n^2), impossible to do better.\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n if n == 1:\n return 1\n \n dict = {}\n max_points = 0\n for i in range(n):\n for j in range(i+1, n):\n xi, yi = points[i] if points[i][0] < points[j][0] else points[j]\n xj, yj = points[j] if points[i][0] < points[j][0] else points[i]\n\n if xj != xi:\n #m = float((yj - yi) / (xj - xi))\n m = Fraction((yj - yi), (xj - xi))\n else:\n m = float('inf')\n\n if m == float('inf'):\n b = float(xi)\n elif m == 0:\n b = \"inf, \" + str(yi)\n else:\n #b = float(yi - m*xi)\n b = Fraction(yi - m*xi)\n\n #b = str(b)\n #m = str(m)\n\n if (m, b) not in dict:\n dict[(m, b)] = set()\n dict[(m, b)].add(i)\n dict[(m, b)].add(j)\n \n max_points = max(max_points, len(dict[(m, b)]))\n\n print(dict)\n\n return max_points","runtime":"769"},{"code":"from fractions import Fraction\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n\n if n <= 2:\n return n\n\n d = {}\n r = 0\n\n # for i in range(n - 1):\n # for j in range(i + 1, n):\n for i in range(n):\n for j in range(n):\n # y = m x + b\n \n # m = dy / dx\n x1, y1 = points[i]\n x2, y2 = points[j]\n\n print(\"Points: \", i, j, points[i], points[j])\n\n dx = x2 - x1\n dy = y2 - y1\n\n if dx == 0:\n m = Fraction(1, 12345)\n b = x1\n else:\n m = Fraction(dy, dx)\n # b = y - m * x\n b = Fraction(y1) - m * Fraction(x1)\n\n print(m, b)\n \n k = (m.numerator, m.denominator, b.numerator, b.denominator)\n \n d[k] = c = d.get(k, 0) + 1\n r = max(c, r)\n \n return int(sqrt(float(r) + 0.25) + 0.5)\n\n\n\"\"\"\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2:\n return len(points)\n \n def find_slope(p1, p2):\n x1, y1 = p1\n x2, y2 = p2\n if x1-x2 == 0:\n return inf\n return (y1-y2)/(x1-x2)\n \n ans = 1\n for i, p1 in enumerate(points):\n slopes = defaultdict(int)\n for j, p2 in enumerate(points[i+1:]):\n slope = find_slope(p1, p2)\n slopes[slope] += 1\n ans = max(slopes[slope], ans)\n return ans+1\n\n\"\"\"","runtime":"769"},{"code":"class Solution:\n def __same_x_cordinates(self, points: list[list[int]]) -> int:\n n = len(points)\n res = 1\n for i in range(0,n-1):\n count = 1\n for j in range(i+1, n):\n if points[i][0] == points[j][0]:\n count += 1\n \n res = max(res, count)\n \n return res\n \n def __same_y_cordinates(self, points: list[list[int]]) -> int:\n n = len(points)\n res = 1\n for i in range(0, n-1):\n count = 1\n for j in range(i+1,n):\n if points[i][1] == points[j][1]:\n count += 1\n \n res = max(res, count)\n \n return res\n\n\n def maxPoints(self, points : list[list[int]]) -> int:\n def diff_cordinates(a:list[int], b:list[int]) -> bool:\n return a[0] != b[0] and a[1] != b[1]\n\n n = len(points)\n if n == 1 or n == 2:\n return n\n \n res = 2\n for i in range(0, n - 2):\n for j in range(i + 1, n - 1):\n if diff_cordinates(points[i], points[j]):\n count = 2\n for z in range(j + 1, n):\n if (points[j][1] - points[i][1]) * (points[z][0] - points[i][0]) == (points[z][1] - points[i][1]) * (points[j][0] - points[i][0]):\n count += 1\n res = max(res, count)\n \n res = max(res, self.__same_x_cordinates(points), self.__same_y_cordinates(points))\n\n return res ","runtime":"791"},{"code":"from typing import List\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \n def on_same_line(p1, p2, p3):\n # Using cross product to check if three points are collinear\n return (p3[1] - p1[1]) * (p2[0] - p1[0]) == (p2[1] - p1[1]) * (p3[0] - p1[0])\n \n n = len(points)\n if n < 3:\n return n\n\n max_res = 1\n\n for i in range(n):\n for j in range(i + 1, n):\n count = 2 # p1 and p2 are always on the same line\n for k in range(j + 1, n):\n if on_same_line(points[i], points[j], points[k]):\n count += 1\n max_res = max(max_res, count)\n \n return max_res\n","runtime":"813"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n if n < 2:\n return n\n res = 2\n for i in range(n):\n for j in range(i + 1, n):\n count = 2\n for x in range(j + 1, n):\n if (points[i][1] - points[j][1]) * (points[i][0] - points[x][0]) == (points[i][0] - points[j][0]) * (points[i][1] - points[x][1]):\n count += 1\n res = max(res, count)\n return res","runtime":"813"},{"code":"\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lines = []\n\n for point in points:\n append_list = []\n for line in lines:\n if len(line) == 1:\n append_list.append([line[0], point])\n else:\n point_1 = line[-2]\n point_2 = line[-1]\n\n if (point_1[1] - point_2[1]) * (point_2[0] - point[0]) == (point_2[1] - point[1]) * (point_1[0] - point_2[0]):\n line.append(point)\n for append in append_list:\n lines.append(append)\n lines.append([point])\n\n\n max_points = max([len(line) for line in lines])\n return max_points\n ","runtime":"835"},{"code":"\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lines = []\n\n for point in points:\n append_list = []\n\n for line in lines:\n if len(line) == 1:\n append_list.append([line[0], point])\n else:\n point_1 = line[-2]\n point_2 = line[-1]\n\n if (point_1[1] - point_2[1]) * (point_2[0] - point[0]) == (point_2[1] - point[1]) * (point_1[0] - point_2[0]):\n line.append(point)\n for append in append_list:\n lines.append(append)\n lines.append([point])\n\n max_points = max([len(line) for line in lines])\n return max_points\n ","runtime":"835"},{"code":"from typing import NamedTuple, Optional\nfrom fractions import Fraction\n\nclass Line(NamedTuple):\n m: Optional[Fraction]\n b: Fraction\n\n @staticmethod \n def from_points(x1: int, y1: int, x2: int, y2: int) -> 'Line':\n if x1 == x2:\n return Line(m=None, b=x1)\n else: \n m = Fraction(y1 - y2, x1 - x2)\n b = y1 - m * x1\n return Line(m=m, b=b)\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2:\n return len(points)\n\n result = 0\n for i in range(len(points)):\n lines = collections.defaultdict(int)\n for j in range(len(points)):\n if i != j:\n line = Line.from_points(*points[i], *points[j])\n lines[line] += 1\n result = max(result, max(lines.values()) + 1)\n return result\n \n \n\n ","runtime":"856"},{"code":"class Solution:\n def isTriple(point1, point2, point3):\n if (point2[1] - point1[1]) * (point3[0] - point2[0]) == (point3[1] - point2[1]) * (point2[0] - point1[0]):\n return True\n else:\n return False\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n best_res = 2\n curr_res = 2\n for i in range(len(points)):\n for j in range(i + 1, len(points)):\n for k in range(j + 1, len(points)):\n if Solution.isTriple(points[i], points[j], points[k]) == True:\n curr_res = 3\n for m in range(k + 1, len(points)):\n if Solution.isTriple(points[i], points[j], points[m]) == True:\n curr_res += 1\n if curr_res > best_res:\n best_res = curr_res\n return best_res","runtime":"856"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n\n result = 2\n for i in range(len(points)):\n for j in range(i+1,len(points)):\n group = 2\n if points[i][0] == points[j][0]:\n for k in range(j+1, len(points)):\n if points[k][0] == points[i][0]:\n group += 1\n else:\n for k in range(j+1, len(points)):\n if (points[j][0]-points[i][0])*(points[k][1] - points[i][1]) == (points[j][1]-points[i][1])*(points[k][0] - points[i][0]):\n group += 1\n if group > result:\n result = group\n return result\n","runtime":"878"},{"code":"import math\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n def count_points(start_idx: int, end_idx: int) -> int:\n s_x, s_y = points[start_idx]\n e_x, e_y = points[end_idx]\n\n # vertical line\n if s_x == e_x:\n return sum([p_x == s_x for p_x, _ in points])\n\n # slope (m): rise / run = (e_y - s_y) / (e_x - s_x)\n m_num, m_den = e_y - s_y, e_x - s_x\n m_gcd = math.gcd(m_num, m_den)\n m_num //= m_gcd\n m_den //= m_gcd\n\n # intercept (b): y = mx + b -> b = y - mx\n b_num, b_den = e_y * m_den - e_x * m_num, m_den\n \n count = 0\n for p_x, p_y in points:\n if p_y * m_den == m_num * p_x + b_num:\n count += 1\n\n return count \n\n N = len(points)\n max_points = 1\n\n for start_idx in range(N):\n for end_idx in range(start_idx + 1, N):\n max_points = max(max_points, count_points(start_idx, end_idx))\n return max_points","runtime":"878"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if(len(points)==1):\n return 1\n\n def slope(a, b, x, y, c, d):\n area = abs(a * (y - d) + x * (d - b) + c * (b - y))\n return area == 0\n \n f = {}\n\n for p in points:\n if(tuple(p) not in f):f[tuple(p)] = 0\n f[tuple(p)]+=1\n\n\n points = list(f.keys())\n\n d = {}\n ans = 2\n for i in range(len(points)):\n x, y = points[i]\n flg = False\n for k in d:\n a, b, c, gd = k\n if(slope(a, b, x, y, c, gd)):\n d[k]+=f[(x, y)]\n ans = max(d[k], ans)\n flg = True\n \n # if(not flg):\n for j in range(i):\n a, b = points[j]\n k = (a, b, x, y)\n d[k] = f[(a, b)]+f[(x, y)]\n print()\n \n return ans\n\n\n \n \n\n","runtime":"900"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \n def getTangent(x, y):\n if x[0] == y[0]:\n return float(\"inf\")\n else:\n return (x[1]-y[1])/(x[0]-y[0])\n\n result = 0\n \n for i in range(len(points)-1):\n tangentCount = {}\n for j in range(i+1, len(points)):\n tan = getTangent(points[i], points[j])\n if tan in tangentCount:\n tangentCount[tan] += 1\n else :\n tangentCount[tan] = 1\n print(*tangentCount.values())\n result = max(result, *tangentCount.values())\n \n\n return result+1","runtime":"900"},{"code":"from collections import defaultdict\nfrom fractions import Fraction\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n if len(points) == 2:\n return 2\n k = b = 0\n hashmap = defaultdict(int)\n for i in range(len(points)):\n for j in range(len(points)):\n if i == j:\n continue\n point1 = points[i]\n point2 = points[j]\n if point2[0] - point1[0] == 0:\n k = \"inf\"\n b = point2[0]\n else:\n k = Fraction((point2[1] - point1[1]), (point2[0] - point1[0]))\n b = point2[1] - k * point2[0]\n hashmap[(k,b)] += 1\n res = 0\n for i in hashmap:\n if hashmap[i] > res:\n res = hashmap[i]\n\n\n return int(sqrt(res)+1)\n\n","runtime":"922"},{"code":"from fractions import Fraction\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 2:\n return len(points)\n line_counts = defaultdict(lambda : 0)\n for p1 in points:\n for p2 in points:\n if p1 != p2:\n if p2[0] - p1[0] == 0:\n slope = \"infinity\"\n else:\n slope = Fraction(p2[1]-p1[1], p2[0]-p1[0])\n if slope == \"infinity\":\n intercept = p1[0]\n else:\n intercept = p1[1] - p1[0] * slope\n line_counts[(slope, intercept)] += 1\n return int(1 + (max(line_counts.values()) ** 0.5))","runtime":"922"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # pick 2 points\n # get gradient between the two\n # iterate over the rest of the points, check whether it fulfils the criteria of same gradient\n # repeat for the rest of the points\n # Output highest points\n if len(points) == 2:\n return 2\n elif len(points) == 1:\n return 1\n \n def checkpoint(a,b,test):\n # check if x is on the same line as a and b\n y = (b[1] - a[1])\n x = (b[0] - a[0])\n if y == 0 or x == 0:\n if (test[1] == b[1] and test[1] == a[1]) or (test[0] == b[0] and test[0] == a[0]):\n return True\n return False\n elif ((test[1] - a[1]) / y) == ((test[0] - a[0]) / x):\n return True\n else:\n return False\n \n line = []\n final = []\n count = 0\n highest = 0\n for i in range(len(points) - 2):\n for j in range(i + 1, len(points) - 1):\n count = 0\n for k in range(j + 1,len(points)):\n if checkpoint(points[i],points[j],points[k]) == True:\n count += 1\n line.append(points[k])\n \n if highest < count:\n highest = count\n line.append(points[i])\n line.append(points[j])\n final = line\n line = []\n else:\n line = []\n \n print(final)\n return highest + 2\n \n\n\n","runtime":"944"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \n def getTangent(x, y):\n if x[0] == y[0]:\n return float(\"inf\")\n else:\n return (x[1]-y[1])/(x[0]-y[0])\n\n result = 0\n \n for i in range(len(points)-1):\n tangentCount = {}\n for j in range(i+1, len(points)):\n tan = getTangent(points[i], points[j])\n if tan in tangentCount:\n tangentCount[tan] += 1\n else :\n tangentCount[tan] = 1\n print(*tangentCount.values())\n result = max(result, *tangentCount.values())\n \n\n return result+1","runtime":"944"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \n longest_line_length = 1\n ind = 0\n for defining_point_1 in points:\n x1, y1 = defining_point_1\n\n for defining_point_2 in points[ind+1:]:\n\n line_length = 0\n x2, y2 = defining_point_2\n\n if x2 != x1:\n m_numerator = y2 - y1\n m_denominator = x2 - x1\n b_times_m_denominator = y1 * m_denominator - m_numerator * x1\n for test_point in points:\n x, y = test_point\n if m_denominator * y == m_numerator * x + b_times_m_denominator:\n line_length += 1\n\n # Undefined slope - they are on a line\n # if they share an x coordinate\n else:\n for test_point in points:\n if test_point[0] == x1:\n line_length += 1\n\n \n \n if longest_line_length < line_length:\n longest_line_length = line_length\n ind += 1\n\n return longest_line_length","runtime":"966"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n l, cache = len(points), {}\n\n if l == 1:\n return 1\n\n def countPoints(p1, p2):\n count = 0\n\n x1, y1 = p1\n x2, y2 = p2\n\n if x1 != x2:\n k = y1 - y2 \n c = x1 - x2\n b = x1 * y2 - x2 * y1\n if (k, b) in cache:\n return cache[(k, b)]\n for point in points:\n x, y = point\n if c * y == k * x + b:\n count += 1\n else:\n k = float('inf')\n b = x1\n if (k, b) in cache:\n return cache[(k, b)]\n for point in points:\n x, y = point\n if x == x1:\n count += 1\n \n cache[(k, b)] = count\n\n return count\n\n max_num = float('-inf')\n for i in range(l):\n for j in range(i + 1, l):\n max_num = max(max_num, countPoints(points[i], points[j]))\n \n return max_num\n ","runtime":"966"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n l, cache = len(points), {}\n\n if l == 1:\n return 1\n\n def countPoints(p1, p2):\n count = 0\n\n x1, y1 = p1\n x2, y2 = p2\n\n if x1 != x2:\n k = y1 - y2 \n c = x1 - x2\n b = x1 * y2 - x2 * y1\n if (k, b) in cache:\n return cache[(k, b)]\n for point in points:\n x, y = point\n if c * y == k * x + b:\n count += 1\n else:\n k = float('inf')\n b = x1\n if (k, b) in cache:\n return cache[(k, b)]\n for point in points:\n x, y = point\n if x == x1:\n count += 1\n \n cache[(k, b)] = count\n\n return count\n\n max_num = float('-inf')\n for i in range(l):\n for j in range(i + 1, l):\n max_num = max(max_num, countPoints(points[i], points[j]))\n \n return max_num\n ","runtime":"987"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 0: return 0\n elif len(points) == 1: return 1\n elif len(points) == 2: return 2\n\n def gcd(a: int, b: int) -> int:\n if a == b: return a\n elif a < b: return gcd(b - a, a)\n else: return gcd(a - b, b)\n \n def keyFinder(i: int, j: int) -> (int, int, int, int):\n slope_y = points[j][1] - points[i][1]\n slope_x = points[j][0] - points[i][0]\n if slope_x < 0: \n slope_x = - slope_x\n slope_y = - slope_y\n if slope_x == 0:\n slope_y = 1\n int_y = 0\n int_x = points[i][0]\n elif slope_y == 0:\n slope_x = 1\n int_y = points[i][1]\n int_x = 0\n else: \n g = gcd(abs(slope_y), slope_x)\n slope_y = slope_y // g\n slope_x = slope_x // g\n int_y = (points[i][1] * slope_x) - (slope_y * points[i][0])\n int_x = slope_x\n if int_y == 0: int_y, int_x = 0, 0\n else:\n g = gcd(abs(int_y), int_x)\n int_y, int_x = int_y // g, int_x // g\n \n out = (slope_x, slope_y, int_x, int_y)\n return out\n\n\n lineDict = dict()\n i = 0\n\n while i < len(points) - 1:\n j = i + 1\n while j < len(points):\n key = keyFinder(i, j)\n if key not in lineDict: lineDict[key] = [i]\n if j not in lineDict[key]: lineDict[key].append(j)\n j += 1\n i += 1\n \n res = 2\n for line in lineDict.keys():\n res = max(res, len(lineDict[line]))\n\n return res","runtime":"987"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n l, cache = len(points), {}\n\n if l == 1:\n return 1\n\n def countPoints(p1, p2):\n count = 0\n\n x1, y1 = p1\n x2, y2 = p2\n\n if x1 != x2:\n k = y1 - y2 \n b = x1 * y2 - x2 * y1\n c = x1 - x2\n if (k, b, c) in cache:\n return cache[(k, b, c)]\n for point in points:\n x, y = point\n if c * y == k * x + b:\n count += 1\n else:\n k = float('inf')\n b = x1\n c = 0\n if (k, b, c) in cache:\n return cache[(k, b, c)]\n for point in points:\n x, y = point\n if x == x1:\n count += 1\n \n cache[(k, b, c)] = count\n\n return count\n\n max_num = float('-inf')\n for i in range(l):\n for j in range(i + 1, l):\n max_num = max(max_num, countPoints(points[i], points[j]))\n \n return max_num\n ","runtime":"1009"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n combs = list(itertools.combinations(points, 2))\n \n n = 0\n a = 0\n if len(points)==1:\n return 1\n for comb in combs:\n \n if comb[1][0] - comb[0][0] == 0: #vert line\n a =0\n for p in points:\n if p[0] == comb[0][0]:\n a+=1\n n = max(n, a)\n else:\n\n m = (comb[1][1] - comb[0][1]) / (comb[1][0] - comb[0][0])\n b = comb[0][1] - (m * comb[0][0])\n a = 0\n for p in points:\n if abs((m * p[0] + b) - p[1]) < 1e-9:\n \n a += 1 \n \n n = max(n, a)\n return n\n\n ","runtime":"1009"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n=len(points)\n d={}\n for i in range(n):\n x,y=points[i][0],points[i][1]\n for j in range(i+1,n):\n x1=x-points[j][0]\n y1=y-points[j][1]\n b=x1*y-y1*x\n d[(y1,x1,b)]=0\n for i in range(n):\n x,y=points[i][0],points[i][1]\n for j in d:\n if j[1]*y==j[0]*x+j[2]:\n d[j]+=1\n m=1\n for x in d:\n m=max(m,d[x])\n return m\n","runtime":"1031"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n=len(points)\n d={}\n for i in range(n):\n x,y=points[i][0],points[i][1]\n for j in range(i+1,n):\n x1=x-points[j][0]\n y1=y-points[j][1]\n b=x1*y-y1*x\n d[(y1,x1,b)]=0\n for i in range(n):\n x,y=points[i][0],points[i][1]\n for j in d:\n if j[1]*y==j[0]*x+j[2]:\n d[j]+=1\n m=1\n for x in d:\n m=max(m,d[x])\n return m","runtime":"1031"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n=len(points)\n d={}\n for i in range(n):\n x,y=points[i][0],points[i][1]\n for j in range(i+1,n):\n x1=x-points[j][0]\n y1=y-points[j][1]\n b=x1*y-y1*x\n d[(y1,x1,b)]=0\n for i in range(n):\n x,y=points[i][0],points[i][1]\n for j in d:\n if j[1]*y==j[0]*x+j[2]:\n d[j]+=1\n m=1\n for x in d:\n m=max(m,d[x])\n return m\n\n \n\n","runtime":"1097"},{"code":"# Line abstracts a geometrical line of the form y = mx + c\nclass Line :\n def __init__(self, x1, y1, x2, y2) :\n if x2 == x1 :\n self.vert = True\n self.xval = x2\n else :\n self.vert = False\n self.m = (y2 - y1) / (x2 - x1)\n self.c = y2 - (self.m * x2)\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n N = len(points)\n if N == 1 :\n return 1\n lines = []\n\n # Generating all line segments\n for i in range(N) :\n for j in range(i) :\n x1, y1 = points[i]\n x2, y2 = points[j]\n lines.append(Line(x1, y1, x2, y2))\n\n # Testing all points to see if they fit in the line segment\n ans = [0 for _ in lines]\n for i, line in enumerate(lines) :\n\n # Vertical line case\n if line.vert :\n for x, y in points :\n if line.xval == x :\n ans[i] += 1\n\n # Generic line\n else :\n for x, y in points :\n if abs(y - (line.m * x + line.c)) < 0.00001 :\n ans[i] += 1\n\n return max(ans)\n \n\n\n\n ","runtime":"1097"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points)<=2:\n return len(points)\n def determine(P, A, B):\n return (P[0] - A[0])*(P[1] - B[1]) == (P[0] - B[0])*(P[1] - A[1])\n n = len(points)\n saved = []\n def check(i,j): # see all the later dots and count maximum count\n nonlocal n, saved\n count=2\n chain = [i,j]\n for k in range(j+1,n):\n if determine(points[i],points[j],points[k]):\n count+=1\n chain.append(k)\n if len(chain)>2:\n saved.append(chain)\n return count\n def check2(i,j):\n for chain in saved:\n if (i in chain) and (j in chain):\n return False\n return True\n\n m = 0\n for i in range(n):\n for j in range(i+1,n):\n if check2(i,j):\n #print(i,j)\n count = check(i,j)\n m = max(m, count)\n\n return m\n","runtime":"1118"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n def check(x, y, z):\n P = (y[1] - x[1], y[0] - x[0])\n Q = (z[1] - x[1], z[0] - x[0])\n return P[0]*Q[1] - P[1]*Q[0] == 0\n \n lp = len(points)\n ans = 1\n for i in range(lp):\n for j in range(i+1, lp):\n cnt = 2\n for k in range(j+1, lp):\n if check(points[i], points[j], points[k]):\n cnt += 1\n ans = max(ans, cnt)\n return ans\n ","runtime":"1118"},{"code":"class Solution:\n def getLine(self, p1, p2, p3):\n if p1[0] == p2[0]:\n return True if p1[0] == p3[0] else False\n slope = (p2[1]- p1[1])/(p2[0] - p1[0])\n return True if abs(p3[1] - (slope*p3[0] + p1[1] - slope*p1[0]))<0.0000001 else False\n\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n maxValue = 2\n if n <= 2:\n return n\n for i in range(n-2):\n for j in range(i+1, n-1):\n curr_max = 2\n for k in range(j+1, n):\n if( self.getLine(points[i], points[j], points[k]) ):\n curr_max += 1\n maxValue = max(maxValue, curr_max)\n return maxValue\n ","runtime":"1140"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n def unit_vector(p1, p2):\n a = p2[0]-p1[0]\n b = p2[1]-p1[1]\n return [round(a/sqrt(a**2 + b**2),6), round(b/sqrt(a**2+b**2),6)]\n\n def same_slope(p1, p2, p3):\n if p2[0]-p1[0] == 0 and p3[0]-p1[0] == 0:\n return True\n if p2[0]-p1[0] == 0 or p3[0]-p1[0] == 0:\n return False\n # u1 = unit_vector(p1, p2)\n # u2 = unit_vector(p1, p3)\n # if u1 == u2:\n # return True\n # u2 = [-1*u2[0], -1*u2[1]]\n # if u1 == u2:\n # return True\n # return False\n return (p2[0]-p1[0])*(p3[1]-p1[1]) == (p3[0]-p1[0])*(p2[1]-p1[1])\n \n n = len(points)\n if n<=2:\n return n\n \n max_count = 0\n for i in range(n-2):\n for j in range(i+1, n-1):\n count = 2\n for k in range(j+1, n):\n if same_slope(points[i], points[j], points[k]):\n count+=1\n if count>max_count:\n max_count=count\n return max_count\n\n ","runtime":"1140"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n=len(points)\n if n==1:\n return 1\n dist_points=set()\n for i in range(n):\n dist_points.add(tuple(points[i]))\n dist_points=list(dist_points)\n k=len(dist_points)\n curr=0\n max_num=0\n \n for j in range(k-1):\n for l in range(j+1,k):\n if dist_points[j][0]==dist_points[l][0]:\n for p in range(n):\n if points[p][0]==dist_points[j][0]:\n curr=curr+1\n else:\n slope=(dist_points[j][1]-dist_points[l][1])/(dist_points[j][0]-dist_points[l][0])\n intercept= dist_points[j][1]-slope*dist_points[j][0]\n \n for p in range(n):\n \n if abs(slope*points[p][0]+intercept-points[p][1])<10**(-10):\n curr=curr+1\n if curr>max_num:\n max_num=curr\n curr=0\n return max_num\n\n \n\n ","runtime":"1162"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lines=[]\n count=0\n visited=set()\n for i,point1 in enumerate(points):\n for point2 in points[i+1:]:\n x1,y1=point1\n x2,y2=point2\n m=inf if x1==x2 else (y1-y2)/(x1-x2)\n c=m*(-x1)+y1\n if (m,c) in visited: continue\n visited.add((m,c))\n if x1==x2: count=max(count,len([1 for point in points if point[0]==x1]))\n else:\n curr_count=0\n for x,y in points:\n if (x-x1)*(y1-y2)==(y-y1)*(x1-x2): curr_count+=1\n count=max(count,curr_count)\n return max(1,count)","runtime":"1184"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lines=[]\n count=0\n for i,point1 in enumerate(points):\n for point2 in points[i+1:]:\n x1,y1=point1\n x2,y2=point2\n if x1==x2: count=max(count,len([1 for point in points if point[0]==x1]))\n else:\n curr_count=0\n for x,y in points:\n if (x-x1)*(y1-y2)==(y-y1)*(x1-x2): curr_count+=1\n count=max(count,curr_count)\n return max(1,count)","runtime":"1184"},{"code":"from math import inf\nimport pprint\n\ndef slope(p1, p2):\n if p1[0] == p2[0]:\n return inf, p1[0], None\n res = (p2[1] - p1[1]) / (p2[0] - p1[0])\n # y = res*x + b\n # 0 = res*x_int + b\n # x_int = -b / res\n y_int = p1[1] - res * p1[0]\n if p1[1] == p2[1]:\n x_int = None\n else:\n x_int = -y_int / res\n return res, x_int, y_int\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n\n max_points = 0\n\n slopes = dict()\n for i in range(len(points) - 1):\n p1 = points[i]\n\n for j in range(i + 1, len(points)):\n p2 = points[j]\n check_slope, check_xint, check_yint = slope(p1, p2)\n key = (check_xint, check_yint)\n\n if key in slopes and check_slope in slopes[key]:\n slopes[key][check_slope].add(tuple(p1))\n slopes[key][check_slope].add(tuple(p2))\n max_points = max(max_points, len(slopes[key][check_slope]))\n else:\n if key not in slopes:\n slopes[key] = dict()\n if check_slope not in slopes[key]:\n slopes[key][check_slope] = set()\n slopes[key][check_slope].add(tuple(p1))\n slopes[key][check_slope].add(tuple(p2))\n max_points = max(max_points, len(slopes[key][check_slope]))\n\n pprint.pp(slopes)\n\n return max_points","runtime":"1206"},{"code":"class Solution:\n def __init__(self):\n self.line_dict = dict()\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 3:\n return len(points)\n max_qty = 2\n for i in range(len(points) - 1):\n self.line_dict[i] = set()\n for j in range(i + 1, len(points)):\n self.line_dict[i].add(j)\n for start, ends in self.line_dict.items():\n str_p = points[start]\n end_point_list = list(ends)\n for i in range(len(end_point_list)):\n curr_line = set()\n curr_line.add(start)\n if end_point_list[i] not in self.line_dict[start]:\n continue\n end_p = points[end_point_list[i]]\n curr_line.add(end_point_list[i])\n var_se_x = end_p[0] - str_p[0]\n var_se_y = end_p[1] - str_p[1]\n for j in range(i + 1, len(end_point_list)):\n if end_point_list[j] not in self.line_dict[start]:\n continue\n ext_p = points[end_point_list[j]]\n var_eo_x = ext_p[0] - end_p[0]\n var_eo_y = ext_p[1] - end_p[1]\n if var_eo_x * var_se_y == var_eo_y * var_se_x:\n self.line_dict[start].remove(end_point_list[j])\n curr_line.add(end_point_list[j])\n max_qty = max(max_qty, len(curr_line))\n return max_qty","runtime":"1228"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n maximum = min(2,len(points))\n for i in range(len(points)-2):\n for j in range(i+1,len(points)-1):\n currmax = 2\n for k in range(j+1,len(points)):\n if points[i][0]==points[j][0]==points[k][0] or (points[k][0]!=points[j][0] and points[i][0]!=points[j][0] and (points[i][1]-points[j][1])/(points[i][0]-points[j][0])==(points[k][1]-points[j][1])/(points[k][0]-points[j][0])):\n currmax += 1\n maximum = max(currmax, maximum)\n return maximum\n\n ","runtime":"1228"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n combs = list(itertools.combinations(points, 2))\n \n n = 0\n a = 0\n if len(points)==1:\n return 1\n print(combs)\n for comb in combs:\n \n if comb[1][0] - comb[0][0] == 0: #vert line\n a =0\n for p in points:\n if p[0] == comb[0][0]:\n a+=1\n n = max(n, a)\n else:\n\n m = (comb[1][1] - comb[0][1]) / (comb[1][0] - comb[0][0])\n b = comb[0][1] - (m * comb[0][0])\n a = 0\n for p in points:\n # print((m * p[0] + b)-p[1])\n \n if abs((m * p[0] + b) - p[1]) < 1e-9:\n \n a += 1 \n \n n = max(n, a)\n return n\n\n ","runtime":"1249"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n=len(points)\n d={}\n for i in range(n):\n x,y=points[i][0],points[i][1]\n for j in range(i+1,n):\n x1=x-points[j][0]\n y1=y-points[j][1]\n b=x1*y-y1*x\n d[(y1,x1,b)]=0\n for i in range(n):\n x,y=points[i][0],points[i][1]\n for j in d:\n if j[1]*y==j[0]*x+j[2]:\n d[j]+=1\n m=1\n for x in d:\n m=max(m,d[x])\n return m","runtime":"1249"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lines=[]\n count=0\n visited=set()\n for i,point1 in enumerate(points):\n for point2 in points[i+1:]:\n x1,y1=point1\n x2,y2=point2\n m=inf if x1==x2 else (y1-y2)/(x1-x2)\n c=m*(-x1)+y1\n m=round(m,5)\n c=round(c,5)\n if (m,c) in visited: continue\n visited.add((m,c))\n if x1==x2: count=max(count,len([1 for point in points if point[0]==x1]))\n else:\n curr_count=0\n for x,y in points:\n if (x-x1)*(y1-y2)==(y-y1)*(x1-x2): curr_count+=1\n count=max(count,curr_count)\n return max(1,count)","runtime":"1271"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n result = 0\n #check horizantal and vertical\n freq = collections.defaultdict(int)\n for [x, y] in points:\n freq[\"x\" + str(x)] += 1\n freq[\"y\" + str(y)] += 1\n result = max(result, freq[\"x\" + str(x)], freq[\"y\" + str(y)])\n\n\n for i in range(len(points)):\n for j in range(i + 1, len(points)):\n \n [x1, y1] = points[i]\n [x2, y2] = points[j]\n if x1 == x2 or y1 == y2:\n continue\n #solve a and b, y = ax + b\n a = (y1 - y2) / (x1 - x2)\n b = y1 - x1 * a\n count = 2\n for k in range(len(points)):\n if k == i or k == j:\n continue\n [x, y] = points[k]\n if abs(a * x + b - y) < 0.00001:\n count += 1\n result = max(result, count)\n return result","runtime":"1271"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2: return len(points)\n\n l = set()\n counter = 0\n i = 0\n while i < len(points):\n j = i + 1\n while j < len(points):\n k = j + 1\n temp = 2\n tempset = set()\n while k < len(points):\n ok = self.isPointInStraightLine(points[i], points[j], points[k])\n if ok: \n temp += 1\n tempset.add(\"{}{}\".format(points[i][0], points[i][1]))\n tempset.add(\"{}{}\".format(points[j][0], points[j][1]))\n tempset.add(\"{}{}\".format(points[k][0], points[k][1]))\n k += 1\n if temp > counter:\n counter = temp\n l = tempset\n print(i, j)\n j += 1\n i += 1\n print(l)\n return counter\n\n \n def isPointInStraightLine(self, num1: int, num2: int, num3: int) -> bool:\n dx1 = num1[0] - num2[0]\n dy1 = num1[1] - num2[1]\n \n dx2 = num1[0] - num3[0]\n dy2 = num1[1] - num3[1]\n\n if dx1 == dx2 == 0: return True\n if dy1 == dy2 == 0: return True\n \n if dx1 == 0: return False\n if dx2 == 0: return False\n \n slope1 = dy1 / dx1 \n slope2 = dy2 / dx2 \n return slope1 == slope2","runtime":"1293"},{"code":"class Solution:\n\n \"\"\" \n func: \n for each later point\n build a (or search) dict\n build a hash table (as dict) with y = ax + b, which has \n key: value as tuple(a, b): list[list[int1, int2]]\n \"\"\"\n def maxPoints(self, points: List[List[int]]) -> int:\n # init dict \n from collections import defaultdict\n import numpy as np\n \n # init a defaultdict with default factory of list\n dict_list = defaultdict(list)\n \n # loop the list \n for i in range(len(points)): \n for j in range(i, -1, -1): \n if i != j: \n # now we get all the pairs that we need to test\n # first check horizontal and vertical line \n if points[i][0] == points[j][0]: \n dict_list[('x', points[i][0])] += [points[i], points[j]]\n \n elif points[i][1] == points[j][1]:\n dict_list[('y', points[i][1])] += [points[i], points[j]]\n \n else:\n \"\"\"using func\"\"\"\n line = self.find_line(points[i], points[j])\n dict_list[tuple(line)] += [points[i], points[j]]\n\n # get all the values\n values = list(dict_list.values())\n # loop values to count len of sets\n max_len = 1\n for ls in values: \n tuples = [tuple(i) for i in ls]\n max_len = max(len(set(tuples)), max_len)\n \n return max_len\n\n def find_line(self, p1, p2):\n import numpy as np\n A = np.array([[p1[0], 1], [p2[0], 1]])\n b = np.array([p1[1], p2[1]])\n #print(A, b)\n x = np.linalg.inv(A) @ b\n return [round(x[0], 9), round(x[1], 9)]\n\n\n","runtime":"1315"},{"code":"import numpy\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 0: return 0\n if len(points) == 1: return 1\n d = defaultdict(None)\n for point_id in range(len(points)):\n point = tuple(points[point_id])\n for _ in points[point_id+1:]:\n point2 = tuple(_)\n try:\n k = (point[1]-point2[1]) / (point[0]-point2[0])\n if k == 0: x = point[1]\n else: x = (point[0] * k - point[1])/k\n except ZeroDivisionError: \n k = numpy.inf\n x = point[0] \n try:\n d[(k,x)].add(point)\n d[(k,x)].add(point2)\n except KeyError: \n d[(k,x)] = {point, point2} \n for line in d:\n if line[0] == 0: point_on_line = (point[1] == line[1])\n else:\n point_on_line = (line[0] * (point[0] - line[1]) == point[1])\n if (point_on_line and (point not in d[line])):\n d[line].add(point)\n \n maxpts = 0\n for line in d:\n print(f'{line = } | {d[line] = }')\n if (len(d[line]) > maxpts): maxpts = len(d[line])\n return maxpts","runtime":"1315"},{"code":"class Solution:\n\n def num(self, points, p1, p2):\n v = [p2[0]-p1[0], p2[1]-p1[1]]\n n = [v[1], -v[0]]\n C = p2[0]*p1[1]-p1[0]*p2[1]\n count = 0\n for p in points:\n sum_v = n[0]*p[0] + n[1]*p[1] + C\n\n if sum_v == 0:\n count += 1\n return count\n\n\n def maxPoints(self, points: List[List[int]]) -> int:\n \n n = len(points)\n if n == 1:\n return 1\n max_num = 0\n d = {}\n for i in range(n):\n for j in range(i+1,n):\n if (i,j) in d or (j,i) in d:\n continue\n max_num = max(max_num, self.num(points, points[i], points[j]))\n d[(i,j)] = max_num\n return max_num\n ","runtime":"1337"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n def slopOf(one, two):\n x1, y1 = one\n x2, y2 = two\n\n return (y2 - y1) / (x2 - x1)\n\n\n N = len(points)\n res = 0\n\n if N == 1: return 1\n\n for i in range(N):\n for j in range(i + 1, N):\n count = 2\n (x1, y1), (x2, y2) = points[i], points[j]\n dy = y2 - y1\n dx = x2 - x1\n\n for k in range(N):\n if k == i or k == j: continue\n\n x3, y3 = points[k]\n dy_ = y3 - y1\n dx_ = x3 - x1\n\n if dy * dx_ == dy_ * dx:\n count += 1\n\n res = max(res, count)\n\n return res\n\n ","runtime":"1359"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n \n eps = 1e-6\n n = len(points)\n lines = []\n l2p = {}\n for i in range(n):\n for j in range(i + 1, n):\n x1, y1 = points[i]\n x2, y2 = points[j]\n dx = x2 - x1\n dy = y2 - y1\n if abs(dx) > eps:\n k = dy / dx\n b = y1 - k * x1\n # print(f\"line through {points[i]} - {points[j]} has k={k}, b={b}\")\n else:\n k = None\n b = x1\n l2p[len(lines)] = (i, j)\n lines.append((k, b))\n n_lines = len(lines)\n res = 0\n for q in range(n_lines):\n val = 0\n k, b = lines[q]\n for i in range(n):\n x, y = points[i]\n if (k is not None and abs(y - (k*x + b)) < eps\n or k is None and abs(x - b) < eps):\n val += 1\n res = max(res, val)\n # print(f\"{points[i]} accounted for\")\n else:\n pass\n # print(f\"{points[i]} is not on the line\")\n # print(k, b)\n # print(x, y)\n # print(k*x + b)\n # print(\"---\")\n p1, p2 = l2p[q]\n print(f\"line through {points[p1]} - {points[p2]}: val = {val}\")\n return res\n","runtime":"1359"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2:\n return len(points)\n lines = set()\n for x_1, y_1 in points:\n for x_2, y_2 in points:\n if x_1 != x_2 or y_1 != y_2:\n if x_1 == x_2:\n lines.add(x_1)\n else:\n slope = (y_2 - y_1) / (x_2 - x_1)\n intercept = y_1 - x_1 * slope\n lines.add((slope, intercept))\n\n max_points = 0\n print(lines)\n for line in lines:\n points_covered = 0\n if type(line) == tuple:\n slope, intercept = line\n for x, y in points:\n if abs(slope * x + intercept - y) < 1e-6:\n points_covered += 1\n else:\n for x, y in points:\n if x == line:\n points_covered += 1\n max_points = max(max_points, points_covered)\n return max_points","runtime":"1381"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n count = defaultdict(int)\n eqn = {}\n n = len(points)\n for i in range(n - 1):\n for j in range(i + 1, n):\n x1, y1 = points[i]\n x2, y2 = points[j]\n \n xDiff, yDiff = x1 - x2, y1 - y2\n eqn[(x1, y1, x2, y2)] = (xDiff, yDiff)\n \n res = 0\n for k, v in eqn.items():\n x1, y1, x2, y2 = k\n xDiff, yDiff = v\n for x, y in points:\n xD = x - x1\n yD = y - y1\n if xDiff == 0:\n if xD == 0:\n count[k] += 1\n continue\n if yDiff == 0:\n if yD == 0:\n count[k] += 1\n continue\n if xD == 0 and yD == 0 or \\\n xD / xDiff == yD / yDiff:\n count[k] += 1\n \n res = max(res, count[k])\n return res","runtime":"1381"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n if(len(points) <= 2):\n return len(points)\n\n def fit_count(i, j, points, line_included):\n x1, y1, x2, y2 = points[i][0], points[i][1], points[j][0], points[j][1]\n a = (y2-y1)\n b = -(x2-x1)\n c = y1*(x2-x1)-x1*(y2-y1)\n fit_count = 0\n for i in range(len(points)):\n if(a*points[i][0]+b*points[i][1]+c == 0):\n line_included[i] = 0\n fit_count += 1\n return line_included, fit_count\n\n fit_count_max = 2\n n = len(points)\n line_included = [0]*n\n for i in range(n):\n if(line_included[i]): continue\n for j in range(i+1, n):\n if(line_included[j]): continue\n line_included, fit_count_tmp = fit_count(i, j, points, line_included)\n if(fit_count_tmp > fit_count_max):\n fit_count_max = fit_count_tmp\n\n return fit_count_max\n\n \n \n\n\n\n\n\n\n ","runtime":"1402"},{"code":"\"\"\"\ngo through every pair of points, compute the slope\ngo through every point and check if it falls on one of the lines\n\n\n\"\"\"\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n lines = []\n for i in range(0, len(points) - 1):\n for j in range(i + 1, len(points)):\n if points[j][0] - points[i][0] == 0:\n slope = None\n y_0 = None\n x_0 = points[i][0]\n else:\n # calculate slope between our pair\n slope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0])\n y_0 = slope * (-points[i][0]) + points[i][1]\n x_0 = None\n\n lines.append((slope, y_0, x_0))\n print(lines)\n max_val = 0\n for line in lines:\n ctr = 0\n for point in points:\n if line[0] is not None and abs((point[0] * line[0] + line[1]) - point[1]) < 0.000001:\n ctr += 1\n elif line[2] is not None and point[0] == line[2]:\n ctr += 1\n max_val = max(ctr, max_val)\n return max_val\n\n ","runtime":"1402"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2: return len(points)\n\n counter = 0\n i = 0\n while i < len(points):\n j = i + 1\n while j < len(points):\n k = j + 1\n temp = 2\n while k < len(points):\n ok = self.isPointInStraightLine(points[i], points[j], points[k])\n if ok: temp += 1\n k += 1\n if temp > counter:\n counter = temp\n j += 1\n i += 1\n return counter\n\n \n def isPointInStraightLine(self, num1: int, num2: int, num3: int) -> bool:\n dx1 = num1[0] - num2[0]\n dy1 = num1[1] - num2[1]\n \n dx2 = num1[0] - num3[0]\n dy2 = num1[1] - num3[1]\n\n if dx1 == dx2 == 0: return True\n if dy1 == dy2 == 0: return True\n \n if dx1 == 0: return False\n if dx2 == 0: return False\n\n slope1 = dy1 / dx1 \n slope2 = dy2 / dx2 \n return slope1 == slope2","runtime":"1424"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n d = []\n for i in range(len(points) - 1):\n for j in range(i + 1, len(points)):\n if points[j][1] - points[i][1] == 0:\n d.append([0, 1, -points[j][1], 0])\n elif points[j][0] - points[i][0] == 0:\n d.append([1, 0, -points[j][0], 0])\n else:\n a = points[j][1] - points[i][1]\n b = -points[j][0] + points[i][0]\n c = 0 - b * points[i][1] - a * points[i][0]\n d.append([a, b, c, 0])\n print(d)\n for i in points:\n for j in d:\n if j[0] * i[0] + j[1] * i[1] + j[2] == 0:\n j[3] += 1\n res = 0\n for i in d:\n res = max(res, i[3])\n return res","runtime":"1424"},{"code":"from collections import defaultdict\n\nclass Solution:\n\n def is_same_line(self, point1, point2, point3):\n x1, y1 = tuple(point1)\n x2, y2 = tuple(point2)\n x3, y3 = tuple(point3)\n return (x3 - x1) * (y2 - y1) == (y3 - y1) * (x2 - x1)\n\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 3:\n return len(points)\n collinears = defaultdict(list)\n pairs = [(i1, i2) for i1 in range(len(points)) for i2 in range(i1 + 1, len(points))]\n while pairs:\n i1, i2 = pairs.pop()\n for i3 in range(i2 + 1, len(points)):\n if self.is_same_line(points[i1], points[i2], points[i3]):\n collinears[(i1, i2)].append(i3)\n try:\n pairs.remove((i1, i3))\n except ValueError:\n pass\n try:\n pairs.remove((i2, i3))\n except ValueError:\n pass\n if len(collinears) == 0:\n return 2\n return 2 + max(len(v) for v in collinears.values())\n","runtime":"1446"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n if len(points) == 1:\n return 1\n\n slope_intercepts = set()\n x_coord_counts = [0]*(2*(10**4+1))\n\n for c1 in points:\n x_coord_counts[c1[0]]+=1\n for c2 in points:\n if c1 != c2 and c1[0] != c2[0]: #CAREFUL OF VERT LINES\n slope = (c2[1] - c1[1]) / (c2[0] - c1[0])\n intercept = c1[1] - c1[0]*slope\n slope_intercepts.add((slope, intercept))\n\n ans = 2\n for s, i in slope_intercepts: #O(3)\n current = 0\n for p in points:\n if abs(p[1] - (p[0]*s + i)) <= 0.00001:\n current+=1\n \n ans = max(current, ans) \n \n return max(ans, max(x_coord_counts))","runtime":"1446"},{"code":"from collections import defaultdict\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n if len(points) == 2:\n return 2\n max_count = 2\n for i in range(len(points)):\n x1, y1 = points[i]\n for j in range(i + 1, len(points)):\n x2, y2 = points[j]\n # handle vertical lines (x = k) as a special case\n if x1 != x2:\n a = (y2 - y1) / (x2 - x1) \n b = y1 - a * x1\n curr_count = 2\n for k in range(len(points)):\n if k != i and k != j:\n x3, y3 = points[k]\n if x1 == x2 == x3:\n curr_count += 1\n elif x1 != x2 and abs(a * x3 + b - y3) < 0.0001:\n curr_count += 1\n max_count = max(max_count, curr_count)\n return max_count\n","runtime":"1468"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n maxlen = 0\n n = len(points)\n if n == 1:\n return 1 \n\n for i in range(0, n-1):\n for j in range(i+1, n):\n vertical = False\n x1, y1 = points[i]\n x2, y2 = points[j]\n if (x2-x1) == 0:\n vertical = True\n else:\n slope = (y2-y1)/(x2-x1)\n length = 2\n\n for k in range(n):\n if k == i or k == j:\n continue\n x3, y3 = points[k]\n if (x3-x1) == 0:\n if vertical:\n length += 1\n else:\n continue\n else:\n if vertical:\n continue \n slope1 = (y3-y1)/(x3-x1)\n if slope == slope1:\n length += 1\n maxlen = max(maxlen, length)\n return maxlen","runtime":"1490"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n global_max_count = 1 # To cover one point case\n\n # Make all the possible line combinations\n for i, (x1, y1) in enumerate(points):\n for j in range(i + 1, len(points)):\n x2, y2 = points[j]\n if x2 != x1:\n global_max_count = max(sum((ny - y1) * (x2 - x1) == (nx - x1) * (y2 - y1)\n for nx, ny in points), global_max_count)\n else:\n # x = const\n global_max_count = max(sum(nx == x1 for nx, _ in points), global_max_count)\n \n return global_max_count","runtime":"1512"},{"code":"class Solution:\n def maxPoints(self, p: List[List[int]]) -> int:\n \n def coord(x1, y1, x2, y2):\n if y1 == y2:\n line[(0, y1, 1)] = 0\n return\n dx, dy = x1 - x2, y1 - y2\n if dy < 0:\n a, c = -dy, -dx\n else:\n a, c = dy, dx\n \n while gcd(a, c) != 1:\n div = gcd(a, c)\n a, c = a // div, c // div\n b = c * y1 - a * x1\n line[(a, b, c)] = 0\n\n line = dict()\n thres = float('inf')\n for i in range(len(p)):\n line[p[i][0]] = 0\n \n for i in range(len(p)):\n for j in range(i + 1,len(p)):\n x1, y1 = p[i][0], p[i][1]\n x2, y2 = p[j][0], p[j][1]\n if x1 != x2:\n coord(x1, y1, x2, y2)\n \n for x, y in p:\n for c in line:\n if c == x:\n line[c] += 1\n if not isinstance(c, int) and c[2] * y == c[0] * x + c[1]:\n line[c] += 1\n \n return max(line.values())\n \n ","runtime":"1512"},{"code":"class Solution:\n\n def num(self, points,d ,i, j):\n p1 = points[i]\n p2 = points[j]\n v = [p2[0]-p1[0], p2[1]-p1[1]]\n n = [v[1], -v[0]]\n C = p2[0]*p1[1]-p1[0]*p2[1]\n count = 0\n l = []\n for k, p in enumerate(points):\n sum_v = n[0]*p[0] + n[1]*p[1] + C\n\n if sum_v == 0:\n count += 1\n l.append(k)\n\n for e in l:\n d[(i,e)] = count\n d[(j,e)] = count\n return count\n\n\n def maxPoints(self, points: List[List[int]]) -> int:\n \n n = len(points)\n if n == 1:\n return 1\n max_num = 0\n d = {}\n for i in range(n):\n for j in range(i+1,n):\n if (i,j) in d or (j,i) in d:\n continue\n max_num = max(max_num, self.num(points,d, i, j))\n \n return max_num\n ","runtime":"1533"},{"code":"class Solution:\n def maxPoints(self, p: List[List[int]]) -> int:\n \n def coord(x1, y1, x2, y2):\n if y1 == y2:\n line[(0, y1, 1)] = 0\n return\n dx, dy = x1 - x2, y1 - y2\n if dy < 0:\n a, c = -dy, -dx\n else:\n a, c = dy, dx\n \n div = gcd(a, c)\n a, c = a // div, c // div\n b = c * y1 - a * x1\n line[(a, b, c)] = 0\n\n line = dict()\n thres = float('inf')\n for i in range(len(p)):\n line[p[i][0]] = 0\n \n for i in range(len(p)):\n for j in range(i + 1,len(p)):\n x1, y1 = p[i][0], p[i][1]\n x2, y2 = p[j][0], p[j][1]\n if x1 != x2:\n coord(x1, y1, x2, y2)\n \n for x, y in p:\n for c in line:\n if c == x:\n line[c] += 1\n if not isinstance(c, int) and c[2] * y == c[0] * x + c[1]:\n line[c] += 1\n \n return max(line.values())\n \n ","runtime":"1533"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n ans = 1\n hm = {}\n n = len(points)\n\n for i in range(n):\n for j in range(i + 1, n):\n x1, y1 = points[i]\n x2, y2 = points[j]\n dx, dy = x1 - x2, y1 - y2\n d = gcd(dx, dy)\n hm[(x2, y2, dx // d, dy // d)] = 0\n \n for x1, y1 in points:\n for key in hm:\n x2, y2, mx, my = key\n dx, dy = x1 - x2, y1 - y2\n d = gcd(dx, dy)\n if d == 0 or dx // d == mx and dy // d == my:\n hm[key] += 1\n ans = max(ans, hm[key])\n \n return ans","runtime":"1555"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n ans = 0\n for i in range(len(points)):\n visit = set()\n for j in range(i+1,len(points)):\n x1,y1 = points[i][0],points[i][1]\n x2,y2 = points[j][0],points[j][1]\n if (x2,y2) not in visit and points[i] != points[j]:\n curr = 0\n for k in range(len(points)):\n x3,y3 = points[k][0],points[k][1]\n if (y3-y2)*(x2-x1) == (y2-y1)*(x3-x2):\n curr +=1\n visit.add((x3,y3))\n ans = max(ans,curr)\n return ans","runtime":"1577"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n maxlen = 0\n n = len(points)\n if n == 1:\n return 1 \n\n for i in range(0, n-1):\n for j in range(i+1, n):\n vertical = False\n x1, y1 = points[i]\n x2, y2 = points[j]\n if (x2-x1) == 0:\n vertical = True\n else:\n slope = (y2-y1)/(x2-x1)\n length = 2\n\n for k in range(n):\n if k == i or k == j:\n continue\n x3, y3 = points[k]\n if (x3-x1) == 0 and vertical:\n length += 1\n elif (x3-x1) != 0 and not vertical:\n slope1 = (y3-y1)/(x3-x1)\n if slope == slope1:\n length += 1\n else:\n continue\n '''\n if (x3-x1) == 0 :\n if vertical:\n length += 1\n else:\n continue\n else:\n if vertical:\n continue \n slope1 = (y3-y1)/(x3-x1)\n if slope == slope1:\n length += 1\n '''\n maxlen = max(maxlen, length)\n return maxlen","runtime":"1577"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n def solve_line(x1,y1,x2,y2):\n rise = y2-y1\n run = x2-x1\n slope =rise/run if run != 0 else None\n\n b = y1 - slope*x1 if slope is not None else x1\n\n return slope,b\n \n def is_on_line(px, py, slope, b):\n if slope is None:\n return b == px\n return abs(py - (px * slope + b)) < .0001\n\n best = 1\n slopes = set()\n \n for i in range(len(points)):\n x1,y1 = points[i]\n for j in range(i+1, len(points)):\n x2,y2 = points[j]\n\n\n slope, b = solve_line(x1,y1,x2,y2)\n slopes.add((slope,b))\n \n for slope, b in slopes:\n current = 0\n for px,py in points:\n if is_on_line(px,py,slope,b):\n current += 1\n best = max(current, best)\n\n return best\n\n\n \n","runtime":"1599"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if(len(points) <= 2): return len(points)\n maxPoints = 2\n for idx1 in range(0, len(points) - 1, 1):\n for idx2 in range(idx1+1, len(points), 1):\n a = points[idx2][1] - points[idx1][1]\n b = points[idx1][0] - points[idx2][0]\n c = (points[idx1][1]*points[idx2][0]) - (points[idx1][0]*points[idx2][1])\n line_points = 2\n for idx3 in range(len(points)):\n if(idx3 == idx2 or idx3 == idx1):\n continue\n if (a*points[idx3][0]) + (b*points[idx3][1]) + c == 0:\n line_points += 1\n maxPoints = max(maxPoints, line_points)\n return maxPoints","runtime":"1599"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n def solve_line(x1,y1,x2,y2):\n rise = y2-y1\n run = x2-x1\n slope =rise/run if run != 0 else None\n\n b = y1 - slope*x1 if slope is not None else x1\n\n return slope,b\n \n def is_on_line(px, py, slope, b):\n if slope is None:\n return b == px\n return abs(py - (px * slope + b)) < .0001\n\n best = 1\n slopes = set()\n \n for i in range(len(points)):\n x1,y1 = points[i]\n for j in range(i+1, len(points)):\n x2,y2 = points[j]\n\n slope, b = solve_line(x1,y1,x2,y2)\n slopes.add((slope,b))\n \n for slope, b in slopes:\n current = 0\n for px,py in points:\n if is_on_line(px,py,slope,b):\n current += 1\n best = max(current, best)\n\n return best\n\n\n \n","runtime":"1621"},{"code":"import sys\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points)==1:\n return 1\n elif len(points)==2:\n return 2\n ans = 2\n for i in range(len(points)-1):\n for j in range(i+1, len(points)):\n count = 2\n first = points[i]\n sec = points[j]\n slope = (sec[1]-first[1])/(sec[0]-first[0]) if sec[0]!=first[0] else sys.maxsize\n for k in range(len(points)):\n if k==i or k==j:\n continue\n else:\n third = points[k]\n slop = (third[1]-first[1])/(third[0]-first[0]) if third[0]!=first[0] else sys.maxsize\n if slop==slope:\n count+=1\n ans = max(ans, count)\n return ans\n \n\n","runtime":"1621"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n def solve_line(x1,y1,x2,y2):\n rise = y2-y1\n run = x2-x1\n slope =rise/run if run != 0 else None\n\n b = y1 - slope*x1 if slope is not None else x1\n\n return slope,b\n \n def is_on_line(px, py, slope, b):\n if slope is None:\n return b == px\n return abs(py - (px * slope + b)) < .0001\n\n best = 1\n slopeCounter = Counter()\n \n for i in range(len(points)):\n x1,y1 = points[i]\n for j in range(i+1, len(points)):\n x2,y2 = points[j]\n\n current = 0\n\n slope, b = solve_line(x1,y1,x2,y2)\n\n for px,py in points:\n if is_on_line(px,py,slope,b):\n current += 1\n \n best = max(current, best)\n return best\n\n\n \n","runtime":"1643"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n seen = set()\n max_point = 0\n n = len(points)\n if n == 1:\n return 1\n\n for i in range(n):\n for j in range(i + 1, n):\n x1, y1 = points[i]\n x2, y2 = points[j]\n\n # calculate the line\n if y1 == y2:\n slope = 'inf'\n intercept = x1\n else:\n slope = (x1 - x2)/(y1 - y2)\n intercept = y1 - slope*x1\n\n if (intercept, slope) in seen:\n continue\n\n curr_point = 2\n # compare with others\n for k in range(n):\n if k in [i, j]:\n continue\n x3, y3 = points[k]\n if y1 == y3:\n curr_slope = 'inf'\n else:\n curr_slope = (x1 - x3)/(y1 - y3)\n\n if curr_slope == slope:\n curr_point += 1\n \n seen.add((intercept, slope))\n max_point = max(max_point, curr_point)\n\n return max_point\n\n\n \n\n ","runtime":"1664"},{"code":"from typing import List, Tuple, Set\nfrom itertools import combinations\nfrom math import isclose\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2:\n return len(points)\n\n points_pairs: List[Tuple[List[int]]] = list(combinations(points, 2))\n all_lines: Set[Tuple] = set()\n for points_pair in points_pairs:\n a = points_pair[1][1] - points_pair[0][1]\n b = points_pair[0][0] - points_pair[1][0]\n c = -(a * points_pair[0][0] + b * points_pair[0][1])\n # Нормализация по a или, если a == 0, то по b\n if a:\n b = b / a\n c = c / a\n a = a / a\n else:\n a = a / b\n c = c / b\n b = b / b\n all_lines.add((a, b, c))\n\n max_points = 0\n for line in all_lines:\n line_points = 0\n for point in points:\n if isclose(line[0] * point[0] + line[1] * point[1] + line[2], 0, abs_tol=1e-9):\n line_points += 1\n max_points = max(max_points, line_points)\n\n return max_points","runtime":"1664"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points)==1:\n return 1\n points.sort(key=lambda x:x[0])\n max_p_all = 2\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n max_p = 2\n p1, p2 = points[i], points[j]\n dx = p2[0]-p1[0]\n dy = p2[1]-p1[1]\n if dx==0:\n for k in range(len(points)):\n if k!=i and k!=j and points[k][0]==p1[0]:\n max_p +=1\n max_p_all = max(max_p_all, max_p)\n elif dy==0:\n for k in range(len(points)):\n if k!=i and k!=j and points[k][1]==p1[1]:\n max_p +=1\n max_p_all = max(max_p_all, max_p)\n else:\n for k in range(len(points)):\n if k!=i and k!=j:\n dx_tmp = points[k][0]-p1[0]\n dy_tmp = points[k][1]-p1[1]\n if dy_tmp!=0 and dx_tmp/dy_tmp == dx/dy:\n max_p +=1\n max_p_all = max(max_p_all, max_p)\n\n return max_p_all\n\n ","runtime":"1686"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # Brute force: O(n^3)\n n = len(points)\n ans = 1\n for i in range(n):\n for j in range(i + 1, n):\n count = 0\n if points[j][0] == points[i][0]:\n # Vertical line\n for k in range(n):\n if points[k][0] == points[i][0]:\n count += 1\n elif points[i][1] == points[j][1]:\n # Horizontal line\n for k in range(n):\n if points[k][1] == points[i][1]:\n count += 1\n else:\n dy = points[j][1] - points[i][1]\n dx = points[j][0] - points[i][0]\n gcd = math.gcd(dy, dx)\n dy /= gcd\n dx /= gcd\n\n # m = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0])\n # b = points[j][1] - m * points[j][0]\n\n for k in range(n):\n if (points[k][1] - points[j][1]) / dy == (points[k][0] - points[j][0]) / dx:\n count += 1\n # if points[k][1] == m * points[k][0] + b:\n # count += 1\n\n ans = max(ans, count)\n\n return ans\n \n","runtime":"1686"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n if n==1:\n return 1\n result = 0\n for i in range(n):\n for j in range(i+1, n):\n count = 2\n dx = points[j][0] - points[i][0]\n dy = points[j][1] - points[i][1]\n \n for k in range(n):\n if k!=i and k!=j:\n dx2 = points[k][0] - points[i][0]\n dy2 = points[k][1] - points[i][1]\n\n if dy*dx2==dy2*dx:\n count+=1\n result = max(result,count)\n return result","runtime":"1708"},{"code":"class Solution:\n def same_line(self, a, b, point1, point3):\n if (b)*(point1[0]-point3[0]) == (point1[1]-point3[1])*(a):\n return True\n else: return False\n def maxPoints(self, points: List[List[int]]) -> int:\n ans = 1\n n = len(points)\n for i in range(n):\n for j in range(i+1, n):\n same = 0\n a = points[i][0]-points[j][0]\n b = points[i][1]-points[j][1]\n for k in range(n):\n if self.same_line(a, b, points[i], points[k]):\n same += 1\n ans = max(ans, same)\n return ans","runtime":"1708"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n res = 1\n for p0, p1 in combinations(points, 2):\n x0, y0 = p0\n x1, y1 = p1\n count = 0\n if p0[0] == p1[0]:\n for x, y in points: count += x0 == x\n else:\n for x, y in points:\n count += y*(x1-x0) == (x-x0)*(y1-y0) + y0*(x1-x0)\n res = max(res, count)\n return res","runtime":"1730"},{"code":"# # Brute Force Approach:- \nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 2:\n return len(points)\n\n result = 0\n for i in range(len(points)):\n for j in range(i + 1, len(points)):\n count = 2\n dx = points[j][0] - points[i][0]\n dy = points[j][1] - points[i][1]\n\n for k in range(len(points)):\n if k != i and k != j:\n dx2 = points[k][0] - points[i][0]\n dy2 = points[k][1] - points[i][1]\n\n if dx * dy2 == dy * dx2:\n count += 1\n result = max(result, count)\n return result \n\n# class Solution:\n# def maxPoints(self, points: List[List[int]]) -> int:\n# n = len(points)\n# if n == 1: \n# return 1\n# res = 2\n# for i in range(n):\n# d = defaultdict(int)\n# for j in range(n):\n# if i != j:\n# d[math.atan2(points[j][1] - points[i][1], points[j][0] - points[i][0])] += 1\n# res = max(res, max(d.values()) + 1)\n# return res\n \n\n# class Solution:\n# def maxPoints(self, P):\n# ans = 1\n# for p0, p1 in combinations(P, 2):\n# x0, y0 = p0\n# x1, y1 = p1\n# count = 0\n# if p0[0] == p1[0]:\n# for p in P: count += p[0] == p0[0]\n# else:\n# for p in P:\n# x, y = p\n# count += y*(x1-x0) == (x-x0)*(y1-y0) + y0*(x1-x0)\n# ans = max(ans, count)\n# return ans ","runtime":"1752"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points) #amount of point\\n maxP = 0 # current max points - initalize variable\\n\\n for i in range(n):\\n X = points[i][0]\\n Y = points[i][1]\\n map = {} # create temperory dict for story points\\n\\n for j in range(i+1, n):\\n dx = points[j][0] - X\\n dy = points[j][1] - Y # change in x and y pos\\n\\n if(dx != 0): \\n d = dy/dx\\n if d in map:\\n map[d] = map[d] + 1\\n else:\\n map[d] = 1 \\n else:\\n if 20001.0 in map:\\n map[20001.0] = map[20001.0] + 1\\n else:\\n map[20001.0] = 1 # test case put here since I cant solve\\n\\n if map:\\n maxP = max(maxP, max(map.values())) # return longest one by sorting it and get the max - since you have to get the value (sort by value), I don't know how to do max() with it\\n\\n return maxP + 1\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n slopes_map = {}\\n for i, point1 in enumerate(points):\\n for point2 in points[i+1:]:\\n if point1[0] - point2[0] != 0:\\n slope = (point1[1]-point2[1])/(point1[0]-point2[0])\\n else:\\n slope = 'inf'\\n current_slope = slopes_map.get((i,slope))\\n if current_slope is None:\\n slopes_map[(i,slope)] = 2\\n else:\\n slopes_map[(i,slope)] += 1\\n return max(slopes_map.values(), default = 1)\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1: return 1\\n \\n def findslope(p1, p2):\\n x1, y1 = p1[0], p1[1]\\n x2, y2 = p2[0], p2[1]\\n if x2-x1 == 0: return inf\\n return (y2-y1)/(x2-x1)\\n res = 0\\n for i in range(len(points)):\\n slope_dict = defaultdict(int)\\n for j in range(i+1, len(points) ):\\n p1 = points[i]\\n p2 = points[j]\\n slope = findslope(p1, p2)\\n slope_dict[slope] += 1\\n res = max(res, max(slope_dict.values(), default=0)+1)\\n\\n return res\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom math import gcd\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n if n < 2:\\n return n\\n \\n max_points = 1 # At least one point is there\\n \\n for i in range(n):\\n slope_count = defaultdict(int)\\n vertical_lines = 0 # Count vertical lines where dx == 0\\n duplicate = 1 # Count the starting point itself\\n cur_max = 0 # Current max points on the same line\\n \\n for j in range(i + 1, n):\\n dx = points[j][0] - points[i][0]\\n dy = points[j][1] - points[i][1]\\n \\n if dx == 0 and dy == 0: # Case of duplicate points\\n duplicate += 1\\n elif dx == 0: # Case of vertical line\\n vertical_lines += 1\\n cur_max = max(cur_max, vertical_lines)\\n else:\\n # Normalize the slope by using gcd\\n g = gcd(dx, dy)\\n dx //= g\\n dy //= g\\n \\n # To handle consistent slope direction, ensure dx is always positive\\n if dx < 0:\\n dx, dy = -dx, -dy\\n \\n # Count points on the same slope\\n slope_count[(dx, dy)] += 1\\n cur_max = max(cur_max, slope_count[(dx, dy)])\\n \\n max_points = max(max_points, cur_max + duplicate)\\n \\n return max_points\\n\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n if n == 1: return 1\\n res = 2\\n for i in range(n):\\n d = defaultdict(int)\\n for j in range(n):\\n if i != j:\\n d[math.atan2(points[j][1] - points[i][1], points[j][0] - points[i][0])] += 1\\n res = max(res, max(d.values()) + 1)\\n return res\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n res = 1\\n for point in points:\\n slopes = defaultdict(int)\\n x1, y1 = point\\n for another in points:\\n if point != another:\\n x2, y2 = another\\n if x1 == x2:\\n slope = inf\\n else:\\n slope = (y2-y1)/(x2-x1)\\n slopes[slope] += 1\\n for slope, count in slopes.items():\\n res = max(res, count + 1)\\n return res\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n slopes = defaultdict(set)\\n for i in range(len(points)):\\n for j in range(i + 1, len(points)):\\n if points[i][0]-points[j][0] == 0:\\n slope = \\\"inf\\\"\\n y_int = points[i][0]\\n else:\\n slope = (points[i][1]-points[j][1])/(points[i][0] - points[j][0])\\n y_int = points[i][1] - (slope * points[i][0])\\n slopes[(slope, y_int)].add(tuple(points[i]))\\n slopes[slope, y_int].add(tuple(points[j]))\\n\\n if len(slopes.values()) == 0:\\n return 1\\n return sorted([len(i) for i in slopes.values()])[-1]\",\n \"runtime\": \"114\"\n },\n {\n \"code\": \"# Hard problem. Max Points on a Line.\\n# Given an array of points where points[i] = [x, y]\\n# Return the maximum number of points on the same straight line\\n\\n# Ok, let's remember from algebra,\\n# the equation of a line is:\\n# y = m * x + b\\n# And given two points, we can find a line between them\\n\\n# We notice that a point can either be on the maximum line\\n# or not on the maximum line\\n\\n# the maximum line is the line that has the most points on it\\n\\n# The minimum answer is going to be 1 if points.length == 1\\n# and 2 is points.length == 2\\n# If the max len is 3 and points.length is 3, then all points\\n# are on the same line\\n\\n# It might take some work to code up the function verifying\\n# If a point is on line A, but it won't be that hard, I\\n# was good at algebra\\n\\n# We have up to 300 points\\n# 300^2 is a reasonable solution\\n# 300^3 == 300 * 90000 == 27000000\\n# which is even doable\\n# One point will have up to 300 lines\\n# Why don't we enumerate every line, check whether other points are on that line\\n# and count for that line?\\n# If there an easy way to tell if a point is on the line?\\n# All we have of a point is its x and y position\\n# Maybe if we plug x and y into the equation of the line,\\n# and we get an equality, the point is on our line\\n# I think I know what to do\\n# Create every line from each point to each other point\\n# check all points if they are on that line\\n# bam\\n\\n# Maybe we could use a set of lines so that we don't\\n# have to recheck\\nclass Solution:\\n def maxPoints(self, points: list[list[int]]) -> int:\\n if len(points) <= 2: return len(points)\\n def defval():\\n return []\\n line_set = defaultdict(defval)\\n \\n for i in range(len(points)):\\n x1, y1 = points[i]\\n #print(\\\"starting: {}, {}\\\".format(x1, y1))\\n for j in range(i + 1, len(points)):\\n x2, y2 = points[j]\\n \\n if x1 == x2:\\n m = float('inf')\\n b = x1\\n else:\\n m = (y2 - y1) / (x2 - x1)\\n b = y1 - (m * x1)\\n \\n #print(x2, y2, m, b)\\n intersects = line_set[(m,b)]\\n if (x1, y1) not in intersects:\\n intersects.append((x1, y1))\\n if (x2, y2) not in intersects:\\n intersects.append((x2, y2))\\n \\n #print(\\\"lines:\\\")\\n max_points = 0\\n for line in line_set:\\n max_points = max(max_points, len(line_set[line]))\\n #print(line, line_set[line])\\n return max_points\",\n \"runtime\": \"114\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 1: \\n return len(points)\\n greatest = 2\\n \\n for i in range(len(points)): \\n lines = {}\\n for j in range(i + 1, len(points)): \\n if points[i][0] - points[j][0] == 0: \\n slope = float(\\\"inf\\\")\\n else:\\n slope = (points[i][1] - points[j][1]) / (points[i][0] - points[j][0])\\n \\n if slope not in lines: \\n lines[slope] = 0\\n lines[slope] += 1\\n greatest = max(greatest, max(lines.values()) + 1)\\n \\n return greatest\\n \\n \",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n c = defaultdict(set)\\n n = len(points)\\n\\n max_points = 0\\n\\n for i in range(n):\\n x1,y1 = points[i]\\n cur_line = Counter()\\n\\n for j in range(i+1, n):\\n x2, y2 = points[j]\\n dx, dy = x1-x2, y1-y2\\n\\n if dx == 0:\\n key = f'vert_{x1}'\\n elif dy == 0:\\n key = f'hrznt_{y1}'\\n else:\\n k = (y1-y2)/(x1-x2)\\n b = y1-k*x1\\n\\n key = f'{k}#{b}'\\n\\n cur_line[key] += 1\\n # print(points[i], cur_line)\\n\\n if cur_line:\\n max_points = max(max_points, max(cur_line.values()))\\n\\n return max_points + 1\",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n \\n equations_to_point_set = defaultdict(set)\\n \\n for p1 in points:\\n for p2 in points:\\n if p1 == p2:\\n continue\\n \\n x1, y1 = p1\\n x2, y2 = p2\\n\\n if (x1 == x2):\\n equations_to_point_set[(None, x1)].add((x1, y1))\\n equations_to_point_set[(None, x1)].add((x2, y2))\\n continue\\n\\n m = (y2 - y1) / (x2 - x1)\\n b = y1 - (m * x1)\\n \\n equations_to_point_set[(m, b)].add((x1, y1))\\n equations_to_point_set[(m, b)].add((x2, y2))\\n\\n # for (m, b), ps in equations_to_point_set.items():\\n # print(f'equation: {m}x + {b}')\\n # print('points: ', ps)\\n # print('@@@')\\n\\n return max([len(ps) for ps in equations_to_point_set.values()])\\n\",\n \"runtime\": \"158\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 2:\\n return len(points)\\n max_points = 2\\n for i in range(500):\\n idx1, idx2 = random.sample(range(0, len(points)), 2)\\n p1, p2 = points[idx1], points[idx2]\\n m, b = self.find_line(p1[0], p1[1], p2[0], p2[1])\\n num_points = 0\\n for i, point in enumerate(points):\\n if self.check_fitline(m, b, point[0], point[1]):\\n num_points += 1\\n\\n max_points = max(num_points, max_points)\\n\\n return max_points\\n\\n def check_fitline(self, m, b, x, y):\\n if m == float(\\\"inf\\\"):\\n return b == x\\n return math.isclose(m * x + b, y)\\n\\n def find_line(self, x1, y1, x2, y2):\\n if x2 - x1 == 0:\\n return float(\\\"inf\\\"), x1\\n m = (y2 - y1) / (x2 - x1)\\n b = y1 - m * x1\\n return m, b\",\n \"runtime\": \"158\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n results = 2\\n if len(points) <= 2:\\n return len(points)\\n slope_map = {}\\n for i in range(len(points) - 1):\\n for j in range(i+1, len(points)):\\n nOP = 0\\n if (points[j][0] - points[i][0]) == 0:\\n nOP = len([p for p in points if p[0] == points[j][0]])\\n if (\\\"inf\\\", points[j][0]) in slope_map:\\n slope_map[(\\\"inf\\\", points[j][0])] += 1\\n else:\\n slope_map[(\\\"inf\\\", points[j][0])] = 1\\n else:\\n a = - (points[j][1] - points[i][1]) / (points[j][0] - points[i][0])\\n c = round(- points[i][0] * a - points[i][1], 3)\\n print(a, c)\\n if (a, c) in slope_map:\\n slope_map[(a, c)] += 1\\n else:\\n slope_map[(a, c)] = 1\\n for point in slope_map.values():\\n if point > results:\\n results = point\\n return int((1 + math.sqrt(8*results+1) / 2 )) if results > 2 else results\",\n \"runtime\": \"179\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lp, maxpoints = len(points), 1\\n if lp ==1: return maxpoints\\n slopes = [defaultdict(int) for _ in range(lp)]\\n for i in range(lp):\\n x1, y1 = points[i]\\n for j in range(lp):\\n if j != i:\\n x2, y2 = points[j]\\n if x1 == x2 and y1 == y2:\\n slope = \\\"0\\\"\\n elif x1 == x2:\\n slope = str(x1) + \\\"v\\\"\\n elif y1 == y2:\\n slope = str(y1) + \\\"h\\\"\\n elif j > i:\\n slope = str(round((y2-y1) / (x2-x1), 10))\\n else:\\n slope = str(round((y1-y2) / (x1-x2), 10))\\n slopes[i][slope] += 1\\n maxpoints = max(maxpoints, slopes[i][slope])\\n return maxpoints + 1\",\n \"runtime\": \"179\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # (y2 - y1) = m(x2 - x1)\\n # y = mx + B\\n # map (slope, B)\\n pointsOnLine = {}\\n for i in range(len(points)):\\n point1 = points[i]\\n for j in range(i + 1, len(points)):\\n point2 = points[j]\\n m = self.calculateSlope(point1, point2)\\n b = self.calculateB(point1, m)\\n line = (m, b)\\n currentSet = pointsOnLine.get(line, set())\\n currentSet.add((point1[0], point1[1]))\\n currentSet.add((point2[0], point2[1]))\\n pointsOnLine[line] = currentSet\\n\\n result = 1\\n for points in pointsOnLine.values():\\n result = max(result, len(points))\\n\\n print(pointsOnLine)\\n \\n return result\\n \\n def calculateSlope(self, point1, point2):\\n x1, x2 = point1[0], point2[0]\\n y1, y2 = point1[1], point2[1]\\n\\n if (x2 - x1) == 0:\\n return None\\n\\n m = (y2 - y1) / (x2 - x1)\\n return m\\n\\n def calculateB(self, point, m):\\n x, y = point[0], point[1]\\n if m == None:\\n return x\\n b = y - (m * x)\\n return b\",\n \"runtime\": \"201\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if not points:\\n return 0\\n if len(points) == 1:\\n return 1\\n Hash = defaultdict(set)\\n n = len(points)\\n for i in range(n):\\n for j in range(i+1, n):\\n pointA = points[i]\\n pointB = points[j]\\n\\n if pointA[0] == pointB[0]:\\n Hash[(float('inf'), pointA[0])].add(tuple(pointA))\\n Hash[(float('inf'), pointA[0])].add(tuple(pointB))\\n\\n else:\\n gradient = (pointA[1] - pointB[1])/(pointA[0]-pointB[0])\\n intercept = pointA[1]-gradient * pointA[0]\\n key = (gradient, intercept)\\n Hash[key].add(tuple(pointA))\\n Hash[key].add(tuple(pointB))\\n \\n print(Hash)\\n\\n return max(len(v) for k, v in Hash.items())\\n\\n \\n\",\n \"runtime\": \"201\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n # y = mx + c\\n # c = y\\n def maxPoints(self, points: List[List[int]]) -> int:\\n points.sort(key = lambda x: (x[0], x[1]))\\n count = 0\\n for i in range(1, len(points)):\\n x0, y0 = points[i]\\n lines = defaultdict(int)\\n for j in range(i):\\n x1, y1 = points[j]\\n slope = (y0-y1)/(x0-x1) if (x0-x1) != 0 else float('inf')\\n intercept = y0-slope*(x0) if slope != float('inf') else y0\\n lines[(slope, intercept)] += 1\\n print(points[i], points[j], slope, intercept)\\n count = max(count, lines[(slope, intercept)])\\n count += 1\\n # print(lines)\\n return count\",\n \"runtime\": \"223\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n options = {}\\n max_a= 1\\n for i in range(len(points)):\\n for j in range(i+1,len(points)):\\n if (points[i][0]-points[j][0]) != 0:\\n a = (points[i][1]-points[j][1])/(points[i][0]-points[j][0])\\n b = -(-points[i][1]+a*(points[i][0]))\\n else:\\n a = 'x'\\n b = points[i][0]\\n print(points[i],points[j])\\n \\n st = str(a)+\\\"_\\\"+str(b)\\n if st in options:\\n options[st].add(str(points[i]))\\n options[st].add(str(points[j]))\\n else:\\n options[st] = set([str(points[i]),str(points[j])])\\n for i in options.keys():\\n print(options[i], i)\\n max_a= max(len(options[i]), max_a)\\n return max_a\\n \\n \\n \\n \",\n \"runtime\": \"223\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n if len(points) == 1 : \\n return 1 \\n\\n n = len(points)\\n\\n slope = [[0 for i in range(n)] for j in range(n)]\\n intercept = [[0 for i in range(n)] for j in range(n)] \\n\\n for i in range(n) : \\n for j in range(n) : \\n if i == j : \\n slope[i][j] = None \\n else : \\n x1 = points[i][0]\\n y1 = points[i][1]\\n x2 = points[j][0]\\n y2 = points[j][1]\\n\\n # Now calculate slope \\n if x2 - x1 == 0 : \\n if y2 - y1 > 0 : \\n m = float('inf')\\n c = x1\\n else : \\n m = float('-inf')\\n c = x1 \\n else : \\n m = (y2 - y1) / (x2 - x1)\\n c = y1 - m * x1\\n\\n slope[i][j] = m \\n intercept[i][j] = c \\n\\n # # Print Slope \\n # for i in range(n) : \\n # print(slope[i])\\n\\n # print(\\\"-\\\" * 20)\\n\\n # # Print Intercept \\n # for i in range(n) : \\n # print(slope[i]) \\n\\n # print(\\\"-\\\" * 20)\\n\\n vals = {} \\n\\n for i in range(n) : \\n for j in range(n) : \\n if i != j : \\n key = str(slope[i][j]) + \\\"*\\\" + str(intercept[i][j])\\n if key not in vals.keys() : \\n vals[key] = set() \\n vals[key].add(i)\\n vals[key].add(j)\\n else : \\n vals[key].add(i)\\n vals[key].add(j)\\n op = 0 \\n for key in list(vals.keys()) : \\n # print(f\\\"Key : {key} , Vals : {vals[key]}\\\")\\n op = max(op, len(vals[key]))\\n return op\\n\\n\\n \",\n \"runtime\": \"245\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n length = len(points)\\n\\n if length <= 2:\\n return length\\n\\n lines = {}\\n \\n for i in range(length-1):\\n p1 = points[i]\\n for j in range(i+1, length):\\n p2 = points[j]\\n m = 'inf'\\n b = p1[0]\\n if p2[0]-p1[0] != 0:\\n m = (p2[1]-p1[1])/(p2[0]-p1[0])\\n b = -p1[0] * m + p1[1]\\n if (m, b) not in lines:\\n lines[(m, b)] = [0, set()]\\n if tuple(p1) not in lines[(m,b)][1]:\\n lines[(m,b)][1].add(tuple(p1))\\n lines[(m, b)][0] += 1\\n if tuple(p2) not in lines[(m,b)][1]:\\n lines[(m,b)][1].add(tuple(p2))\\n lines[(m, b)][0] += 1\\n\\n print(lines)\\n return max(lines.values())[0]\",\n \"runtime\": \"245\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom fractions import Fraction\\nfrom math import inf\\n\\nclass Solution:\\n def getSlope(self, point: List[int], other_point: List[int]) -> Fraction:\\n x1, y1 = point\\n x2, y2 = other_point\\n \\n slope = inf if x2 == x1 else Fraction((y2 - y1), (x2 - x1))\\n \\n return slope\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n \\n max_num_points_on_line = 1\\n \\n for i in range(0, len(points)):\\n slope_map = defaultdict(set)\\n for j in range(i + 1, len(points)):\\n point = points[i]\\n other_point = points[j]\\n slope = self.getSlope(point, other_point)\\n slope_map[slope].add(tuple(point))\\n slope_map[slope].add(tuple(other_point))\\n \\n if len(slope_map[slope]) > max_num_points_on_line:\\n max_num_points_on_line = len(slope_map[slope])\\n \\n return max_num_points_on_line\",\n \"runtime\": \"267\"\n },\n {\n \"code\": \"\\nimport functools\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n if len(points) == 1:\\n return 1\\n\\n lines = {}\\n # a line has a key (slope, intercept), if slope is None, intercept is x=<value>\\n # value is a set of points\\n\\n def addLine(x1, y1, x2, y2):\\n if (x2 - x1) == 0:\\n slope = None\\n intercept = x1\\n else:\\n slope = (y2 - y1) / (x2 - x1)\\n intercept = y1 - slope * x1\\n if not (slope, intercept) in lines:\\n lines[(slope, intercept)] = set()\\n lines[(slope, intercept)].add((x1, y1))\\n lines[(slope, intercept)].add((x2, y2))\\n\\n for i in range(len(points)):\\n for j in range(i + 1, len(points)):\\n addLine(points[i][0], points[i][1], points[j][0], points[j][1])\\n \\n print(lines)\\n print(lines.values())\\n\\n m = \\\\\\n functools.reduce(lambda a, x: len(x) if a < len(x) else a, lines.values(), 0)\\n\\n return m\\n\",\n \"runtime\": \"267\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n hashmap = defaultdict(set)\\n # {(slope, intercept): set(point1, point2, point3)}\\n if len(points) == 1: return 1\\n elif len(points) == 2: return 2\\n\\n for x1, y1 in points:\\n for x2, y2 in points:\\n if (x2 - x1) != 0:\\n slope = (y2 - y1) / (x2 - x1)\\n intercept = y1 - slope * x1\\n hashmap[(slope, intercept)].add((x1, y1))\\n hashmap[(slope, intercept)].add((x2, y2))\\n else:\\n slope = None\\n intercept = x1\\n hashmap[(slope, intercept)].add((x1, y1))\\n hashmap[(slope, intercept)].add((x2, y2))\\n \\n print(hashmap)\\n maxcount = 1\\n for key, values in hashmap.items():\\n maxcount = max(maxcount, len(values))\\n \\n return maxcount\\n\\n\\n\\n\\n\",\n \"runtime\": \"289\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n mapping = {}\\n for point in points:\\n toAdd = (point[0], point[1])\\n mapping[toAdd] = {}\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n pointi = (points[i][0], points[i][1])\\n pointj = (points[j][0], points[j][1])\\n if points[i][0]- points[j][0] == 0:\\n mapping[pointi][pointj] = float(\\\"inf\\\")\\n mapping[pointj][pointi] = float(\\\"inf\\\")\\n else:\\n mapping[pointi][pointj] = (points[i][1]-points[j][1])/(points[i][0]-points[j][0])\\n mapping[pointj][pointi] = (points[i][1]-points[j][1])/(points[i][0]-points[j][0])\\n \\n def getFrequency(items):\\n print(items)\\n mapping = {}\\n for i in items:\\n print(i)\\n if i in mapping:\\n mapping[i] += 1\\n else:\\n mapping[i] = 1\\n maximum = 0\\n print(mapping)\\n return getLargest(mapping.values())\\n \\n def getLargest(items):\\n maximum = 0\\n for item in items:\\n maximum = max(maximum, item)\\n return maximum\\n\\n maximums = []\\n for i in range(len(points)):\\n point = (points[i][0], points[i][1])\\n maximum = 0\\n maximums.append(getFrequency(mapping[point].values()))\\n \\n return getLargest(maximums) + 1\\n \\n \\n \\\"\\\"\\\"\\n counting = {}\\n for i in range(len(points)):\\n for item in mapping[points[i]].values():\\n if item in counting:\\n counting[item] += 1\\n else:\\n counting[item] = 1\\n \\n maximum = 0\\n for i in counting.values():\\n if i > maximum:\\n maximum = i\\n \\n return int(math.sqrt(maximum+1))\\n \\\"\\\"\\\"\\n\\n \\n\",\n \"runtime\": \"289\"\n },\n {\n \"code\": \"import fractions\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n \\n max_count = 0\\n\\n for ax, ay in points:\\n slope_counts = Counter()\\n for bx, by in points:\\n if (ax, ay) == (bx, by):\\n continue\\n slope = fractions.Fraction(by - ay, bx - ax) if bx != ax else None\\n slope_counts[slope] += 1\\n max_through_a = max(slope_counts.values())\\n max_count = max(max_count, 1 + max_through_a)\\n \\n return max_count\\n\",\n \"runtime\": \"310\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # (y2 - y1) = m(x2 - x1)\\n # y = mx + B\\n # map (slope, B)\\n pointsOnLine = {}\\n for point1 in points:\\n for point2 in points:\\n if id(point1) != id(point2):\\n m = self.calculateSlope(point1, point2)\\n b = self.calculateB(point1, m)\\n line = (m, b)\\n currentSet = pointsOnLine.get(line, set())\\n currentSet.add((point1[0], point1[1]))\\n currentSet.add((point2[0], point2[1]))\\n pointsOnLine[line] = currentSet\\n\\n result = 1\\n for points in pointsOnLine.values():\\n result = max(result, len(points))\\n\\n print(pointsOnLine)\\n \\n return result\\n \\n def calculateSlope(self, point1, point2):\\n x1, x2 = point1[0], point2[0]\\n y1, y2 = point1[1], point2[1]\\n\\n if (x2 - x1) == 0:\\n return None\\n\\n m = (y2 - y1) / (x2 - x1)\\n return m\\n\\n def calculateB(self, point, m):\\n x, y = point[0], point[1]\\n if m == None:\\n return x\\n b = y - (m * x)\\n return b\",\n \"runtime\": \"310\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n out = 2\\n for i in range(len(points)):\\n slope_map = {}\\n for j in range(i + 1, len(points)):\\n x, y = points[i]\\n p, q = points[j]\\n found = False\\n for rise, run in slope_map.keys():\\n if not found and rise * (x - p) == run * (y - q):\\n slope_map[(rise, run)] += 1\\n out = max(slope_map[(rise, run)], out)\\n found = True\\n if not found:\\n rise, run = y - q, x - p\\n slope_map[(rise, run)] = 2\\n return out\\n\",\n \"runtime\": \"332\"\n },\n {\n \"code\": \"import numpy as np\\nimport math\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n record = {}\\n best = 0\\n directions = [[1, 0], [0, 1], [-1, 0], [0, -1], [1, 1], [-1,-1], [-1, 1], [1, -1]]\\n\\n for i in range(len(points)):\\n record[tuple(points[i])] = {}\\n current = points[i]\\n #print(\\\"Current is: \\\", current)\\n for j in range(i+1, len(points)):\\n other = points[j]\\n difference = [current[0]-other[0], current[1]-other[1]]\\n # here I'll have to convert the difference to a normalised direction vector\\n current_gcd = math.gcd(difference[0], difference[1])\\n difference[0] = int(difference[0]/current_gcd)\\n difference[1] = int(difference[1]/current_gcd)\\n if difference[0]<=0 and difference[1]<=0:\\n difference[0] = difference[0]*(-1)\\n difference[1] = difference[1]*(-1)\\n #print(\\\" Difference is: \\\", difference)\\n if difference[0]>0 and difference[1]<0:\\n difference[0] = difference[0]*(-1)\\n difference[1] = difference[1]*(-1)\\n #print(difference, current, other)\\n if tuple(difference) in record[tuple(current)].keys():\\n #print(\\\"heya\\\")\\n record[tuple(current)][tuple(difference)].append(tuple(other))\\n best = max(best, len(record[tuple(current)][tuple(difference)]))\\n else :\\n record[tuple(current)][tuple(difference)] = [tuple(other)]\\n best = max(1, best)\\n #print('\\\\t\\\\t\\\\t', record)\\n return best+1\\n\\n\\n\\n \",\n \"runtime\": \"332\"\n },\n {\n \"code\": \"import fractions\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 3: return len(points)\\n\\n line_count = Counter()\\n def line(x1,y1,x2,y2):\\n if x1 == x2: return (x1,inf)\\n\\n slope = fractions.Fraction(y2-y1,x2-x1)\\n intercept = y1-slope*x1\\n return (intercept,slope)\\n for i in range(len(points)):\\n px,py = points[i]\\n for j in range(i+1,len(points)):\\n qx,qy = points[j]\\n line_count[line(px,py,qx,qy)] += 1\\n return int(0.5*(sqrt(8*max(line_count.values())+1)+1))\\n\",\n \"runtime\": \"376\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom fractions import Fraction\\n\\nclass Solution:\\n def maxPoints(self, points: list[list[int]]) -> int:\\n def slope(p1, p2):\\n dx = p2[0] - p1[0]\\n dy = p2[1] - p1[1]\\n if dx == 0: # vertical line\\n return float('inf')\\n if dy == 0: # horizontal line\\n return 0\\n return Fraction(dy, dx)\\n \\n if len(points) <= 2:\\n return len(points)\\n \\n max_points = 1\\n \\n for i in range(len(points)):\\n slopes = defaultdict(int)\\n same_point_count = 1\\n for j in range(len(points)):\\n if i != j:\\n if points[i] == points[j]:\\n same_point_count += 1\\n else:\\n s = slope(points[i], points[j])\\n slopes[s] += 1\\n \\n max_points = max(max_points, same_point_count + max(slopes.values(), default=0))\\n \\n return max_points\\n\",\n \"runtime\": \"376\"\n },\n {\n \"code\": \"from fractions import Fraction\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n rows = {}\\n cols = {}\\n wb = {}\\n for i, p1 in enumerate(points[:-1]):\\n x1, y1 = p1\\n for x2, y2 in points[i + 1:]:\\n if x1 == x2:\\n if x1 in rows:\\n rows[x1] += 1\\n else:\\n rows[x1] = 1\\n continue\\n if y1 == y2:\\n if y1 in cols:\\n cols[y1] += 1\\n else:\\n cols[y1] = 1\\n continue\\n w = Fraction(y1 - y2, x1 - x2)\\n b = y1 - x1 * w\\n if (w, b) in wb:\\n wb[(w, b)] += 1\\n else:\\n wb[(w, b)] = 1\\n max_row = max(rows.values()) if rows.values() else 0\\n max_col = max(cols.values()) if cols.values() else 0\\n max_wb = max(wb.values()) if wb.values() else 0\\n max_edges = max([max_wb, max_row, max_col])\\n res = int(0.5 * (1 + (1 + 8 * max_edges)**0.5))\\n return res\",\n \"runtime\": \"398\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom fractions import Fraction\\nfrom itertools import combinations\\nfrom typing import List, Dict, Tuple, Set\\n\\n\\ndef solution(points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n\\n vertical: Dict[int, Set[Tuple[int, int]]] = defaultdict(set)\\n hist: Dict[Tuple[Fraction, Fraction], Set[Tuple[int, int]]] = defaultdict(set)\\n for p0, p1 in combinations(points, 2):\\n if p0[0] == p1[0]: # horizontal\\n vertical[p0[0]].add(tuple(p0))\\n vertical[p0[0]].add(tuple(p1))\\n else:\\n a = Fraction(p1[1] - p0[1], p1[0] - p0[0])\\n b = Fraction(p0[1] * p1[0] - p0[0] * p1[1], p1[0] - p0[0])\\n hist[(a, b)].add(tuple(p0))\\n hist[(a, b)].add(tuple(p1))\\n best = 0\\n if vertical:\\n best = max(map(len, vertical.values()))\\n if hist:\\n best = max(best, max(map(len, hist.values())))\\n return best\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n return solution(points)\",\n \"runtime\": \"398\"\n },\n {\n \"code\": \"from fractions import Fraction\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lines = {0:[1]}\\n for i in range(len(points)):\\n ax,ay = points[i]\\n for j in range(i+1,len(points)):\\n bx,by = points[j]\\n if bx != ax:\\n slope = Fraction(by-ay,bx-ax)\\n intercept = ay-slope*ax\\n else:\\n slope = inf\\n intercept = ax\\n if (slope,intercept) in lines:\\n lines[(slope,intercept)].add((bx,by))\\n else:\\n lines[(slope,intercept)] = set([(ax,ay),(bx,by)])\\n return max([len(b) for b in lines.values()])\\n \\n\\n \",\n \"runtime\": \"420\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n maxCount = 1\\n\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n slope = (y2 - y1) / (x2 - x1) if x2 != x1 else None\\n count = 2\\n for k in range(j+1, len(points)):\\n x3, y3 = points[k]\\n mySlope = (y3 - y2) / (x3 - x2) if x3 != x2 else None\\n if slope == mySlope:\\n count += 1\\n maxCount = max(count, maxCount)\\n\\n\\n return maxCount\",\n \"runtime\": \"420\"\n },\n {\n \"code\": \"import math\\nfrom fractions import Fraction\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n num_pts= {}\\n for n0 in range(len(points)):\\n for n1 in range(n0+1, len(points)):\\n if points[n1][0] == points[n0][0]:\\n m = float(\\\"inf\\\")\\n b = points[n1][0]\\n else:\\n m = Fraction(points[n1][1] - points[n0][1], points[n1][0] - points[n0][0])\\n b = points[n1][1] - m * points[n1][0]\\n if (m,b) not in num_pts:\\n num_pts[(m,b)] = 1\\n else:\\n num_pts[(m,b)] += 1\\n print(num_pts)\\n maxval = 0\\n for k, v in num_pts.items():\\n if v > maxval:\\n maxval = v\\n return int(math.floor(math.sqrt(maxval * 2))) + 1\\n\",\n \"runtime\": \"441\"\n },\n {\n \"code\": \"import fractions\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n ans = 0\\n for i in range(len(points)):\\n cnt = defaultdict(int)\\n for j in range(len(points)):\\n if i == j:\\n continue\\n if points[i][0] != points[j][0]:\\n slope = fractions.Fraction(points[i][1] - points[j][1], points[i][0] - points[j][0])\\n else:\\n slope = math.inf\\n cnt[slope] += 1\\n ans = max(ans, cnt[slope])\\n return ans + 1\",\n \"runtime\": \"441\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: list[list[int]]) -> int:\\n n = len(points)\\n ans = 1\\n for i in range(n):\\n x1, y1 = points[i]\\n for j in range(i):\\n x2, y2 = points[j]\\n cnt = 2\\n for k in range(j):\\n x3, y3 = points[k]\\n if (y2-y1)*(x3-x1) == (x2-x1)*(y3-y1): cnt += 1\\n ans = max(ans, cnt)\\n return ans\\n\",\n \"runtime\": \"463\"\n },\n {\n \"code\": \"from typing import NamedTuple, Optional\\nfrom fractions import Fraction\\n\\nclass Line(NamedTuple):\\n m: Optional[Fraction]\\n b: Fraction\\n\\n @staticmethod \\n def from_points(x1: int, y1: int, x2: int, y2: int) -> 'Line':\\n if x1 == x2:\\n return Line(m=None, b=x1)\\n else: \\n m = Fraction(y1 - y2, x1 - x2)\\n b = y1 - m * x1\\n return Line(m=m, b=b)\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2:\\n return len(points)\\n\\n result = 0\\n for i in range(len(points) - 1):\\n lines = collections.defaultdict(int)\\n for j in range(i + 1, len(points)):\\n line = Line.from_points(*points[i], *points[j])\\n lines[line] += 1\\n result = max(result, max(lines.values()) + 1)\\n return result\\n \\n \\n\\n \",\n \"runtime\": \"463\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n result = 2\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n current_result = 2\\n for k in range(j+1, len(points)):\\n x3, y3 = points[k]\\n if (x2-x1) * (y3 - y2) == (x3 - x2) * (y2 - y1):\\n current_result += 1\\n result = max(result, current_result)\\n return result\\n\\n \",\n \"runtime\": \"485\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n N = len(points)\\n if N <= 2:\\n return N\\n \\n def countPoints(i, a, b):\\n p0 = points[i]\\n if a == 0:\\n return sum(p[0] == p0[0] for p in points[i + 1:])\\n if b == 0:\\n return sum(p[1] == p0[1] for p in points[i + 1:])\\n \\n count = 0\\n for p in points[i + 1:]:\\n dx = p[0] - p0[0]\\n dy = p[1] - p0[1]\\n if dx % a == 0 and dy % b == 0 and dy == dx * b // a:\\n count += 1\\n return count\\n \\n #seen = set()\\n most = 0\\n for i in range(N - 1):\\n p1 = points[i]\\n for j in range(i + 1, N):\\n p2 = points[j]\\n dx = p2[0] - p1[0]\\n dy = p2[1] - p1[1]\\n g = gcd(dx, dy)\\n a = dx // g\\n b = dy // g\\n #if (a, b) in seen:\\n # continue\\n #seen.add((a, b))\\n most = max(most, 2 + countPoints(j, a, b))\\n return most\",\n \"runtime\": \"485\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # each edge can be mapped to a pair (a, b)\\n # where a=slope, b=bias of the unique line containing edge\\n from collections import defaultdict\\n import fractions\\n from itertools import combinations\\n \\n lines = defaultdict(int)\\n vert_lines = defaultdict(int)\\n \\n for p1, p2 in combinations(points, 2):\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n if x1 == x2:\\n vert_lines[x1] += 1\\n else:\\n a = fractions.Fraction(y2 - y1, x2 - x1)\\n b = y2 - x2 * a\\n lines[a, b] += 1\\n\\n # if line contains n points\\n # lines[a,b] = (n choose 2)\\n # how to extract n?\\n # x = n*(n-1) / 2\\n # 2x = n*(n-1)\\n # 2x = n^2 - n\\n # 0 = n^2 - n - 2x\\n # delta = 1 + 8x\\n # n = (1 + sqrt(delta) / 2)\\n\\n import math\\n\\n def comb_to_n(combs):\\n delta = 1 + 8*combs\\n n = (1 + math.sqrt(delta)) / 2\\n n = int(n)\\n return n\\n\\n m = 1\\n for v in vert_lines.values():\\n v = comb_to_n(v)\\n if v > m:\\n m = v\\n\\n for (a, b), v in lines.items():\\n v = comb_to_n(v)\\n if v > m:\\n m = v\\n\\n print(lines)\\n print(vert_lines)\\n\\n return m\",\n \"runtime\": \"507\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n if len(points) == 2:\\n return 2\\n\\n lineMap = defaultdict(set) # key will be (x_intercept, y_intercept, slop)\\n\\n def getKey(p1, p2) -> Tuple: \\n deltaX = p1[0] - p2[0]\\n deltaY = p1[1] - p2[1]\\n y_intercept, x_intercept = 0, 0\\n if deltaX == 0:\\n y_intercept = float(\\\"inf\\\")\\n x_intercept = p1[0]\\n slope = float(\\\"inf\\\")\\n elif deltaY == 0:\\n x_intercept = float(\\\"inf\\\")\\n y_intercept = p1[1]\\n slope = 0\\n else:\\n slope = deltaY / deltaX\\n x_intercept = p1[0] - p1[1]/slope\\n y_intercept = p1[1] - slope*p1[0]\\n return (x_intercept, y_intercept, slope)\\n rslt = 0\\n for p1 in points:\\n tempMap = lineMap.copy()\\n for p2 in points:\\n if p1 != p2:\\n key = getKey(p1, p2)\\n if key not in lineMap:\\n tempMap[key].add((p1[0], p1[1]))\\n tempMap[key].add((p2[0], p2[1]))\\n rslt = max(rslt, len(tempMap[key]))\\n lineMap = tempMap\\n return rslt\\n\\n \",\n \"runtime\": \"507\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # y = k*x + b\\n\\n N = len(points)\\n if (N in [1,2]):\\n #print(\\\"--- N=\\\",N)\\n return N\\n maxn = 0\\n for i in range(0,N):\\n if (N-i+2<maxn):\\n #print(\\\"Break because N=\\\",N,\\\"; iii=\\\",i,\\\"; maxn=\\\",maxn)\\n break\\n xy1 = points[i]\\n # form a pair, get [k,b] and check other items with [k,b]\\n for j in range(i+1,N):\\n if (N-j+2<maxn):\\n #print(\\\"Break because N=\\\",N,\\\"; j=\\\",j,\\\"; maxn=\\\",maxn)\\n break\\n xy2 = points[j]\\n\\n # cases with vertical line\\n only = (xy1[0] == xy2[0]) or (xy1[1] == xy2[1])\\n onlyidx = 0 if (xy1[0] == xy2[0]) else 1\\n\\n # k = (y1-y2)/(x1-x2)\\n # b = y1 - k*x1\\n k = 1 if (only) else ((xy1[1] - xy2[1])/(xy1[0] - xy2[0]))\\n b = xy1[1] - k*xy1[0]\\n\\n #print(\\\"cur pair:\\\",xy1,xy2)\\n cnt = 2\\n # try to form lines\\n for idx in range(j+1,N):\\n #print(\\\".. trying to append:\\\",points[idx])\\n\\n if (only):\\n cnt += 1 if (points[idx][onlyidx] == xy1[onlyidx]) else 0\\n else:\\n x,y = points[idx][0],points[idx][1]\\n cnt += 1 if (abs(y-(k*x+b)) < 1.0e-13 ) else 0\\n maxn = cnt if (cnt>maxn) else maxn\\n #print(\\\"-- maxn=\\\", maxn)\\n return maxn\\n\\n \",\n \"runtime\": \"529\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n if n == 1:\\n return 1\\n elif n == 2:\\n return 2\\n slope = None\\n out = 0\\n\\n for idxstart in range(n-2):\\n for idx2 in range(idxstart+1, n-1):\\n cnt = 2\\n if points[idx2][0] == points[idxstart][0]:\\n for newidx in range(idx2+1, n):\\n newx, newy = points[newidx]\\n if newx == points[idx2][0]:\\n cnt += 1\\n else:\\n slope = (points[idx2][1] - points[idxstart][1]) / (points[idx2][0] - points[idxstart][0]) \\n ystart = points[idxstart][1]\\n xstart = points[idxstart][0]\\n\\n cnt = 2\\n for newidx in range(idx2+1, n):\\n newx, newy = points[newidx]\\n yexpected = slope * (newx - xstart) + ystart\\n if abs(yexpected - newy) < 0.00001:\\n cnt += 1\\n if cnt > out:\\n out = cnt\\n dprint(\\\"out just became\\\", out, \\\"with slope\\\", slope)\\n\\n return out\\n\\n\\ndef dprint(*args):\\n if 1 :\\n print(*args)\",\n \"runtime\": \"529\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n ans = 1\\n for i in range(n):\\n x1, y1 = points[i]\\n for j in range(i + 1, n):\\n x2, y2 = points[j]\\n cnt = 2\\n for k in range(j + 1, n):\\n x3, y3 = points[k]\\n a = (y2 - y1) * (x3 - x1)\\n b = (y3 - y1) * (x2 - x1)\\n cnt += a == b\\n ans = max(ans, cnt)\\n return ans\",\n \"runtime\": \"551\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n ans = 1\\n for i in range(n):\\n x1, y1 = points[i]\\n for j in range(i + 1, n):\\n x2, y2 = points[j]\\n cnt = 2\\n for k in range(j + 1, n):\\n x3, y3 = points[k]\\n a = (y2 - y1) * (x3 - x1)\\n b = (y3 - y1) * (x2 - x1)\\n cnt += a == b\\n ans = max(ans, cnt)\\n return ans\",\n \"runtime\": \"551\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n total_aligned_points = 1\\n\\n for i in range(n):\\n x1, y1 = points[i]\\n for j in range(i + 1, n):\\n x2, y2 = points[j]\\n cnt = 2\\n for k in range(j + 1, n):\\n x3, y3 = points[k]\\n a = (y2 - y1) * (x3 - x1)\\n b = (y3 - y1) * (x2 - x1)\\n cnt += a == b\\n total_aligned_points = max(total_aligned_points,cnt)\\n return total_aligned_points\\n \",\n \"runtime\": \"573\"\n },\n {\n \"code\": \"from fractions import Fraction\\nfrom collections import Counter\\nimport math\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n s=Counter()\\n for i in range(len(points)):\\n for j in range(i+1,len(points)):\\n if (points[j][0]==points[i][0]):\\n m,c=float('inf'),'inf'+str(points[j][0])\\n if points[j][0]==0:\\n print(points[i][0],points[i][1],points[j][0],points[j][1])\\n else:\\n m=Fraction(points[j][1]-points[i][1],points[j][0]-points[i][0])\\n c=points[i][1]-m*(points[i][0])\\n s[(m,c)] += 1\\n\\n ma =0 \\n print(s)\\n for i in s:\\n if s[i]>ma:\\n ma = s[i]\\n return int(1 + math.sqrt(1+8*ma))//2 \\n\",\n \"runtime\": \"573\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n res = 1\\n for i in range(n):\\n x1, y1 = points[i]\\n for j in range(i+1, n):\\n x2, y2 = points[j]\\n count = 2\\n for k in range(j+1, n):\\n x3, y3 = points[k]\\n a = (y2 - y1) * (x3 - x1)\\n b = (y3 - y1) * (x2 - x1)\\n count += a == b\\n res = max(res, count)\\n return res\",\n \"runtime\": \"594\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # y = k*x + b\\n\\n N = len(points)\\n if (N in [1,2]):\\n #print(\\\"--- N=\\\",N)\\n return N\\n maxn = 0\\n for i in range(0,N):\\n if (N-i+2<maxn):\\n #print(\\\"Break because N=\\\",N,\\\"; iii=\\\",i,\\\"; maxn=\\\",maxn)\\n break\\n xy1 = points[i]\\n # form a pair, get [k,b] and check other items with [k,b]\\n for j in range(i+1,N):\\n if (N-j+2<maxn):\\n #print(\\\"Break because N=\\\",N,\\\"; j=\\\",j,\\\"; maxn=\\\",maxn)\\n break\\n xy2 = points[j]\\n\\n # cases with vertical line\\n only = (xy1[0] == xy2[0]) or (xy1[1] == xy2[1])\\n onlyidx = 0 if (xy1[0] == xy2[0]) else 1\\n\\n # k = (y1-y2)/(x1-x2)\\n # b = y1 - k*x1\\n k = 1 if (only) else ((xy1[1] - xy2[1])/(xy1[0] - xy2[0]))\\n b = xy1[1] - k*xy1[0]\\n\\n #print(\\\"cur pair:\\\",xy1,xy2)\\n cnt = 2\\n # try to form lines\\n for idx in range(j+1,N):\\n if (N-idx+cnt<maxn):\\n #print(\\\"Break because N=\\\",N,\\\"; j=\\\",j,\\\"; maxn=\\\",maxn)\\n break\\n\\n if (only):\\n cnt += 1 if (points[idx][onlyidx] == xy1[onlyidx]) else 0\\n else:\\n x,y = points[idx][0],points[idx][1]\\n cnt += 1 if (abs(y-(k*x+b)) < 1.0e-13 ) else 0\\n maxn = cnt if (cnt>maxn) else maxn\\n #print(\\\"-- maxn=\\\", maxn)\\n return maxn\\n\\n \",\n \"runtime\": \"594\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n ans = 1\\n for i in range(n):\\n x1, y1 = points[i]\\n for j in range(i + 1, n):\\n x2, y2 = points[j]\\n cnt = 2\\n for k in range(j + 1, n):\\n x3, y3 = points[k]\\n a = (y2 - y1) * (x3 - x1)\\n b = (y3 - y1) * (x2 - x1)\\n cnt += a == b\\n ans = max(ans, cnt)\\n return ans\",\n \"runtime\": \"616\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n ans = min(2, len(points))\\n for i in range(len(points)-2):\\n p1 = points[i]\\n for j in range(i+1, len(points)-1):\\n p2 = points[j]\\n if p2[0] - p1[0] != 0:\\n angle = (p2[1] - p1[1]) / (p2[0] - p1[0])\\n else:\\n angle = \\\"line\\\"\\n cur = 2\\n for k in range(j+1, len(points)):\\n p3 = points[k]\\n if p3[0] - p1[0] != 0:\\n angle2 = (p3[1] - p1[1]) / (p3[0] - p1[0])\\n else:\\n angle2 = \\\"line\\\"\\n if angle == angle2:\\n cur += 1\\n ans = max(ans, cur)\\n return ans\",\n \"runtime\": \"616\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n def slope(p, q):\\n if p[0] == q[0]:\\n return inf\\n \\n return (p[1] - q[1]) / (p[0] - q[0])\\n\\n if len(points) <= 2:\\n return len(points)\\n \\n result = 0\\n for i in range(len(points)):\\n p = points[i]\\n for j in range(i + 1, len(points)):\\n q = points[j]\\n pq_slope = slope(p, q)\\n count = 2\\n\\n for k in range(j + 1, len(points)):\\n r = points[k]\\n if slope(q, r) == pq_slope:\\n count += 1\\n \\n result = max(result, count)\\n \\n return result\\n\",\n \"runtime\": \"638\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n res = 0\\n for i in range(len(points)-1):\\n x1,y1 = points[i]\\n for j in range(i+1,len(points)):\\n x2,y2 = points[j]\\n s = 0\\n x_min = min([x1,x2])\\n x_max = max([x1,x2])\\n y_min = min([y1,y2])\\n y_max = max([y1,y2])\\n for (x3,y3) in points:\\n if x3 < x_min or x3 > x_max:\\n continue\\n if y3 < y_min or y3 > y_max:\\n continue\\n if x1 == x2:\\n if x3 == x1:\\n s += 1\\n else:\\n if (y2 - y1) * (x3 - x1) == (y3 - y1) * (x2 - x1):\\n s += 1\\n if s > res:\\n res = s\\n return res\\n\",\n \"runtime\": \"638\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def get_gradient(self, p1: List[int], p2: List[int]) -> float:\\n if (p1[0] == p2[0]):\\n raise Exception()\\n \\n return (p1[1] - p2[1]) / (p1[0] - p2[0])\\n \\n def maxPoints(self, points: List[List[int]]) -> int:\\n if (len(points) < 2):\\n return len(points)\\n \\n ans = 2\\n\\n for i in range(len(points) - 2):\\n for j in range(i + 1, len(points) - 1):\\n p1 = points[i]\\n p2 = points[j]\\n \\n m0 = 0\\n is_vertical = False\\n\\n try:\\n m0 = self.get_gradient(p1, p2)\\n\\n except:\\n is_vertical = True\\n\\n count = 2\\n for k in range(j + 1, len(points)):\\n m1 = 0\\n p3 = points[k]\\n\\n try:\\n m1 = self.get_gradient(p1, p3)\\n\\n if (not is_vertical and m0 == m1):\\n count += 1\\n\\n except Exception:\\n if (is_vertical):\\n count += 1\\n\\n ans = max(ans, count)\\n\\n return ans\",\n \"runtime\": \"660\"\n },\n {\n \"code\": \"class Solution:\\n def check_line(self, a, b, c, p):\\n x, y = p\\n return a*x+b*y+c == 0\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n max_points = 1\\n for i1 in range(len(points)-1):\\n for i2 in range(i1+1, len(points)):\\n p1, p2 = points[i1], points[i2]\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n # cur_line ax+by+c=0\\n a = y2-y1\\n b = x1-x2\\n c = y1*x2-x1*y2\\n\\n num_points = 2\\n for i in range(i2+1, len(points)):\\n if self.check_line(a, b, c, points[i]):\\n num_points += 1\\n\\n if num_points > max_points:\\n max_points = num_points\\n return max_points\\n\",\n \"runtime\": \"660\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n \\n if len(points) <= 2:\\n return len(points)\\n if len(points) == 3:\\n #(y1-y2)(x1-x3)-(y1-y3)(x1-x2) = 0\\n delta = (points[0][1] - points[1][1])*(points[0][0]-points[2][0]) \\\\\\n - (points[0][1] - points[2][1])*(points[0][0]-points[1][0])\\n if delta == 0:\\n return 3\\n else:\\n return 2\\n \\n \\n N = len(points)\\n num_max = 2\\n \\n for i in range(N-2):\\n p1 = points[i]\\n for j in range(i+1, N-1):\\n num = 2\\n p2 = points[j]\\n for k in range(j+1, N):\\n p3 = points[k]\\n delta = (p1[1]-p2[1])*(p1[0]-p3[0]) - (p1[1]-p3[1])*(p1[0]-p2[0])\\n \\n if delta == 0:\\n num = num +1\\n pass\\n if num > num_max:\\n num_max = num\\n return num_max\",\n \"runtime\": \"682\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n graph = defaultdict(list)\\n\\n for i in range(len(points)-1) :\\n for j in range(i+1, len(points)) :\\n slope = 10 ** 9\\n\\n if (points[j][0] - points[i][0]) != 0 :\\n slope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0]) \\n\\n graph[(points[i][0], points[i][1])].append((points[j][0], points[j][1], slope ))\\n \\n # print(graph)\\n def dfsUtil(p, q, dist) :\\n # print(p, q, dist)\\n max_len = 1\\n neighbors = graph[(p, q)]\\n # print(neighbors)\\n\\n for x, y, distance in neighbors :\\n if dist == -sys.maxsize or dist == distance :\\n max_len = max(max_len, 1 + dfsUtil(x, y, distance))\\n\\n return max_len \\n\\n \\n max_points = 0\\n for k in range(len(points)) :\\n # print(points[k])\\n max_points = max(max_points, dfsUtil(points[k][0], points[k][1], -sys.maxsize))\\n # print(points[k], dfsUtil(points[k][0], points[k][1], -sys.maxsize))\\n return max_points\",\n \"runtime\": \"682\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n graph = defaultdict(list)\\n for i in range(len(points)-1) :\\n for j in range(i+1, len(points)) :\\n slope = 10 ** 9\\n if (points[j][0] - points[i][0]) != 0 :\\n slope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0]) \\n\\n graph[(points[i][0], points[i][1])].append((points[j][0], points[j][1], slope ))\\n \\n\\n def dfsUtil(p, q, dist) :\\n max_len = 1\\n neighbors = graph[(p, q)]\\n\\n for x, y, distance in neighbors :\\n if dist == -sys.maxsize or dist == distance :\\n max_len = max(max_len, 1 + dfsUtil(x, y, distance))\\n\\n return max_len \\n\\n \\n max_points = 0\\n for k in range(len(points)) :\\n max_points = max(max_points, dfsUtil(points[k][0], points[k][1], -sys.maxsize))\\n \\n return max_points\",\n \"runtime\": \"704\"\n },\n {\n \"code\": \"class Solution:\\n def get_a_c(self,point1, point2):\\n x1,y1 = point1\\n x2,y2 = point2\\n\\n if x1-x2 == 0:\\n return None, x1\\n\\n dy = y1-y2 \\n dx = x1-x2\\n\\n a = (y1-y2) / (x1-x2)\\n b = y1 - a * x1\\n\\n return a,b\\n \\n def check_in_line(self,ab, point):\\n x,y = point\\n a,b = ab\\n if a == None:\\n if x == b:\\n return True\\n else:\\n return False\\n if abs((a*x + b) - y) < 0.00001:\\n return True\\n else:\\n return False\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n visited = set()\\n\\n max_point = 1\\n\\n for i in range(0,len(points)):\\n for j in range(i+1, len(points)):\\n ab = self.get_a_c(points[i],points[j])\\n if ab not in visited:\\n temp_count = 2\\n for k in range(j+1, len(points)):\\n if self.check_in_line(ab, points[k]):\\n temp_count += 1\\n if temp_count > max_point:\\n max_point = temp_count\\n visited.add(ab)\\n \\n return max_point\",\n \"runtime\": \"704\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def Line(self, p1: List[int], p2: List[int]) -> list[int]:\\n d = 1/(p1[0] - p2[0])\\n a = d*(p1[1] - p2[1])\\n b = d*(-p2[0]*p1[1] + p1[0]*p2[1])\\n return [a,b]\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n points = np.array(points)\\n result = 0\\n for i in range(len(points)):\\n px , py = points[i]\\n for j in range(i+1,len(points)):\\n if px == points[j][0]:\\n point_count = ((points[:,0]) == points[i][0]).sum()\\n else :\\n a, b = self.Line(points[i],points[j])\\n point_count = (abs(points[:,0]*a + b - points[:,1]) <= 1e-10).sum()\\n result = max(result, point_count)\\n return result\\n\",\n \"runtime\": \"725\"\n },\n {\n \"code\": \"class Solution:\\n def get_a_c(self,point1, point2):\\n x1,y1 = point1\\n x2,y2 = point2\\n\\n if x1-x2 == 0:\\n return None, x1\\n\\n dy = y1-y2 \\n dx = x1-x2\\n\\n a = (y1-y2) / (x1-x2)\\n b = y1 - a * x1\\n\\n return a,b\\n \\n def check_in_line(self,ab, point):\\n x,y = point\\n a,b = ab\\n if a == None:\\n if x == b:\\n return True\\n else:\\n return False\\n if abs((a*x + b) - y) < 0.00001:\\n return True\\n else:\\n return False\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n visited = set()\\n\\n max_point = 1\\n\\n for i in range(0,len(points)):\\n for j in range(i+1, len(points)):\\n ab = self.get_a_c(points[i],points[j])\\n if ab not in visited:\\n temp_count = 2\\n for k in range(j+1, len(points)):\\n if self.check_in_line(ab, points[k]):\\n temp_count += 1\\n if temp_count > max_point:\\n max_point = temp_count\\n visited.add(ab)\\n \\n return max_point\",\n \"runtime\": \"725\"\n },\n {\n \"code\": \"class Solution:\\n def aligned_2(self, x,y, q):\\n if x == y :\\n return True\\n if (x[0]==y[0] ):\\n if q == None:\\n return True\\n else:\\n return False\\n if (x[1]-y[1])/(x[0]-y[0]) == q:\\n return True\\n return False\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2:\\n return len(points)\\n m = 0\\n for i in range(1,len(points)):\\n if (points[0][0] - points[i][0]) == 0:\\n q = None\\n else:\\n q = (points[0][1] - points[i][1])/(points[0][0] - points[i][0])\\n n =2\\n for j in range(i+1,len(points)):\\n if self.aligned_2(points[0], points[j], q):\\n n+=1\\n m = max(m,n)\\n return max(m, self.maxPoints(points[1:]))\\n \\n \\n\",\n \"runtime\": \"747\"\n },\n {\n \"code\": \"from typing import List\\nfrom fractions import Fraction\\n\\nclass Solution:\\n # a line can be described by y = mx + b, e.g. two numbers: m and b.\\n # for each point i, compare with all other points j > i, calculate slop and intercept\\n # bin the results, keep track of the max bin size.\\n # very simple, O(n^2), impossible to do better.\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n if n == 1:\\n return 1\\n \\n dict = {}\\n max_points = 0\\n for i in range(n):\\n for j in range(i+1, n):\\n xi, yi = points[i] if points[i][0] < points[j][0] else points[j]\\n xj, yj = points[j] if points[i][0] < points[j][0] else points[i]\\n\\n if xj != xi:\\n #m = float((yj - yi) / (xj - xi))\\n m = Fraction((yj - yi), (xj - xi))\\n else:\\n m = float('inf')\\n\\n if m == float('inf'):\\n b = float(xi)\\n elif m == 0:\\n b = \\\"inf, \\\" + str(yi)\\n else:\\n #b = float(yi - m*xi)\\n b = Fraction(yi - m*xi)\\n\\n #b = str(b)\\n #m = str(m)\\n\\n if (m, b) not in dict:\\n dict[(m, b)] = set()\\n dict[(m, b)].add(i)\\n dict[(m, b)].add(j)\\n \\n max_points = max(max_points, len(dict[(m, b)]))\\n\\n print(dict)\\n\\n return max_points\",\n \"runtime\": \"769\"\n },\n {\n \"code\": \"from fractions import Fraction\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n\\n if n <= 2:\\n return n\\n\\n d = {}\\n r = 0\\n\\n # for i in range(n - 1):\\n # for j in range(i + 1, n):\\n for i in range(n):\\n for j in range(n):\\n # y = m x + b\\n \\n # m = dy / dx\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n\\n print(\\\"Points: \\\", i, j, points[i], points[j])\\n\\n dx = x2 - x1\\n dy = y2 - y1\\n\\n if dx == 0:\\n m = Fraction(1, 12345)\\n b = x1\\n else:\\n m = Fraction(dy, dx)\\n # b = y - m * x\\n b = Fraction(y1) - m * Fraction(x1)\\n\\n print(m, b)\\n \\n k = (m.numerator, m.denominator, b.numerator, b.denominator)\\n \\n d[k] = c = d.get(k, 0) + 1\\n r = max(c, r)\\n \\n return int(sqrt(float(r) + 0.25) + 0.5)\\n\\n\\n\\\"\\\"\\\"\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2:\\n return len(points)\\n \\n def find_slope(p1, p2):\\n x1, y1 = p1\\n x2, y2 = p2\\n if x1-x2 == 0:\\n return inf\\n return (y1-y2)/(x1-x2)\\n \\n ans = 1\\n for i, p1 in enumerate(points):\\n slopes = defaultdict(int)\\n for j, p2 in enumerate(points[i+1:]):\\n slope = find_slope(p1, p2)\\n slopes[slope] += 1\\n ans = max(slopes[slope], ans)\\n return ans+1\\n\\n\\\"\\\"\\\"\",\n \"runtime\": \"769\"\n },\n {\n \"code\": \"class Solution:\\n def __same_x_cordinates(self, points: list[list[int]]) -> int:\\n n = len(points)\\n res = 1\\n for i in range(0,n-1):\\n count = 1\\n for j in range(i+1, n):\\n if points[i][0] == points[j][0]:\\n count += 1\\n \\n res = max(res, count)\\n \\n return res\\n \\n def __same_y_cordinates(self, points: list[list[int]]) -> int:\\n n = len(points)\\n res = 1\\n for i in range(0, n-1):\\n count = 1\\n for j in range(i+1,n):\\n if points[i][1] == points[j][1]:\\n count += 1\\n \\n res = max(res, count)\\n \\n return res\\n\\n\\n def maxPoints(self, points : list[list[int]]) -> int:\\n def diff_cordinates(a:list[int], b:list[int]) -> bool:\\n return a[0] != b[0] and a[1] != b[1]\\n\\n n = len(points)\\n if n == 1 or n == 2:\\n return n\\n \\n res = 2\\n for i in range(0, n - 2):\\n for j in range(i + 1, n - 1):\\n if diff_cordinates(points[i], points[j]):\\n count = 2\\n for z in range(j + 1, n):\\n if (points[j][1] - points[i][1]) * (points[z][0] - points[i][0]) == (points[z][1] - points[i][1]) * (points[j][0] - points[i][0]):\\n count += 1\\n res = max(res, count)\\n \\n res = max(res, self.__same_x_cordinates(points), self.__same_y_cordinates(points))\\n\\n return res \",\n \"runtime\": \"791\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n def on_same_line(p1, p2, p3):\\n # Using cross product to check if three points are collinear\\n return (p3[1] - p1[1]) * (p2[0] - p1[0]) == (p2[1] - p1[1]) * (p3[0] - p1[0])\\n \\n n = len(points)\\n if n < 3:\\n return n\\n\\n max_res = 1\\n\\n for i in range(n):\\n for j in range(i + 1, n):\\n count = 2 # p1 and p2 are always on the same line\\n for k in range(j + 1, n):\\n if on_same_line(points[i], points[j], points[k]):\\n count += 1\\n max_res = max(max_res, count)\\n \\n return max_res\\n\",\n \"runtime\": \"813\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n if n < 2:\\n return n\\n res = 2\\n for i in range(n):\\n for j in range(i + 1, n):\\n count = 2\\n for x in range(j + 1, n):\\n if (points[i][1] - points[j][1]) * (points[i][0] - points[x][0]) == (points[i][0] - points[j][0]) * (points[i][1] - points[x][1]):\\n count += 1\\n res = max(res, count)\\n return res\",\n \"runtime\": \"813\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lines = []\\n\\n for point in points:\\n append_list = []\\n for line in lines:\\n if len(line) == 1:\\n append_list.append([line[0], point])\\n else:\\n point_1 = line[-2]\\n point_2 = line[-1]\\n\\n if (point_1[1] - point_2[1]) * (point_2[0] - point[0]) == (point_2[1] - point[1]) * (point_1[0] - point_2[0]):\\n line.append(point)\\n for append in append_list:\\n lines.append(append)\\n lines.append([point])\\n\\n\\n max_points = max([len(line) for line in lines])\\n return max_points\\n \",\n \"runtime\": \"835\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lines = []\\n\\n for point in points:\\n append_list = []\\n\\n for line in lines:\\n if len(line) == 1:\\n append_list.append([line[0], point])\\n else:\\n point_1 = line[-2]\\n point_2 = line[-1]\\n\\n if (point_1[1] - point_2[1]) * (point_2[0] - point[0]) == (point_2[1] - point[1]) * (point_1[0] - point_2[0]):\\n line.append(point)\\n for append in append_list:\\n lines.append(append)\\n lines.append([point])\\n\\n max_points = max([len(line) for line in lines])\\n return max_points\\n \",\n \"runtime\": \"835\"\n },\n {\n \"code\": \"from typing import NamedTuple, Optional\\nfrom fractions import Fraction\\n\\nclass Line(NamedTuple):\\n m: Optional[Fraction]\\n b: Fraction\\n\\n @staticmethod \\n def from_points(x1: int, y1: int, x2: int, y2: int) -> 'Line':\\n if x1 == x2:\\n return Line(m=None, b=x1)\\n else: \\n m = Fraction(y1 - y2, x1 - x2)\\n b = y1 - m * x1\\n return Line(m=m, b=b)\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2:\\n return len(points)\\n\\n result = 0\\n for i in range(len(points)):\\n lines = collections.defaultdict(int)\\n for j in range(len(points)):\\n if i != j:\\n line = Line.from_points(*points[i], *points[j])\\n lines[line] += 1\\n result = max(result, max(lines.values()) + 1)\\n return result\\n \\n \\n\\n \",\n \"runtime\": \"856\"\n },\n {\n \"code\": \"class Solution:\\n def isTriple(point1, point2, point3):\\n if (point2[1] - point1[1]) * (point3[0] - point2[0]) == (point3[1] - point2[1]) * (point2[0] - point1[0]):\\n return True\\n else:\\n return False\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n best_res = 2\\n curr_res = 2\\n for i in range(len(points)):\\n for j in range(i + 1, len(points)):\\n for k in range(j + 1, len(points)):\\n if Solution.isTriple(points[i], points[j], points[k]) == True:\\n curr_res = 3\\n for m in range(k + 1, len(points)):\\n if Solution.isTriple(points[i], points[j], points[m]) == True:\\n curr_res += 1\\n if curr_res > best_res:\\n best_res = curr_res\\n return best_res\",\n \"runtime\": \"856\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n\\n result = 2\\n for i in range(len(points)):\\n for j in range(i+1,len(points)):\\n group = 2\\n if points[i][0] == points[j][0]:\\n for k in range(j+1, len(points)):\\n if points[k][0] == points[i][0]:\\n group += 1\\n else:\\n for k in range(j+1, len(points)):\\n if (points[j][0]-points[i][0])*(points[k][1] - points[i][1]) == (points[j][1]-points[i][1])*(points[k][0] - points[i][0]):\\n group += 1\\n if group > result:\\n result = group\\n return result\\n\",\n \"runtime\": \"878\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n def count_points(start_idx: int, end_idx: int) -> int:\\n s_x, s_y = points[start_idx]\\n e_x, e_y = points[end_idx]\\n\\n # vertical line\\n if s_x == e_x:\\n return sum([p_x == s_x for p_x, _ in points])\\n\\n # slope (m): rise / run = (e_y - s_y) / (e_x - s_x)\\n m_num, m_den = e_y - s_y, e_x - s_x\\n m_gcd = math.gcd(m_num, m_den)\\n m_num //= m_gcd\\n m_den //= m_gcd\\n\\n # intercept (b): y = mx + b -> b = y - mx\\n b_num, b_den = e_y * m_den - e_x * m_num, m_den\\n \\n count = 0\\n for p_x, p_y in points:\\n if p_y * m_den == m_num * p_x + b_num:\\n count += 1\\n\\n return count \\n\\n N = len(points)\\n max_points = 1\\n\\n for start_idx in range(N):\\n for end_idx in range(start_idx + 1, N):\\n max_points = max(max_points, count_points(start_idx, end_idx))\\n return max_points\",\n \"runtime\": \"878\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if(len(points)==1):\\n return 1\\n\\n def slope(a, b, x, y, c, d):\\n area = abs(a * (y - d) + x * (d - b) + c * (b - y))\\n return area == 0\\n \\n f = {}\\n\\n for p in points:\\n if(tuple(p) not in f):f[tuple(p)] = 0\\n f[tuple(p)]+=1\\n\\n\\n points = list(f.keys())\\n\\n d = {}\\n ans = 2\\n for i in range(len(points)):\\n x, y = points[i]\\n flg = False\\n for k in d:\\n a, b, c, gd = k\\n if(slope(a, b, x, y, c, gd)):\\n d[k]+=f[(x, y)]\\n ans = max(d[k], ans)\\n flg = True\\n \\n # if(not flg):\\n for j in range(i):\\n a, b = points[j]\\n k = (a, b, x, y)\\n d[k] = f[(a, b)]+f[(x, y)]\\n print()\\n \\n return ans\\n\\n\\n \\n \\n\\n\",\n \"runtime\": \"900\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n def getTangent(x, y):\\n if x[0] == y[0]:\\n return float(\\\"inf\\\")\\n else:\\n return (x[1]-y[1])/(x[0]-y[0])\\n\\n result = 0\\n \\n for i in range(len(points)-1):\\n tangentCount = {}\\n for j in range(i+1, len(points)):\\n tan = getTangent(points[i], points[j])\\n if tan in tangentCount:\\n tangentCount[tan] += 1\\n else :\\n tangentCount[tan] = 1\\n print(*tangentCount.values())\\n result = max(result, *tangentCount.values())\\n \\n\\n return result+1\",\n \"runtime\": \"900\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom fractions import Fraction\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n if len(points) == 2:\\n return 2\\n k = b = 0\\n hashmap = defaultdict(int)\\n for i in range(len(points)):\\n for j in range(len(points)):\\n if i == j:\\n continue\\n point1 = points[i]\\n point2 = points[j]\\n if point2[0] - point1[0] == 0:\\n k = \\\"inf\\\"\\n b = point2[0]\\n else:\\n k = Fraction((point2[1] - point1[1]), (point2[0] - point1[0]))\\n b = point2[1] - k * point2[0]\\n hashmap[(k,b)] += 1\\n res = 0\\n for i in hashmap:\\n if hashmap[i] > res:\\n res = hashmap[i]\\n\\n\\n return int(sqrt(res)+1)\\n\\n\",\n \"runtime\": \"922\"\n },\n {\n \"code\": \"from fractions import Fraction\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 2:\\n return len(points)\\n line_counts = defaultdict(lambda : 0)\\n for p1 in points:\\n for p2 in points:\\n if p1 != p2:\\n if p2[0] - p1[0] == 0:\\n slope = \\\"infinity\\\"\\n else:\\n slope = Fraction(p2[1]-p1[1], p2[0]-p1[0])\\n if slope == \\\"infinity\\\":\\n intercept = p1[0]\\n else:\\n intercept = p1[1] - p1[0] * slope\\n line_counts[(slope, intercept)] += 1\\n return int(1 + (max(line_counts.values()) ** 0.5))\",\n \"runtime\": \"922\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # pick 2 points\\n # get gradient between the two\\n # iterate over the rest of the points, check whether it fulfils the criteria of same gradient\\n # repeat for the rest of the points\\n # Output highest points\\n if len(points) == 2:\\n return 2\\n elif len(points) == 1:\\n return 1\\n \\n def checkpoint(a,b,test):\\n # check if x is on the same line as a and b\\n y = (b[1] - a[1])\\n x = (b[0] - a[0])\\n if y == 0 or x == 0:\\n if (test[1] == b[1] and test[1] == a[1]) or (test[0] == b[0] and test[0] == a[0]):\\n return True\\n return False\\n elif ((test[1] - a[1]) / y) == ((test[0] - a[0]) / x):\\n return True\\n else:\\n return False\\n \\n line = []\\n final = []\\n count = 0\\n highest = 0\\n for i in range(len(points) - 2):\\n for j in range(i + 1, len(points) - 1):\\n count = 0\\n for k in range(j + 1,len(points)):\\n if checkpoint(points[i],points[j],points[k]) == True:\\n count += 1\\n line.append(points[k])\\n \\n if highest < count:\\n highest = count\\n line.append(points[i])\\n line.append(points[j])\\n final = line\\n line = []\\n else:\\n line = []\\n \\n print(final)\\n return highest + 2\\n \\n\\n\\n\",\n \"runtime\": \"944\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n def getTangent(x, y):\\n if x[0] == y[0]:\\n return float(\\\"inf\\\")\\n else:\\n return (x[1]-y[1])/(x[0]-y[0])\\n\\n result = 0\\n \\n for i in range(len(points)-1):\\n tangentCount = {}\\n for j in range(i+1, len(points)):\\n tan = getTangent(points[i], points[j])\\n if tan in tangentCount:\\n tangentCount[tan] += 1\\n else :\\n tangentCount[tan] = 1\\n print(*tangentCount.values())\\n result = max(result, *tangentCount.values())\\n \\n\\n return result+1\",\n \"runtime\": \"944\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n longest_line_length = 1\\n ind = 0\\n for defining_point_1 in points:\\n x1, y1 = defining_point_1\\n\\n for defining_point_2 in points[ind+1:]:\\n\\n line_length = 0\\n x2, y2 = defining_point_2\\n\\n if x2 != x1:\\n m_numerator = y2 - y1\\n m_denominator = x2 - x1\\n b_times_m_denominator = y1 * m_denominator - m_numerator * x1\\n for test_point in points:\\n x, y = test_point\\n if m_denominator * y == m_numerator * x + b_times_m_denominator:\\n line_length += 1\\n\\n # Undefined slope - they are on a line\\n # if they share an x coordinate\\n else:\\n for test_point in points:\\n if test_point[0] == x1:\\n line_length += 1\\n\\n \\n \\n if longest_line_length < line_length:\\n longest_line_length = line_length\\n ind += 1\\n\\n return longest_line_length\",\n \"runtime\": \"966\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n l, cache = len(points), {}\\n\\n if l == 1:\\n return 1\\n\\n def countPoints(p1, p2):\\n count = 0\\n\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n if x1 != x2:\\n k = y1 - y2 \\n c = x1 - x2\\n b = x1 * y2 - x2 * y1\\n if (k, b) in cache:\\n return cache[(k, b)]\\n for point in points:\\n x, y = point\\n if c * y == k * x + b:\\n count += 1\\n else:\\n k = float('inf')\\n b = x1\\n if (k, b) in cache:\\n return cache[(k, b)]\\n for point in points:\\n x, y = point\\n if x == x1:\\n count += 1\\n \\n cache[(k, b)] = count\\n\\n return count\\n\\n max_num = float('-inf')\\n for i in range(l):\\n for j in range(i + 1, l):\\n max_num = max(max_num, countPoints(points[i], points[j]))\\n \\n return max_num\\n \",\n \"runtime\": \"966\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n l, cache = len(points), {}\\n\\n if l == 1:\\n return 1\\n\\n def countPoints(p1, p2):\\n count = 0\\n\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n if x1 != x2:\\n k = y1 - y2 \\n c = x1 - x2\\n b = x1 * y2 - x2 * y1\\n if (k, b) in cache:\\n return cache[(k, b)]\\n for point in points:\\n x, y = point\\n if c * y == k * x + b:\\n count += 1\\n else:\\n k = float('inf')\\n b = x1\\n if (k, b) in cache:\\n return cache[(k, b)]\\n for point in points:\\n x, y = point\\n if x == x1:\\n count += 1\\n \\n cache[(k, b)] = count\\n\\n return count\\n\\n max_num = float('-inf')\\n for i in range(l):\\n for j in range(i + 1, l):\\n max_num = max(max_num, countPoints(points[i], points[j]))\\n \\n return max_num\\n \",\n \"runtime\": \"987\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 0: return 0\\n elif len(points) == 1: return 1\\n elif len(points) == 2: return 2\\n\\n def gcd(a: int, b: int) -> int:\\n if a == b: return a\\n elif a < b: return gcd(b - a, a)\\n else: return gcd(a - b, b)\\n \\n def keyFinder(i: int, j: int) -> (int, int, int, int):\\n slope_y = points[j][1] - points[i][1]\\n slope_x = points[j][0] - points[i][0]\\n if slope_x < 0: \\n slope_x = - slope_x\\n slope_y = - slope_y\\n if slope_x == 0:\\n slope_y = 1\\n int_y = 0\\n int_x = points[i][0]\\n elif slope_y == 0:\\n slope_x = 1\\n int_y = points[i][1]\\n int_x = 0\\n else: \\n g = gcd(abs(slope_y), slope_x)\\n slope_y = slope_y // g\\n slope_x = slope_x // g\\n int_y = (points[i][1] * slope_x) - (slope_y * points[i][0])\\n int_x = slope_x\\n if int_y == 0: int_y, int_x = 0, 0\\n else:\\n g = gcd(abs(int_y), int_x)\\n int_y, int_x = int_y // g, int_x // g\\n \\n out = (slope_x, slope_y, int_x, int_y)\\n return out\\n\\n\\n lineDict = dict()\\n i = 0\\n\\n while i < len(points) - 1:\\n j = i + 1\\n while j < len(points):\\n key = keyFinder(i, j)\\n if key not in lineDict: lineDict[key] = [i]\\n if j not in lineDict[key]: lineDict[key].append(j)\\n j += 1\\n i += 1\\n \\n res = 2\\n for line in lineDict.keys():\\n res = max(res, len(lineDict[line]))\\n\\n return res\",\n \"runtime\": \"987\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n l, cache = len(points), {}\\n\\n if l == 1:\\n return 1\\n\\n def countPoints(p1, p2):\\n count = 0\\n\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n if x1 != x2:\\n k = y1 - y2 \\n b = x1 * y2 - x2 * y1\\n c = x1 - x2\\n if (k, b, c) in cache:\\n return cache[(k, b, c)]\\n for point in points:\\n x, y = point\\n if c * y == k * x + b:\\n count += 1\\n else:\\n k = float('inf')\\n b = x1\\n c = 0\\n if (k, b, c) in cache:\\n return cache[(k, b, c)]\\n for point in points:\\n x, y = point\\n if x == x1:\\n count += 1\\n \\n cache[(k, b, c)] = count\\n\\n return count\\n\\n max_num = float('-inf')\\n for i in range(l):\\n for j in range(i + 1, l):\\n max_num = max(max_num, countPoints(points[i], points[j]))\\n \\n return max_num\\n \",\n \"runtime\": \"1009\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n combs = list(itertools.combinations(points, 2))\\n \\n n = 0\\n a = 0\\n if len(points)==1:\\n return 1\\n for comb in combs:\\n \\n if comb[1][0] - comb[0][0] == 0: #vert line\\n a =0\\n for p in points:\\n if p[0] == comb[0][0]:\\n a+=1\\n n = max(n, a)\\n else:\\n\\n m = (comb[1][1] - comb[0][1]) / (comb[1][0] - comb[0][0])\\n b = comb[0][1] - (m * comb[0][0])\\n a = 0\\n for p in points:\\n if abs((m * p[0] + b) - p[1]) < 1e-9:\\n \\n a += 1 \\n \\n n = max(n, a)\\n return n\\n\\n \",\n \"runtime\": \"1009\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n=len(points)\\n d={}\\n for i in range(n):\\n x,y=points[i][0],points[i][1]\\n for j in range(i+1,n):\\n x1=x-points[j][0]\\n y1=y-points[j][1]\\n b=x1*y-y1*x\\n d[(y1,x1,b)]=0\\n for i in range(n):\\n x,y=points[i][0],points[i][1]\\n for j in d:\\n if j[1]*y==j[0]*x+j[2]:\\n d[j]+=1\\n m=1\\n for x in d:\\n m=max(m,d[x])\\n return m\\n\",\n \"runtime\": \"1031\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n=len(points)\\n d={}\\n for i in range(n):\\n x,y=points[i][0],points[i][1]\\n for j in range(i+1,n):\\n x1=x-points[j][0]\\n y1=y-points[j][1]\\n b=x1*y-y1*x\\n d[(y1,x1,b)]=0\\n for i in range(n):\\n x,y=points[i][0],points[i][1]\\n for j in d:\\n if j[1]*y==j[0]*x+j[2]:\\n d[j]+=1\\n m=1\\n for x in d:\\n m=max(m,d[x])\\n return m\",\n \"runtime\": \"1031\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n=len(points)\\n d={}\\n for i in range(n):\\n x,y=points[i][0],points[i][1]\\n for j in range(i+1,n):\\n x1=x-points[j][0]\\n y1=y-points[j][1]\\n b=x1*y-y1*x\\n d[(y1,x1,b)]=0\\n for i in range(n):\\n x,y=points[i][0],points[i][1]\\n for j in d:\\n if j[1]*y==j[0]*x+j[2]:\\n d[j]+=1\\n m=1\\n for x in d:\\n m=max(m,d[x])\\n return m\\n\\n \\n\\n\",\n \"runtime\": \"1097\"\n },\n {\n \"code\": \"# Line abstracts a geometrical line of the form y = mx + c\\nclass Line :\\n def __init__(self, x1, y1, x2, y2) :\\n if x2 == x1 :\\n self.vert = True\\n self.xval = x2\\n else :\\n self.vert = False\\n self.m = (y2 - y1) / (x2 - x1)\\n self.c = y2 - (self.m * x2)\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n N = len(points)\\n if N == 1 :\\n return 1\\n lines = []\\n\\n # Generating all line segments\\n for i in range(N) :\\n for j in range(i) :\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n lines.append(Line(x1, y1, x2, y2))\\n\\n # Testing all points to see if they fit in the line segment\\n ans = [0 for _ in lines]\\n for i, line in enumerate(lines) :\\n\\n # Vertical line case\\n if line.vert :\\n for x, y in points :\\n if line.xval == x :\\n ans[i] += 1\\n\\n # Generic line\\n else :\\n for x, y in points :\\n if abs(y - (line.m * x + line.c)) < 0.00001 :\\n ans[i] += 1\\n\\n return max(ans)\\n \\n\\n\\n\\n \",\n \"runtime\": \"1097\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points)<=2:\\n return len(points)\\n def determine(P, A, B):\\n return (P[0] - A[0])*(P[1] - B[1]) == (P[0] - B[0])*(P[1] - A[1])\\n n = len(points)\\n saved = []\\n def check(i,j): # see all the later dots and count maximum count\\n nonlocal n, saved\\n count=2\\n chain = [i,j]\\n for k in range(j+1,n):\\n if determine(points[i],points[j],points[k]):\\n count+=1\\n chain.append(k)\\n if len(chain)>2:\\n saved.append(chain)\\n return count\\n def check2(i,j):\\n for chain in saved:\\n if (i in chain) and (j in chain):\\n return False\\n return True\\n\\n m = 0\\n for i in range(n):\\n for j in range(i+1,n):\\n if check2(i,j):\\n #print(i,j)\\n count = check(i,j)\\n m = max(m, count)\\n\\n return m\\n\",\n \"runtime\": \"1118\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n def check(x, y, z):\\n P = (y[1] - x[1], y[0] - x[0])\\n Q = (z[1] - x[1], z[0] - x[0])\\n return P[0]*Q[1] - P[1]*Q[0] == 0\\n \\n lp = len(points)\\n ans = 1\\n for i in range(lp):\\n for j in range(i+1, lp):\\n cnt = 2\\n for k in range(j+1, lp):\\n if check(points[i], points[j], points[k]):\\n cnt += 1\\n ans = max(ans, cnt)\\n return ans\\n \",\n \"runtime\": \"1118\"\n },\n {\n \"code\": \"class Solution:\\n def getLine(self, p1, p2, p3):\\n if p1[0] == p2[0]:\\n return True if p1[0] == p3[0] else False\\n slope = (p2[1]- p1[1])/(p2[0] - p1[0])\\n return True if abs(p3[1] - (slope*p3[0] + p1[1] - slope*p1[0]))<0.0000001 else False\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n maxValue = 2\\n if n <= 2:\\n return n\\n for i in range(n-2):\\n for j in range(i+1, n-1):\\n curr_max = 2\\n for k in range(j+1, n):\\n if( self.getLine(points[i], points[j], points[k]) ):\\n curr_max += 1\\n maxValue = max(maxValue, curr_max)\\n return maxValue\\n \",\n \"runtime\": \"1140\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n def unit_vector(p1, p2):\\n a = p2[0]-p1[0]\\n b = p2[1]-p1[1]\\n return [round(a/sqrt(a**2 + b**2),6), round(b/sqrt(a**2+b**2),6)]\\n\\n def same_slope(p1, p2, p3):\\n if p2[0]-p1[0] == 0 and p3[0]-p1[0] == 0:\\n return True\\n if p2[0]-p1[0] == 0 or p3[0]-p1[0] == 0:\\n return False\\n # u1 = unit_vector(p1, p2)\\n # u2 = unit_vector(p1, p3)\\n # if u1 == u2:\\n # return True\\n # u2 = [-1*u2[0], -1*u2[1]]\\n # if u1 == u2:\\n # return True\\n # return False\\n return (p2[0]-p1[0])*(p3[1]-p1[1]) == (p3[0]-p1[0])*(p2[1]-p1[1])\\n \\n n = len(points)\\n if n<=2:\\n return n\\n \\n max_count = 0\\n for i in range(n-2):\\n for j in range(i+1, n-1):\\n count = 2\\n for k in range(j+1, n):\\n if same_slope(points[i], points[j], points[k]):\\n count+=1\\n if count>max_count:\\n max_count=count\\n return max_count\\n\\n \",\n \"runtime\": \"1140\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n=len(points)\\n if n==1:\\n return 1\\n dist_points=set()\\n for i in range(n):\\n dist_points.add(tuple(points[i]))\\n dist_points=list(dist_points)\\n k=len(dist_points)\\n curr=0\\n max_num=0\\n \\n for j in range(k-1):\\n for l in range(j+1,k):\\n if dist_points[j][0]==dist_points[l][0]:\\n for p in range(n):\\n if points[p][0]==dist_points[j][0]:\\n curr=curr+1\\n else:\\n slope=(dist_points[j][1]-dist_points[l][1])/(dist_points[j][0]-dist_points[l][0])\\n intercept= dist_points[j][1]-slope*dist_points[j][0]\\n \\n for p in range(n):\\n \\n if abs(slope*points[p][0]+intercept-points[p][1])<10**(-10):\\n curr=curr+1\\n if curr>max_num:\\n max_num=curr\\n curr=0\\n return max_num\\n\\n \\n\\n \",\n \"runtime\": \"1162\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lines=[]\\n count=0\\n visited=set()\\n for i,point1 in enumerate(points):\\n for point2 in points[i+1:]:\\n x1,y1=point1\\n x2,y2=point2\\n m=inf if x1==x2 else (y1-y2)/(x1-x2)\\n c=m*(-x1)+y1\\n if (m,c) in visited: continue\\n visited.add((m,c))\\n if x1==x2: count=max(count,len([1 for point in points if point[0]==x1]))\\n else:\\n curr_count=0\\n for x,y in points:\\n if (x-x1)*(y1-y2)==(y-y1)*(x1-x2): curr_count+=1\\n count=max(count,curr_count)\\n return max(1,count)\",\n \"runtime\": \"1184\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lines=[]\\n count=0\\n for i,point1 in enumerate(points):\\n for point2 in points[i+1:]:\\n x1,y1=point1\\n x2,y2=point2\\n if x1==x2: count=max(count,len([1 for point in points if point[0]==x1]))\\n else:\\n curr_count=0\\n for x,y in points:\\n if (x-x1)*(y1-y2)==(y-y1)*(x1-x2): curr_count+=1\\n count=max(count,curr_count)\\n return max(1,count)\",\n \"runtime\": \"1184\"\n },\n {\n \"code\": \"from math import inf\\nimport pprint\\n\\ndef slope(p1, p2):\\n if p1[0] == p2[0]:\\n return inf, p1[0], None\\n res = (p2[1] - p1[1]) / (p2[0] - p1[0])\\n # y = res*x + b\\n # 0 = res*x_int + b\\n # x_int = -b / res\\n y_int = p1[1] - res * p1[0]\\n if p1[1] == p2[1]:\\n x_int = None\\n else:\\n x_int = -y_int / res\\n return res, x_int, y_int\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n\\n max_points = 0\\n\\n slopes = dict()\\n for i in range(len(points) - 1):\\n p1 = points[i]\\n\\n for j in range(i + 1, len(points)):\\n p2 = points[j]\\n check_slope, check_xint, check_yint = slope(p1, p2)\\n key = (check_xint, check_yint)\\n\\n if key in slopes and check_slope in slopes[key]:\\n slopes[key][check_slope].add(tuple(p1))\\n slopes[key][check_slope].add(tuple(p2))\\n max_points = max(max_points, len(slopes[key][check_slope]))\\n else:\\n if key not in slopes:\\n slopes[key] = dict()\\n if check_slope not in slopes[key]:\\n slopes[key][check_slope] = set()\\n slopes[key][check_slope].add(tuple(p1))\\n slopes[key][check_slope].add(tuple(p2))\\n max_points = max(max_points, len(slopes[key][check_slope]))\\n\\n pprint.pp(slopes)\\n\\n return max_points\",\n \"runtime\": \"1206\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.line_dict = dict()\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 3:\\n return len(points)\\n max_qty = 2\\n for i in range(len(points) - 1):\\n self.line_dict[i] = set()\\n for j in range(i + 1, len(points)):\\n self.line_dict[i].add(j)\\n for start, ends in self.line_dict.items():\\n str_p = points[start]\\n end_point_list = list(ends)\\n for i in range(len(end_point_list)):\\n curr_line = set()\\n curr_line.add(start)\\n if end_point_list[i] not in self.line_dict[start]:\\n continue\\n end_p = points[end_point_list[i]]\\n curr_line.add(end_point_list[i])\\n var_se_x = end_p[0] - str_p[0]\\n var_se_y = end_p[1] - str_p[1]\\n for j in range(i + 1, len(end_point_list)):\\n if end_point_list[j] not in self.line_dict[start]:\\n continue\\n ext_p = points[end_point_list[j]]\\n var_eo_x = ext_p[0] - end_p[0]\\n var_eo_y = ext_p[1] - end_p[1]\\n if var_eo_x * var_se_y == var_eo_y * var_se_x:\\n self.line_dict[start].remove(end_point_list[j])\\n curr_line.add(end_point_list[j])\\n max_qty = max(max_qty, len(curr_line))\\n return max_qty\",\n \"runtime\": \"1228\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n maximum = min(2,len(points))\\n for i in range(len(points)-2):\\n for j in range(i+1,len(points)-1):\\n currmax = 2\\n for k in range(j+1,len(points)):\\n if points[i][0]==points[j][0]==points[k][0] or (points[k][0]!=points[j][0] and points[i][0]!=points[j][0] and (points[i][1]-points[j][1])/(points[i][0]-points[j][0])==(points[k][1]-points[j][1])/(points[k][0]-points[j][0])):\\n currmax += 1\\n maximum = max(currmax, maximum)\\n return maximum\\n\\n \",\n \"runtime\": \"1228\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n combs = list(itertools.combinations(points, 2))\\n \\n n = 0\\n a = 0\\n if len(points)==1:\\n return 1\\n print(combs)\\n for comb in combs:\\n \\n if comb[1][0] - comb[0][0] == 0: #vert line\\n a =0\\n for p in points:\\n if p[0] == comb[0][0]:\\n a+=1\\n n = max(n, a)\\n else:\\n\\n m = (comb[1][1] - comb[0][1]) / (comb[1][0] - comb[0][0])\\n b = comb[0][1] - (m * comb[0][0])\\n a = 0\\n for p in points:\\n # print((m * p[0] + b)-p[1])\\n \\n if abs((m * p[0] + b) - p[1]) < 1e-9:\\n \\n a += 1 \\n \\n n = max(n, a)\\n return n\\n\\n \",\n \"runtime\": \"1249\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n=len(points)\\n d={}\\n for i in range(n):\\n x,y=points[i][0],points[i][1]\\n for j in range(i+1,n):\\n x1=x-points[j][0]\\n y1=y-points[j][1]\\n b=x1*y-y1*x\\n d[(y1,x1,b)]=0\\n for i in range(n):\\n x,y=points[i][0],points[i][1]\\n for j in d:\\n if j[1]*y==j[0]*x+j[2]:\\n d[j]+=1\\n m=1\\n for x in d:\\n m=max(m,d[x])\\n return m\",\n \"runtime\": \"1249\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lines=[]\\n count=0\\n visited=set()\\n for i,point1 in enumerate(points):\\n for point2 in points[i+1:]:\\n x1,y1=point1\\n x2,y2=point2\\n m=inf if x1==x2 else (y1-y2)/(x1-x2)\\n c=m*(-x1)+y1\\n m=round(m,5)\\n c=round(c,5)\\n if (m,c) in visited: continue\\n visited.add((m,c))\\n if x1==x2: count=max(count,len([1 for point in points if point[0]==x1]))\\n else:\\n curr_count=0\\n for x,y in points:\\n if (x-x1)*(y1-y2)==(y-y1)*(x1-x2): curr_count+=1\\n count=max(count,curr_count)\\n return max(1,count)\",\n \"runtime\": \"1271\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n result = 0\\n #check horizantal and vertical\\n freq = collections.defaultdict(int)\\n for [x, y] in points:\\n freq[\\\"x\\\" + str(x)] += 1\\n freq[\\\"y\\\" + str(y)] += 1\\n result = max(result, freq[\\\"x\\\" + str(x)], freq[\\\"y\\\" + str(y)])\\n\\n\\n for i in range(len(points)):\\n for j in range(i + 1, len(points)):\\n \\n [x1, y1] = points[i]\\n [x2, y2] = points[j]\\n if x1 == x2 or y1 == y2:\\n continue\\n #solve a and b, y = ax + b\\n a = (y1 - y2) / (x1 - x2)\\n b = y1 - x1 * a\\n count = 2\\n for k in range(len(points)):\\n if k == i or k == j:\\n continue\\n [x, y] = points[k]\\n if abs(a * x + b - y) < 0.00001:\\n count += 1\\n result = max(result, count)\\n return result\",\n \"runtime\": \"1271\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2: return len(points)\\n\\n l = set()\\n counter = 0\\n i = 0\\n while i < len(points):\\n j = i + 1\\n while j < len(points):\\n k = j + 1\\n temp = 2\\n tempset = set()\\n while k < len(points):\\n ok = self.isPointInStraightLine(points[i], points[j], points[k])\\n if ok: \\n temp += 1\\n tempset.add(\\\"{}{}\\\".format(points[i][0], points[i][1]))\\n tempset.add(\\\"{}{}\\\".format(points[j][0], points[j][1]))\\n tempset.add(\\\"{}{}\\\".format(points[k][0], points[k][1]))\\n k += 1\\n if temp > counter:\\n counter = temp\\n l = tempset\\n print(i, j)\\n j += 1\\n i += 1\\n print(l)\\n return counter\\n\\n \\n def isPointInStraightLine(self, num1: int, num2: int, num3: int) -> bool:\\n dx1 = num1[0] - num2[0]\\n dy1 = num1[1] - num2[1]\\n \\n dx2 = num1[0] - num3[0]\\n dy2 = num1[1] - num3[1]\\n\\n if dx1 == dx2 == 0: return True\\n if dy1 == dy2 == 0: return True\\n \\n if dx1 == 0: return False\\n if dx2 == 0: return False\\n \\n slope1 = dy1 / dx1 \\n slope2 = dy2 / dx2 \\n return slope1 == slope2\",\n \"runtime\": \"1293\"\n },\n {\n \"code\": \"class Solution:\\n\\n \\\"\\\"\\\" \\n func: \\n for each later point\\n build a (or search) dict\\n build a hash table (as dict) with y = ax + b, which has \\n key: value as tuple(a, b): list[list[int1, int2]]\\n \\\"\\\"\\\"\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # init dict \\n from collections import defaultdict\\n import numpy as np\\n \\n # init a defaultdict with default factory of list\\n dict_list = defaultdict(list)\\n \\n # loop the list \\n for i in range(len(points)): \\n for j in range(i, -1, -1): \\n if i != j: \\n # now we get all the pairs that we need to test\\n # first check horizontal and vertical line \\n if points[i][0] == points[j][0]: \\n dict_list[('x', points[i][0])] += [points[i], points[j]]\\n \\n elif points[i][1] == points[j][1]:\\n dict_list[('y', points[i][1])] += [points[i], points[j]]\\n \\n else:\\n \\\"\\\"\\\"using func\\\"\\\"\\\"\\n line = self.find_line(points[i], points[j])\\n dict_list[tuple(line)] += [points[i], points[j]]\\n\\n # get all the values\\n values = list(dict_list.values())\\n # loop values to count len of sets\\n max_len = 1\\n for ls in values: \\n tuples = [tuple(i) for i in ls]\\n max_len = max(len(set(tuples)), max_len)\\n \\n return max_len\\n\\n def find_line(self, p1, p2):\\n import numpy as np\\n A = np.array([[p1[0], 1], [p2[0], 1]])\\n b = np.array([p1[1], p2[1]])\\n #print(A, b)\\n x = np.linalg.inv(A) @ b\\n return [round(x[0], 9), round(x[1], 9)]\\n\\n\\n\",\n \"runtime\": \"1315\"\n },\n {\n \"code\": \"import numpy\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 0: return 0\\n if len(points) == 1: return 1\\n d = defaultdict(None)\\n for point_id in range(len(points)):\\n point = tuple(points[point_id])\\n for _ in points[point_id+1:]:\\n point2 = tuple(_)\\n try:\\n k = (point[1]-point2[1]) / (point[0]-point2[0])\\n if k == 0: x = point[1]\\n else: x = (point[0] * k - point[1])/k\\n except ZeroDivisionError: \\n k = numpy.inf\\n x = point[0] \\n try:\\n d[(k,x)].add(point)\\n d[(k,x)].add(point2)\\n except KeyError: \\n d[(k,x)] = {point, point2} \\n for line in d:\\n if line[0] == 0: point_on_line = (point[1] == line[1])\\n else:\\n point_on_line = (line[0] * (point[0] - line[1]) == point[1])\\n if (point_on_line and (point not in d[line])):\\n d[line].add(point)\\n \\n maxpts = 0\\n for line in d:\\n print(f'{line = } | {d[line] = }')\\n if (len(d[line]) > maxpts): maxpts = len(d[line])\\n return maxpts\",\n \"runtime\": \"1315\"\n },\n {\n \"code\": \"class Solution:\\n\\n def num(self, points, p1, p2):\\n v = [p2[0]-p1[0], p2[1]-p1[1]]\\n n = [v[1], -v[0]]\\n C = p2[0]*p1[1]-p1[0]*p2[1]\\n count = 0\\n for p in points:\\n sum_v = n[0]*p[0] + n[1]*p[1] + C\\n\\n if sum_v == 0:\\n count += 1\\n return count\\n\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n n = len(points)\\n if n == 1:\\n return 1\\n max_num = 0\\n d = {}\\n for i in range(n):\\n for j in range(i+1,n):\\n if (i,j) in d or (j,i) in d:\\n continue\\n max_num = max(max_num, self.num(points, points[i], points[j]))\\n d[(i,j)] = max_num\\n return max_num\\n \",\n \"runtime\": \"1337\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n def slopOf(one, two):\\n x1, y1 = one\\n x2, y2 = two\\n\\n return (y2 - y1) / (x2 - x1)\\n\\n\\n N = len(points)\\n res = 0\\n\\n if N == 1: return 1\\n\\n for i in range(N):\\n for j in range(i + 1, N):\\n count = 2\\n (x1, y1), (x2, y2) = points[i], points[j]\\n dy = y2 - y1\\n dx = x2 - x1\\n\\n for k in range(N):\\n if k == i or k == j: continue\\n\\n x3, y3 = points[k]\\n dy_ = y3 - y1\\n dx_ = x3 - x1\\n\\n if dy * dx_ == dy_ * dx:\\n count += 1\\n\\n res = max(res, count)\\n\\n return res\\n\\n \",\n \"runtime\": \"1359\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n \\n eps = 1e-6\\n n = len(points)\\n lines = []\\n l2p = {}\\n for i in range(n):\\n for j in range(i + 1, n):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n dx = x2 - x1\\n dy = y2 - y1\\n if abs(dx) > eps:\\n k = dy / dx\\n b = y1 - k * x1\\n # print(f\\\"line through {points[i]} - {points[j]} has k={k}, b={b}\\\")\\n else:\\n k = None\\n b = x1\\n l2p[len(lines)] = (i, j)\\n lines.append((k, b))\\n n_lines = len(lines)\\n res = 0\\n for q in range(n_lines):\\n val = 0\\n k, b = lines[q]\\n for i in range(n):\\n x, y = points[i]\\n if (k is not None and abs(y - (k*x + b)) < eps\\n or k is None and abs(x - b) < eps):\\n val += 1\\n res = max(res, val)\\n # print(f\\\"{points[i]} accounted for\\\")\\n else:\\n pass\\n # print(f\\\"{points[i]} is not on the line\\\")\\n # print(k, b)\\n # print(x, y)\\n # print(k*x + b)\\n # print(\\\"---\\\")\\n p1, p2 = l2p[q]\\n print(f\\\"line through {points[p1]} - {points[p2]}: val = {val}\\\")\\n return res\\n\",\n \"runtime\": \"1359\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2:\\n return len(points)\\n lines = set()\\n for x_1, y_1 in points:\\n for x_2, y_2 in points:\\n if x_1 != x_2 or y_1 != y_2:\\n if x_1 == x_2:\\n lines.add(x_1)\\n else:\\n slope = (y_2 - y_1) / (x_2 - x_1)\\n intercept = y_1 - x_1 * slope\\n lines.add((slope, intercept))\\n\\n max_points = 0\\n print(lines)\\n for line in lines:\\n points_covered = 0\\n if type(line) == tuple:\\n slope, intercept = line\\n for x, y in points:\\n if abs(slope * x + intercept - y) < 1e-6:\\n points_covered += 1\\n else:\\n for x, y in points:\\n if x == line:\\n points_covered += 1\\n max_points = max(max_points, points_covered)\\n return max_points\",\n \"runtime\": \"1381\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n count = defaultdict(int)\\n eqn = {}\\n n = len(points)\\n for i in range(n - 1):\\n for j in range(i + 1, n):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n \\n xDiff, yDiff = x1 - x2, y1 - y2\\n eqn[(x1, y1, x2, y2)] = (xDiff, yDiff)\\n \\n res = 0\\n for k, v in eqn.items():\\n x1, y1, x2, y2 = k\\n xDiff, yDiff = v\\n for x, y in points:\\n xD = x - x1\\n yD = y - y1\\n if xDiff == 0:\\n if xD == 0:\\n count[k] += 1\\n continue\\n if yDiff == 0:\\n if yD == 0:\\n count[k] += 1\\n continue\\n if xD == 0 and yD == 0 or \\\\\\n xD / xDiff == yD / yDiff:\\n count[k] += 1\\n \\n res = max(res, count[k])\\n return res\",\n \"runtime\": \"1381\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n if(len(points) <= 2):\\n return len(points)\\n\\n def fit_count(i, j, points, line_included):\\n x1, y1, x2, y2 = points[i][0], points[i][1], points[j][0], points[j][1]\\n a = (y2-y1)\\n b = -(x2-x1)\\n c = y1*(x2-x1)-x1*(y2-y1)\\n fit_count = 0\\n for i in range(len(points)):\\n if(a*points[i][0]+b*points[i][1]+c == 0):\\n line_included[i] = 0\\n fit_count += 1\\n return line_included, fit_count\\n\\n fit_count_max = 2\\n n = len(points)\\n line_included = [0]*n\\n for i in range(n):\\n if(line_included[i]): continue\\n for j in range(i+1, n):\\n if(line_included[j]): continue\\n line_included, fit_count_tmp = fit_count(i, j, points, line_included)\\n if(fit_count_tmp > fit_count_max):\\n fit_count_max = fit_count_tmp\\n\\n return fit_count_max\\n\\n \\n \\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"1402\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\ngo through every pair of points, compute the slope\\ngo through every point and check if it falls on one of the lines\\n\\n\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n lines = []\\n for i in range(0, len(points) - 1):\\n for j in range(i + 1, len(points)):\\n if points[j][0] - points[i][0] == 0:\\n slope = None\\n y_0 = None\\n x_0 = points[i][0]\\n else:\\n # calculate slope between our pair\\n slope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0])\\n y_0 = slope * (-points[i][0]) + points[i][1]\\n x_0 = None\\n\\n lines.append((slope, y_0, x_0))\\n print(lines)\\n max_val = 0\\n for line in lines:\\n ctr = 0\\n for point in points:\\n if line[0] is not None and abs((point[0] * line[0] + line[1]) - point[1]) < 0.000001:\\n ctr += 1\\n elif line[2] is not None and point[0] == line[2]:\\n ctr += 1\\n max_val = max(ctr, max_val)\\n return max_val\\n\\n \",\n \"runtime\": \"1402\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2: return len(points)\\n\\n counter = 0\\n i = 0\\n while i < len(points):\\n j = i + 1\\n while j < len(points):\\n k = j + 1\\n temp = 2\\n while k < len(points):\\n ok = self.isPointInStraightLine(points[i], points[j], points[k])\\n if ok: temp += 1\\n k += 1\\n if temp > counter:\\n counter = temp\\n j += 1\\n i += 1\\n return counter\\n\\n \\n def isPointInStraightLine(self, num1: int, num2: int, num3: int) -> bool:\\n dx1 = num1[0] - num2[0]\\n dy1 = num1[1] - num2[1]\\n \\n dx2 = num1[0] - num3[0]\\n dy2 = num1[1] - num3[1]\\n\\n if dx1 == dx2 == 0: return True\\n if dy1 == dy2 == 0: return True\\n \\n if dx1 == 0: return False\\n if dx2 == 0: return False\\n\\n slope1 = dy1 / dx1 \\n slope2 = dy2 / dx2 \\n return slope1 == slope2\",\n \"runtime\": \"1424\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n d = []\\n for i in range(len(points) - 1):\\n for j in range(i + 1, len(points)):\\n if points[j][1] - points[i][1] == 0:\\n d.append([0, 1, -points[j][1], 0])\\n elif points[j][0] - points[i][0] == 0:\\n d.append([1, 0, -points[j][0], 0])\\n else:\\n a = points[j][1] - points[i][1]\\n b = -points[j][0] + points[i][0]\\n c = 0 - b * points[i][1] - a * points[i][0]\\n d.append([a, b, c, 0])\\n print(d)\\n for i in points:\\n for j in d:\\n if j[0] * i[0] + j[1] * i[1] + j[2] == 0:\\n j[3] += 1\\n res = 0\\n for i in d:\\n res = max(res, i[3])\\n return res\",\n \"runtime\": \"1424\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n\\n def is_same_line(self, point1, point2, point3):\\n x1, y1 = tuple(point1)\\n x2, y2 = tuple(point2)\\n x3, y3 = tuple(point3)\\n return (x3 - x1) * (y2 - y1) == (y3 - y1) * (x2 - x1)\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 3:\\n return len(points)\\n collinears = defaultdict(list)\\n pairs = [(i1, i2) for i1 in range(len(points)) for i2 in range(i1 + 1, len(points))]\\n while pairs:\\n i1, i2 = pairs.pop()\\n for i3 in range(i2 + 1, len(points)):\\n if self.is_same_line(points[i1], points[i2], points[i3]):\\n collinears[(i1, i2)].append(i3)\\n try:\\n pairs.remove((i1, i3))\\n except ValueError:\\n pass\\n try:\\n pairs.remove((i2, i3))\\n except ValueError:\\n pass\\n if len(collinears) == 0:\\n return 2\\n return 2 + max(len(v) for v in collinears.values())\\n\",\n \"runtime\": \"1446\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n if len(points) == 1:\\n return 1\\n\\n slope_intercepts = set()\\n x_coord_counts = [0]*(2*(10**4+1))\\n\\n for c1 in points:\\n x_coord_counts[c1[0]]+=1\\n for c2 in points:\\n if c1 != c2 and c1[0] != c2[0]: #CAREFUL OF VERT LINES\\n slope = (c2[1] - c1[1]) / (c2[0] - c1[0])\\n intercept = c1[1] - c1[0]*slope\\n slope_intercepts.add((slope, intercept))\\n\\n ans = 2\\n for s, i in slope_intercepts: #O(3)\\n current = 0\\n for p in points:\\n if abs(p[1] - (p[0]*s + i)) <= 0.00001:\\n current+=1\\n \\n ans = max(current, ans) \\n \\n return max(ans, max(x_coord_counts))\",\n \"runtime\": \"1446\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n if len(points) == 2:\\n return 2\\n max_count = 2\\n for i in range(len(points)):\\n x1, y1 = points[i]\\n for j in range(i + 1, len(points)):\\n x2, y2 = points[j]\\n # handle vertical lines (x = k) as a special case\\n if x1 != x2:\\n a = (y2 - y1) / (x2 - x1) \\n b = y1 - a * x1\\n curr_count = 2\\n for k in range(len(points)):\\n if k != i and k != j:\\n x3, y3 = points[k]\\n if x1 == x2 == x3:\\n curr_count += 1\\n elif x1 != x2 and abs(a * x3 + b - y3) < 0.0001:\\n curr_count += 1\\n max_count = max(max_count, curr_count)\\n return max_count\\n\",\n \"runtime\": \"1468\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n maxlen = 0\\n n = len(points)\\n if n == 1:\\n return 1 \\n\\n for i in range(0, n-1):\\n for j in range(i+1, n):\\n vertical = False\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n if (x2-x1) == 0:\\n vertical = True\\n else:\\n slope = (y2-y1)/(x2-x1)\\n length = 2\\n\\n for k in range(n):\\n if k == i or k == j:\\n continue\\n x3, y3 = points[k]\\n if (x3-x1) == 0:\\n if vertical:\\n length += 1\\n else:\\n continue\\n else:\\n if vertical:\\n continue \\n slope1 = (y3-y1)/(x3-x1)\\n if slope == slope1:\\n length += 1\\n maxlen = max(maxlen, length)\\n return maxlen\",\n \"runtime\": \"1490\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n global_max_count = 1 # To cover one point case\\n\\n # Make all the possible line combinations\\n for i, (x1, y1) in enumerate(points):\\n for j in range(i + 1, len(points)):\\n x2, y2 = points[j]\\n if x2 != x1:\\n global_max_count = max(sum((ny - y1) * (x2 - x1) == (nx - x1) * (y2 - y1)\\n for nx, ny in points), global_max_count)\\n else:\\n # x = const\\n global_max_count = max(sum(nx == x1 for nx, _ in points), global_max_count)\\n \\n return global_max_count\",\n \"runtime\": \"1512\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, p: List[List[int]]) -> int:\\n \\n def coord(x1, y1, x2, y2):\\n if y1 == y2:\\n line[(0, y1, 1)] = 0\\n return\\n dx, dy = x1 - x2, y1 - y2\\n if dy < 0:\\n a, c = -dy, -dx\\n else:\\n a, c = dy, dx\\n \\n while gcd(a, c) != 1:\\n div = gcd(a, c)\\n a, c = a // div, c // div\\n b = c * y1 - a * x1\\n line[(a, b, c)] = 0\\n\\n line = dict()\\n thres = float('inf')\\n for i in range(len(p)):\\n line[p[i][0]] = 0\\n \\n for i in range(len(p)):\\n for j in range(i + 1,len(p)):\\n x1, y1 = p[i][0], p[i][1]\\n x2, y2 = p[j][0], p[j][1]\\n if x1 != x2:\\n coord(x1, y1, x2, y2)\\n \\n for x, y in p:\\n for c in line:\\n if c == x:\\n line[c] += 1\\n if not isinstance(c, int) and c[2] * y == c[0] * x + c[1]:\\n line[c] += 1\\n \\n return max(line.values())\\n \\n \",\n \"runtime\": \"1512\"\n },\n {\n \"code\": \"class Solution:\\n\\n def num(self, points,d ,i, j):\\n p1 = points[i]\\n p2 = points[j]\\n v = [p2[0]-p1[0], p2[1]-p1[1]]\\n n = [v[1], -v[0]]\\n C = p2[0]*p1[1]-p1[0]*p2[1]\\n count = 0\\n l = []\\n for k, p in enumerate(points):\\n sum_v = n[0]*p[0] + n[1]*p[1] + C\\n\\n if sum_v == 0:\\n count += 1\\n l.append(k)\\n\\n for e in l:\\n d[(i,e)] = count\\n d[(j,e)] = count\\n return count\\n\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n n = len(points)\\n if n == 1:\\n return 1\\n max_num = 0\\n d = {}\\n for i in range(n):\\n for j in range(i+1,n):\\n if (i,j) in d or (j,i) in d:\\n continue\\n max_num = max(max_num, self.num(points,d, i, j))\\n \\n return max_num\\n \",\n \"runtime\": \"1533\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, p: List[List[int]]) -> int:\\n \\n def coord(x1, y1, x2, y2):\\n if y1 == y2:\\n line[(0, y1, 1)] = 0\\n return\\n dx, dy = x1 - x2, y1 - y2\\n if dy < 0:\\n a, c = -dy, -dx\\n else:\\n a, c = dy, dx\\n \\n div = gcd(a, c)\\n a, c = a // div, c // div\\n b = c * y1 - a * x1\\n line[(a, b, c)] = 0\\n\\n line = dict()\\n thres = float('inf')\\n for i in range(len(p)):\\n line[p[i][0]] = 0\\n \\n for i in range(len(p)):\\n for j in range(i + 1,len(p)):\\n x1, y1 = p[i][0], p[i][1]\\n x2, y2 = p[j][0], p[j][1]\\n if x1 != x2:\\n coord(x1, y1, x2, y2)\\n \\n for x, y in p:\\n for c in line:\\n if c == x:\\n line[c] += 1\\n if not isinstance(c, int) and c[2] * y == c[0] * x + c[1]:\\n line[c] += 1\\n \\n return max(line.values())\\n \\n \",\n \"runtime\": \"1533\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n ans = 1\\n hm = {}\\n n = len(points)\\n\\n for i in range(n):\\n for j in range(i + 1, n):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n dx, dy = x1 - x2, y1 - y2\\n d = gcd(dx, dy)\\n hm[(x2, y2, dx // d, dy // d)] = 0\\n \\n for x1, y1 in points:\\n for key in hm:\\n x2, y2, mx, my = key\\n dx, dy = x1 - x2, y1 - y2\\n d = gcd(dx, dy)\\n if d == 0 or dx // d == mx and dy // d == my:\\n hm[key] += 1\\n ans = max(ans, hm[key])\\n \\n return ans\",\n \"runtime\": \"1555\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n ans = 0\\n for i in range(len(points)):\\n visit = set()\\n for j in range(i+1,len(points)):\\n x1,y1 = points[i][0],points[i][1]\\n x2,y2 = points[j][0],points[j][1]\\n if (x2,y2) not in visit and points[i] != points[j]:\\n curr = 0\\n for k in range(len(points)):\\n x3,y3 = points[k][0],points[k][1]\\n if (y3-y2)*(x2-x1) == (y2-y1)*(x3-x2):\\n curr +=1\\n visit.add((x3,y3))\\n ans = max(ans,curr)\\n return ans\",\n \"runtime\": \"1577\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n maxlen = 0\\n n = len(points)\\n if n == 1:\\n return 1 \\n\\n for i in range(0, n-1):\\n for j in range(i+1, n):\\n vertical = False\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n if (x2-x1) == 0:\\n vertical = True\\n else:\\n slope = (y2-y1)/(x2-x1)\\n length = 2\\n\\n for k in range(n):\\n if k == i or k == j:\\n continue\\n x3, y3 = points[k]\\n if (x3-x1) == 0 and vertical:\\n length += 1\\n elif (x3-x1) != 0 and not vertical:\\n slope1 = (y3-y1)/(x3-x1)\\n if slope == slope1:\\n length += 1\\n else:\\n continue\\n '''\\n if (x3-x1) == 0 :\\n if vertical:\\n length += 1\\n else:\\n continue\\n else:\\n if vertical:\\n continue \\n slope1 = (y3-y1)/(x3-x1)\\n if slope == slope1:\\n length += 1\\n '''\\n maxlen = max(maxlen, length)\\n return maxlen\",\n \"runtime\": \"1577\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n def solve_line(x1,y1,x2,y2):\\n rise = y2-y1\\n run = x2-x1\\n slope =rise/run if run != 0 else None\\n\\n b = y1 - slope*x1 if slope is not None else x1\\n\\n return slope,b\\n \\n def is_on_line(px, py, slope, b):\\n if slope is None:\\n return b == px\\n return abs(py - (px * slope + b)) < .0001\\n\\n best = 1\\n slopes = set()\\n \\n for i in range(len(points)):\\n x1,y1 = points[i]\\n for j in range(i+1, len(points)):\\n x2,y2 = points[j]\\n\\n\\n slope, b = solve_line(x1,y1,x2,y2)\\n slopes.add((slope,b))\\n \\n for slope, b in slopes:\\n current = 0\\n for px,py in points:\\n if is_on_line(px,py,slope,b):\\n current += 1\\n best = max(current, best)\\n\\n return best\\n\\n\\n \\n\",\n \"runtime\": \"1599\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if(len(points) <= 2): return len(points)\\n maxPoints = 2\\n for idx1 in range(0, len(points) - 1, 1):\\n for idx2 in range(idx1+1, len(points), 1):\\n a = points[idx2][1] - points[idx1][1]\\n b = points[idx1][0] - points[idx2][0]\\n c = (points[idx1][1]*points[idx2][0]) - (points[idx1][0]*points[idx2][1])\\n line_points = 2\\n for idx3 in range(len(points)):\\n if(idx3 == idx2 or idx3 == idx1):\\n continue\\n if (a*points[idx3][0]) + (b*points[idx3][1]) + c == 0:\\n line_points += 1\\n maxPoints = max(maxPoints, line_points)\\n return maxPoints\",\n \"runtime\": \"1599\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n def solve_line(x1,y1,x2,y2):\\n rise = y2-y1\\n run = x2-x1\\n slope =rise/run if run != 0 else None\\n\\n b = y1 - slope*x1 if slope is not None else x1\\n\\n return slope,b\\n \\n def is_on_line(px, py, slope, b):\\n if slope is None:\\n return b == px\\n return abs(py - (px * slope + b)) < .0001\\n\\n best = 1\\n slopes = set()\\n \\n for i in range(len(points)):\\n x1,y1 = points[i]\\n for j in range(i+1, len(points)):\\n x2,y2 = points[j]\\n\\n slope, b = solve_line(x1,y1,x2,y2)\\n slopes.add((slope,b))\\n \\n for slope, b in slopes:\\n current = 0\\n for px,py in points:\\n if is_on_line(px,py,slope,b):\\n current += 1\\n best = max(current, best)\\n\\n return best\\n\\n\\n \\n\",\n \"runtime\": \"1621\"\n },\n {\n \"code\": \"import sys\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points)==1:\\n return 1\\n elif len(points)==2:\\n return 2\\n ans = 2\\n for i in range(len(points)-1):\\n for j in range(i+1, len(points)):\\n count = 2\\n first = points[i]\\n sec = points[j]\\n slope = (sec[1]-first[1])/(sec[0]-first[0]) if sec[0]!=first[0] else sys.maxsize\\n for k in range(len(points)):\\n if k==i or k==j:\\n continue\\n else:\\n third = points[k]\\n slop = (third[1]-first[1])/(third[0]-first[0]) if third[0]!=first[0] else sys.maxsize\\n if slop==slope:\\n count+=1\\n ans = max(ans, count)\\n return ans\\n \\n\\n\",\n \"runtime\": \"1621\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n def solve_line(x1,y1,x2,y2):\\n rise = y2-y1\\n run = x2-x1\\n slope =rise/run if run != 0 else None\\n\\n b = y1 - slope*x1 if slope is not None else x1\\n\\n return slope,b\\n \\n def is_on_line(px, py, slope, b):\\n if slope is None:\\n return b == px\\n return abs(py - (px * slope + b)) < .0001\\n\\n best = 1\\n slopeCounter = Counter()\\n \\n for i in range(len(points)):\\n x1,y1 = points[i]\\n for j in range(i+1, len(points)):\\n x2,y2 = points[j]\\n\\n current = 0\\n\\n slope, b = solve_line(x1,y1,x2,y2)\\n\\n for px,py in points:\\n if is_on_line(px,py,slope,b):\\n current += 1\\n \\n best = max(current, best)\\n return best\\n\\n\\n \\n\",\n \"runtime\": \"1643\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n seen = set()\\n max_point = 0\\n n = len(points)\\n if n == 1:\\n return 1\\n\\n for i in range(n):\\n for j in range(i + 1, n):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n\\n # calculate the line\\n if y1 == y2:\\n slope = 'inf'\\n intercept = x1\\n else:\\n slope = (x1 - x2)/(y1 - y2)\\n intercept = y1 - slope*x1\\n\\n if (intercept, slope) in seen:\\n continue\\n\\n curr_point = 2\\n # compare with others\\n for k in range(n):\\n if k in [i, j]:\\n continue\\n x3, y3 = points[k]\\n if y1 == y3:\\n curr_slope = 'inf'\\n else:\\n curr_slope = (x1 - x3)/(y1 - y3)\\n\\n if curr_slope == slope:\\n curr_point += 1\\n \\n seen.add((intercept, slope))\\n max_point = max(max_point, curr_point)\\n\\n return max_point\\n\\n\\n \\n\\n \",\n \"runtime\": \"1664\"\n },\n {\n \"code\": \"from typing import List, Tuple, Set\\nfrom itertools import combinations\\nfrom math import isclose\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2:\\n return len(points)\\n\\n points_pairs: List[Tuple[List[int]]] = list(combinations(points, 2))\\n all_lines: Set[Tuple] = set()\\n for points_pair in points_pairs:\\n a = points_pair[1][1] - points_pair[0][1]\\n b = points_pair[0][0] - points_pair[1][0]\\n c = -(a * points_pair[0][0] + b * points_pair[0][1])\\n # Нормализация по a или, если a == 0, то по b\\n if a:\\n b = b / a\\n c = c / a\\n a = a / a\\n else:\\n a = a / b\\n c = c / b\\n b = b / b\\n all_lines.add((a, b, c))\\n\\n max_points = 0\\n for line in all_lines:\\n line_points = 0\\n for point in points:\\n if isclose(line[0] * point[0] + line[1] * point[1] + line[2], 0, abs_tol=1e-9):\\n line_points += 1\\n max_points = max(max_points, line_points)\\n\\n return max_points\",\n \"runtime\": \"1664\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points)==1:\\n return 1\\n points.sort(key=lambda x:x[0])\\n max_p_all = 2\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n max_p = 2\\n p1, p2 = points[i], points[j]\\n dx = p2[0]-p1[0]\\n dy = p2[1]-p1[1]\\n if dx==0:\\n for k in range(len(points)):\\n if k!=i and k!=j and points[k][0]==p1[0]:\\n max_p +=1\\n max_p_all = max(max_p_all, max_p)\\n elif dy==0:\\n for k in range(len(points)):\\n if k!=i and k!=j and points[k][1]==p1[1]:\\n max_p +=1\\n max_p_all = max(max_p_all, max_p)\\n else:\\n for k in range(len(points)):\\n if k!=i and k!=j:\\n dx_tmp = points[k][0]-p1[0]\\n dy_tmp = points[k][1]-p1[1]\\n if dy_tmp!=0 and dx_tmp/dy_tmp == dx/dy:\\n max_p +=1\\n max_p_all = max(max_p_all, max_p)\\n\\n return max_p_all\\n\\n \",\n \"runtime\": \"1686\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # Brute force: O(n^3)\\n n = len(points)\\n ans = 1\\n for i in range(n):\\n for j in range(i + 1, n):\\n count = 0\\n if points[j][0] == points[i][0]:\\n # Vertical line\\n for k in range(n):\\n if points[k][0] == points[i][0]:\\n count += 1\\n elif points[i][1] == points[j][1]:\\n # Horizontal line\\n for k in range(n):\\n if points[k][1] == points[i][1]:\\n count += 1\\n else:\\n dy = points[j][1] - points[i][1]\\n dx = points[j][0] - points[i][0]\\n gcd = math.gcd(dy, dx)\\n dy /= gcd\\n dx /= gcd\\n\\n # m = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0])\\n # b = points[j][1] - m * points[j][0]\\n\\n for k in range(n):\\n if (points[k][1] - points[j][1]) / dy == (points[k][0] - points[j][0]) / dx:\\n count += 1\\n # if points[k][1] == m * points[k][0] + b:\\n # count += 1\\n\\n ans = max(ans, count)\\n\\n return ans\\n \\n\",\n \"runtime\": \"1686\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n if n==1:\\n return 1\\n result = 0\\n for i in range(n):\\n for j in range(i+1, n):\\n count = 2\\n dx = points[j][0] - points[i][0]\\n dy = points[j][1] - points[i][1]\\n \\n for k in range(n):\\n if k!=i and k!=j:\\n dx2 = points[k][0] - points[i][0]\\n dy2 = points[k][1] - points[i][1]\\n\\n if dy*dx2==dy2*dx:\\n count+=1\\n result = max(result,count)\\n return result\",\n \"runtime\": \"1708\"\n },\n {\n \"code\": \"class Solution:\\n def same_line(self, a, b, point1, point3):\\n if (b)*(point1[0]-point3[0]) == (point1[1]-point3[1])*(a):\\n return True\\n else: return False\\n def maxPoints(self, points: List[List[int]]) -> int:\\n ans = 1\\n n = len(points)\\n for i in range(n):\\n for j in range(i+1, n):\\n same = 0\\n a = points[i][0]-points[j][0]\\n b = points[i][1]-points[j][1]\\n for k in range(n):\\n if self.same_line(a, b, points[i], points[k]):\\n same += 1\\n ans = max(ans, same)\\n return ans\",\n \"runtime\": \"1708\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n res = 1\\n for p0, p1 in combinations(points, 2):\\n x0, y0 = p0\\n x1, y1 = p1\\n count = 0\\n if p0[0] == p1[0]:\\n for x, y in points: count += x0 == x\\n else:\\n for x, y in points:\\n count += y*(x1-x0) == (x-x0)*(y1-y0) + y0*(x1-x0)\\n res = max(res, count)\\n return res\",\n \"runtime\": \"1730\"\n },\n {\n \"code\": \"# # Brute Force Approach:- \\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 2:\\n return len(points)\\n\\n result = 0\\n for i in range(len(points)):\\n for j in range(i + 1, len(points)):\\n count = 2\\n dx = points[j][0] - points[i][0]\\n dy = points[j][1] - points[i][1]\\n\\n for k in range(len(points)):\\n if k != i and k != j:\\n dx2 = points[k][0] - points[i][0]\\n dy2 = points[k][1] - points[i][1]\\n\\n if dx * dy2 == dy * dx2:\\n count += 1\\n result = max(result, count)\\n return result \\n\\n# class Solution:\\n# def maxPoints(self, points: List[List[int]]) -> int:\\n# n = len(points)\\n# if n == 1: \\n# return 1\\n# res = 2\\n# for i in range(n):\\n# d = defaultdict(int)\\n# for j in range(n):\\n# if i != j:\\n# d[math.atan2(points[j][1] - points[i][1], points[j][0] - points[i][0])] += 1\\n# res = max(res, max(d.values()) + 1)\\n# return res\\n \\n\\n# class Solution:\\n# def maxPoints(self, P):\\n# ans = 1\\n# for p0, p1 in combinations(P, 2):\\n# x0, y0 = p0\\n# x1, y1 = p1\\n# count = 0\\n# if p0[0] == p1[0]:\\n# for p in P: count += p[0] == p0[0]\\n# else:\\n# for p in P:\\n# x, y = p\\n# count += y*(x1-x0) == (x-x0)*(y1-y0) + y0*(x1-x0)\\n# ans = max(ans, count)\\n# return ans \",\n \"runtime\": \"1752\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":140,"string":"140"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n if n < 3:\n return n\n\n max_pts = 2\n for i in range(n):\n [x1, y1] = points[i]\n for j in range(i+1,n):\n [x2, y2] = points[j]\n pts = 2\n for k in range(j+1,n):\n [x3, y3] = points[k]\n if x1*y2 + x2*y3 + x3*y1 == x1*y3 + x2*y1 + x3*y2: # (y2-y1)/(x2-x1) = (y3-y1)/(x3-x1)\n pts += 1\n max_pts = max(max_pts, pts)\n return max_pts","memory":"16354"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n ans = 1\n n = len(points)\n \n def cross(i, j, k):\n vx = points[i][0] - points[j][0]\n vy = points[i][1] - points[j][1]\n \n ux = points[i][0] - points[k][0]\n uy = points[i][1] - points[k][1]\n \n return vx * uy - vy * ux\n for i in range(n):\n for j in range(i + 1, n):\n cnt = 0\n for k in range(n):\n if cross(k, i, j) == 0:\n cnt += 1\n ans = max(ans, cnt)\n return ans","memory":"16354"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n def countPoints(p1, p2):\n\n x1, y1 = p1\n x2, y2 = p2\n\n if x1 != x2:\n prek = y1 - y2 \n preb = x1 * y2 - x2 * y1\n prec = x1 - x2\n a = gcd(prek, preb, prec)\n k, b, c = prek // a, preb // a, prec // a\n if k < 0 or (k == 0 and b < 0):\n k, b, c = -k, -b, -c\n else:\n k, b, c = float('inf'), x1, 0\n \n cache[(k, b, c)] = cache.get((k, b, c), 0) + 1\n return cache[(k, b, c)]\n\n l = len(points)\n\n if l == 1:\n return 1\n\n max_num = 0\n for i in range(l):\n cache = {}\n for j in range(i + 1, l):\n max_num = max(max_num, countPoints(points[i], points[j]) + 1)\n \n return max_num\n ","memory":"16663"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points);\n if n == 1: return 1\n res = 2;\n for i in range(n):\n d = defaultdict(int);\n for j in range(n):\n if i != j:\n d[math.atan2(points[j][1] - points[i][1], points[j][0] - points[i][0])] += 1;\n res = max(res, max(d.values()) + 1);\n return res","memory":"16663"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n ratio = None\n n = len(points)\n if n == 1:\n return 1\n elif n == 2:\n return 2\n slope = None\n out = 0\n\n for idxstart in range(n-1):\n c = defaultdict(int)\n for idx2 in range(idxstart+1, n):\n if points[idx2][0] == points[idxstart][0]:\n ratio = math.inf\n else:\n ratio = (points[idx2][1] - points[idxstart][1]) / (points[idx2][0] - points[idxstart][0])\n\n c[ratio] += 1\n \n # localans = 0\n dprint(\"c\", c)\n for k,v in c.items():\n out = max(out, v+1)\n \n return out\n\n\ndef dprint(*args):\n if 1 :\n print(*args)","memory":"16971"},{"code":"class Solution:\n def aligned_2(self, x,y, q):\n if x == y :\n return True\n if (x[0]==y[0] ):\n if q == None:\n return True\n else:\n return False\n if (x[1]-y[1])/(x[0]-y[0]) == q:\n return True\n return False\n\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2:\n return len(points)\n m = 0\n for i in range(1,len(points)):\n if (points[0][0] - points[i][0]) == 0:\n q = None\n else:\n q = (points[0][1] - points[i][1])/(points[0][0] - points[i][0])\n n =2\n for j in range(i+1,len(points)):\n if self.aligned_2(points[0], points[j], q):\n n+=1\n m = max(m,n)\n return max(m, self.maxPoints(points[1:]))\n \n \n","memory":"16971"},{"code":"class Solution:\n def maxPoints(self, points: list[list[int]]) -> int:\n if len(points) <= 1:\n return len(points)\n else:\n # equations: dict[tuple, int] = dict()\n res = []\n for p in points:\n for q in points:\n if p != q:\n r = 2\n for w in points:\n if (w != p) and (w != q):\n if (q[1]-p[1]) * (w[0]-p[0]) == (w[1]-p[1]) * (q[0]-p[0]):\n r += 1\n res.append(r)\n return max(res)","memory":"17280"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n m=0\n d=[[0]*n for _ in range(n)]\n if len(points)==1:\n return 1\n for i in range(0,n):\n def dfs(j,p_2):\n visited.add(j)\n count =1\n x1,y1 = points[p_2[0]]\n x2,y2 = points[p_2[1]]\n for k in range(0,n):\n if k not in visited and d[p_2[0]][k]==0 and d[p_2[1]][k]==0:\n x3, y3=points[k]\n if (y2 - y1) * (x3 - x1) == (y3 - y1) * (x2 - x1) :\n # print(points[k], end=\" | \") \n count += dfs(k, p_2)\n print(count)\n return count\n \n for j in range(0,n):\n if j!= i:\n d[i][j]=1\n c=1\n visited = set()\n p_2=[i,j]\n visited.add(i)\n c += dfs(j,p_2)\n m = max(c,m)\n \n return m","memory":"17280"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n result = 1\n\n if len(points) == 1:\n return result\n\n inf = 'I'\n NA = 'N'\n arrayOfArrayOfSlopes = []\n for i in range(0, len(points)):\n arrayOfSlopes = []\n for j in range(0, i):\n p1 = points[j]\n x1, y1 = p1[0], p1[1]\n p2 = points[i]\n x2, y2 = p2[0], p2[1]\n\n if x1 == x2:\n arrayOfSlopes.append(inf)\n else:\n arrayOfSlopes.append((y2 - y1) / (x2 - x1))\n arrayOfArrayOfSlopes.append(arrayOfSlopes)\n\n for i in range(0, len(points)):\n arrayOfSlopes = []\n for j in range(0, len(points)):\n if i > j :\n arrayOfSlopes.append(arrayOfArrayOfSlopes[i][j])\n elif i < j:\n arrayOfSlopes.append(arrayOfArrayOfSlopes[j][i])\n elif i == j:\n arrayOfSlopes.append(NA)\n c = collections.Counter(arrayOfSlopes)\n freq = c.most_common(1)\n\n result = max(freq[0][1] + 1, result)\n\n return result\n","memory":"17898"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n result = 1\n\n if len(points) == 1:\n return result\n\n inf = 'I'\n NA = 'N'\n arrayOfArrayOfSlopes = []\n for i in range(0, len(points)):\n arrayOfSlopes = []\n for j in range(0, i):\n p1 = points[j]\n x1, y1 = p1[0], p1[1]\n p2 = points[i]\n x2, y2 = p2[0], p2[1]\n\n if x1 == x2:\n arrayOfSlopes.append(inf)\n else:\n arrayOfSlopes.append((y2 - y1) / (x2 - x1))\n arrayOfArrayOfSlopes.append(arrayOfSlopes)\n\n for i in range(0, len(points)):\n arrayOfSlopes = []\n for j in range(0, len(points)):\n if i > j :\n arrayOfSlopes.append(arrayOfArrayOfSlopes[i][j])\n elif i < j:\n arrayOfSlopes.append(arrayOfArrayOfSlopes[j][i])\n elif i == j:\n arrayOfSlopes.append(NA)\n c = collections.Counter(arrayOfSlopes)\n freq = c.most_common(1)\n\n result = max(freq[0][1] + 1, result)\n\n return result\n","memory":"17898"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1: return 1\n maxpts = 0\n slopes = [[0 for i in range(len(points))] for j in range(len(points))]\n i = 0\n while i + maxpts <= len(points):\n countSlopes = dict()\n for j in range(i+1, len(points)):\n if points[i][0] == points[j][0]:\n slopes[i][j] = None\n else:\n slopes[i][j] = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0])\n\n if slopes[i][j] == None:\n if 'UND' not in countSlopes.keys():\n countSlopes['UND'] = 1\n else:\n countSlopes['UND'] += 1\n if countSlopes['UND'] + 1 > maxpts: maxpts = countSlopes['UND'] + 1\n else:\n if slopes[i][j] not in countSlopes.keys():\n countSlopes[slopes[i][j]] = 1\n else:\n countSlopes[slopes[i][j]] += 1\n if countSlopes[slopes[i][j]] + 1 > maxpts: maxpts = countSlopes[slopes[i][j]] + 1\n i += 1\n\n\n\n return maxpts\n ","memory":"18206"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \"\"\"\n sort pints by x coordinate\n \n compare pairs of points\n \n \"\"\"\n points.sort()\n n = len(points)\n \n \n def get_slope(i: int, j: int):\n numerator = points[j][1] - points[i][1]\n denominator = points[j][0] - points[i][0]\n if denominator == 0:\n return float(\"inf\")\n else:\n return numerator / denominator\n \n slope = [[0] * n for i in range(n)]\n for i in range(n):\n for j in range(i + 1, n):\n slope[i][j] = get_slope(i, j)\n \n \n res = 0\n for i in range(n):\n freq = defaultdict(int)\n for j in range(i + 1, n):\n freq[slope[i][j]] += 1\n res = max(res, freq[slope[i][j]])\n \n return res + 1","memory":"18515"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n slopes = defaultdict(list)\n points.sort()\n for i in range(len(points)):\n for j in range(i +1, len(points)):\n if points[i][0] == points[j][0]:\n slopes[i].append(\"v\")\n slopes[j].append(\"v\")\n else:\n # print(points[i], points[j], i, j)\n slope = (points[i][1] - points[j][1] ) / (points[i][0] - points[j][0])\n\n slopes[i].append(slope)\n slopes[j].append(slope)\n # print(slopes)\n m =1\n for key, vals in slopes.items():\n # if max(list(Counter(vals).values())) ==7:\n # print(Counter(vals))\n m = max(m,1 + max(list(Counter(vals).values())))\n \n return m\n \n\n ","memory":"18824"},{"code":"class Solution:\n def __init__(self):\n self.line_dict = dict()\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 3:\n return len(points)\n max_qty = 2\n for i in range(len(points) - 1):\n self.line_dict[i] = set()\n for j in range(i + 1, len(points)):\n self.line_dict[i].add(j)\n for start, ends in self.line_dict.items():\n str_p = points[start]\n end_point_list = list(ends)\n for i in range(len(end_point_list)):\n curr_line = set()\n curr_line.add(start)\n if end_point_list[i] not in self.line_dict[start]:\n continue\n end_p = points[end_point_list[i]]\n curr_line.add(end_point_list[i])\n var_se_x = end_p[0] - str_p[0]\n var_se_y = end_p[1] - str_p[1]\n for j in range(i + 1, len(end_point_list)):\n if end_point_list[j] not in self.line_dict[start]:\n continue\n ext_p = points[end_point_list[j]]\n var_eo_x = ext_p[0] - end_p[0]\n var_eo_y = ext_p[1] - end_p[1]\n if var_eo_x * var_se_y == var_eo_y * var_se_x:\n self.line_dict[start].remove(end_point_list[j])\n curr_line.add(end_point_list[j])\n max_qty = max(max_qty, len(curr_line))\n return max_qty","memory":"18824"},{"code":"class Solution:\n def __init__(self):\n self.line_dict = dict()\n\n def maxPoints(self, points: List[List[int]]) -> int:\n \n if len(points) < 3:\n return len(points)\n\n max_qty = 2\n for i in range(len(points) - 1):\n self.line_dict[i] = set()\n for j in range(i + 1, len(points)):\n self.line_dict[i].add(j)\n \n # print(len(self.line_dict), self.line_dict)\n \n # traverse\n for start, ends in self.line_dict.items():\n # print(str_p, ends)\n str_p = points[start]\n end_point_list = list(ends)\n # print(str_p, end_point_list)\n # 以str_p為起始點，逐個點做為end_p檢驗連線上有沒有其他點\n for i in range(len(end_point_list)):\n curr_line = set()\n curr_line.add(start)\n if end_point_list[i] not in self.line_dict[start]:\n continue\n end_p = points[end_point_list[i]]\n curr_line.add(end_point_list[i])\n # print(f\"current line: from {str_p} to {end_p}\")\n var_se_x = end_p[0] - str_p[0]\n var_se_y = end_p[1] - str_p[1]\n for j in range(i + 1, len(end_point_list)):\n if end_point_list[j] not in self.line_dict[start]:\n continue\n ext_p = points[end_point_list[j]]\n # print(f\"斜率: {var_se_x}, {var_se_y} - 測試點: {ext_p}\")\n var_eo_x = ext_p[0] - end_p[0]\n var_eo_y = ext_p[1] - end_p[1]\n if var_eo_x * var_se_y == var_eo_y * var_se_x:\n # print(f\"3點連成一線: {str_p},{end_p},{ext_p}\")\n self.line_dict[start].remove(end_point_list[j])\n # self.line_dict[end_point_list[i]].remove(end_point_list[j])\n curr_line.add(end_point_list[j])\n # print()\n max_qty = max(max_qty, len(curr_line))\n # print(self.line_dict)\n \n \n return max_qty","memory":"19133"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n N = len(points)\n if N == 1:\n return 1\n\n points.sort()\n point2slopeCounter = defaultdict(lambda: defaultdict(lambda: 0))\n #compute slopes \n for i in range(N):\n for j in range(i+1, N):\n if points[i][0] - points[j][0] != 0:\n # delta y / delta x\n slope = (points[i][1] - points[j][1]) / (points[i][0] - points[j][0])\n else:\n slope = float(\"inf\") #? \n \n point2slopeCounter[tuple(points[i])][slope] += 1\n\n # scan dict\n maxNum = 0\n for startPoint, slopeCountDict in point2slopeCounter.items():\n for slope, count in slopeCountDict.items():\n # count + 1 to accounter for the starting point\n maxNum = max(maxNum, count + 1)\n\n return maxNum","memory":"19133"},{"code":"class Solution(object):\n def maxPoints(self, points):\n \"\"\"\n :type points: List[List[int]]\n :rtype: int\n \"\"\"\n ll = len(points) \n if ll == 1: return 1\n elif ll == 2: return 2\n else:\n ans = 0\n for i in list(combinations(points,2)):\n cnt = 0\n for j in points:\n if (j[1] - i[0][1]) * (i[1][0] - i[0][0]) == (j[0] - i[0][0]) * (i[1][1] - i[0][1]):\n cnt += 1\n ans = max(ans, cnt)\n return ans","memory":"19441"},{"code":"class Solution:\n def maxPoints(self, points):\n len_points = len(points) \n if len_points == 1: return 1\n elif len_points == 2: return 2\n else:\n ans = 0\n # get all combination of length 2 from points\n for i in list(combinations(points,2)):\n count = 0\n for j in points:\n x1,y1 = i[0][0], i[0][1]\n x2, y2 = i[1][0], i[1][1]\n x3, y3 = j[0], j[1]\n # condition for three points to be coliniear\n if (y3 - y2) * (x2 - x1) == (x3 - x2) * (y2 - y1):\n count += 1\n ans = max(ans, count)\n return ans\n ","memory":"19441"},{"code":"\n\"\"\"\n+7 min on timer btw\n\nneed to be able to determine which existing straight lines a new point is on, then we can update thos e counters.\nfinally, we can iterate over all teh lines and max their sizes.\n\n\nmaybe we can keep track of unique lines by its left and right most points (poitnts with min and max x).\n\n\nthen for every thing we can iterate over all points and update their counte if the point falls within those two points. we also update the point thing if we find that the new point is further left\n\n\nN = len(points)\nThis would be an O(N^3), O(N^2) space solution as there can be up to N^2 unique staright lines as every single point can be joing with any of the other n points to make a new line.\n\n\nif there is a duplicate point, that is coinsideerd an addiontal point for whatever line the existing point is.\n\n\n\nwe can have up to 2* (2*10^4) distinct lines that a point can fall on (all lines intersecting with\nall integer points on x-axis, and all lines inetersiection with all itngeter points o axis)\n\nwhat if we keep a hash table of which points intersectwith each distinc point on the x or \ny axis and \n\n a line can be uniquitely idetnifeid with its m and b values in y = mx + b\n\nIDEA:\n\nfirst, iterate through the ponitns and keep count of # of poitns at each\nunique (x,y) value.\n\nthen iterate over this map and for each point, iterate over all other points and \nsee if the points have a point at that slope. Basiaal,y we need a map that maps (x,y) values to\na dictionary of slopes to the size of the lines with that sloe. if therei s one, we add to that value in both points maps with the count of the current point, if not we create a lnew line entry and make it the sume of teh count of points between the two points. everytime we do an updat, updateh tem ax.\n\nThis is an O(N^2) solution with O(N^2 ) space (because each point can have up to n unique-sloped lines)\n\n\"\"\"\nimport dataclasses \nfrom typing import Dict, List\n@dataclasses.dataclass\nclass Point:\n\n x : int\n y : int\n lines : Dict[float , int] # mapping slope to # of points in that line \n\n def get_slope(self, other_point : \"Point\"):\n if other_point.x - self.x == 0:\n return float(\"inf\")\n return (other_point.y- self.y) / (other_point.x- self.x) \n\n def update_line_size(self, other_point : \"Point\") -> int:\n # update line size of lines that meet the other point, returning the new # of points in the line after adding the other point \n slope = self.get_slope(other_point)\n\n if slope in other_point.lines:\n \n other_point.lines[slope] += 1\n #self.lines[slope] = other_point.lines[slope]\n else:\n other_point.lines[slope] = 2\n #self.lines[slope] = 2\n \n \n return other_point.lines[slope]\n\n\n\n\n\ndef get_point_counts(points):\n out = []\n for pos in points:\n x,y = pos\n out.append(Point(x =x, y=y, lines = {}))\n\n return out\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n points : List[Point] = get_point_counts(points) # tuple of points\n ans = 0\n for i in range(len(points)):\n for j in range(i): # only iterate over previous points so we dont overcount\n\n ans = max(ans, points[i].update_line_size(points[j]))\n\n return ans","memory":"19750"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n combs = list(itertools.combinations(points, 2))\n \n n = 0\n a = 0\n if len(points)==1:\n return 1\n for comb in combs:\n \n if comb[1][0] - comb[0][0] == 0: #vert line\n a =0\n for p in points:\n if p[0] == comb[0][0]:\n a+=1\n n = max(n, a)\n else:\n\n m = (comb[1][1] - comb[0][1]) / (comb[1][0] - comb[0][0])\n b = comb[0][1] - (m * comb[0][0])\n a = 0\n for p in points:\n # print((m * p[0] + b)-p[1])\n \n if abs((m * p[0] + b) - p[1]) < 1e-9:\n \n a += 1 \n \n n = max(n, a)\n return n\n\n ","memory":"19750"},{"code":"from collections import defaultdict\n\nclass Solution:\n\n def is_same_line(self, point1, point2, point3):\n x1, y1 = tuple(point1)\n x2, y2 = tuple(point2)\n x3, y3 = tuple(point3)\n return (x3 - x1) * (y2 - y1) == (y3 - y1) * (x2 - x1)\n\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 3:\n return len(points)\n collinears = defaultdict(list)\n pairs = [(i1, i2) for i1 in range(len(points)) for i2 in range(i1 + 1, len(points))]\n while pairs:\n i1, i2 = pairs.pop()\n for i3 in range(i2 + 1, len(points)):\n if self.is_same_line(points[i1], points[i2], points[i3]):\n collinears[(i1, i2)].append(i3)\n try:\n pairs.remove((i1, i3))\n except ValueError:\n pass\n try:\n pairs.remove((i2, i3))\n except ValueError:\n pass\n if len(collinears) == 0:\n return 2\n return 2 + max(len(v) for v in collinears.values())\n","memory":"20059"},{"code":"from collections import defaultdict\n\nclass Solution:\n\n def is_same_line(self, point1, point2, point3):\n x1, y1 = tuple(point1)\n x2, y2 = tuple(point2)\n x3, y3 = tuple(point3)\n return (x3 - x1) * (y2 - y1) == (y3 - y1) * (x2 - x1)\n\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 3:\n return len(points)\n collinears = defaultdict(int)\n pairs = [(i1, i2) for i1 in range(len(points)) for i2 in range(i1 + 1, len(points))]\n while pairs:\n i1, i2 = pairs.pop()\n for i3 in range(i2 + 1, len(points)):\n if self.is_same_line(points[i1], points[i2], points[i3]):\n collinears[(i1, i2)] += 1\n try:\n pairs.remove((i1, i3))\n except ValueError:\n pass\n try:\n pairs.remove((i2, i3))\n except ValueError:\n pass\n if len(collinears) == 0:\n return 2\n return 2 + max(collinears.values())\n","memory":"20059"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lp, maxpoints = len(points), 1\n if lp ==1: return maxpoints\n slopes = [defaultdict(int) for _ in range(lp)]\n for i in range(lp):\n x1, y1 = points[i]\n for j in range(i+1, lp):\n x2, y2 = points[j]\n if x1 == x2 and y1 == y2:\n slope = \"0\"\n elif x1 == x2:\n slope = str(x1) + \"v\"\n elif y1 == y2:\n slope = str(y1) + \"h\"\n else:\n slope = str(round((y2-y1) / (x2-x1), 10))\n slopes[i][slope] += 1\n if slopes[i][slope] > maxpoints:\n maxpoints = slopes[i][slope]\n return maxpoints + 1","memory":"20368"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lp, maxpoints = len(points), 1\n if lp ==1: return maxpoints\n slopes = [defaultdict(int) for _ in range(lp)]\n for i in range(lp):\n x1, y1 = points[i]\n slopes_i = slopes[i]\n for j in range(i+1, lp):\n x2, y2 = points[j]\n if x1 == x2 and y1 == y2:\n slope = \"0\"\n elif x1 == x2:\n slope = str(x1) + \"v\"\n elif y1 == y2:\n slope = str(y1) + \"h\"\n else:\n slope = str(round((y2-y1) / (x2-x1), 10))\n slopes_i[slope] += 1\n if slopes_i[slope] > maxpoints:\n maxpoints = slopes_i[slope]\n return maxpoints + 1","memory":"20368"},{"code":"\n\"\"\"\n+7 min on timer btw\n\nneed to be able to determine which existing straight lines a new point is on, then we can update thos e counters.\nfinally, we can iterate over all teh lines and max their sizes.\n\n\nmaybe we can keep track of unique lines by its left and right most points (poitnts with min and max x).\n\n\nthen for every thing we can iterate over all points and update their counte if the point falls within those two points. we also update the point thing if we find that the new point is further left\n\n\nN = len(points)\nThis would be an O(N^3), O(N^2) space solution as there can be up to N^2 unique staright lines as every single point can be joing with any of the other n points to make a new line.\n\n\nif there is a duplicate point, that is coinsideerd an addiontal point for whatever line the existing point is.\n\n\n\nwe can have up to 2* (2*10^4) distinct lines that a point can fall on (all lines intersecting with\nall integer points on x-axis, and all lines inetersiection with all itngeter points o axis)\n\nwhat if we keep a hash table of which points intersectwith each distinc point on the x or \ny axis and \n\n a line can be uniquitely idetnifeid with its m and b values in y = mx + b\n\nIDEA:\n\nfirst, iterate through the ponitns and keep count of # of poitns at each\nunique (x,y) value.\n\nthen iterate over this map and for each point, iterate over all other points and \nsee if the points have a point at that slope. Basiaal,y we need a map that maps (x,y) values to\na dictionary of slopes to the size of the lines with that sloe. if therei s one, we add to that value in both points maps with the count of the current point, if not we create a lnew line entry and make it the sume of teh count of points between the two points. everytime we do an updat, updateh tem ax.\n\nThis is an O(N^2) solution with O(N^2 ) space (because each point can have up to n unique-sloped lines)\n\n\"\"\"\nimport dataclasses \nfrom typing import Dict, List\n@dataclasses.dataclass\nclass Point:\n\n x : int\n y : int\n lines : Dict[float , int] # mapping slope to # of points in that line \n\n def get_slope(self, other_point : \"Point\"):\n if other_point.x - self.x == 0:\n return float(\"inf\")\n return (other_point.y- self.y) / (other_point.x- self.x) \n\n def update_line_size(self, other_point : \"Point\") -> int:\n # update line size of lines that meet the other point, returning the new # of points in the line after adding the other point \n slope = self.get_slope(other_point)\n\n if slope in other_point.lines:\n \n other_point.lines[slope] += 1\n self.lines[slope] = other_point.lines[slope]\n else:\n other_point.lines[slope] = 2\n self.lines[slope] = 2\n \n \n return other_point.lines[slope]\n\n\n\n\n\ndef get_point_counts(points):\n out = []\n for pos in points:\n x,y = pos\n out.append(Point(x =x, y=y, lines = {}))\n\n return out\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n points : List[Point] = get_point_counts(points) # tuple of points\n ans = 0\n for i in range(len(points)):\n for j in range(i): # only iterate over previous points so we dont overcount\n\n ans = max(ans, points[i].update_line_size(points[j]))\n\n return ans","memory":"20676"},{"code":"\nimport dataclasses \nfrom typing import Dict, List\n@dataclasses.dataclass\nclass Point:\n\n x : int\n y : int\n lines : Dict[float , int] # mapping slope to # of points in that line \n\n def get_slope(self, other_point : \"Point\"):\n if other_point.x - self.x == 0:\n return float(\"inf\")\n return (other_point.y- self.y) / (other_point.x- self.x) \n\n def update_line_size(self, other_point : \"Point\") -> int:\n # update line size of lines that meet the other point, returning the new # of points in the line after adding the other point \n slope = self.get_slope(other_point)\n\n if slope in other_point.lines:\n \n other_point.lines[slope] += 1\n self.lines[slope] = other_point.lines[slope]\n else:\n other_point.lines[slope] = 2\n self.lines[slope] = 2\n \n \n return other_point.lines[slope]\n\n\n\n\n\ndef get_point_counts(points):\n out = []\n for pos in points:\n x,y = pos\n out.append(Point(x =x, y=y, lines = {}))\n\n return out\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n points : List[Point] = get_point_counts(points) # tuple of points\n ans = 0\n for i in range(len(points)):\n for j in range(i): # only iterate over previous points so we dont overcount\n\n ans = max(ans, points[i].update_line_size(points[j]))\n\n return ans","memory":"20676"},{"code":"\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lines = []\n\n for point in points:\n append_list = []\n for line in lines:\n if len(line) == 1:\n append_list.append([line[0], point])\n else:\n point_1 = line[-2]\n point_2 = line[-1]\n\n if (point_1[1] - point_2[1]) * (point_2[0] - point[0]) == (point_2[1] - point[1]) * (point_1[0] - point_2[0]):\n line.append(point)\n for append in append_list:\n lines.append(append)\n lines.append([point])\n\n\n max_points = max([len(line) for line in lines])\n return max_points\n ","memory":"20985"},{"code":"def points2rect(p0, p1):\n try:\n m = (p1[1] - p0[1])/(p1[0] - p0[0])\n q = p1[1] - m * p1[0]\n except:\n m = float(inf)\n q = p1[0]\n return round(m, 3), round(q, 3)\n\ndef fac(n):\n if n <= 1:\n return 1\n return n * fac(n-1)\n \n\ndef binom(n):\n return fac(n)/(fac(n-2)*2)\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n d = {}\n n = len(points)\n if n <= 2:\n return n\n r = 2\n for i, p0 in enumerate(points):\n for p1 in points[i+1:]:\n m, q = points2rect(p0, p1)\n if m not in d:\n d[m] = {}\n d[m][q] = d[m].get(q, 0) + 1\n if d[m][q] > r:\n r = d[m][q]\n for i in range(2, r+1):\n if binom(i) == r:\n return i\n return r","memory":"20985"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n slopes = []\n\n for i in range(len(points)):\n for j in range(i + 1, len(points)):\n (x1, y1) = points[i]\n (x2, y2) = points[j]\n\n # a x_1 + b y_1 + c = 0\n # a x_2 + b y_2 + c = 0\n # a (x_1 - x_2) + b (y_1 - y_2) = 0\n # b (y_1 - y_2) = a (x_2 - x_1)\n\n dy = y1 - y2 # a\n dx = x2 - x1 # b\n\n if dy < 0:\n dy *= -1\n dx *= -1\n\n c = 0 - dy * x1 - dx * y1\n\n slopes.append((dy, dx, c))\n\n best_count = 1\n\n for (a, b, c) in slopes:\n count = 0\n\n for (x, y) in points:\n if a * x + b * y + c == 0:\n count += 1\n\n best_count = max(count, best_count)\n\n return best_count","memory":"21294"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n graph = defaultdict(list)\n for i in range(len(points)-1) :\n for j in range(i+1, len(points)) :\n slope = 10 ** 9\n if (points[j][0] - points[i][0]) != 0 :\n slope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0]) \n\n graph[(points[i][0], points[i][1])].append((points[j][0], points[j][1], slope ))\n \n\n def dfsUtil(p, q, dist) :\n max_len = 1\n neighbors = graph[(p, q)]\n\n for x, y, distance in neighbors :\n if dist == -sys.maxsize or dist == distance :\n max_len = max(max_len, 1 + dfsUtil(x, y, distance))\n\n return max_len \n\n \n max_points = 0\n for k in range(len(points)) :\n max_points = max(max_points, dfsUtil(points[k][0], points[k][1], -sys.maxsize))\n \n return max_points","memory":"21603"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n graph = defaultdict(list)\n\n for i in range(len(points)-1) :\n for j in range(i+1, len(points)) :\n slope = 10 ** 9\n\n if (points[j][0] - points[i][0]) != 0 :\n slope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0]) \n\n graph[(points[i][0], points[i][1])].append((points[j][0], points[j][1], slope ))\n \n # print(graph)\n def dfsUtil(p, q, dist) :\n # print(p, q, dist)\n max_len = 1\n neighbors = graph[(p, q)]\n # print(neighbors)\n\n for x, y, distance in neighbors :\n if dist == -sys.maxsize or dist == distance :\n max_len = max(max_len, 1 + dfsUtil(x, y, distance))\n\n return max_len \n\n \n max_points = 0\n for k in range(len(points)) :\n # print(points[k])\n max_points = max(max_points, dfsUtil(points[k][0], points[k][1], -sys.maxsize))\n # print(points[k], dfsUtil(points[k][0], points[k][1], -sys.maxsize))\n return max_points","memory":"21911"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n\n deg = defaultdict(lambda: defaultdict(lambda: 1))\n max_n = 2\n for i in range(len(points)):\n for j in range(len(points)):\n if i == j:\n continue\n y = points[j][1] - points[i][1]\n x = points[j][0] - points[i][0]\n deg[i][math.atan2(y, x)] += 1\n max_n = max(max_n, max(deg[i].values()))\n\n return max_n","memory":"21911"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n combs = list(itertools.combinations(points, 2))\n \n n = 0\n a = 0\n if len(points)==1:\n return 1\n print(combs)\n for comb in combs:\n \n if comb[1][0] - comb[0][0] == 0: #vert line\n a =0\n for p in points:\n if p[0] == comb[0][0]:\n a+=1\n n = max(n, a)\n else:\n\n m = (comb[1][1] - comb[0][1]) / (comb[1][0] - comb[0][0])\n b = comb[0][1] - (m * comb[0][0])\n a = 0\n for p in points:\n # print((m * p[0] + b)-p[1])\n \n if abs((m * p[0] + b) - p[1]) < 1e-9:\n \n a += 1 \n \n n = max(n, a)\n return n\n\n ","memory":"22220"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \"\"\"\n How to figure this out:\n \n Brute force way:\n\n between every pair, there is a line. you can calculate all of these lines\n and check if any of the other ones fit on the line\n \"\"\"\n tol = 0.000001\n n = len(points)\n max_points = 1\n\n seen = set()\n for i in range(0, n):\n for x in range(0, n):\n if x == i or (min(i, x), max(i, x)) in seen:\n pass\n else:\n seen.add((min(i, x), max(i, x)))\n p1 = points[i]\n p2 = points[x]\n vertical = None\n if p2[0] == p1[0]:\n slope = float('inf')\n intercept = None\n vertical = p1[0] #stores the x value \n else:\n slope = (p2[1] - p1[1]) / (p2[0] - p1[0])\n intercept = - slope * p1[0] + p1[1] # y = mx + b (solve for b so b = -mx + y)\n num_points = 2\n for j in range(0, n):\n if j not in {x, i}:\n if vertical is not None:\n if points[j][0] == vertical:\n num_points += 1\n seen.add((min(i,j), max(i, j)))\n seen.add((min(x,j), max(x, j)))\n else:\n if abs(points[j][0] * slope + intercept - points[j][1]) <= tol:\n num_points += 1\n seen.add((min(i,j), max(i, j)))\n seen.add((min(x,j), max(x, j)))\n \n max_points = max(num_points, max_points)\n\n if max_points > n // 2:\n return max_points\n\n return max_points\n\n","memory":"22220"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 3:\n return len(points)\n\n combinations = []\n for i in range(len(points)):\n for j in range(i + 1, len(points)):\n if points[i] == points[j]:\n continue\n a = points[i][1] - points[j][1]\n b = points[j][0] - points[i][0]\n c = points[i][0] * points[j][1] - points[j][0] * points[i][1]\n combinations.append((a, b, c))\n \n max_points = 0\n for i in range(len(combinations)):\n a, b, c = combinations[i]\n cur_points = 0\n for j in range(len(points)):\n if a * points[j][0] + b * points[j][1] + c == 0:\n cur_points += 1\n max_points = max(max_points, cur_points)\n\n return max_points\n","memory":"22529"},{"code":"from collections import defaultdict\nimport math\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \n def find_slope(p1, p2):\n x1, y1 = p1\n x2, y2 = p2\n\n if x1 == x2: return (0, 1)\n if y1 == y2: return (1, 0)\n\n diff1 = x1 - x2\n diff2 = y1 - y2\n d = math.gcd(diff1, diff2)\n\n if diff1 < 0:\n diff1 = -diff1\n diff2 = -diff2\n\n return (diff1 // d, diff2 // d)\n \n \n # points -> slope counter\n\n count = {}\n for i in range(len(points)):\n count[i] = defaultdict(lambda : 1)\n\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n slope = find_slope(points[i], points[j])\n\n count[i][slope] += 1\n count[j][slope] += 1\n \n max_freq = 1\n for key in count:\n for slope in count[key]:\n max_freq = max(max_freq, count[key][slope])\n\n return max_freq","memory":"22529"},{"code":"\"\"\"\nNaive solution: look at all lines defined by a pair of points and check how many points on that line\nO(n^2*n)\n\nCan I do O(n)? No\n- must decide whether a point is or is not on the longest line\n\nO(n^2)?\n- iterate through all pairs of points and encode line\n- count line that is most popular\n\nBut hmm this is O(n^2) space\n\nPoints lie on integer lattice.\n\ny = mx + b\nb = y - mx\n\nIf a line has n points it has (n choose 2) pairs of points?\n(n choose 2) = n(n-1)/2 = n^2/2 - n/2\nc = n(n-1)/2 <==> 0 = n^2 - n - 2c <==> n = (1 + sqrt(1+8c)) / 2\n\"\"\"\nfrom collections import defaultdict\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n lines = defaultdict(int)\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n p1, p2 = points[i], points[j]\n if p1[0] != p2[0] or p1[1] != p2[1]:\n if p2[0] < p1[0]:\n t = p2\n p2 = p1\n p1 = t\n if p1[0] == p2[0]:\n m = \"inf\"\n b = p1[0]\n lines[f\"({m},{b:.5f})\"] += 1\n else:\n m = (p2[1]-p1[1])/(p2[0]-p1[0])\n b = p2[1] - m*p2[0]\n lines[f\"({m:.5f},{b:.5f})\"] += 1\n n_choose_2 = max(list(lines.values()))\n n = int((1 + sqrt(1+8*n_choose_2)) // 2)\n return n\n ","memory":"22838"},{"code":"class Solution(object):\n def maxPoints(self, points):\n \"\"\"\n :type points: List[List[int]]\n :rtype: int\n \"\"\"\n INF = 10**5\n\n n = len(points)\n pairs = [[0]*n for i in range(n)]\n max_occ = 0\n for i, (x,y) in enumerate(points):\n rep = {}\n for j, (x2, y2) in enumerate(points[i+1:]):\n if x == x2:\n a = INF\n b = x\n else:\n a = (y2-y)/(x2-x)\n b = y - a*x #y = ax + b, b = y - ax\n pairs[i][j] = (a, b)\n rep[(a, b)] = rep.get((a,b), 0) + 1\n max_occ = max(max_occ, rep[(a,b)])\n\n # for a in pairs:\n # for b in a:\n # print(b, end=\", \")\n # print()\n return max_occ+1\n","memory":"22838"},{"code":"class Solution:\n\n def num(self, points, p1, p2):\n v = [p2[0]-p1[0], p2[1]-p1[1]]\n n = [v[1], -v[0]]\n C = p2[0]*p1[1]-p1[0]*p2[1]\n count = 0\n for p in points:\n sum_v = n[0]*p[0] + n[1]*p[1] + C\n\n if sum_v == 0:\n count += 1\n return count\n\n\n def maxPoints(self, points: List[List[int]]) -> int:\n \n n = len(points)\n if n == 1:\n return 1\n max_num = 0\n d = {}\n for i in range(n):\n for j in range(i+1,n):\n if (i,j) in d or (j,i) in d:\n continue\n max_num = max(max_num, self.num(points, points[i], points[j]))\n d[(i,j)] = max_num\n return max_num\n ","memory":"23146"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n if len(points) == 1:\n return 1\n if len(points) == 2:\n return 2\n\n pair_points = []\n for i in range(len(points)):\n for j in points[i+1:]:\n pairs=[]\n pairs.append(points[i])\n pairs.append(j)\n pair_points.append(pairs)\n \n \n\n for i in (pair_points):\n for j in points:\n area = j[0]*(i[0][1] - i[1][1]) + i[0][0]*(i[1][1] - j[1])+i[1][0]*(j[1]-i[0][1])\n if j not in i and area == 0:\n i.append(j)\n max = len(pair_points[0])\n for i in range(len(pair_points) -1):\n if len(pair_points[i])> max:\n max = len(pair_points[i])\n print(pair_points)\n return max\n \n\n\n\n\n\n\n ","memory":"23146"},{"code":"from collections import defaultdict, Counter\nfrom math import gcd\n\ndef most_frequent_char(lists):\n results = []\n \n for lst in lists:\n if not lst:\n results.append(None)\n continue\n \n char_counts = Counter(lst)\n most_common_char, freq = char_counts.most_common(1)[0]\n results.append(freq)\n \n return results\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n _grads = []\n length = len(points)\n if length == 1:\n return 1\n for p in points:\n x, y =p \n l = []\n for c in range(length):\n if p != points[c]:\n x2, y2 = points[c]\n dy = y - y2\n dx = x - x2\n if dx == 0 and dy == 0:\n grad = 1\n elif dx != 0:\n grad = dy / dx\n else:\n grad = \"0\"\n l.append(grad)\n _grads.append(l)\n print(_grads)\n newmans = max(most_frequent_char(_grads))\n\n return newmans + 1\n ","memory":"23455"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points)==1:\n return 1\n lines={}\n maxi=0\n for i in range(len(points)):\n for j in range(i):\n if points[j][0]==points[i][0]:\n y_intercept=1e9\n x_intercept=points[i][0]\n elif points[j][1]==points[i][1]:\n y_intercept=points[i][1]\n x_intercept=1e9\n else:\n slope=(points[j][1]-points[i][1])/(points[j][0]-points[i][0])\n y_intercept=round(points[i][1] - slope*points[i][0],2)\n x_intercept=round(-y_intercept/slope,2)\n if str([x_intercept,y_intercept]) in lines:\n lines[str([x_intercept,y_intercept])]+=1\n if lines[str([x_intercept,y_intercept])]>maxi:\n maxi=lines[str([x_intercept,y_intercept])]\n else:\n lines.update({str([x_intercept,y_intercept]):1})\n print(lines, maxi)\n det=math.sqrt(1+(8*maxi))\n return max(2,int((1+det)/2))\n","memory":"23455"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # if on a line means on y = kx + b, y2 - y1/x2 - x1, (y2 - y1)x - (x2 - x1)y + x2y1 - x1y2 = 0\n # how to avoid x3, y3 x2, y2? visited set add(k, b)\n n = len(points)\n if n <= 2:\n return n\n\n visited = set()\n ans = 2\n for i in range(n):\n for j in range(i + 1, n):\n x1, y1 = points[i]\n x2, y2 = points[j]\n if x1 != x2 and ((y2 - y1) / (x2 - x1), y1 - ((y2 - y1) / (x2 - x1)) * x1) in visited:\n continue\n if x1 == x2 and (float('inf'), x1) in visited:\n continue\n ans = max(ans, self.countPoints(points, visited, x1, y1, x2, y2))\n return ans\n\n \n\n def countPoints(self, points, visited, x1, y1, x2, y2):\n ans = 2\n for x, y in points:\n if (x == x1 and y == y1) or (x == x2 and y == y2):\n continue\n if (y2 - y1) * x - (x2 - x1) * y + x2 * y1 - x1 * y2 == 0:\n ans += 1\n visited.add(((y2 - y1) / (x2 - x1), y1 - ((y2 - y1) / (x2 - x1)) * x1) if x1 != x2 else (float('inf'), x1)) \n return ans\n","memory":"23764"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lp, maxpoints = len(points), 1\n if lp ==1: return maxpoints\n slopes = [defaultdict(int) for _ in range(lp)]\n for i in range(lp):\n x1, y1 = points[i]\n for j in range(lp):\n if j != i:\n x2, y2 = points[j]\n if x1 == x2 and y1 == y2:\n slope = \"0\"\n elif x1 == x2:\n slope = str(x1) + \"v\"\n elif y1 == y2:\n slope = str(y1) + \"h\"\n elif j > i:\n slope = str(round((y2-y1) / (x2-x1), 10))\n else:\n slope = str(round((y1-y2) / (x1-x2), 10))\n slopes[i][slope] += 1\n if slopes[i][slope] > maxpoints:\n maxpoints = slopes[i][slope]\n return maxpoints + 1","memory":"23764"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lp, maxpoints = len(points), 1\n if lp ==1: return maxpoints\n slopes = [defaultdict(int) for _ in range(lp)]\n for i in range(lp):\n x1, y1 = points[i][0], points[i][1]\n for j in range(lp):\n if j != i:\n x2, y2 = points[j][0], points[j][1]\n if x1 == x2 and y1 == y2:\n slope = \"0\"\n if x1 == x2:\n slope = str(x1) + \"v\"\n elif y1 == y2:\n slope = str(y1) + \"h\"\n elif j > i:\n slope = str(round((y2-y1) / (x2-x1), 10))\n else:\n slope = str(round((y1-y2) / (x1-x2), 10))\n slopes[i][slope] += 1\n maxpoints = max(maxpoints, slopes[i][slope])\n # print(slopes)\n return maxpoints + 1","memory":"24073"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lp, maxpoints = len(points), 1\n if lp ==1: return maxpoints\n slopes = [defaultdict(int) for _ in range(lp)]\n for i in range(lp):\n x1, y1 = points[i]\n for j in range(lp):\n if j != i:\n x2, y2 = points[j]\n if x1 == x2 and y1 == y2:\n slope = \"0\"\n elif x1 == x2:\n slope = str(x1) + \"v\"\n elif y1 == y2:\n slope = str(y1) + \"h\"\n elif j > i:\n slope = str(round((y2-y1) / (x2-x1), 10))\n else:\n slope = str(round((y1-y2) / (x1-x2), 10))\n slopes[i][slope] += 1\n maxpoints = max(maxpoints, slopes[i][slope])\n return maxpoints + 1","memory":"24073"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n slopes_map = {}\n for i, point1 in enumerate(points):\n for point2 in points[i+1:]:\n if point1[0] - point2[0] != 0:\n slope = (point1[1]-point2[1])/(point1[0]-point2[0])\n else:\n slope = 'inf'\n current_slope = slopes_map.get((i,slope))\n if current_slope is None:\n slopes_map[(i,slope)] = 2\n else:\n slopes_map[(i,slope)] += 1\n return max(slopes_map.values(), default = 1)","memory":"24381"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n slopes_map = {}\n for i, point1 in enumerate(points):\n for point2 in points[i+1:]:\n if point1[0] - point2[0] != 0:\n slope = (point1[1]-point2[1])/(point1[0]-point2[0])\n else:\n slope = 'inf'\n current_slope = slopes_map.get((i,slope))\n if current_slope is None:\n slopes_map[(i,slope)] = 2\n else:\n slopes_map[(i,slope)] += 1\n return max(slopes_map.values(), default = 1)","memory":"24381"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # compute slope for each 2 points, keep a [slope, groups]\n nums = len(points)\n if nums < 2:\n return nums\n m = {}\n for i in range(1, nums):\n for j in range(0, i):\n # print(i, j, points[i], points[j])\n if points[i][1] != points[j][1]:\n slope = float((points[i][0] - points[j][0]) / (\n points[i][1] - points[j][1])\n )\n else:\n slope = float(\"inf\")\n if slope in m:\n values = m[slope]\n found = False\n for value in values:\n if points[j] in value and points[i] not in value:\n value.append(points[i])\n found = True\n break\n if not found:\n values.append([points[i], points[j]])\n else:\n m[slope] = [[points[j], points[i]]]\n # print(m)\n line = 0\n for v in m.values():\n for a in v:\n line = max(line, len(a))\n return line\n","memory":"24690"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # max_points = 0\n # for point1 in points:\n # for point2 in points:\n # count = 0\n # if point1[0] != point2[0]: # line is not vertical\n # yslope = (point2[1] - point1[1])\n # xslope = (point2[0] - point1[0])\n # for point in points:\n # if xslope * (point[1] - point1[1]) == yslope * (point[0] - point1[0]):\n # count += 1\n # else: # vertical\n # for point in points:\n # if point[0] == point1[0]:\n # count += 1\n # print(count)\n # max_points = max(max_points, count)\n # return max_points\n\n slopes = {}\n for i, point1 in enumerate(points):\n for j, point2 in enumerate(points[:i]):\n if point1[0] == point2[0]: # vertical\n slopeStr = \"inf\"\n else:\n slopeStr = str((point2[1] - point1[1]) / (point2[0] - point1[0]))\n \n if slopeStr in slopes: \n slopes[slopeStr].append((j,i))\n else: \n slopes[slopeStr] = [(j,i)]\n \n maxLength = 1\n for slopeStr in slopes:\n components = []\n for pair in slopes[slopeStr]:\n s = set(pair)\n flag = True\n #print(s)\n for st in components:\n if len(st.intersection(s)) > 0:\n #print(\"JOIN\")\n components.remove(st)\n st = st.union(s)\n components.append(st)\n flag = False\n #print(components)\n if flag:\n components.append(s)\n if max([len(c) for c in components]) > maxLength:\n maxLength = max([len(c) for c in components])\n \n return maxLength\n ","memory":"24690"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n l, cache = len(points), {}\n\n if l == 1:\n return 1\n\n def countPoints(p1, p2):\n count = 0\n\n x1, y1 = p1\n x2, y2 = p2\n\n if x1 != x2:\n k = y1 - y2 \n c = x1 - x2\n b = x1 * y2 - x2 * y1\n if (k, b) in cache:\n return cache[(k, b)]\n for point in points:\n x, y = point\n if c * y == k * x + b:\n print([x, y], end = ' ')\n count += 1\n else:\n k = float('inf')\n b = x1\n if (k, b) in cache:\n return cache[(k, b)]\n for point in points:\n x, y = point\n if x == x1:\n print([x, y], end = ' ')\n count += 1\n \n cache[(k, b)] = count\n\n print()\n\n return count\n\n max_num = float('-inf')\n for i in range(l):\n for j in range(i + 1, l):\n max_num = max(max_num, countPoints(points[i], points[j]))\n \n return max_num\n ","memory":"24999"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n l, cache = len(points), {}\n\n if l == 1:\n return 1\n\n def countPoints(p1, p2):\n count = 0\n\n x1, y1 = p1\n x2, y2 = p2\n\n if x1 != x2:\n k = y1 - y2 \n c = x1 - x2\n b = x1 * y2 - x2 * y1\n if (k, b) in cache:\n return cache[(k, b)]\n for point in points:\n x, y = point\n if c * y == k * x + b:\n count += 1\n else:\n k = float('inf')\n b = x1\n if (k, b) in cache:\n return cache[(k, b)]\n for point in points:\n x, y = point\n if x == x1:\n count += 1\n \n cache[(k, b)] = count\n\n return count\n\n max_num = float('-inf')\n for i in range(l):\n for j in range(i + 1, l):\n max_num = max(max_num, countPoints(points[i], points[j]))\n \n return max_num\n ","memory":"24999"},{"code":"class Solution:\n def get_a_c(self,point1, point2):\n x1,y1 = point1\n x2,y2 = point2\n\n if x1-x2 == 0:\n return None, x1\n\n dy = y1-y2 \n dx = x1-x2\n\n a = (y1-y2) / (x1-x2)\n b = y1 - a * x1\n\n return a,b\n \n def check_in_line(self,ab, point):\n x,y = point\n a,b = ab\n if a == None:\n if x == b:\n return True\n else:\n return False\n if abs((a*x + b) - y) < 0.00001:\n return True\n else:\n return False\n\n def maxPoints(self, points: List[List[int]]) -> int:\n\n tab = [[0] * len(points) for _ in points]\n visited = set()\n\n max_point = 1\n\n for i in range(0,len(points)):\n for j in range(i+1, len(points)):\n ab = self.get_a_c(points[i],points[j])\n if ab not in visited:\n temp_count = 2\n for k in range(j+1, len(points)):\n if self.check_in_line(ab, points[k]):\n temp_count += 1\n if temp_count > max_point:\n max_point = temp_count\n visited.add(ab)\n \n return max_point","memory":"25308"},{"code":"from fractions import Fraction\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lines = defaultdict(int)\n ans = 0\n\n for i in range(len(points)):\n curLines = set()\n for j in range(i):\n x1, y1 = points[i]\n x2, y2 = points[j]\n dx = x2 - x1\n dy = y2 - y1\n z = dx * y2 - dy * x2\n\n if (dx != 0):\n angle = Fraction(dy, dx)\n y0 = Fraction(z, dx)\n curLines.add((angle.numerator, angle.denominator, y0.numerator, y0.denominator))\n else: \n curLines.add((x1, 0, 0, 0))\n \n for line in curLines:\n lines[line] += 1\n\n # for count in lines.values():\n for key in lines: \n ans = max(ans, lines[key])\n\n return ans + 1\n\n\n","memory":"25308"},{"code":"import math\n\nclass LineCounter:\n\n def __init__(self):\n self._line_dict = {}\n self._max_count = 0\n \n def _least_terms(self, num, den):\n # Ensure that denominator is positive; if denominator is zero, than numerator should be positive\n if den < 0:\n num *= -1\n den *= -1\n elif den == 0:\n num = abs(num)\n \n # Put in least terms\n gcd = math.gcd(num, den)\n if gcd != 0:\n num //= gcd\n den //= gcd\n \n return num, den\n\n def _get_index(self, p1, p2):\n # f(t) = [at + c, bt + d]\n\n # Compute change in x, y\n dy, dx = self._least_terms(p2[1] - p1[1], p2[0] - p1[0])\n\n # Compute offset\n # (dy/dx)*x + b = y\n # dy*x + dx*b = dx*y\n # dx*b = dx*y - dy*x\n\n if dx == 0:\n bn, bd = p1[0], 1\n else:\n bn, bd = self._least_terms(dx*p1[1] - dy*p1[0], dx)\n\n return (dx, dy, bn, bd)\n\n def max(self):\n # n choose 2 = n(n+1)/2 = 1/2(n^2 + n) = m\n # n^2 + n - 2m = 0\n return (math.isqrt(8*self._max_count + 1) + 1)//2\n \n def increment(self, p1, p2):\n key = self._get_index(p1, p2)\n if key not in self._line_dict:\n self._line_dict[key] = 0\n \n self._line_dict[key] += 1\n\n if self._line_dict[key] > self._max_count:\n self._max_count = self._line_dict[key]\n\n return self._line_dict[key]\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n line_counter = LineCounter()\n for i,p1 in enumerate(points):\n for j in range(i+1, n):\n line_counter.increment(p1, points[j])\n \n return line_counter.max()\n","memory":"25616"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n=len(points)\n d={}\n for i in range(n):\n x,y=points[i][0],points[i][1]\n for j in range(i+1,n):\n x1=x-points[j][0]\n y1=y-points[j][1]\n b=x1*y-y1*x\n d[(y1,x1,b)]=0\n for i in range(n):\n x,y=points[i][0],points[i][1]\n for j in d:\n if j[1]*y==j[0]*x+j[2]:\n d[j]+=1\n m=1\n for x in d:\n m=max(m,d[x])\n return m\n","memory":"25616"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n import math\n\n if len(points) == 1:\n return 1\n d = {}\n for i in range(len(points)):\n l = points[i]\n for j in range(i+1, len(points)):\n r = points[j]\n slope = (r[1] - l[1]) / (r[0] - l[0]) if r[0] != l[0] else float('inf')\n bias = r[1] - slope * r[0] if slope != float('inf') else r[0]\n slope = round(slope, 5) if slope != float('inf') else slope\n bias = round(bias, 5)\n if (slope, bias) not in d:\n d[(slope, bias)] = 0\n d[(slope, bias)] += 1\n ans = max(d.values()) # kC2 = k * (k-1) // 2\n return math.ceil(math.sqrt(ans * 2))","memory":"25925"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n res = 0\n\n def lies_on_line(x,y,a,b):\n return abs(a*x + b - y) < 10e-6\n \n def compute_line(x1, y1, x2, y2):\n #print(x1, y1, x2, y2)\n if x2 - x1 == 0:\n return None # TODO\n\n a = (y2-y1)/(x2-x1)\n b = y1 - a * x1\n return a, b\n \n # Edge cases: vertical lines \n xs = [p[0] for p in points]\n x_counts = {}\n for x in xs:\n if x not in x_counts:\n x_counts[x] = 1\n else:\n x_counts[x] = x_counts[x] + 1\n for _, c in x_counts.items():\n if c>res:\n res = c\n \n\n lines = []\n for i, point_i in enumerate(points):\n for point_j in points[i+1:]:\n line = compute_line(*point_i, *point_j)\n if line is not None:\n lines.append(line)\n print(lines)\n for line in lines:\n curr_res = 0\n for point in points:\n #print(point, line)\n if lies_on_line(*point, *line):\n curr_res = curr_res + 1\n #print(line, curr_res)\n if curr_res>res:\n res = curr_res\n \n return res\n","memory":"25925"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n r = 12\n def kb(p1,p2):\n if round(p1[0]-p2[0],r)==0:\n return float('inf'), round(p1[0],r)\n\n k = (p1[1]-p2[1])/(p1[0]-p2[0])\n b = p1[1]-p1[0]*k\n return round(k,r),round(b,r)\n\n l = len(points)\n if l == 1: return 1\n lines = dict()\n for i in range(l-1):\n s = set([kb(points[i], points[j]) for j in range(i+1,l)])\n for kb1 in s:\n lines.setdefault(kb1, 1)\n lines[kb1] += 1\n return max(x for x in lines.values())\n","memory":"26234"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n slope_list = [{} for _ in range(len(points))]\n ans = 0\n for i,x in enumerate(points):\n for j,y in enumerate(points):\n if i == j:\n continue\n try:\n slope = (x[1] - y[1]) / (x[0] - y[0])\n except:\n slope = float(\"inf\")\n slope_list[i][slope] = slope_list[i].get(slope,0) + 1\n ans = max(ans,slope_list[i][slope])\n print(slope_list)\n return ans +1","memory":"26234"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n map = {}\n\n for i in range(len(points)):\n curr = set()\n for j in range(i+1, len(points), 1):\n if (points[i][0]-points[j][0]) != 0: div = (points[i][1]-points[j][1]) / (points[i][0]-points[j][0])\n else: div = 'inf'\n if div == -0: div = 0\n if div != 'inf': dif = points[i][1]-div*points[i][0]\n else: dif = points[i][0]\n key = f'{div}${dif}'\n if key in map.keys() and key not in curr: continue\n curr.add(key)\n try:\n map[key] += 1\n except KeyError:\n map[key] = 2\n print(map)\n if len(map.keys()) > 0: return max([map[key] for key in map.keys()])\n else: return 1","memory":"26543"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n def slopeCalculator(x1, y1, x2, y2):\n if x2 - x1 == 0:\n return \"und\"\n slope = (y2 - y1) / (x2 - x1)\n if slope == 0:\n slope = 0\n return slope\n \n pointSlopeDict = {}\n pointsLength = len(points)\n if pointsLength == 1:\n return 1\n\n for i in range(pointsLength):\n currPoint1 = points[i]\n for j in range(i + 1, pointsLength):\n currPoint2 = points[j]\n x1 = currPoint1[0]\n y1 = currPoint1[1]\n x2 = currPoint2[0]\n y2 = currPoint2[1]\n currSlope = slopeCalculator(x1, y1, x2, y2)\n currKey = \"point: \" + str(i) + \", slope: \" + str(currSlope)\n try:\n pointSlopeDict[currKey] = pointSlopeDict[currKey] + 1\n except KeyError:\n pointSlopeDict[currKey] = 1\n print(pointSlopeDict)\n return max(list(pointSlopeDict.values())) + 1","memory":"26543"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points)<2:\n return 1\n line={}\n m=0\n for i in range(len(points)):\n for j in range(i+1,len(points)):\n slope=float('inf')\n \n if(points[j][0]-points[i][0]!=0):\n slope=(points[j][1]-points[i][1])/(points[j][0]-points[i][0])\n c=points[j][1]-slope*points[j][0]\n else:\n c=points[j][0]\n mix=str(slope)+str(c)\n if mix in line:\n if points[j] not in line[mix]:\n line[mix].append(points[j])\n if points[i] not in line[mix]:\n line[mix].append(points[i])\n else:\n line[mix]=[points[j],points[i]]\n for i in line.keys():\n if len(line[i])>m:\n m=len(line[i])\n return m","memory":"26851"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points)<2:\n return 1\n line={}\n m=0\n for i in range(len(points)):\n for j in range(i+1,len(points)):\n slope=float('inf')\n \n if(points[j][0]-points[i][0]!=0):\n slope=(points[j][1]-points[i][1])/(points[j][0]-points[i][0])\n c=points[j][1]-slope*points[j][0]\n else:\n c=points[j][0]\n mix=str(slope)+str(c)\n if mix in line:\n if points[j] not in line[mix]:\n line[mix].append(points[j])\n if points[i] not in line[mix]:\n line[mix].append(points[i])\n else:\n line[mix]=[points[j],points[i]]\n for i in line.keys():\n if len(line[i])>m:\n m=len(line[i])\n return m","memory":"26851"},{"code":"import math\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n=len(points)\n if n==1:\n return 1\n d={}\n ans=0\n for i in range(n):\n x1,y1=points[i][0],points[i][1]\n for j in range(i+1,n):\n x2,y2=points[j][0],points[j][1]\n if(x2-x1==0):\n slope='-1'\n else:\n slope=(y2-y1)/(x2-x1)\n if ((x1,y1),slope) not in d:\n d[((x1,y1),slope)]=1\n d[((x1,y1),slope)]+=1\n ans=max(ans,d[((x1,y1),slope)])\n return ans","memory":"27160"},{"code":"from fractions import Fraction\nfrom dataclasses import dataclass\n\n@dataclass\nclass Line:\n origin: tuple[int, int]\n slope: Fraction | None\n l: int = 2\n \n def contains(self, point: tuple[int, int]) -> bool:\n x, y = point\n x1, y1 = self.origin\n dx = x - x1\n dy = y - y1\n\n if dx == 0:\n return self.slope is None\n else:\n if self.slope is None:\n return False\n fr = Fraction(dy, dx)\n return fr == self.slope\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lines = []\n best = min(2, len(points))\n\n for i, (x, y) in enumerate(points):\n for l in lines:\n if l.contains((x, y)):\n l.l += 1\n best = max(best, l.l)\n for (x1, y1) in points[:i]:\n dy = y - y1\n dx = x - x1\n if dx == 0:\n slope = None\n else:\n slope = Fraction(dy, dx)\n lines.append(Line((x1, y1), slope))\n \n # if len(points) == 7:\n # print(*lines, sep=\"\\n\")\n \n return best\n ","memory":"27160"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) < 3:\n return len(points)\n keep_dict = {}\n for i in range(len(points) - 1):\n for j in range(i+1, len(points)):\n x1, y1 = points[i]\n x2, y2 = points[j]\n if x2 - x1 == 0:\n if (\"inf\", x1) in keep_dict:\n keep_dict[(\"inf\", x1)] += 1\n else:\n keep_dict[(\"inf\", x1)] = 1\n continue\n m = (y2 - y1) / (x2 - x1)\n\n b = round(10**8 * (y2 - m * x2))\n m = round(10**8 * m)\n\n if (m, b) in keep_dict:\n keep_dict[(m, b)] += 1\n else:\n keep_dict[(m, b)] = 1\n x = 2 * max(keep_dict.values())\n print(keep_dict)\n return int((1 + (4 * x + 1)**(0.5)) / 2)","memory":"27469"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n res = 0\n if len(points) <= 2:\n return len(points)\n xy = defaultdict(list)\n for i in range (len(points)):\n \n\n for j in range (i+1, len(points)):\n \n if (points[i][0] - points[j][0]) == 0:\n k = '0.0'\n b = points[i][0]\n else: \n k = (points[i][1] - points[j][1]) / (points[i][0] - points[j][0])\n b = points[i][1] - k * points[i][0]\n\n key = str(k)+ str(b)\n if i not in xy[key]:\n xy[key].append(i)\n if j not in xy[key]:\n xy[key].append(j)\n \n for key, val in xy.items():\n res = max(len(val), res)\n \n\n return res\n","memory":"27469"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n def param(p1,p2):\n try :\n a = (p1[1] - p2[1])/(p1[0] - p2[0])\n b = p1[1] - a*p1[0]\n return (a,b)\n except :\n return ( float(\"inf\"), p1[0])\n def appartient(p3,para):\n return p3[1] == para[0] * p3[0] + para[1]\n\n\n d = {}\n if (len(points)<=2) : return len(points)\n n =len(points)\n h = set()\n for i in range(n-1) :\n L = set()\n for j in range(i+1,n):\n coeff = param(points[i], points[j])\n if coeff in h : continue\n if (coeff in d.keys()):\n d[coeff] += 1\n else : \n L.add(coeff)\n\n d[coeff] = 2\n h.update(L)\n \n return max(d.values()) \n \n \n ","memory":"28086"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n def getID(p1, p2):\n if p2[0] == p1[0]:\n return p1[0]\n if p2 >= p1:\n m = (p2[1]-p1[1]) / (p2[0]-p1[0])\n y = p2[1] - m*p2[0]\n else:\n m = (p1[1]-p2[1]) / (p1[0]-p2[0])\n y = p1[1] - m*p1[0]\n return (round(m, 5),round(y,5))\n lines = defaultdict(int)\n sealed = set()\n for i in range(len(points)):\n temp = set()\n for j in range(i+1, len(points)):\n id = getID(points[i], points[j])\n if id not in sealed: \n lines[id] += 1\n temp.add(id)\n sealed |= temp\n ans = 1\n for times in lines.values():\n times += 1\n if times > ans:\n ans = times \n return ans","memory":"28086"},{"code":"from collections import defaultdict\nimport math\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n \n if n <= 2:\n return n\n D = defaultdict(lambda: 0)\n max_points = 0\n for i in range(n):\n for j in range(i):\n xa, ya = points[i]\n xb, yb = points[j]\n if xb == xa:\n slope = \"fuck\"\n intercept = xb\n else:\n slope = (yb - ya) / (xb - xa)\n intercept = yb - slope * xb\n slope = f\"{slope:.8f}\"\n intercept = f\"{intercept:.8f}\"\n print(slope)\n\n key = (slope, intercept)\n D[key] += 1\n max_points = max(max_points, D[key])\n\n print(max_points)\n return int(math.sqrt(max_points * 2)) + 1\n\n \n \n \n ","memory":"28395"},{"code":"from collections import defaultdict\nimport math\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n \n if n <= 2:\n return n\n D = defaultdict(lambda: 0)\n max_points = 0\n for i in range(n):\n for j in range(i):\n xa, ya = points[i]\n xb, yb = points[j]\n if xb == xa:\n slope = \"fuck\"\n intercept = xb\n else:\n slope = (yb - ya) / (xb - xa)\n intercept = yb - slope * xb\n slope = f\"{slope:.8f}\"\n intercept = f\"{intercept:.8f}\"\n # print(slope)\n\n key = (slope, intercept)\n D[key] += 1\n max_points = max(max_points, D[key])\n\n print(max_points)\n return int(math.sqrt(max_points * 2)) + 1\n\n \n \n \n ","memory":"28395"},{"code":"from collections import defaultdict\nimport math\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n \n if n <= 2:\n return n\n D = defaultdict(lambda: 0)\n max_points = 0\n for i in range(n):\n for j in range(i):\n xa, ya = points[i]\n xb, yb = points[j]\n if xb == xa:\n slope = \"fuck\"\n intercept = xb\n else:\n slope = (yb - ya) / (xb - xa)\n intercept = yb - slope * xb\n slope = f\"{slope:.8f}\"\n intercept = f\"{intercept:.8f}\"\n # print(slope)\n\n key = (slope, intercept)\n D[key] += 1\n max_points = max(max_points, D[key])\n\n print(max_points)\n return int(math.sqrt(max_points * 2)) + 1\n\n \n \n \n ","memory":"28704"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n def getID(p1, p2):\n if p2[0] == p1[0]:\n return p1[0]\n if p2 >= p1:\n m = (p2[1]-p1[1]) / (p2[0]-p1[0])\n y = p2[1] - m*p2[0]\n else:\n m = (p1[1]-p2[1]) / (p1[0]-p2[0])\n y = p1[1] - m*p1[0]\n return (round(m, 5),round(y,5))\n lines = defaultdict(int)\n sealed = set()\n for i in range(len(points)):\n temp = set()\n for j in range(i+1, len(points)):\n id = getID(points[i], points[j])\n if id not in sealed: \n lines[id] += 1\n temp.add(id)\n sealed |= temp\n ans = 1\n print(lines)\n for times in lines.values():\n times += 1\n if times > ans:\n ans = times \n return ans","memory":"28704"},{"code":"import numpy as np\n\n\n\nclass Solution:\n\n def num_on(self, p1: np.ndarray, p2: np.ndarray , points : np.ndarray):\n vec = (p2 -p1)\n if vec[0] == 0:\n #print((points[ :, 0] == p1[0]), points, p1)\n return int((points[:, 0] == p1[0]).sum())\n\n if vec[1] == 0:\n return int((points[:, 1] == p1[1]).sum())\n\n points_p1 = points - p1[None, :]\n alphas = points_p1 / vec[None, : ]\n mean_alpha = np.mean(alphas, axis=-1, keepdims=True)\n #print(alphas)\n linear = np.abs((mean_alpha - alphas)).max(axis=-1) == 0\n #print(linear)\n num = int((linear & (mean_alpha[:, 0] <= 1) & (mean_alpha[:, 0]>=0)).sum())\n return num\n\n\n def maxPoints(self, points: List[List[int]]) -> int:\n\n points = np.array(points)\n max_points = 1\n for idx , p1 in enumerate(points):\n for jdx, p2 in enumerate(points[idx+1:]):\n max_points = max(max_points, self.num_on(p1, p2, points))\n\n return max_points\n \n\n ","memory":"29013"},{"code":"from decimal import Decimal\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n\n # y = mx + c\n \n lines = {}\n\n\n for i in range(len(points)):\n pnt = set()\n for j in range(len(points)):\n if i == j:\n continue\n \n\n if (points[j][0] - points[i][0]) == 0:\n m = inf\n else:\n m = round((points[j][1] - points[i][1])/(points[j][0] - points[i][0]), 10)\n \n\n if m is inf:\n c = points[i][0]\n else:\n c = round(points[j][1]-(m*points[j][0]), 8)\n\n \n\n if (m,c) not in lines:\n lines[(m,c)] = 1\n elif (m,c) not in pnt:\n lines[(m,c)] += 1\n\n pnt.add((m,c))\n \n print(lines)\n\n return max(lines.values())\n\n\n\n ","memory":"29013"},{"code":"import numpy as np\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # Consider two points\n # Then compute the line\n # Then count how many points satisfy that\n \n TOL = 1e-8\n n = len(points)\n if n <= 2:\n return n\n\n data = np.array(points)\n x = data[:, 0]\n y = data[:, 1]\n max_count = 1\n for i in range(n-1):\n for j in range(i+1, n):\n if x[i] == x[j]:\n num = np.sum(x == x[i])\n else:\n slope = (y[j] - y[i]) / (x[j] - x[i])\n intercept = slope * (-x[i]) + y[i]\n\n res = slope * x + intercept - y\n\n num = np.sum(abs(res) < TOL)\n if num > max_count:\n max_count = num\n\n return max_count","memory":"29321"},{"code":"from fractions import Fraction\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2:\n return len(points)\n si = defaultdict(int)\n si[None]\n vert = defaultdict(int)\n vert[None]\n for i in range(len(points) - 1):\n for j in range(i + 1, len(points)):\n x1, y1 = points[i]\n x2, y2 = points[j]\n if x1 == x2:\n vert[x1] += 1\n continue\n slope = Fraction(y2 - y1, x2 - x1)\n intercept = y1 - slope * x1\n si[(slope, intercept)] += 1\n return ceil(sqrt(2 * max(max(si.values()), max(vert.values()))))","memory":"29321"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \n if len(points) == 1: return 1\n\n slopes = {}\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n dx = points[i][0] - points[j][0]\n dy = points[i][1] - points[j][1]\n slope = dy/dx if dx != 0 else \"vertical\"\n\n if slope in slopes:\n slopes[slope].add(i)\n slopes[slope].add(j)\n else:\n slopes[slope] = {i, j}\n\n print(slopes)\n\n maxPoints = 0\n for slope in slopes:\n if slope == 'vertical':\n intercepts = [points[i][0] for i in slopes[slope]]\n else:\n intercepts = [round(points[i][1] - slope * points[i][0], 5) for i in slopes[slope]]\n\n max_occurence = intercepts.count(max(intercepts, key=intercepts.count))\n if maxPoints < max_occurence: maxPoints = max_occurence\n\n return maxPoints\n","memory":"29630"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n #calculate sllope y = mx + b b = y-mx\n m = {}\n for i in range(len(points)):\n one = points[i]\n for j in range(i+1, len(points)):\n \n two = points[j]\n if (one[1] == two[1]):\n slope = 0\n b = one[1]\n elif (one[0] == two[0]):\n slope = \"undefined\"\n b = one[0]\n else:\n slope = (one[1] - two[1])/(one[0] - two[0])\n b = one[1] - (one[0]*slope)\n if (slope, b) not in m:\n m[(slope, b)] = []\n if one not in m[(slope, b)]:\n m[(slope, b)].append(one) \n if two not in m[(slope, b)]:\n m[(slope, b)].append(two)\n c = [len(v) for v in m.values()]\n if not c:\n return 1\n return max(c)\n \n\n\n\n \n ","memory":"29630"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n from collections import defaultdict\n dc=defaultdict(list)\n def getslope(p1,p2):\n x1,y1=p1\n x2,y2=p2\n try:\n m=(y2-y1)/(x2-x1)\n c=y1-m*x1\n except:\n m=float('inf')\n c=x1\n return (m,c)\n for i in range(len(points)):\n for j in range(i+1,len(points)):\n m,c=getslope(points[i], points[j])\n points[i], points[j]=tuple(points[i]), tuple(points[j])\n if points[i] not in dc[(m,c)]:\n dc[(m,c)].append(points[i]) \n if points[j] not in dc[(m,c)]:\n dc[(m,c)].append(points[j])\n if not dc:\n return 1\n else:\n return max([len(x) for x in dc.values()])\n\n","memory":"29939"},{"code":"# 1 <= points.length <= 300\n# All the points are unique\n\n# Option 1. Brutal force\n# use two points to define a line, check if other points are on the same line\n# O(N**3)\n\n# Option 2. Caching\n# use two points to define a line, and cache slope with dict {slope: (p1, p2)}\n# if two lines have the same slope and connected point, then +1 in the path, this can be resolved with DFS\n\n# Start with Option 2\n\nclass Solution:\n def count_max(self, points_list: List[Tuple[Tuple[int, int], Tuple[int, int]]]) -> int:\n if len(points_list) == 1:\n return 2\n\n # build a graph\n point_map: Dict[Tuple[int, int], int] = {}\n curr_index = 0\n for points in points_list:\n for point in points:\n if point not in point_map:\n point_map[point] = curr_index\n curr_index += 1\n # print(point_map)\n\n n = len(point_map)\n graph: List[List[int]] = [[0] * n for _ in range(n)]\n\n for points in points_list:\n p1 = points[0]\n p2 = points[1]\n index1 = point_map[p1]\n index2 = point_map[p2]\n graph[index1][index2] = 1\n graph[index2][index1] = 1\n # print(graph)\n\n # dfs\n visited: Set[int] = set()\n max_points = 0\n for i in range(n):\n if i in visited:\n continue\n\n curr_points = 0\n stack: List[int] = []\n stack.append(i)\n while len(stack) > 0:\n curr_index = stack.pop()\n if curr_index not in visited:\n visited.add(curr_index)\n curr_points += 1\n\n for j in range(n):\n if graph[curr_index][j] == 1:\n if j not in visited:\n stack.append(j)\n\n max_points = max(max_points, curr_points)\n\n return max_points\n\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 2:\n return len(points)\n\n slope_to_points: Dict[float, List[Tuple[Tuple[int, int], Tuple[int, int]]]] = {}\n\n for i in range(len(points)):\n for j in range(i + 1, len(points)):\n p1 = points[i]\n p2 = points[j]\n if p2[0] - p1[0] == 0:\n slope = float(sys.maxsize)\n else:\n slope = (p2[1] - p1[1]) / (p2[0] - p1[0])\n if slope in slope_to_points:\n slope_to_points[slope].append(((p1[0], p1[1]), (p2[0], p2[1])))\n else:\n slope_to_points[slope] = [((p1[0], p1[1]), (p2[0], p2[1]))]\n # print(slope_to_points)\n\n max_points = 0\n for points_list in slope_to_points.values():\n curr_points = self.count_max(points_list)\n max_points = max(max_points, curr_points)\n\n return max_points","memory":"29939"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n vectors = []\n for i in range(len(points)):\n vectors.append(defaultdict(int))\n for j in range(len(points)):\n if j == i:\n continue\n x = points[j][0] - points[i][0]\n y = points[j][1] - points[i][1]\n if x < 0:\n x *= -1\n y *= -1\n length = math.sqrt(x * x + y * y)\n new_tuple = (round(x / length, 10), round(y / length, 10))\n vectors[i][new_tuple] += 1\n\n max_matches = 0\n for v in vectors:\n for count in v.values():\n max_matches = max(count + 1, max_matches)\n\n return max_matches","memory":"30248"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n length = len(points)\n dic = {}\n max_element = 0\n if(len(points)==1):\n return 1\n for i in range(0,length):\n for j in range(i+1,length):\n if (points[i][0] == points[j][0]):\n slope = points[i][0]\n offset = 99999\n else:\n slope = (points[i][1]-points[j][1])/(points[i][0]-points[j][0])\n offset=points[i][1] - slope * points[i][0]\n print(slope,offset)\n if (slope, offset) in dic:\n if i not in dic[(slope,offset)]:\n dic[(slope,offset)].append(i)\n if j not in dic[(slope,offset)]:\n dic[(slope,offset)].append(j)\n # print(\"adding a point to (\", slope, \", \", offset, \")\")\n if len(dic[(slope, offset)]) > max_element:\n max_element = len(dic[(slope,offset)])\n else:\n dic[(slope,offset)] = []\n dic[(slope,offset)].append(i)\n dic[(slope,offset)].append(j)\n if len(dic[(slope, offset)]) > max_element:\n max_element = len(dic[(slope,offset)])\n # print(dic)\n return max_element","memory":"30248"},{"code":"import collections\nimport itertools\nimport math\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n if len(points) == 1:\n return 1\n \n gcd_cache = {}\n line_descriptors = collections.Counter()\n for p1, p2 in itertools.combinations(points, 2):\n line_descriptors[self.getLineDescriptor(p1, p2, gcd_cache)] += 1\n \n sum_of_pairs = line_descriptors.most_common(1)[0][1]\n\n ans = math.ceil(math.sqrt(2*sum_of_pairs)) \n\n return ans\n\n def getLineDescriptor(self, p1: Tuple[int], p2: Tuple[int], gcd_cache) -> Tuple[int]:\n \"\"\"\n Returns slope_num, slope_denom, intercept\n \"\"\"\n x1, y1 = p1\n x2, y2 = p2\n\n m_num = y2 - y1\n m_denom = x2 - x1\n\n if m_num == 0:\n return 0, 0, y1\n \n if m_denom == 0:\n return math.inf, math.inf, x1\n\n if m_denom < 0:\n m_num *= -1\n m_denom *= -1\n\n m_num_abs = abs(m_num)\n m_denom_abs = abs(m_denom)\n\n gcd_cache_key = (m_num_abs, m_denom_abs)\n if gcd_cache_key in gcd_cache:\n gcd = gcd_cache[gcd_cache_key]\n else:\n gcd = math.gcd(m_num_abs, m_denom_abs)\n gcd_cache[gcd_cache_key] = gcd\n\n m_num /= gcd\n m_denom /= gcd\n\n return m_num, m_denom, y1*m_denom - m_num*x1\n\n","memory":"30556"},{"code":"class Solution:\n def lineEq(self, point1: list[int], point2: list[int]) -> str:\n if point2[0] == point1[0]:\n return f\"x{point1[0]}\"\n\n elif point2[1] == point1[1]:\n return f\"y{point1[1]}\"\n\n slope = (point2[1] - point1[1]) / (point2[0] - point1[0])\n intercept = point1[1] - slope * point1[0]\n\n if intercept >= 0:\n return f\"{slope}x + {intercept}\"\n else:\n return f\"{slope}x - {abs(intercept)}\"\n\n def maxPoints(self, points: list[list[int]]) -> int:\n if len(points) == 1:\n return 1\n slops = {}\n max: int = 0\n for i in range(0, len(points)):\n for j in range(0, len(points)):\n if j == i:\n continue\n key: str = self.lineEq(points[i], points[j])\n if key not in slops:\n slops[key] = [points[j]]\n elif points[j] not in slops[key]:\n slops[key].append(points[j])\n\n if points[i] not in slops[key]:\n slops[key].append(points[i])\n\n for slop in slops:\n if max < len(slops[slop]):\n max = len(slops[slop])\n return max","memory":"30865"},{"code":"from math import gcd\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points)==1: return 1\n d,d2,dv = set(),set(),set()\n points.sort(key=lambda x:x[0])\n for i,c1 in enumerate(points):\n for j,c2 in enumerate(points[i+1:]):\n x1,y1 = c1\n x2,y2 = c2\n if x1==x2: d.add(x1)\n if y1==y2: d2.add(y1)\n if x1!=x2 and y1!=y2:\n\n dx,dy = (x2-x1)//gcd(x2-x1,y2-y1), (y2-y1)//gcd(x2-x1,y2-y1)\n if dx<0 and dy<0: dx *= -1; dy *= -1\n fac = x1//dx\n dv.add((dx,dy,x1-dx*fac,y1-dy*fac))\n d3 = {}\n for x,y in points:\n if x in d: d3[(x,\"x\")] = d3.get((x,\"x\"),0)+1\n if y in d2: d3[(y,\"y\")] = d3.get((y,\"y\"),0)+1\n for dx,dy,ix,iy in dv:\n if x==ix and y==iy: d3[(dx,dy,ix,iy)] = d3.get((dx,dy,ix,iy),0)+1\n else:\n cx,cy = (x-ix)/gcd(x-ix,y-iy), (y-iy)/gcd(x-ix,y-iy)\n if cx<0: cx *= -1; cy *= -1\n if cx==dx and cy==dy: d3[(dx,dy,ix,iy)] = d3.get((dx,dy,ix,iy),0)+1\n print(d3)\n return max(d3.values())","memory":"30865"},{"code":"from math import gcd\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points)==1: return 1\n d,d2,dv = set(),set(),set()\n points.sort(key=lambda x:x[0])\n for i,c1 in enumerate(points):\n for j,c2 in enumerate(points[i+1:]):\n x1,y1 = c1\n x2,y2 = c2\n if x1==x2: d.add(x1)\n if y1==y2: d2.add(y1)\n if x1!=x2 and y1!=y2:\n\n dx,dy = (x2-x1)//gcd(x2-x1,y2-y1), (y2-y1)//gcd(x2-x1,y2-y1)\n if dx<0 and dy<0: dx *= -1; dy *= -1\n fac = x1//dx\n dv.add((dx,dy,x1-dx*fac,y1-dy*fac))\n d3 = {}\n for x,y in points:\n if x in d: d3[(x,\"x\")] = d3.get((x,\"x\"),0)+1\n if y in d2: d3[(y,\"y\")] = d3.get((y,\"y\"),0)+1\n for dx,dy,ix,iy in dv:\n if x==ix and y==iy: d3[(dx,dy,ix,iy)] = d3.get((dx,dy,ix,iy),0)+1\n else:\n cx,cy = (x-ix)/gcd(x-ix,y-iy), (y-iy)/gcd(x-ix,y-iy)\n if cx<0: cx *= -1; cy *= -1\n if cx==dx and cy==dy: d3[(dx,dy,ix,iy)] = d3.get((dx,dy,ix,iy),0)+1\n return max(d3.values())","memory":"31174"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 1:\n return len(points)\n \n res_map = defaultdict(list)\n for i, point in enumerate(points):\n for next in points[i + 1:]:\n try:\n rate = (next[0] - point[0]) / (next[1] - point[1])\n except ZeroDivisionError:\n rate = ''\n res_map[rate, tuple(point)].append(next)\n\n return max([len(points) for _, points in res_map.items()]) + 1","memory":"31174"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1: return 1\n cnt = Counter()\n\n def line(p1, p2):\n if p1[0] == p2[0]:\n return inf, p1[0]\n slp = (p2[1] - p1[1])/(p2[0] - p1[0])\n intercept = (p2[0]*p1[1] - p1[0]*p2[1])/(p2[0] - p1[0])\n return slp, intercept\n\n # given sum of s, return n such that s == n*(n+1)/2\n def helper(s):\n return int(abs((-1 + math.sqrt(1 + 8*s))//2))\n\n for i in range(len(points)-1):\n for j in range(i+1, len(points)):\n slp, b = line(points[i], points[j])\n cnt[(slp, b)] += 1\n\n print(cnt.most_common())\n s = cnt.most_common()[0][1] \n return helper(s) + 1 ","memory":"31483"},{"code":"import math\nfrom fractions import Fraction\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n num_pts= {}\n for n0 in range(len(points)):\n for n1 in range(n0+1, len(points)):\n if points[n1][0] == points[n0][0]:\n m = float(\"inf\")\n b = points[n1][0]\n else:\n m = Fraction(points[n1][1] - points[n0][1], points[n1][0] - points[n0][0])\n b = points[n1][1] - m * points[n1][0]\n if (m,b) not in num_pts:\n num_pts[(m,b)] = 1\n else:\n num_pts[(m,b)] += 1\n print(num_pts)\n maxval = 0\n for k, v in num_pts.items():\n if v > maxval:\n maxval = v\n return int(math.floor(math.sqrt(maxval * 2))) + 1\n","memory":"31483"},{"code":"class Solution:\n def maxPoints(self, points: list[list[int]]) -> int:\n if len(points) < 2:\n return len(points) \n line_set = set()\n count = {}\n def evc_algo (a, b): #assume that both positive\n a_ = a\n b_ = b\n while (a_ != 0 and b_ != 0):\n if (a_ >= b_): a_ = a_ % b_\n else: b_ = b_ % a_\n if a_ == 0:\n return b_\n else: return a_\n def func(x0, x1, y0, y1):\n if (x0 == x1):\n t = (None, x0)\n if t not in line_set:\n line_set.add(t)\n else:\n if y0 - y1 >= 0: a = y0 - y1\n else: a = - (y0 - y1)\n if x0 - x1 >= 0: b = x0 - x1\n else: b = - (x0 - x1)\n nod = evc_algo(a, b)\n if y1 * (x0 - x1) - x1 * (y0 - y1) >= 0: c = y1 * (x0 - x1) - x1 * (y0 - y1)\n else: c = - (y1* (x0 - x1) - x1 * (y0 - y1))\n nod1 = evc_algo(b, c)\n #####\n t = []\n if (y0 - y1 >= 0 and x0 -x1 >=0) or (y0 - y1 < 0 and x0 - x1 < 0):\n t.append((a//nod, b//nod))\n else:\n t.append((-a//nod,b//nod))\n if ((y1* (x0-x1) - x1 * (y0-y1)) >= 0 and x0 -x1 >=0) or ((y1 * (x0-x1) - x1 * (y0-y1)) < 0 and x0 - x1 < 0):\n t.append((c//nod1, b//nod1))\n else:\n t.append((-c//nod1, b//nod1))\n t = tuple(t)\n if t not in line_set:\n line_set.add(t)\n set_point = set()\n for p in points:\n t = tuple(p)\n if t not in set_point:\n set_point.add(t)\n set_point = list(set_point)\n for i in range (len(set_point) - 1):\n for j in range (i + 1, len(set_point)):\n func(set_point[i][0], set_point[j][0], set_point[i][1], set_point[j][1])\n line_set = list(line_set)\n # print(line_set)\n for line in line_set:\n count[line] = 0\n for p in set_point:\n if line == ((70, 23), (9, 1)):\n print(p[1], (line[0][0] / line[0][1]) * p[0] + line[1][0]/line[1][1])\n if line[0] == None and line[1] == p[0]:\n count[line] += 1\n elif (line[0] != None and p[1] == (line[0][0] * p[0] * line[1][1] + line[1][0] * line[0][1])/(line[0][1] * line[1][1])):\n count[line] += 1\n return max(count.values())","memory":"31791"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n N = len(points)\n points.sort(key = lambda x : x[0])\n \n grad_ = {}\n di = {}\n\n max_ = 1\n\n for i in range(N-1):\n point1 = points[i]\n for j in range(i+1,N):\n \n point2 = points[j]\n if point2[0]-point1[0]==0:\n grad = float(inf)\n intercept = point1[0]\n else:\n grad = (point2[1]-point1[1])/(point2[0]-point1[0])\n intercept = round(point2[1] - grad*point2[0], 10)\n \n if tuple(point2+[grad,intercept]) not in di.keys():\n if tuple([grad, intercept]) not in grad_.keys():\n grad_[tuple([grad, intercept])] = 2\n else:\n grad_[tuple([grad, intercept])] += 1\n if grad_[tuple([grad, intercept])]>max_:\n max_ = grad_[tuple([grad, intercept])]\n\n if tuple(point2+[grad, intercept]) not in di.keys():\n di[tuple(point2+[grad,intercept])] = None\n return(max_)\n\n","memory":"32100"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 0:\n return 0\n elif len(points) == 1:\n return 1\n\n n = len(points)\n lines = {}\n line_points = {}\n\n for i in range(0, n):\n for j in range(i+1, n):\n if points[j][0] != points[i][0]:\n slope = (points[j][1] - points[i][1])/(points[j][0] - points[i][0])\n intercept = points[j][1] - slope*points[j][0]\n else:\n slope = \"inf\"\n intercept = points[j][0]\n\n pair = (slope, intercept)\n\n if pair not in lines:\n lines[pair] = 2\n line_points[pair] = [points[j], points[i]]\n elif points[i] not in line_points[pair] or points[j] not in line_points[pair]:\n lines[pair] += 1\n if points[i] not in line_points[pair]:\n line_points[pair].append(points[i])\n else:\n line_points[pair].append(points[j])\n\n #print(i, j, pair)\n #print(lines, line_points) \n\n return max(lines.values())","memory":"32100"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n #y = mx + c\n #c = y - mx\n #c_x = -c/m\n def grad(p1, p2):\n y1,x1 = p1\n y2,x2 = p2\n if (x2 - x1) == 0:\n m = \"inf\"\n c = None\n c_x = x1\n else:\n m = (y2 - y1) / (x2 - x1)\n if m == 0:\n c = y1\n c_x = None\n else:\n c = y1 - m * x1\n c_x = -c / m\n return m,c,c_x\n\n lines = {} # (m,c) -> freq\n visited = {}\n points.sort(key=lambda x: x[0])\n n = len(points)\n for i in range(n):\n for j in range(i+1, n):\n m,c,c_x = grad(points[i], points[j])\n if (m,c,c_x) in visited:\n continue\n else:\n lines[(m,c,c_x)] = lines.get((m,c,c_x), 1) + 1\n visited.update(lines)\n if n < 2:\n return n\n return max(lines.values())\n\n\n ","memory":"32409"},{"code":"import math\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \n def norm(loc):\n return (loc[0]**2+loc[1]**2)**0.5\n\n def get_angle(loc1,loc2):\n del_x = loc1[0] - loc2[0]\n del_y = loc1[1] - loc2[1]\n return math.atan2(del_x,del_y)\n\n cosine_map = {}\n for i in range(len(points)):\n for j in range(len(points)):\n if i != j:\n angle = str(get_angle(points[i],points[j]))\n key = tuple(points[i])\n if key in cosine_map:\n # print(key,points[j],angle,cosine_map[key].get(angle,[]))\n cosine_map[key][angle] = cosine_map[key].get(angle,[]) + [points[j]]\n else:\n cosine_map[key] = {angle:[points[j]]}\n\n # print(cosine_map)\n max_length = 0\n for p1 in cosine_map:\n for p2 in cosine_map[p1]:\n max_length = max(max_length,len(cosine_map[p1][p2]))\n\n return max_length + 1\n ","memory":"32409"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n plen = len(points)\n\n lines = dict()\n\n maxp = 1\n\n for i, p1 in enumerate(points[:-1]):\n x1, y1 = p1[0], p1[1]\n for j in range(i+1, plen):\n p2 = points[j]\n x2, y2 = p2[0], p2[1]\n\n # Get the slope and intercept tuple\n c = ((x2*y1) - (x1*y2)) / (x2 - x1) if x1 != x2 else x1\n m = (y2-y1) / (x2-x1) if x1 != x2 else 9999999999\n cline = (m,c)\n # print(cline, lines)\n if cline not in lines.keys():\n lines[cline] = [2, [p1, p2]]\n else: \n if p1 not in lines[cline][1]: \n lines[cline][1].append(p1)\n if p2 not in lines[cline][1]: \n lines[cline][1].append(p2)\n\n lines[cline][0] = len(lines[cline][1])\n\n if lines[cline][0] > maxp:\n maxp = lines[cline][0]\n\n # print(lines)\n return maxp\n \n\n \n ","memory":"32718"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n if n == 1:\n return 1\n elif n == 2:\n return 2\n ans = 2\n # Get the points with same x value, since they cannot get K\n x_freq = {}\n for p in points:\n (x, y) = p\n if x not in x_freq:\n x_freq[x] = 1\n else:\n x_freq[x] += 1\n ans = max(ans, x_freq[x])\n k_freq = {}\n for i in range(n):\n x1, y1 = points[i]\n for j in range(i+1, n):\n x2, y2 = points[j]\n if x2 != x1:\n k = (y2 - y1) / (x2 - x1)\n b = y2 - k * x2\n id = f\"{k}#{b}\"\n if id not in k_freq:\n k_freq[id] = set([x1, x2])\n else:\n k_freq[id].add(x1)\n k_freq[id].add(x2)\n ans = max(ans, len(k_freq[id]))\n return ans\n ","memory":"32718"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n d={}\n for i in range(len(points)):\n for j in points[i+1:]:\n xd=points[i][0]-j[0]\n yd=points[i][1]-j[1]\n if not xd:\n slope=\"inf\"\n c=j[0]\n else:\n slope=yd/xd\n c=j[1]-slope*j[0]\n if (slope,c) not in d.keys():\n d[(slope,c)]=[2,[points[i],j]]\n else:\n if points[i] not in d[(slope,c)][1]:\n d[(slope,c)][1].append(points[i])\n d[(slope,c)][0]+=1\n if j not in d[(slope,c)][1]:\n d[(slope,c)][1].append(j)\n d[(slope,c)][0]+=1\n for i in d.keys():\n print(i,d[i])\n if not d:\n return 1\n return max([i[0] for i in d.values()])","memory":"33026"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n lines = {}\n for i in range(n):\n for j in range(i + 1, n):\n if points[i][0] == points[j][0]:\n idx = f\"1,0,{-points[i][0]}\"\n elif points[i][1] == points[j][1]:\n idx = f\"0,1,{-points[i][1]}\"\n else:\n x1, y1 = points[i]\n x2, y2 = points[j]\n idx = f\"{(y2 - y1) / (x2 - x1)},-1,{(y1 * x2 - y2 * x1) / (x2 - x1)}\"\n if idx in lines:\n lines[idx].add(i)\n lines[idx].add(j)\n else:\n lines[idx] = set([i, j])\n ans = 1\n for k, v in lines.items():\n ans = max(ans, len(v))\n return ans","memory":"33026"},{"code":"from collections import defaultdict\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n def gcd(a, b):\n return a if b == 0 else gcd(b, a % b)\n\n d = defaultdict(int)\n n = len(points)\n for i in range(n):\n pt1 = points[i]\n for j in range(n):\n if i == j:\n continue\n pt2 = points[j]\n p, q = pt1[0] - pt2[0], pt1[1] - pt2[1]\n g = gcd(abs(p), abs(q))\n p //= g\n q //= g\n d[(pt1[0], pt1[1], p, q)] += 1\n if len(d) == 0:\n return 1\n return max(d.values()) + 1\n","memory":"33335"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # each edge can be mapped to a pair (a, b)\n # where a=slope, b=bias of the unique line containing edge\n from collections import defaultdict\n import fractions\n from itertools import combinations\n \n lines = defaultdict(int)\n vert_lines = defaultdict(int)\n \n for p1, p2 in combinations(points, 2):\n x1, y1 = p1\n x2, y2 = p2\n\n if x1 == x2:\n vert_lines[x1] += 1\n else:\n a = fractions.Fraction(y2 - y1, x2 - x1)\n b = y2 - x2 * a\n lines[a, b] += 1\n\n # if line contains n points\n # lines[a,b] = (n choose 2)\n # how to extract n?\n # x = n*(n-1) / 2\n # 2x = n*(n-1)\n # 2x = n^2 - n\n # 0 = n^2 - n - 2x\n # delta = 1 + 8x\n # n = (1 + sqrt(delta) / 2)\n\n import math\n\n def comb_to_n(combs):\n delta = 1 + 8*combs\n n = (1 + math.sqrt(delta)) / 2\n n = int(n)\n return n\n\n m = 1\n for v in vert_lines.values():\n v = comb_to_n(v)\n if v > m:\n m = v\n\n for (a, b), v in lines.items():\n v = comb_to_n(v)\n if v > m:\n m = v\n\n print(lines)\n print(vert_lines)\n\n return m","memory":"33335"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n cache = {}\n for index in range(len(points)):\n for pairindex in range(index+1,len(points)):\n x1,y1 = points[index]\n x2,y2 = points[pairindex]\n if x2 >x1:\n grad = (y2-y1)/(x2-x1)\n intercept = y2-grad*x2\n if x2 < x1:\n grad = (y1-y2)/(x1-x2)\n intercept = y2-grad*x2\n if x2 == x1:\n grad = None\n intercept = x2\n key = str(grad) + \",\" +str(intercept)\n if key not in cache:\n cache[key] = [[x1,y1],[x2,y2]]\n else:\n if [x1,y1] not in cache[key]:\n cache[key].append([x1,y1])\n if [x2,y2] not in cache[key]:\n cache[key].append([x2,y2])\n\n max_val = 1\n for key in cache.keys():\n if len(cache[key]) > max_val:\n max_val = len(cache[key])\n return max_val","memory":"33644"},{"code":"# 2:07pm\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # Thoughts:\n # - In order for a point to be on the same line, they must have a matching slope\n # Meaning p1 = p2 + x(slope)\n # - There are a lot of possible slopes\n # - So brute force solution:\n # - Calculate all slopes between each 2 points\n # - Try applying those slopes to all the relevant points, and count the number of items that match\n # Edgecases:\n # - Slope is not an integer\n # - Can points not be integers?: NO\n # - Dont' want to accidentally calculate the opposite slope by iterating backwards\n # \n # Approach 1:\n # Sort the points by x coord (so we don't get opposite slopes) O(nlogn)\n # Iterate all combination of points with later points to calc possible slopes at each point O(n^2)\n # Combine slopes with points and compare (use % operation) Iterate over each obtained slope once, then apply it to all points, so O(n^3)\n # How do I reduce slopes?\n # Approach 2:\n # Is there a faster/cleaner way to calculate all possible slopes?\n # What if I tried applying the operations out of order?\n # Take the mod of all x's from 1-max(x)\n # Take the mod of all y's from 1-max(y)\n # Try to match them up?\n # That sounds interesting. Let's write out some pseudocode\n # Approach 3: Saw in someone's solution\n # Create a line from every combination of 2 data points. \n # Convert line to y-intercept form\n # Line that is created the most often is the answer\n count = {}\n visited = {}\n maxCount = 0\n if not points:\n return 0\n \n if len(points) == 1:\n return 1\n\n points.sort(key=lambda a: a[0]) # Sort by ascending x value\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n x1, y1 = points[i]\n x2, y2 = points[j]\n if x2 == x1:\n slope = 'inf'\n yInt = x1 # No y-intercept. So put x-int instead\n else:\n slope = (y2-y1)/(x2-x1)\n yInt = y1 - x1*slope\n if slope not in count:\n count[slope] = {}\n\n if slope not in visited:\n visited[slope] = {}\n # Only concern here is how sloppy python is with floats.\n # I don't know if using floats as keys is a good idea.\n \n # If the start and endpoint have both had this slope before, don't count them again\n if i not in visited[slope] or j not in visited[slope]:\n count[slope][yInt] = count[slope].get(yInt, 1) + 1\n maxCount = max(maxCount, count[slope][yInt]) \n visited[slope][i] = True\n visited[slope][j] = True\n\n return maxCount\n\n\n","memory":"33953"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n \n x = {}\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n k, b = self.line(points[i], points[j])\n if k not in x:\n x[k] = {}\n \n if b not in x[k]:\n x[k][b] = [i, j]\n else:\n temp = x[k][b]\n if i not in temp:\n temp.append(i)\n if j not in temp:\n temp.append(j) \n x[k][b] = temp\n \n print(x)\n maxl = 1\n for k in x:\n for b in x[k]:\n maxl = max(maxl, len(x[k][b]))\n return maxl\n \n def line(self, a, b):\n if a[1] == b[1]:\n return 'NA', a[1]\n if a[0] == b[0]:\n return a[0], 'NA'\n k = (b[1] - a[1])/(b[0] - a[0])\n return k, a[1] - k * a[0]\n ","memory":"33953"},{"code":"import collections\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n points = sorted(points, key=lambda v:v[0] * 10001 + v[1])\n if len(points) < 2:\n return len(points)\n primes = list(range(201))\n for i in range(2, len(primes)):\n p = primes[i]\n if not p:\n continue\n for j in range(2*p, len(primes), p):\n primes[j] = 0\n primes = [v for v in primes if v > 1]\n\n N = len(points)\n slopes = collections.defaultdict(set)\n for s in range(N):\n xs, ys = points[s]\n for e in range(s + 1, N):\n xe, ye = points[e]\n lx, ly = xe - xs, ye - ys\n if lx == 0:\n ly = abs(ly)\n if ly == 0:\n lx = abs(lx)\n for p in primes:\n while lx % p == 0 and ly % p == 0:\n lx, ly = lx // p, ly // p\n key = (lx, ly, xs, ys)\n slopes[key] |= {s, e}\n return max(len(v) for v in slopes.values())","memory":"34261"},{"code":"import collections\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n points = sorted(points, key=lambda v:v[0] * 10001 + v[1])\n if len(points) < 2:\n return len(points)\n primes = list(range(201))\n for i in range(2, len(primes)):\n p = primes[i]\n if not p:\n continue\n for j in range(2*p, len(primes), p):\n primes[j] = 0\n primes = [v for v in primes if v > 1]\n\n N = len(points)\n slopes = collections.defaultdict(set)\n for s in range(N):\n xs, ys = points[s]\n for e in range(s + 1, N):\n xe, ye = points[e]\n lx, ly = xe - xs, ye - ys\n if lx == 0:\n ly = abs(ly)\n if ly == 0:\n lx = abs(lx)\n for p in primes:\n while lx % p == 0 and ly % p == 0:\n lx, ly = lx // p, ly // p\n key = (lx, ly, xs, ys)\n slopes[key] |= {s, e}\n return max(len(v) for v in slopes.values())","memory":"34261"},{"code":"\nclass Solution:\n def maxPoints(self, points) -> int:\n if(len(points) < 2):\n return len(points)\n\n m_map = {}\n\n for i in range(len(points)-1):\n p2 = points[i+1]\n j_to_skip = {}\n for j in range(i+1):\n p1 = points[j]\n m = self.calcGradient(p1, p2)\n \n if j in j_to_skip:\n continue\n \n if (m, j) not in m_map:\n m_map[(m, j)] = {j, i+1}\n else:\n m_map[(m, j)] = m_map[(m, j)].union({i+1})\n\n j_to_skip = m_map[(m, j)].union(j_to_skip)\n \n return self.getMaxPoint(m_map)\n\n def getMaxPoint(self, m_map) -> int:\n max_val = -1\n\n for val in m_map.values():\n # total_points = max(len(list_point) for list_point in val)\n total_points = len(val)\n if total_points > max_val:\n max_val = total_points\n\n return max_val\n\n def calcGradient(self, p1, p2):\n x1, y1 = p1\n x2, y2 = p2\n try:\n m = (y2-y1)/(x2-x1)\n except:\n m = 999999\n return m\n","memory":"34570"},{"code":"\nclass Solution:\n def maxPoints(self, points) -> int:\n if(len(points) < 2):\n return len(points)\n\n m_map = {}\n\n for i in range(len(points)-1):\n p2 = points[i+1]\n # j_to_skip = {}\n for j in range(i+1):\n p1 = points[j]\n m = self.calcGradient(p1, p2)\n \n # if j in j_to_skip:\n # continue\n \n if (m, j) not in m_map:\n m_map[(m, j)] = {j, i+1}\n else:\n m_map[(m, j)] = m_map[(m, j)].union({i+1})\n\n # j_to_skip = m_map[(m, j)].union(j_to_skip)\n \n return self.getMaxPoint(m_map)\n\n def getMaxPoint(self, m_map) -> int:\n max_val = -1\n\n for val in m_map.values():\n # total_points = max(len(list_point) for list_point in val)\n total_points = len(val)\n if total_points > max_val:\n max_val = total_points\n\n return max_val\n\n def calcGradient(self, p1, p2):\n x1, y1 = p1\n x2, y2 = p2\n try:\n m = (y2-y1)/(x2-x1)\n except:\n m = 999999\n return m\n","memory":"34570"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n if len(points) <= 1:\n return len(points)\n\n points = sorted(points)\n\n slopeIntercept = {}\n\n i = 0\n while i < len(points):\n j = i + 1\n while j < len(points):\n currSlope = float('inf')\n if (points[j][0] - points[i][0]) != 0:\n currSlope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0])\n \n intercept = points[j][0]\n if currSlope != float('inf'):\n intercept = points[j][1] - (currSlope * points[j][0])\n \n intercept = round(intercept, 2)\n \n \n\n if (currSlope, intercept) not in slopeIntercept:\n slopeIntercept[(currSlope, intercept)] = [(points[i][0], points[i][1]), (points[j][0], points[j][1])]\n else:\n slopeIntercept[(currSlope, intercept)].append((points[j][0], points[j][1]))\n j += 1\n i += 1\n \n currMax = 0\n for key in slopeIntercept:\n currSet = slopeIntercept[key]\n currSet = set(currSet)\n currMax = max(currMax, len(currSet))\n\n return currMax\n\n\n ","memory":"34879"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n L = defaultdict(set)\n def line(points, i, j):\n x0, y0 = points[i]\n x1, y1 = points[j]\n a , b = y1 - y0, x0 - x1\n c = x0 * a + y0 * b\n d = gcd(gcd(a, b), c)\n a, b, c = a // d, b // d, c // d\n if c < 0:\n a, b, c=-a, -b, -c\n elif c==0:# This can occur!\n if b<0 or (a<0 and b==0): \n a=-a \n b=-b\n line_key = (a, b, c)\n L[line_key].add(i)\n L[line_key].add(j)\n\n n = len(points)\n if n == 1:\n return 1 # edge case\n\n for i in range(n - 1):\n for j in range(i + 1, n):\n line(points, i, j)\n\n max_points_on_line = 0\n\n for _, point_set in L.items():\n max_points_on_line = max(max_points_on_line, len(point_set))\n\n return max_points_on_line","memory":"35188"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n points = list(map(tuple, points))\n n = len(points)\n d = collections.defaultdict(set)\n for i in range(n-1):\n for j in range(i+1,n):\n x = points[j][0]-points[i][0]\n y = points[j][1]-points[i][1]\n if x == 0:\n line = points[i][0]\n else:\n k =y/x\n b = points[i][1] - points[i][0]*k\n line = k,b\n d[line].add(points[i])\n d[line].add(points[j])\n res = 1\n for i in d:\n res = max(res, len(d[i]))\n\n return res","memory":"35496"},{"code":"# Hard problem. Max Points on a Line.\n# Given an array of points where points[i] = [x, y]\n# Return the maximum number of points on the same straight line\n\n# Ok, let's remember from algebra,\n# the equation of a line is:\n# y = m * x + b\n# And given two points, we can find a line between them\n\n# We notice that a point can either be on the maximum line\n# or not on the maximum line\n\n# the maximum line is the line that has the most points on it\n\n# The minimum answer is going to be 1 if points.length == 1\n# and 2 is points.length == 2\n# If the max len is 3 and points.length is 3, then all points\n# are on the same line\n\n# It might take some work to code up the function verifying\n# If a point is on line A, but it won't be that hard, I\n# was good at algebra\n\n# We have up to 300 points\n# 300^2 is a reasonable solution\n# 300^3 == 300 * 90000 == 27000000\n# which is even doable\n# One point will have up to 300 lines\n# Why don't we enumerate every line, check whether other points are on that line\n# and count for that line?\n# If there an easy way to tell if a point is on the line?\n# All we have of a point is its x and y position\n# Maybe if we plug x and y into the equation of the line,\n# and we get an equality, the point is on our line\n# I think I know what to do\n# Create every line from each point to each other point\n# check all points if they are on that line\n# bam\n\n# Maybe we could use a set of lines so that we don't\n# have to recheck\nclass Solution:\n def maxPoints(self, points: list[list[int]]) -> int:\n if len(points) <= 2: return len(points)\n def defval():\n return []\n line_set = defaultdict(defval)\n \n for i in range(len(points)):\n x1, y1 = points[i]\n #print(\"starting: {}, {}\".format(x1, y1))\n for j in range(i + 1, len(points)):\n x2, y2 = points[j]\n \n if x1 == x2:\n m = float('inf')\n b = x1\n else:\n m = (y2 - y1) / (x2 - x1)\n b = y1 - (m * x1)\n \n #print(x2, y2, m, b)\n intersects = line_set[(m,b)]\n if (x1, y1) not in intersects:\n intersects.append((x1, y1))\n if (x2, y2) not in intersects:\n intersects.append((x2, y2))\n \n #print(\"lines:\")\n max_points = 0\n for line in line_set:\n max_points = max(max_points, len(line_set[line]))\n #print(line, line_set[line])\n return max_points","memory":"35496"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n n = len(points)\n if n == 1:\n return 1\n \n def get_line(x1, y1, x2, y2):\n if x2 - x1 == 0:\n return ('None', x1)\n m = (y2 - y1) / (x2 - x1)\n b = y1 - m * x1\n return (m, b)\n \n \n line_map = defaultdict(set)\n for i in range(n):\n for j in range(i + 1, n):\n line_eq = get_line(points[i][0], points[i][1], points[j][0], points[j][1])\n line_map[line_eq].add(i)\n line_map[line_eq].add(j)\n \n return max([len(line_map[key]) for key in line_map])","memory":"35805"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n equation_point_count = {}\n max_points = 0\n n = len(points)\n\n if n==1: \n return 1\n \n for i in range(n):\n x1, y1 = points[i]\n for j in range(i+1, n):\n x2, y2 = points[j]\n if x2-x1==0:\n m = float(\"inf\")\n c = x1\n else:\n m = (y2-y1)/(x2-x1) \n c = y1-m*x1\n\n if (m,c) not in equation_point_count:\n equation_point_count[(m,c)] = set()\n\n equation_point_count[(m,c)].add(i)\n equation_point_count[(m,c)].add(j)\n max_points = max(max_points, len(equation_point_count[(m,c)]))\n\n return max_points\n ","memory":"35805"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n import math\n\n if len(points) < 2:\n return 1\n\n def slope(p1, p2):\n if (p2[0] - p1[0]) == 0:\n return \"inf\"\n return ((p2[1] - p1[1]) / (p2[0] - p1[0]))\n\n all = {}\n\n for curr in points:\n for comp in points:\n if comp == curr:\n continue\n slp = slope(curr, comp)\n if slp == \"inf\":\n eq = (curr[0], slope(curr, comp))\n else:\n eq = (round(curr[1] - slope(curr, comp) * curr[0], 5), slope(curr, comp))\n if eq not in all:\n all[eq] = [(curr, comp)]\n else:\n all[eq].append((curr, comp))\n\n maxiVal = float(\"-inf\")\n\n for key, val in all.items():\n if len(val) > maxiVal:\n maxiVal = len(val)\n return (int((1 + math.sqrt(1 + 4 * maxiVal)) / 2))\n\n","memory":"36114"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n #calculate sllope y = mx + b b = y-mx\n m = {}\n for i in range(len(points)):\n one = points[i]\n for j in range(i, len(points)):\n if j == i:\n continue\n else:\n two = points[j]\n if (one[1] == two[1]):\n slope = 0\n b = one[1]\n elif (one[0] == two[0]):\n slope = \"undefined\"\n b = one[0]\n else:\n slope = (one[1] - two[1])/(one[0] - two[0])\n b = one[1] - (one[0]*slope)\n if (slope, b) not in m:\n m[(slope, b)] = []\n if one not in m[(slope, b)]:\n m[(slope, b)].append(one) \n if two not in m[(slope, b)]:\n m[(slope, b)].append(two)\n c = [len(v) for v in m.values()]\n print(m)\n if not c:\n return 1\n return max(c)\n \n\n\n\n \n ","memory":"36114"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # all points in the group have same slope ratio with all others\n m = {} # slope - [points_set1, points_set2]\n ret = 1\n # ratio_op = lambda x1,x2:(x1[0]-x2[0])/(x1[1]-x2[1])\n def ratio_op(x1,x2):\n if x1[1]==x2[1]:\n return 1<<32\n return (x1[0]-x2[0])/(x1[1]-x2[1])\n\n for i in range(len(points)-1):\n pt1 = points[i]\n for j in range(i+1,len(points)):\n pt2 = points[j]\n ratio = ratio_op(pt1,pt2)\n m[ratio] = m.get(ratio, [])\n new_set = True\n for set_s in m[ratio]:\n if tuple(pt1) in set_s or tuple(pt2) in set_s or \\\n any([ratio_op(pt1,p) == ratio for p in set_s]):\n # add to this set\n set_s.add(tuple(pt1))\n set_s.add(tuple(pt2))\n new_set = False\n ret = max(ret, len(set_s))\n break\n if new_set:\n m[ratio].append(set([tuple(pt1), tuple(pt2)]))\n ret = max(ret, 2)\n return ret\n \n ","memory":"36423"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points)<2:\n return len(points)\n cache = {}\n op = 0\n for p1id in range(len(points)):\n for p2id in range(p1id+1,len(points)):\n if points[p2id][1] == points[p1id][1]:\n d1 = cache.get((p1id,float(\"inf\")),set())\n d1.add(p1id)\n d1.add(p2id)\n cache[(p1id,float(\"inf\"))] = d1\n if len(d1) > op:\n op = len(d1)\n else:\n m1 = (points[p2id][0] - points[p1id][0])/(points[p2id][1] - points[p1id][1])\n d1 = cache.get((p1id,m1),set())\n d1.add(p1id)\n d1.add(p2id)\n cache[(p1id,m1)] = d1\n if len(d1) > op:\n op = len(d1)\n print(cache)\n return op","memory":"36731"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # find all pairwise lines\n # start with arbitrary unpaired point and another point\n # grow the line\n # remove need for pairwise compute for grown line\n\n if len(points) == 1:\n return 1\n\n for i in range(len(points)):\n points[i] = tuple(points[i])\n\n def get_line_params(p1, p2):\n if p1[0] == p2[0]:\n m = float('inf')\n yi = None\n xi = p1[0]\n elif p1[1] == p2[1]:\n m = 0\n yi = p1[1]\n xi = None\n else:\n m = (p1[1] - p2[1]) / (p1[0] - p2[0]) # slope\n yi = p1[1] - m * p1[0] # y-intercept\n xi = -yi / m # x-intercept\n return m, yi, xi\n\n lines = {}\n\n for i in range(len(points) - 1):\n for j in range(i + 1, len(points)):\n if i != j:\n p1, p2 = points[i], points[j]\n m, yi, xi = get_line_params(p1, p2)\n if (m, yi, xi) in lines:\n lines[(m, yi, xi)].add(p1)\n lines[(m, yi, xi)].add(p2)\n else:\n lines[(m, yi, xi)] = {p1, p2}\n\n return max(len(v) for v in lines.values())\n ","memory":"36731"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n # find all pairwise lines\n # start with arbitrary unpaired point and another point\n # grow the line\n # remove need for pairwise compute for grown line\n\n if len(points) == 1:\n return 1\n\n for i in range(len(points)):\n points[i] = tuple(points[i])\n\n def get_line_params(p1, p2):\n if p1[0] == p2[0]:\n m = float('inf')\n yi = None\n xi = p1[0]\n elif p1[1] == p2[1]:\n m = 0\n yi = p1[1]\n xi = None\n else:\n m = (p1[1] - p2[1]) / (p1[0] - p2[0]) # slope\n yi = p1[1] - m * p1[0] # y-intercept\n xi = -yi / m # x-intercept\n return m, yi, xi\n\n lines = {}\n\n for i in range(len(points) - 1):\n for j in range(i + 1, len(points)):\n if i != j:\n p1, p2 = points[i], points[j]\n m, yi, xi = get_line_params(p1, p2)\n if (m, yi, xi) in lines:\n lines[(m, yi, xi)].add(p1)\n lines[(m, yi, xi)].add(p2)\n else:\n lines[(m, yi, xi)] = {p1, p2}\n\n return max(len(v) for v in lines.values())\n ","memory":"37040"},{"code":"from math import inf\nimport pprint\n\ndef slope_xint_yint(p1, p2):\n if p1[0] == p2[0]:\n return inf, p1[0], None\n res = (p2[1] - p1[1]) / (p2[0] - p1[0])\n y_int = p1[1] - res * p1[0]\n if p1[1] == p2[1]:\n x_int = None\n else:\n x_int = -y_int / res\n return res, x_int, y_int\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) == 1:\n return 1\n if len(points) == 2:\n return 2\n\n max_points = 0\n\n slopes = dict()\n for i in range(len(points) - 1):\n p1 = points[i]\n\n for j in range(i + 1, len(points)):\n tup = slope_xint_yint(p1, points[j])\n\n if tup in slopes:\n slopes[tup].add(i)\n slopes[tup].add(j)\n max_points = max(max_points, len(slopes[tup]))\n else:\n slopes[tup] = set([i, j])\n max_points = max(max_points, 2)\n\n return max_points\n","memory":"37040"},{"code":"class Solution:\n def commonDivisor(self, x: int, y: int) -> int:\n if x < 0:\n x = -x\n if y < 0:\n y = -y\n if x < y:\n x, y = y, x\n while y > 0:\n x, y = y, x % y\n return x\n\n def maxPoints(self, points: List[List[int]]) -> int:\n\n # (x-x0)(y1-y0) == (x1-x0)(y-y0)\n # x y1 + x0 y0 - x0 y1 - x y0 == x1 y + x0 y0 - x1 y0 - x0 y\n # x (y1 - y0) - x0 (y1 - y0) == y (x1 - x0) - y0 (x1 - x0)\n # Hash key = (x1 - x0, y1 - y0, x0 y1 - x1 y0), value = indices\n table = {}\n for i in range(len(points)):\n for j in range(i + 1, len(points)):\n x0, y0 = points[i]\n x1, y1 = points[j]\n a = x1 - x0\n b = y1 - y0\n c = x0 * y1 - x1 * y0\n if a < 0 or (a == 0 and b < 0):\n a, b, c = -a, -b, -c\n d = self.commonDivisor(a, b)\n a, b, c = a / d, b / d, c / d\n s = table.get((a, b, c))\n if not s:\n s = set()\n table[(a, b, c)] = s\n s.add(i)\n s.add(j)\n n = 1 if points else 0\n for _, indices in table.items():\n n = max(n, len(indices))\n return n","memory":"37349"},{"code":"import operator\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n \n def slope(id1,id2):\n if id2[0]-id1[0] != 0:\n return (id2[1]-id1[1])/(id2[0]-id1[0])\n else:\n return float('inf')\n\n def ontheline(id1,id2,id3):\n if (id1[0]-id2[0])*(id1[1]-id3[1]) == (id1[0]-id3[0])*(id1[1]-id2[1]):\n return True\n else:\n return False\n\n slopemap = {}\n slope_lines = []\n for iid1 in range(len(points)-1):\n for iid2 in range(iid1+1,len(points),1):\n id1 = tuple(points[iid1])\n id2 = tuple(points[iid2])\n s12 = slope(id1,id2)\n if s12 not in slopemap:\n slopemap[s12] = len(slope_lines)\n slope_lines.append([{id1,id2},])\n else:\n flag = False\n j = slopemap[s12]\n lines = slope_lines[j]\n for l in range(len(lines)):\n line = lines[l]\n if len(line & {id1,id2}) == 2:\n flag = True\n break\n elif len(line & {id1,id2}) == 1:\n slope_lines[j][l] = line | {id1,id2}\n # print(lines, id1, id2)\n flag = True\n break\n else:\n id3 = next(iter(line))\n if ontheline(id1,id2,id3):\n slope_lines[j][l]= line | {id1,id2} \n # print(lines, id1, id2, id3)\n flag = True\n break\n if flag is False:\n slope_lines[j].append({id1,id2})\n # print(lines, id1, id2)\n maxcnt = 1\n for lines in slope_lines:\n for line in lines:\n maxcnt = max(len(line),maxcnt)\n return maxcnt \n\n","memory":"37349"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points) <= 1:\n return len(points)\n \n slope_counter = defaultdict(set)\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n x1, y1 = points[i]\n x2, y2 = points[j]\n if x1 == x2:\n key = f\"x-{x1}\"\n slope_counter[key].add(y1)\n slope_counter[key].add(y2)\n elif y1 == y2:\n key = f\"y-{y1}\"\n slope_counter[key].add(x1)\n slope_counter[key].add(x2)\n else:\n slope = (y2 - y1) / float(x2 - x1)\n intercept = y1 - slope * x1\n key = f\"{slope:.8f}-{intercept:.8f}\"\n slope_counter[key].add((x1, y1))\n slope_counter[key].add((x2, y2))\n \n max_points = 0\n for key, value in slope_counter.items():\n max_points = max(max_points, len(value))\n \n return max_points","memory":"37658"},{"code":"from collections import defaultdict\n\nclass Solution:\n # map every pair of points by 'm,b' for y=mx+b\n # find the m,b key with the most segments in it, then return number of distinct points in it \n # n^2 \n def maxPoints(self, points: List[List[int]]) -> int:\n pointToEq = defaultdict(lambda:set())\n maxNum = 1\n for i in range(len(points)):\n for j in range(i+1, len(points)):\n p1 = points[i]\n p2 = points[j]\n # y = mx + b\n # m = y/x\n yDiff = p1[1] - p2[1]\n xDiff = p1[0] - p2[0]\n if xDiff == 0:\n m = \"vertical\"\n b = p1[0]\n else:\n mFloat = yDiff / xDiff\n m = \"{:.9f}\".format(mFloat)\n # y = mx + b\n # b = y - mx\n bFloat = p1[1] - mFloat * p1[0]\n b = \"{:.9f}\".format(bFloat)\n key = f\"{m},{b}\"\n pointToEq[key].add(f\"{p1[0]},{p1[1]}\")\n pointToEq[key].add(f\"{p2[0]},{p2[1]}\")\n maxNum = max(maxNum, len(pointToEq[key]))\n return maxNum","memory":"37658"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n from collections import defaultdict\n\n if len(points)==1:\n return 1\n\n counter = defaultdict(set)\n n = len(points)\n \n # Initialize a 2D list (list of lists) to store (slope, intercept) tuples\n result = [[None] * n for _ in range(n)]\n \n for i in range(n):\n for j in range(i):\n x1, y1 = points[i]\n x2, y2 = points[j]\n \n if x1 == x2:\n slope = None # Infinite slope\n intercept = None # Intercept is undefined\n x_intercept = x1 # x-intercept is the x-coordinate of the line\n else:\n # Calculate slope (m)\n slope = (y2 - y1) / (x2 - x1)\n # Calculate y-intercept (c)\n intercept = y1 - slope * x1\n # Calculate x-intercept (-c/m) if slope is not zero\n x_intercept = -intercept / slope if slope != 0 else None\n \n # Store the result as a tuple (slope, y_intercept, x_intercept)\n result[i][j] = (slope, intercept, x_intercept)\n\n for i in range(n):\n for j in range(i):\n counter[result[i][j]].update({i,j})\n\n counter = max([len(v) for v in counter.values()])\n\n return counter","memory":"37966"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n from collections import defaultdict\n\n if len(points)==1:\n return 1\n\n counter = defaultdict(set)\n n = len(points)\n \n # Initialize a 2D list (list of lists) to store (slope, intercept) tuples\n result = [[None] * n for _ in range(n)]\n \n for i in range(n):\n for j in range(i):\n x1, y1 = points[i]\n x2, y2 = points[j]\n \n if x1 == x2:\n slope = float('inf') # Infinite slope\n intercept = None # Intercept is undefined\n x_intercept = x1 # x-intercept is the x-coordinate of the line\n else:\n # Calculate slope (m)\n slope = (y2 - y1) / (x2 - x1)\n # Calculate y-intercept (c)\n intercept = y1 - slope * x1\n # Calculate x-intercept (-c/m) if slope is not zero\n x_intercept = -intercept / slope if slope != 0 else None\n \n # Store the result as a tuple (slope, y_intercept, x_intercept)\n result[i][j] = (slope, intercept, x_intercept)\n\n for i in range(n):\n for j in range(i):\n counter[result[i][j]].update({i,j})\n\n # print(counter)\n counter = max([len(v) for v in counter.values()])\n\n return counter","memory":"37966"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n plen = len(points)\n\n lines = dict()\n\n maxp = 1\n\n for i, p1 in enumerate(points[:-1]):\n x1, y1 = p1[0], p1[1]\n for j in range(i+1, plen):\n p2 = points[j]\n x2, y2 = p2[0], p2[1]\n\n # Get the slope and intercept tuple\n c = ((x2*y1) - (x1*y2)) / (x2 - x1) if x1 != x2 else x1\n m = (y2-y1) / (x2-x1) if x1 != x2 else 9999999999\n cline = (m,c)\n # print(cline, lines)\n if cline not in lines.keys():\n lines[cline] = [2, [p1, p2]]\n else: \n if p1 not in lines[cline][1]: \n lines[cline][1].append(p1)\n if p2 not in lines[cline][1]: \n lines[cline][1].append(p2)\n\n lines[cline][0] = len(lines[cline][1])\n\n if lines[cline][0] > maxp:\n maxp = lines[cline][0]\n\n print(lines)\n return maxp\n \n\n \n ","memory":"38893"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n #Lines characterized by slope and intercept (unless vertical)\n\n ##For each line, compute the slope and intercept\n\n def findLine(point1,point2):\n\n ##vertical line; handle later\n if point1[0] == point2[0]:\n return (float('inf'),float('inf'))\n \n m = (point1[1] - point2[1])/(point1[0]-point2[0])\n b = point1[1] - m*point1[0]\n return (m,b)\n \n lines = {}\n seen_values = {}\n\n for i in range(len(points)):\n for j in range(i+1,len(points)):\n\n (m,b) = findLine(points[i],points[j])\n\n if (m,b) != (float('inf'),float('inf')):\n if (m,b) not in lines:\n lines[(m,b)] = 0\n if (m,b,points[i][0],points[i][1]) not in seen_values:\n seen_values[ (m,b,points[i][0],points[i][1] ) ] = 0\n lines[(m,b)] += 1\n if (m,b,points[j][0],points[j][1]) not in seen_values:\n seen_values[ (m,b,points[j][0],points[j][1] ) ] = 0\n lines[(m,b)] += 1\n \n ##vertical lines\n vertical_line = {}\n ans = 0\n\n for point in points:\n \n if point[0] not in vertical_line:\n vertical_line[point[0]] = 0\n \n vertical_line[point[0]] += 1\n ans = max(ans,vertical_line[point[0]])\n\n for key in lines:\n ans = max(ans,lines[key])\n \n return ans\n\n\n \n\n\n \n ","memory":"38893"},{"code":"import numpy as np\n\ndef get_line(p1, p2):\n x1, y1 = p1\n x2, y2 = p2\n if x1 == x2:\n return (np.inf, x1)\n else:\n m = (y2 - y1) / (x2 - x1)\n b = y1 - m * x1\n return (round(m, 10), round(b, 10))\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n lines = {}\n n = len(points)\n if n <= 2:\n return n\n for i in range(n):\n for j in range(i):\n point1 = points[i]\n point2 = points[j]\n line = get_line(point1, point2)\n if line in lines:\n lines[line] += 1\n else:\n lines[line] = 1\n most_frequent_line = None\n highest_count = 0\n for line in lines:\n if lines[line] > highest_count:\n highest_count = lines[line]\n most_frequent_line = line\n m, b = most_frequent_line\n print(lines)\n if m == np.inf:\n return len([p for p in points if np.abs(p[0] - b) < 1e-6])\n else:\n return len([p for p in points if np.abs(m * p[0] + b - p[1]) < 1e-6])\n","memory":"39201"},{"code":"import collections\nfrom typing import *\nfrom fractions import Fraction\nfrom pprint import pp\n\nPoint = Tuple #[int, int]\nInfSlopeT = float\nInfSlope = InfSlopeT(float('inf'))\nLine = Tuple[Union[Fraction,InfSlopeT], Fraction] # (m, c) for a line y = mx + c\n\ndef line(a: Point, b: Point) -> Line:\n if b[0] == a[0]:\n return (InfSlope, Fraction(a[0]))\n\n m = Fraction(b[1] - a[1], b[0] - a[0])\n c = Fraction(a[1] * b[0] - a[0] * b[1], b[0] - a[0])\n return (m, c)\n\n\ndef find(points):\n l = len(points)\n groups = collections.defaultdict(set)\n for idx, a in enumerate(points):\n a = tuple(a)\n for offset in range(1, l - idx):\n b = tuple(points[idx + offset])\n lineab = line(a, b)\n groups[lineab].add(idx)\n groups[lineab].add(idx + offset)\n \n #pp(groups)\n if len(points) <= 1:\n return len(points)\n return len(max(groups.items(), key=lambda i: len(i[1]))[1])\n\n\n\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n return find(points)","memory":"39201"},{"code":"from collections import defaultdict\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n p = []\n mp = defaultdict(set)\n for l in points:\n (x, y) = tuple(l) \n p.append((x,y))\n\n for i, (x, y) in enumerate(p):\n for j, (jx, jy) in enumerate(p):\n if i == j:\n continue\n if x - jx == 0:\n mp[(2**64+7, x)].add(i)\n mp[(2**64+7, x)].add(j)\n else:\n sl = (y-jy)/(x - jx)\n mv = y-(sl*x)\n mp[(sl, mv)].add(i)\n mp[(sl, mv)].add(j)\n # print(i, j, sl, mv)\n mx = 1\n # print(mp.items())\n for i in mp.values():\n mx = max(mx, len(i)) \n return mx","memory":"39510"},{"code":"def calc_sign(v: tuple[int, ...]) -> int:\n if v[0] > 0:\n return 1\n if v[0] < 0:\n return -1\n return calc_sign(v[1:])\n\n\ndef calc_gcd(v: list[int]) -> int:\n \"\"\"\n v[0] > v[1] > ... > v[-1] > 0\n \"\"\"\n if len(v) == 1:\n return v[0]\n r = v[0] % v[-1]\n if r == 0:\n return calc_gcd(v[1:])\n return calc_gcd(v[1:] + [r])\n\n\ndef coprimize(v: tuple[int, ...]) -> tuple[int, ...]:\n sign = calc_sign(v)\n gcd = calc_gcd([x for x in sorted(map(abs, v), reverse=True) if x > 0])\n return tuple(sign * x // gcd for x in v)\n\n\nclass Solution:\n def maxPoints(self, points: list[list[int]]) -> int:\n if len(points) == 1:\n return 1\n line_to_points: dict[tuple[float, ...], set[tuple[int, int]]] = {}\n for (x1, y1), (x2, y2) in combinations(points, r=2):\n t = coprimize((x2 - x1, y2 - y1, x1 * y2 - x2 * y1))\n if t not in line_to_points:\n line_to_points[t] = set()\n line_to_points[t].add((x1, y1))\n line_to_points[t].add((x2, y2))\n return max(map(len, line_to_points.values()))","memory":"39510"},{"code":"import numpy as np\nimport math\nclass Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n record = {}\n best = 0\n directions = [[1, 0], [0, 1], [-1, 0], [0, -1], [1, 1], [-1,-1], [-1, 1], [1, -1]]\n\n for i in range(len(points)):\n record[tuple(points[i])] = {}\n current = points[i]\n #print(\"Current is: \", current)\n for j in range(i+1, len(points)):\n other = points[j]\n difference = [current[0]-other[0], current[1]-other[1]]\n # here I'll have to convert the difference to a normalised direction vector\n current_gcd = math.gcd(difference[0], difference[1])\n difference[0] = int(difference[0]/current_gcd)\n difference[1] = int(difference[1]/current_gcd)\n if difference[0]<=0 and difference[1]<=0:\n difference[0] = difference[0]*(-1)\n difference[1] = difference[1]*(-1)\n #print(\" Difference is: \", difference)\n if difference[0]>0 and difference[1]<0:\n difference[0] = difference[0]*(-1)\n difference[1] = difference[1]*(-1)\n #print(difference, current, other)\n if tuple(difference) in record[tuple(current)].keys():\n #print(\"heya\")\n record[tuple(current)][tuple(difference)].append(tuple(other))\n best = max(best, len(record[tuple(current)][tuple(difference)]))\n else :\n record[tuple(current)][tuple(difference)] = [tuple(other)]\n best = max(1, best)\n #print('\\t\\t\\t', record)\n return best+1\n\n\n\n ","memory":"39819"},{"code":"class Solution:\n def get_slope(self, pt1: List[int], pt2: List[int]) -> float:\n x1, y1 = pt1\n x2, y2 = pt2\n if x1 == x2:\n return self.inf\n else:\n return float(y2-y1)/float(x2-x1)\n \n def maxPoints(self, points: List[List[int]]) -> int:\n self.inf = 10**10\n if len(points) == 1:\n return 1\n n = len(points)\n slopes = {}\n for i in range(n):\n for j in range(i+1, n):\n x1, y1 = points[i]\n x2, y2 = points[j]\n s = self.get_slope([x1,y1], [x2,y2])\n if (s,x1,y1) not in slopes:\n slopes[s,x1,y1] = {(x1,y1), (x2,y2)}\n else:\n slopes[s,x1,y1].add((x2,y2))\n \n for i in range(n):\n pt = points[i]\n for s,x1,y1 in slopes:\n cur_s = self.get_slope([x1,y1], pt)\n if abs(cur_s-s) <= 1e-25:\n slopes[s,x1,y1].add((pt[0], pt[1]))\n \n ans = 0\n for val in slopes.values():\n ans = max(ans, len(val))\n \n return ans","memory":"39819"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n if len(points)==0:\n return 0\n if len(points)==1:\n return 1\n def gcd(a,b):\n while True:\n r = b%a\n if r==0:\n return a\n else:\n a,b = r,a\n\n mp = {}\n n = len(points)\n for i in range(n):\n for j in range(i+1,n):\n x1,y1 = points[i][0],points[i][1]\n x2,y2 = points[j][0],points[j][1]\n a = y1-y2\n b = x2-x1\n c = y1*x2-y2*x1\n # print(a,b,c)\n div = 1\n if a==0 and b==0:\n c = 1\n elif a==0 and c==0:\n b = 1\n elif c==0 and b==0:\n a = 1\n elif b==0:\n div = gcd(abs(a),abs(c))\n if a<0:\n a,b,c = -a,-b,-c\n elif c==0:\n div = gcd(abs(a),abs(b))\n if a<0:\n a,b,c = -a,-b,-c\n elif a==0:\n div = gcd(abs(b),abs(c))\n if b<0:\n a,b,c = -a,-b,-c\n else:\n div = gcd(abs(a),abs(b))\n div = gcd(div,abs(c))\n if a<0:\n a,b,c = -a,-b,-c\n a,b,c = a//div,b//div,c//div\n pl = (a,b,c)\n if pl in mp:\n if (x1,y1) not in mp[pl]:\n mp[pl][(x1,y1)] = 1\n if (x2,y2) not in mp[pl]:\n mp[pl][(x2,y2)] = 1\n else:\n mp[pl] = {}\n mp[pl][(x1,y1)] = 1\n mp[pl][(x2,y2)] = 1\n maxlen = 0\n # print(mp)\n for k in mp.keys():\n maxlen = max(maxlen,len(mp[k]))\n return maxlen\n","memory":"40128"},{"code":"\n\ndef calc_sign(v: tuple[int, ...]) -> int:\n if v[0] > 0:\n return 1\n if v[0] < 0:\n return -1\n return calc_sign(v[1:])\n\n\ndef calc_gcd(v: list[int]) -> int:\n \"\"\"\n v[0] > v[1] > ... > v[-1] > 0\n \"\"\"\n if len(v) == 1:\n return v[0]\n r = v[0] % v[-1]\n if r == 0:\n return calc_gcd(v[1:])\n return calc_gcd(v[1:] + [r])\n\n\ndef coprimize(v: tuple[int, ...]) -> tuple[int, ...]:\n sign = calc_sign(v)\n gcd = calc_gcd([x for x in sorted(map(abs, v), reverse=True) if x > 0])\n return tuple(sign * x // gcd for x in v)\n\n\nclass Solution:\n def maxPoints(self, points: list[list[int]]) -> int:\n if len(points) == 1:\n return 1\n line_to_points: dict[tuple[float, ...], set[tuple[int, int]]] = {}\n for (x1, y1), (x2, y2) in combinations(points, r=2):\n t = coprimize((x2 - x1, y2 - y1, x1 * y2 - x2 * y1))\n if t not in line_to_points:\n line_to_points[t] = set()\n line_to_points[t].add((x1, y1))\n line_to_points[t].add((x2, y2))\n return max(map(len, line_to_points.values()))","memory":"40436"},{"code":"from typing import List\nfrom fractions import Fraction\n\nclass Solution:\n # a line can be described by y = mx + b, e.g. two numbers: m and b.\n # for each point i, compare with all other points j > i, calculate slop and intercept\n # bin the results, keep track of the max bin size.\n # very simple, O(n^2), impossible to do better.\n def maxPoints(self, points: List[List[int]]) -> int:\n n = len(points)\n if n == 1:\n return 1\n \n dict = {}\n max_points = 0\n for i in range(n):\n for j in range(i+1, n):\n xi, yi = points[i] if points[i][0] < points[j][0] else points[j]\n xj, yj = points[j] if points[i][0] < points[j][0] else points[i]\n\n if xj != xi:\n #m = float((yj - yi) / (xj - xi))\n m = Fraction((yj - yi), (xj - xi))\n else:\n m = float('inf')\n\n if m == float('inf'):\n b = float(xi)\n elif m == 0:\n b = \"inf, \" + str(yi)\n else:\n #b = float(yi - m*xi)\n b = Fraction(yi - m*xi)\n\n b = str(b)\n m = str(m)\n\n if (m, b) not in dict:\n dict[(m, b)] = set()\n dict[(m, b)].add(i)\n dict[(m, b)].add(j)\n \n max_points = max(max_points, len(dict[(m, b)]))\n\n print(dict)\n\n return max_points","memory":"40436"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n\n if len(points) <= 2: \n return len(points)\n \n dc_slopes = dict()\n\n for pointA in points: \n for pointB in points: \n if pointA == pointB: \n continue\n delta_x = pointA[0] - pointB[0]\n if delta_x == 0: \n if (tuple(pointA),pointA[0], 0, \"X\") not in dc_slopes:\n dc_slopes[(tuple(pointA),pointA[0], 0, \"X\")] = 2\n else:\n dc_slopes[(tuple(pointA),pointA[0], 0, \"X\")] += 1\n continue\n\n delta_y = pointA[1] - pointB[1]\n slope = delta_y / delta_x\n \n y_intersect = (pointA[0]*pointB[1] - pointB[0]*pointA[1]) / delta_x\n \n if (tuple(pointA),slope, y_intersect) in dc_slopes:\n dc_slopes[(tuple(pointA),slope, y_intersect)] += 1\n else:\n dc_slopes[(tuple(pointA),slope, y_intersect)] = 2\n\n return max(dc_slopes.values())\n","memory":"40745"},{"code":"class Solution:\n def maxPoints(self, points: List[List[int]]) -> int:\n N = len(points)\n if N <= 1:\n return N\n lines = defaultdict(dict)\n\n output = 0\n for ind1 in range(N-1):\n for ind2 in range(ind1+1, N):\n x1, y1 = points[ind1]\n x2, y2 = points[ind2]\n if x1 == x2:\n m = \"inf\"\n c = x1\n else:\n m = (y2 - y1) / (x2 - x1)\n c = y1 - m * x1\n lines[(m, c)][(x1, y1)] = 1\n lines[(m, c)][(x2, y2)] = 1\n if len(lines[(m, c)]) > output:\n output = len(lines[(m, c)])\n return output","memory":"40745"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n if n < 3:\\n return n\\n\\n max_pts = 2\\n for i in range(n):\\n [x1, y1] = points[i]\\n for j in range(i+1,n):\\n [x2, y2] = points[j]\\n pts = 2\\n for k in range(j+1,n):\\n [x3, y3] = points[k]\\n if x1*y2 + x2*y3 + x3*y1 == x1*y3 + x2*y1 + x3*y2: # (y2-y1)/(x2-x1) = (y3-y1)/(x3-x1)\\n pts += 1\\n max_pts = max(max_pts, pts)\\n return max_pts\",\n \"memory\": \"16354\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n ans = 1\\n n = len(points)\\n \\n def cross(i, j, k):\\n vx = points[i][0] - points[j][0]\\n vy = points[i][1] - points[j][1]\\n \\n ux = points[i][0] - points[k][0]\\n uy = points[i][1] - points[k][1]\\n \\n return vx * uy - vy * ux\\n for i in range(n):\\n for j in range(i + 1, n):\\n cnt = 0\\n for k in range(n):\\n if cross(k, i, j) == 0:\\n cnt += 1\\n ans = max(ans, cnt)\\n return ans\",\n \"memory\": \"16354\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n def countPoints(p1, p2):\\n\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n if x1 != x2:\\n prek = y1 - y2 \\n preb = x1 * y2 - x2 * y1\\n prec = x1 - x2\\n a = gcd(prek, preb, prec)\\n k, b, c = prek // a, preb // a, prec // a\\n if k < 0 or (k == 0 and b < 0):\\n k, b, c = -k, -b, -c\\n else:\\n k, b, c = float('inf'), x1, 0\\n \\n cache[(k, b, c)] = cache.get((k, b, c), 0) + 1\\n return cache[(k, b, c)]\\n\\n l = len(points)\\n\\n if l == 1:\\n return 1\\n\\n max_num = 0\\n for i in range(l):\\n cache = {}\\n for j in range(i + 1, l):\\n max_num = max(max_num, countPoints(points[i], points[j]) + 1)\\n \\n return max_num\\n \",\n \"memory\": \"16663\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points);\\n if n == 1: return 1\\n res = 2;\\n for i in range(n):\\n d = defaultdict(int);\\n for j in range(n):\\n if i != j:\\n d[math.atan2(points[j][1] - points[i][1], points[j][0] - points[i][0])] += 1;\\n res = max(res, max(d.values()) + 1);\\n return res\",\n \"memory\": \"16663\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n ratio = None\\n n = len(points)\\n if n == 1:\\n return 1\\n elif n == 2:\\n return 2\\n slope = None\\n out = 0\\n\\n for idxstart in range(n-1):\\n c = defaultdict(int)\\n for idx2 in range(idxstart+1, n):\\n if points[idx2][0] == points[idxstart][0]:\\n ratio = math.inf\\n else:\\n ratio = (points[idx2][1] - points[idxstart][1]) / (points[idx2][0] - points[idxstart][0])\\n\\n c[ratio] += 1\\n \\n # localans = 0\\n dprint(\\\"c\\\", c)\\n for k,v in c.items():\\n out = max(out, v+1)\\n \\n return out\\n\\n\\ndef dprint(*args):\\n if 1 :\\n print(*args)\",\n \"memory\": \"16971\"\n },\n {\n \"code\": \"class Solution:\\n def aligned_2(self, x,y, q):\\n if x == y :\\n return True\\n if (x[0]==y[0] ):\\n if q == None:\\n return True\\n else:\\n return False\\n if (x[1]-y[1])/(x[0]-y[0]) == q:\\n return True\\n return False\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2:\\n return len(points)\\n m = 0\\n for i in range(1,len(points)):\\n if (points[0][0] - points[i][0]) == 0:\\n q = None\\n else:\\n q = (points[0][1] - points[i][1])/(points[0][0] - points[i][0])\\n n =2\\n for j in range(i+1,len(points)):\\n if self.aligned_2(points[0], points[j], q):\\n n+=1\\n m = max(m,n)\\n return max(m, self.maxPoints(points[1:]))\\n \\n \\n\",\n \"memory\": \"16971\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: list[list[int]]) -> int:\\n if len(points) <= 1:\\n return len(points)\\n else:\\n # equations: dict[tuple, int] = dict()\\n res = []\\n for p in points:\\n for q in points:\\n if p != q:\\n r = 2\\n for w in points:\\n if (w != p) and (w != q):\\n if (q[1]-p[1]) * (w[0]-p[0]) == (w[1]-p[1]) * (q[0]-p[0]):\\n r += 1\\n res.append(r)\\n return max(res)\",\n \"memory\": \"17280\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n m=0\\n d=[[0]*n for _ in range(n)]\\n if len(points)==1:\\n return 1\\n for i in range(0,n):\\n def dfs(j,p_2):\\n visited.add(j)\\n count =1\\n x1,y1 = points[p_2[0]]\\n x2,y2 = points[p_2[1]]\\n for k in range(0,n):\\n if k not in visited and d[p_2[0]][k]==0 and d[p_2[1]][k]==0:\\n x3, y3=points[k]\\n if (y2 - y1) * (x3 - x1) == (y3 - y1) * (x2 - x1) :\\n # print(points[k], end=\\\" | \\\") \\n count += dfs(k, p_2)\\n print(count)\\n return count\\n \\n for j in range(0,n):\\n if j!= i:\\n d[i][j]=1\\n c=1\\n visited = set()\\n p_2=[i,j]\\n visited.add(i)\\n c += dfs(j,p_2)\\n m = max(c,m)\\n \\n return m\",\n \"memory\": \"17280\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n result = 1\\n\\n if len(points) == 1:\\n return result\\n\\n inf = 'I'\\n NA = 'N'\\n arrayOfArrayOfSlopes = []\\n for i in range(0, len(points)):\\n arrayOfSlopes = []\\n for j in range(0, i):\\n p1 = points[j]\\n x1, y1 = p1[0], p1[1]\\n p2 = points[i]\\n x2, y2 = p2[0], p2[1]\\n\\n if x1 == x2:\\n arrayOfSlopes.append(inf)\\n else:\\n arrayOfSlopes.append((y2 - y1) / (x2 - x1))\\n arrayOfArrayOfSlopes.append(arrayOfSlopes)\\n\\n for i in range(0, len(points)):\\n arrayOfSlopes = []\\n for j in range(0, len(points)):\\n if i > j :\\n arrayOfSlopes.append(arrayOfArrayOfSlopes[i][j])\\n elif i < j:\\n arrayOfSlopes.append(arrayOfArrayOfSlopes[j][i])\\n elif i == j:\\n arrayOfSlopes.append(NA)\\n c = collections.Counter(arrayOfSlopes)\\n freq = c.most_common(1)\\n\\n result = max(freq[0][1] + 1, result)\\n\\n return result\\n\",\n \"memory\": \"17898\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n result = 1\\n\\n if len(points) == 1:\\n return result\\n\\n inf = 'I'\\n NA = 'N'\\n arrayOfArrayOfSlopes = []\\n for i in range(0, len(points)):\\n arrayOfSlopes = []\\n for j in range(0, i):\\n p1 = points[j]\\n x1, y1 = p1[0], p1[1]\\n p2 = points[i]\\n x2, y2 = p2[0], p2[1]\\n\\n if x1 == x2:\\n arrayOfSlopes.append(inf)\\n else:\\n arrayOfSlopes.append((y2 - y1) / (x2 - x1))\\n arrayOfArrayOfSlopes.append(arrayOfSlopes)\\n\\n for i in range(0, len(points)):\\n arrayOfSlopes = []\\n for j in range(0, len(points)):\\n if i > j :\\n arrayOfSlopes.append(arrayOfArrayOfSlopes[i][j])\\n elif i < j:\\n arrayOfSlopes.append(arrayOfArrayOfSlopes[j][i])\\n elif i == j:\\n arrayOfSlopes.append(NA)\\n c = collections.Counter(arrayOfSlopes)\\n freq = c.most_common(1)\\n\\n result = max(freq[0][1] + 1, result)\\n\\n return result\\n\",\n \"memory\": \"17898\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1: return 1\\n maxpts = 0\\n slopes = [[0 for i in range(len(points))] for j in range(len(points))]\\n i = 0\\n while i + maxpts <= len(points):\\n countSlopes = dict()\\n for j in range(i+1, len(points)):\\n if points[i][0] == points[j][0]:\\n slopes[i][j] = None\\n else:\\n slopes[i][j] = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0])\\n\\n if slopes[i][j] == None:\\n if 'UND' not in countSlopes.keys():\\n countSlopes['UND'] = 1\\n else:\\n countSlopes['UND'] += 1\\n if countSlopes['UND'] + 1 > maxpts: maxpts = countSlopes['UND'] + 1\\n else:\\n if slopes[i][j] not in countSlopes.keys():\\n countSlopes[slopes[i][j]] = 1\\n else:\\n countSlopes[slopes[i][j]] += 1\\n if countSlopes[slopes[i][j]] + 1 > maxpts: maxpts = countSlopes[slopes[i][j]] + 1\\n i += 1\\n\\n\\n\\n return maxpts\\n \",\n \"memory\": \"18206\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\\"\\\"\\\"\\n sort pints by x coordinate\\n \\n compare pairs of points\\n \\n \\\"\\\"\\\"\\n points.sort()\\n n = len(points)\\n \\n \\n def get_slope(i: int, j: int):\\n numerator = points[j][1] - points[i][1]\\n denominator = points[j][0] - points[i][0]\\n if denominator == 0:\\n return float(\\\"inf\\\")\\n else:\\n return numerator / denominator\\n \\n slope = [[0] * n for i in range(n)]\\n for i in range(n):\\n for j in range(i + 1, n):\\n slope[i][j] = get_slope(i, j)\\n \\n \\n res = 0\\n for i in range(n):\\n freq = defaultdict(int)\\n for j in range(i + 1, n):\\n freq[slope[i][j]] += 1\\n res = max(res, freq[slope[i][j]])\\n \\n return res + 1\",\n \"memory\": \"18515\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n slopes = defaultdict(list)\\n points.sort()\\n for i in range(len(points)):\\n for j in range(i +1, len(points)):\\n if points[i][0] == points[j][0]:\\n slopes[i].append(\\\"v\\\")\\n slopes[j].append(\\\"v\\\")\\n else:\\n # print(points[i], points[j], i, j)\\n slope = (points[i][1] - points[j][1] ) / (points[i][0] - points[j][0])\\n\\n slopes[i].append(slope)\\n slopes[j].append(slope)\\n # print(slopes)\\n m =1\\n for key, vals in slopes.items():\\n # if max(list(Counter(vals).values())) ==7:\\n # print(Counter(vals))\\n m = max(m,1 + max(list(Counter(vals).values())))\\n \\n return m\\n \\n\\n \",\n \"memory\": \"18824\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.line_dict = dict()\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 3:\\n return len(points)\\n max_qty = 2\\n for i in range(len(points) - 1):\\n self.line_dict[i] = set()\\n for j in range(i + 1, len(points)):\\n self.line_dict[i].add(j)\\n for start, ends in self.line_dict.items():\\n str_p = points[start]\\n end_point_list = list(ends)\\n for i in range(len(end_point_list)):\\n curr_line = set()\\n curr_line.add(start)\\n if end_point_list[i] not in self.line_dict[start]:\\n continue\\n end_p = points[end_point_list[i]]\\n curr_line.add(end_point_list[i])\\n var_se_x = end_p[0] - str_p[0]\\n var_se_y = end_p[1] - str_p[1]\\n for j in range(i + 1, len(end_point_list)):\\n if end_point_list[j] not in self.line_dict[start]:\\n continue\\n ext_p = points[end_point_list[j]]\\n var_eo_x = ext_p[0] - end_p[0]\\n var_eo_y = ext_p[1] - end_p[1]\\n if var_eo_x * var_se_y == var_eo_y * var_se_x:\\n self.line_dict[start].remove(end_point_list[j])\\n curr_line.add(end_point_list[j])\\n max_qty = max(max_qty, len(curr_line))\\n return max_qty\",\n \"memory\": \"18824\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.line_dict = dict()\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n if len(points) < 3:\\n return len(points)\\n\\n max_qty = 2\\n for i in range(len(points) - 1):\\n self.line_dict[i] = set()\\n for j in range(i + 1, len(points)):\\n self.line_dict[i].add(j)\\n \\n # print(len(self.line_dict), self.line_dict)\\n \\n # traverse\\n for start, ends in self.line_dict.items():\\n # print(str_p, ends)\\n str_p = points[start]\\n end_point_list = list(ends)\\n # print(str_p, end_point_list)\\n # 以str_p為起始點，逐個點做為end_p檢驗連線上有沒有其他點\\n for i in range(len(end_point_list)):\\n curr_line = set()\\n curr_line.add(start)\\n if end_point_list[i] not in self.line_dict[start]:\\n continue\\n end_p = points[end_point_list[i]]\\n curr_line.add(end_point_list[i])\\n # print(f\\\"current line: from {str_p} to {end_p}\\\")\\n var_se_x = end_p[0] - str_p[0]\\n var_se_y = end_p[1] - str_p[1]\\n for j in range(i + 1, len(end_point_list)):\\n if end_point_list[j] not in self.line_dict[start]:\\n continue\\n ext_p = points[end_point_list[j]]\\n # print(f\\\"斜率: {var_se_x}, {var_se_y} - 測試點: {ext_p}\\\")\\n var_eo_x = ext_p[0] - end_p[0]\\n var_eo_y = ext_p[1] - end_p[1]\\n if var_eo_x * var_se_y == var_eo_y * var_se_x:\\n # print(f\\\"3點連成一線: {str_p},{end_p},{ext_p}\\\")\\n self.line_dict[start].remove(end_point_list[j])\\n # self.line_dict[end_point_list[i]].remove(end_point_list[j])\\n curr_line.add(end_point_list[j])\\n # print()\\n max_qty = max(max_qty, len(curr_line))\\n # print(self.line_dict)\\n \\n \\n return max_qty\",\n \"memory\": \"19133\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n N = len(points)\\n if N == 1:\\n return 1\\n\\n points.sort()\\n point2slopeCounter = defaultdict(lambda: defaultdict(lambda: 0))\\n #compute slopes \\n for i in range(N):\\n for j in range(i+1, N):\\n if points[i][0] - points[j][0] != 0:\\n # delta y / delta x\\n slope = (points[i][1] - points[j][1]) / (points[i][0] - points[j][0])\\n else:\\n slope = float(\\\"inf\\\") #? \\n \\n point2slopeCounter[tuple(points[i])][slope] += 1\\n\\n # scan dict\\n maxNum = 0\\n for startPoint, slopeCountDict in point2slopeCounter.items():\\n for slope, count in slopeCountDict.items():\\n # count + 1 to accounter for the starting point\\n maxNum = max(maxNum, count + 1)\\n\\n return maxNum\",\n \"memory\": \"19133\"\n },\n {\n \"code\": \"class Solution(object):\\n def maxPoints(self, points):\\n \\\"\\\"\\\"\\n :type points: List[List[int]]\\n :rtype: int\\n \\\"\\\"\\\"\\n ll = len(points) \\n if ll == 1: return 1\\n elif ll == 2: return 2\\n else:\\n ans = 0\\n for i in list(combinations(points,2)):\\n cnt = 0\\n for j in points:\\n if (j[1] - i[0][1]) * (i[1][0] - i[0][0]) == (j[0] - i[0][0]) * (i[1][1] - i[0][1]):\\n cnt += 1\\n ans = max(ans, cnt)\\n return ans\",\n \"memory\": \"19441\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points):\\n len_points = len(points) \\n if len_points == 1: return 1\\n elif len_points == 2: return 2\\n else:\\n ans = 0\\n # get all combination of length 2 from points\\n for i in list(combinations(points,2)):\\n count = 0\\n for j in points:\\n x1,y1 = i[0][0], i[0][1]\\n x2, y2 = i[1][0], i[1][1]\\n x3, y3 = j[0], j[1]\\n # condition for three points to be coliniear\\n if (y3 - y2) * (x2 - x1) == (x3 - x2) * (y2 - y1):\\n count += 1\\n ans = max(ans, count)\\n return ans\\n \",\n \"memory\": \"19441\"\n },\n {\n \"code\": \"\\n\\\"\\\"\\\"\\n+7 min on timer btw\\n\\nneed to be able to determine which existing straight lines a new point is on, then we can update thos e counters.\\nfinally, we can iterate over all teh lines and max their sizes.\\n\\n\\nmaybe we can keep track of unique lines by its left and right most points (poitnts with min and max x).\\n\\n\\nthen for every thing we can iterate over all points and update their counte if the point falls within those two points. we also update the point thing if we find that the new point is further left\\n\\n\\nN = len(points)\\nThis would be an O(N^3), O(N^2) space solution as there can be up to N^2 unique staright lines as every single point can be joing with any of the other n points to make a new line.\\n\\n\\nif there is a duplicate point, that is coinsideerd an addiontal point for whatever line the existing point is.\\n\\n\\n\\nwe can have up to 2* (2*10^4) distinct lines that a point can fall on (all lines intersecting with\\nall integer points on x-axis, and all lines inetersiection with all itngeter points o axis)\\n\\nwhat if we keep a hash table of which points intersectwith each distinc point on the x or \\ny axis and \\n\\n a line can be uniquitely idetnifeid with its m and b values in y = mx + b\\n\\nIDEA:\\n\\nfirst, iterate through the ponitns and keep count of # of poitns at each\\nunique (x,y) value.\\n\\nthen iterate over this map and for each point, iterate over all other points and \\nsee if the points have a point at that slope. Basiaal,y we need a map that maps (x,y) values to\\na dictionary of slopes to the size of the lines with that sloe. if therei s one, we add to that value in both points maps with the count of the current point, if not we create a lnew line entry and make it the sume of teh count of points between the two points. everytime we do an updat, updateh tem ax.\\n\\nThis is an O(N^2) solution with O(N^2 ) space (because each point can have up to n unique-sloped lines)\\n\\n\\\"\\\"\\\"\\nimport dataclasses \\nfrom typing import Dict, List\\n@dataclasses.dataclass\\nclass Point:\\n\\n x : int\\n y : int\\n lines : Dict[float , int] # mapping slope to # of points in that line \\n\\n def get_slope(self, other_point : \\\"Point\\\"):\\n if other_point.x - self.x == 0:\\n return float(\\\"inf\\\")\\n return (other_point.y- self.y) / (other_point.x- self.x) \\n\\n def update_line_size(self, other_point : \\\"Point\\\") -> int:\\n # update line size of lines that meet the other point, returning the new # of points in the line after adding the other point \\n slope = self.get_slope(other_point)\\n\\n if slope in other_point.lines:\\n \\n other_point.lines[slope] += 1\\n #self.lines[slope] = other_point.lines[slope]\\n else:\\n other_point.lines[slope] = 2\\n #self.lines[slope] = 2\\n \\n \\n return other_point.lines[slope]\\n\\n\\n\\n\\n\\ndef get_point_counts(points):\\n out = []\\n for pos in points:\\n x,y = pos\\n out.append(Point(x =x, y=y, lines = {}))\\n\\n return out\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n points : List[Point] = get_point_counts(points) # tuple of points\\n ans = 0\\n for i in range(len(points)):\\n for j in range(i): # only iterate over previous points so we dont overcount\\n\\n ans = max(ans, points[i].update_line_size(points[j]))\\n\\n return ans\",\n \"memory\": \"19750\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n combs = list(itertools.combinations(points, 2))\\n \\n n = 0\\n a = 0\\n if len(points)==1:\\n return 1\\n for comb in combs:\\n \\n if comb[1][0] - comb[0][0] == 0: #vert line\\n a =0\\n for p in points:\\n if p[0] == comb[0][0]:\\n a+=1\\n n = max(n, a)\\n else:\\n\\n m = (comb[1][1] - comb[0][1]) / (comb[1][0] - comb[0][0])\\n b = comb[0][1] - (m * comb[0][0])\\n a = 0\\n for p in points:\\n # print((m * p[0] + b)-p[1])\\n \\n if abs((m * p[0] + b) - p[1]) < 1e-9:\\n \\n a += 1 \\n \\n n = max(n, a)\\n return n\\n\\n \",\n \"memory\": \"19750\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n\\n def is_same_line(self, point1, point2, point3):\\n x1, y1 = tuple(point1)\\n x2, y2 = tuple(point2)\\n x3, y3 = tuple(point3)\\n return (x3 - x1) * (y2 - y1) == (y3 - y1) * (x2 - x1)\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 3:\\n return len(points)\\n collinears = defaultdict(list)\\n pairs = [(i1, i2) for i1 in range(len(points)) for i2 in range(i1 + 1, len(points))]\\n while pairs:\\n i1, i2 = pairs.pop()\\n for i3 in range(i2 + 1, len(points)):\\n if self.is_same_line(points[i1], points[i2], points[i3]):\\n collinears[(i1, i2)].append(i3)\\n try:\\n pairs.remove((i1, i3))\\n except ValueError:\\n pass\\n try:\\n pairs.remove((i2, i3))\\n except ValueError:\\n pass\\n if len(collinears) == 0:\\n return 2\\n return 2 + max(len(v) for v in collinears.values())\\n\",\n \"memory\": \"20059\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n\\n def is_same_line(self, point1, point2, point3):\\n x1, y1 = tuple(point1)\\n x2, y2 = tuple(point2)\\n x3, y3 = tuple(point3)\\n return (x3 - x1) * (y2 - y1) == (y3 - y1) * (x2 - x1)\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 3:\\n return len(points)\\n collinears = defaultdict(int)\\n pairs = [(i1, i2) for i1 in range(len(points)) for i2 in range(i1 + 1, len(points))]\\n while pairs:\\n i1, i2 = pairs.pop()\\n for i3 in range(i2 + 1, len(points)):\\n if self.is_same_line(points[i1], points[i2], points[i3]):\\n collinears[(i1, i2)] += 1\\n try:\\n pairs.remove((i1, i3))\\n except ValueError:\\n pass\\n try:\\n pairs.remove((i2, i3))\\n except ValueError:\\n pass\\n if len(collinears) == 0:\\n return 2\\n return 2 + max(collinears.values())\\n\",\n \"memory\": \"20059\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lp, maxpoints = len(points), 1\\n if lp ==1: return maxpoints\\n slopes = [defaultdict(int) for _ in range(lp)]\\n for i in range(lp):\\n x1, y1 = points[i]\\n for j in range(i+1, lp):\\n x2, y2 = points[j]\\n if x1 == x2 and y1 == y2:\\n slope = \\\"0\\\"\\n elif x1 == x2:\\n slope = str(x1) + \\\"v\\\"\\n elif y1 == y2:\\n slope = str(y1) + \\\"h\\\"\\n else:\\n slope = str(round((y2-y1) / (x2-x1), 10))\\n slopes[i][slope] += 1\\n if slopes[i][slope] > maxpoints:\\n maxpoints = slopes[i][slope]\\n return maxpoints + 1\",\n \"memory\": \"20368\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lp, maxpoints = len(points), 1\\n if lp ==1: return maxpoints\\n slopes = [defaultdict(int) for _ in range(lp)]\\n for i in range(lp):\\n x1, y1 = points[i]\\n slopes_i = slopes[i]\\n for j in range(i+1, lp):\\n x2, y2 = points[j]\\n if x1 == x2 and y1 == y2:\\n slope = \\\"0\\\"\\n elif x1 == x2:\\n slope = str(x1) + \\\"v\\\"\\n elif y1 == y2:\\n slope = str(y1) + \\\"h\\\"\\n else:\\n slope = str(round((y2-y1) / (x2-x1), 10))\\n slopes_i[slope] += 1\\n if slopes_i[slope] > maxpoints:\\n maxpoints = slopes_i[slope]\\n return maxpoints + 1\",\n \"memory\": \"20368\"\n },\n {\n \"code\": \"\\n\\\"\\\"\\\"\\n+7 min on timer btw\\n\\nneed to be able to determine which existing straight lines a new point is on, then we can update thos e counters.\\nfinally, we can iterate over all teh lines and max their sizes.\\n\\n\\nmaybe we can keep track of unique lines by its left and right most points (poitnts with min and max x).\\n\\n\\nthen for every thing we can iterate over all points and update their counte if the point falls within those two points. we also update the point thing if we find that the new point is further left\\n\\n\\nN = len(points)\\nThis would be an O(N^3), O(N^2) space solution as there can be up to N^2 unique staright lines as every single point can be joing with any of the other n points to make a new line.\\n\\n\\nif there is a duplicate point, that is coinsideerd an addiontal point for whatever line the existing point is.\\n\\n\\n\\nwe can have up to 2* (2*10^4) distinct lines that a point can fall on (all lines intersecting with\\nall integer points on x-axis, and all lines inetersiection with all itngeter points o axis)\\n\\nwhat if we keep a hash table of which points intersectwith each distinc point on the x or \\ny axis and \\n\\n a line can be uniquitely idetnifeid with its m and b values in y = mx + b\\n\\nIDEA:\\n\\nfirst, iterate through the ponitns and keep count of # of poitns at each\\nunique (x,y) value.\\n\\nthen iterate over this map and for each point, iterate over all other points and \\nsee if the points have a point at that slope. Basiaal,y we need a map that maps (x,y) values to\\na dictionary of slopes to the size of the lines with that sloe. if therei s one, we add to that value in both points maps with the count of the current point, if not we create a lnew line entry and make it the sume of teh count of points between the two points. everytime we do an updat, updateh tem ax.\\n\\nThis is an O(N^2) solution with O(N^2 ) space (because each point can have up to n unique-sloped lines)\\n\\n\\\"\\\"\\\"\\nimport dataclasses \\nfrom typing import Dict, List\\n@dataclasses.dataclass\\nclass Point:\\n\\n x : int\\n y : int\\n lines : Dict[float , int] # mapping slope to # of points in that line \\n\\n def get_slope(self, other_point : \\\"Point\\\"):\\n if other_point.x - self.x == 0:\\n return float(\\\"inf\\\")\\n return (other_point.y- self.y) / (other_point.x- self.x) \\n\\n def update_line_size(self, other_point : \\\"Point\\\") -> int:\\n # update line size of lines that meet the other point, returning the new # of points in the line after adding the other point \\n slope = self.get_slope(other_point)\\n\\n if slope in other_point.lines:\\n \\n other_point.lines[slope] += 1\\n self.lines[slope] = other_point.lines[slope]\\n else:\\n other_point.lines[slope] = 2\\n self.lines[slope] = 2\\n \\n \\n return other_point.lines[slope]\\n\\n\\n\\n\\n\\ndef get_point_counts(points):\\n out = []\\n for pos in points:\\n x,y = pos\\n out.append(Point(x =x, y=y, lines = {}))\\n\\n return out\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n points : List[Point] = get_point_counts(points) # tuple of points\\n ans = 0\\n for i in range(len(points)):\\n for j in range(i): # only iterate over previous points so we dont overcount\\n\\n ans = max(ans, points[i].update_line_size(points[j]))\\n\\n return ans\",\n \"memory\": \"20676\"\n },\n {\n \"code\": \"\\nimport dataclasses \\nfrom typing import Dict, List\\n@dataclasses.dataclass\\nclass Point:\\n\\n x : int\\n y : int\\n lines : Dict[float , int] # mapping slope to # of points in that line \\n\\n def get_slope(self, other_point : \\\"Point\\\"):\\n if other_point.x - self.x == 0:\\n return float(\\\"inf\\\")\\n return (other_point.y- self.y) / (other_point.x- self.x) \\n\\n def update_line_size(self, other_point : \\\"Point\\\") -> int:\\n # update line size of lines that meet the other point, returning the new # of points in the line after adding the other point \\n slope = self.get_slope(other_point)\\n\\n if slope in other_point.lines:\\n \\n other_point.lines[slope] += 1\\n self.lines[slope] = other_point.lines[slope]\\n else:\\n other_point.lines[slope] = 2\\n self.lines[slope] = 2\\n \\n \\n return other_point.lines[slope]\\n\\n\\n\\n\\n\\ndef get_point_counts(points):\\n out = []\\n for pos in points:\\n x,y = pos\\n out.append(Point(x =x, y=y, lines = {}))\\n\\n return out\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n points : List[Point] = get_point_counts(points) # tuple of points\\n ans = 0\\n for i in range(len(points)):\\n for j in range(i): # only iterate over previous points so we dont overcount\\n\\n ans = max(ans, points[i].update_line_size(points[j]))\\n\\n return ans\",\n \"memory\": \"20676\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lines = []\\n\\n for point in points:\\n append_list = []\\n for line in lines:\\n if len(line) == 1:\\n append_list.append([line[0], point])\\n else:\\n point_1 = line[-2]\\n point_2 = line[-1]\\n\\n if (point_1[1] - point_2[1]) * (point_2[0] - point[0]) == (point_2[1] - point[1]) * (point_1[0] - point_2[0]):\\n line.append(point)\\n for append in append_list:\\n lines.append(append)\\n lines.append([point])\\n\\n\\n max_points = max([len(line) for line in lines])\\n return max_points\\n \",\n \"memory\": \"20985\"\n },\n {\n \"code\": \"def points2rect(p0, p1):\\n try:\\n m = (p1[1] - p0[1])/(p1[0] - p0[0])\\n q = p1[1] - m * p1[0]\\n except:\\n m = float(inf)\\n q = p1[0]\\n return round(m, 3), round(q, 3)\\n\\ndef fac(n):\\n if n <= 1:\\n return 1\\n return n * fac(n-1)\\n \\n\\ndef binom(n):\\n return fac(n)/(fac(n-2)*2)\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n d = {}\\n n = len(points)\\n if n <= 2:\\n return n\\n r = 2\\n for i, p0 in enumerate(points):\\n for p1 in points[i+1:]:\\n m, q = points2rect(p0, p1)\\n if m not in d:\\n d[m] = {}\\n d[m][q] = d[m].get(q, 0) + 1\\n if d[m][q] > r:\\n r = d[m][q]\\n for i in range(2, r+1):\\n if binom(i) == r:\\n return i\\n return r\",\n \"memory\": \"20985\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n slopes = []\\n\\n for i in range(len(points)):\\n for j in range(i + 1, len(points)):\\n (x1, y1) = points[i]\\n (x2, y2) = points[j]\\n\\n # a x_1 + b y_1 + c = 0\\n # a x_2 + b y_2 + c = 0\\n # a (x_1 - x_2) + b (y_1 - y_2) = 0\\n # b (y_1 - y_2) = a (x_2 - x_1)\\n\\n dy = y1 - y2 # a\\n dx = x2 - x1 # b\\n\\n if dy < 0:\\n dy *= -1\\n dx *= -1\\n\\n c = 0 - dy * x1 - dx * y1\\n\\n slopes.append((dy, dx, c))\\n\\n best_count = 1\\n\\n for (a, b, c) in slopes:\\n count = 0\\n\\n for (x, y) in points:\\n if a * x + b * y + c == 0:\\n count += 1\\n\\n best_count = max(count, best_count)\\n\\n return best_count\",\n \"memory\": \"21294\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n graph = defaultdict(list)\\n for i in range(len(points)-1) :\\n for j in range(i+1, len(points)) :\\n slope = 10 ** 9\\n if (points[j][0] - points[i][0]) != 0 :\\n slope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0]) \\n\\n graph[(points[i][0], points[i][1])].append((points[j][0], points[j][1], slope ))\\n \\n\\n def dfsUtil(p, q, dist) :\\n max_len = 1\\n neighbors = graph[(p, q)]\\n\\n for x, y, distance in neighbors :\\n if dist == -sys.maxsize or dist == distance :\\n max_len = max(max_len, 1 + dfsUtil(x, y, distance))\\n\\n return max_len \\n\\n \\n max_points = 0\\n for k in range(len(points)) :\\n max_points = max(max_points, dfsUtil(points[k][0], points[k][1], -sys.maxsize))\\n \\n return max_points\",\n \"memory\": \"21603\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n graph = defaultdict(list)\\n\\n for i in range(len(points)-1) :\\n for j in range(i+1, len(points)) :\\n slope = 10 ** 9\\n\\n if (points[j][0] - points[i][0]) != 0 :\\n slope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0]) \\n\\n graph[(points[i][0], points[i][1])].append((points[j][0], points[j][1], slope ))\\n \\n # print(graph)\\n def dfsUtil(p, q, dist) :\\n # print(p, q, dist)\\n max_len = 1\\n neighbors = graph[(p, q)]\\n # print(neighbors)\\n\\n for x, y, distance in neighbors :\\n if dist == -sys.maxsize or dist == distance :\\n max_len = max(max_len, 1 + dfsUtil(x, y, distance))\\n\\n return max_len \\n\\n \\n max_points = 0\\n for k in range(len(points)) :\\n # print(points[k])\\n max_points = max(max_points, dfsUtil(points[k][0], points[k][1], -sys.maxsize))\\n # print(points[k], dfsUtil(points[k][0], points[k][1], -sys.maxsize))\\n return max_points\",\n \"memory\": \"21911\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n\\n deg = defaultdict(lambda: defaultdict(lambda: 1))\\n max_n = 2\\n for i in range(len(points)):\\n for j in range(len(points)):\\n if i == j:\\n continue\\n y = points[j][1] - points[i][1]\\n x = points[j][0] - points[i][0]\\n deg[i][math.atan2(y, x)] += 1\\n max_n = max(max_n, max(deg[i].values()))\\n\\n return max_n\",\n \"memory\": \"21911\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n combs = list(itertools.combinations(points, 2))\\n \\n n = 0\\n a = 0\\n if len(points)==1:\\n return 1\\n print(combs)\\n for comb in combs:\\n \\n if comb[1][0] - comb[0][0] == 0: #vert line\\n a =0\\n for p in points:\\n if p[0] == comb[0][0]:\\n a+=1\\n n = max(n, a)\\n else:\\n\\n m = (comb[1][1] - comb[0][1]) / (comb[1][0] - comb[0][0])\\n b = comb[0][1] - (m * comb[0][0])\\n a = 0\\n for p in points:\\n # print((m * p[0] + b)-p[1])\\n \\n if abs((m * p[0] + b) - p[1]) < 1e-9:\\n \\n a += 1 \\n \\n n = max(n, a)\\n return n\\n\\n \",\n \"memory\": \"22220\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\\"\\\"\\\"\\n How to figure this out:\\n \\n Brute force way:\\n\\n between every pair, there is a line. you can calculate all of these lines\\n and check if any of the other ones fit on the line\\n \\\"\\\"\\\"\\n tol = 0.000001\\n n = len(points)\\n max_points = 1\\n\\n seen = set()\\n for i in range(0, n):\\n for x in range(0, n):\\n if x == i or (min(i, x), max(i, x)) in seen:\\n pass\\n else:\\n seen.add((min(i, x), max(i, x)))\\n p1 = points[i]\\n p2 = points[x]\\n vertical = None\\n if p2[0] == p1[0]:\\n slope = float('inf')\\n intercept = None\\n vertical = p1[0] #stores the x value \\n else:\\n slope = (p2[1] - p1[1]) / (p2[0] - p1[0])\\n intercept = - slope * p1[0] + p1[1] # y = mx + b (solve for b so b = -mx + y)\\n num_points = 2\\n for j in range(0, n):\\n if j not in {x, i}:\\n if vertical is not None:\\n if points[j][0] == vertical:\\n num_points += 1\\n seen.add((min(i,j), max(i, j)))\\n seen.add((min(x,j), max(x, j)))\\n else:\\n if abs(points[j][0] * slope + intercept - points[j][1]) <= tol:\\n num_points += 1\\n seen.add((min(i,j), max(i, j)))\\n seen.add((min(x,j), max(x, j)))\\n \\n max_points = max(num_points, max_points)\\n\\n if max_points > n // 2:\\n return max_points\\n\\n return max_points\\n\\n\",\n \"memory\": \"22220\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 3:\\n return len(points)\\n\\n combinations = []\\n for i in range(len(points)):\\n for j in range(i + 1, len(points)):\\n if points[i] == points[j]:\\n continue\\n a = points[i][1] - points[j][1]\\n b = points[j][0] - points[i][0]\\n c = points[i][0] * points[j][1] - points[j][0] * points[i][1]\\n combinations.append((a, b, c))\\n \\n max_points = 0\\n for i in range(len(combinations)):\\n a, b, c = combinations[i]\\n cur_points = 0\\n for j in range(len(points)):\\n if a * points[j][0] + b * points[j][1] + c == 0:\\n cur_points += 1\\n max_points = max(max_points, cur_points)\\n\\n return max_points\\n\",\n \"memory\": \"22529\"\n },\n {\n \"code\": \"from collections import defaultdict\\nimport math\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n def find_slope(p1, p2):\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n if x1 == x2: return (0, 1)\\n if y1 == y2: return (1, 0)\\n\\n diff1 = x1 - x2\\n diff2 = y1 - y2\\n d = math.gcd(diff1, diff2)\\n\\n if diff1 < 0:\\n diff1 = -diff1\\n diff2 = -diff2\\n\\n return (diff1 // d, diff2 // d)\\n \\n \\n # points -> slope counter\\n\\n count = {}\\n for i in range(len(points)):\\n count[i] = defaultdict(lambda : 1)\\n\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n slope = find_slope(points[i], points[j])\\n\\n count[i][slope] += 1\\n count[j][slope] += 1\\n \\n max_freq = 1\\n for key in count:\\n for slope in count[key]:\\n max_freq = max(max_freq, count[key][slope])\\n\\n return max_freq\",\n \"memory\": \"22529\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nNaive solution: look at all lines defined by a pair of points and check how many points on that line\\nO(n^2*n)\\n\\nCan I do O(n)? No\\n- must decide whether a point is or is not on the longest line\\n\\nO(n^2)?\\n- iterate through all pairs of points and encode line\\n- count line that is most popular\\n\\nBut hmm this is O(n^2) space\\n\\nPoints lie on integer lattice.\\n\\ny = mx + b\\nb = y - mx\\n\\nIf a line has n points it has (n choose 2) pairs of points?\\n(n choose 2) = n(n-1)/2 = n^2/2 - n/2\\nc = n(n-1)/2 <==> 0 = n^2 - n - 2c <==> n = (1 + sqrt(1+8c)) / 2\\n\\\"\\\"\\\"\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n lines = defaultdict(int)\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n p1, p2 = points[i], points[j]\\n if p1[0] != p2[0] or p1[1] != p2[1]:\\n if p2[0] < p1[0]:\\n t = p2\\n p2 = p1\\n p1 = t\\n if p1[0] == p2[0]:\\n m = \\\"inf\\\"\\n b = p1[0]\\n lines[f\\\"({m},{b:.5f})\\\"] += 1\\n else:\\n m = (p2[1]-p1[1])/(p2[0]-p1[0])\\n b = p2[1] - m*p2[0]\\n lines[f\\\"({m:.5f},{b:.5f})\\\"] += 1\\n n_choose_2 = max(list(lines.values()))\\n n = int((1 + sqrt(1+8*n_choose_2)) // 2)\\n return n\\n \",\n \"memory\": \"22838\"\n },\n {\n \"code\": \"class Solution(object):\\n def maxPoints(self, points):\\n \\\"\\\"\\\"\\n :type points: List[List[int]]\\n :rtype: int\\n \\\"\\\"\\\"\\n INF = 10**5\\n\\n n = len(points)\\n pairs = [[0]*n for i in range(n)]\\n max_occ = 0\\n for i, (x,y) in enumerate(points):\\n rep = {}\\n for j, (x2, y2) in enumerate(points[i+1:]):\\n if x == x2:\\n a = INF\\n b = x\\n else:\\n a = (y2-y)/(x2-x)\\n b = y - a*x #y = ax + b, b = y - ax\\n pairs[i][j] = (a, b)\\n rep[(a, b)] = rep.get((a,b), 0) + 1\\n max_occ = max(max_occ, rep[(a,b)])\\n\\n # for a in pairs:\\n # for b in a:\\n # print(b, end=\\\", \\\")\\n # print()\\n return max_occ+1\\n\",\n \"memory\": \"22838\"\n },\n {\n \"code\": \"class Solution:\\n\\n def num(self, points, p1, p2):\\n v = [p2[0]-p1[0], p2[1]-p1[1]]\\n n = [v[1], -v[0]]\\n C = p2[0]*p1[1]-p1[0]*p2[1]\\n count = 0\\n for p in points:\\n sum_v = n[0]*p[0] + n[1]*p[1] + C\\n\\n if sum_v == 0:\\n count += 1\\n return count\\n\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n n = len(points)\\n if n == 1:\\n return 1\\n max_num = 0\\n d = {}\\n for i in range(n):\\n for j in range(i+1,n):\\n if (i,j) in d or (j,i) in d:\\n continue\\n max_num = max(max_num, self.num(points, points[i], points[j]))\\n d[(i,j)] = max_num\\n return max_num\\n \",\n \"memory\": \"23146\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n if len(points) == 1:\\n return 1\\n if len(points) == 2:\\n return 2\\n\\n pair_points = []\\n for i in range(len(points)):\\n for j in points[i+1:]:\\n pairs=[]\\n pairs.append(points[i])\\n pairs.append(j)\\n pair_points.append(pairs)\\n \\n \\n\\n for i in (pair_points):\\n for j in points:\\n area = j[0]*(i[0][1] - i[1][1]) + i[0][0]*(i[1][1] - j[1])+i[1][0]*(j[1]-i[0][1])\\n if j not in i and area == 0:\\n i.append(j)\\n max = len(pair_points[0])\\n for i in range(len(pair_points) -1):\\n if len(pair_points[i])> max:\\n max = len(pair_points[i])\\n print(pair_points)\\n return max\\n \\n\\n\\n\\n\\n\\n\\n \",\n \"memory\": \"23146\"\n },\n {\n \"code\": \"from collections import defaultdict, Counter\\nfrom math import gcd\\n\\ndef most_frequent_char(lists):\\n results = []\\n \\n for lst in lists:\\n if not lst:\\n results.append(None)\\n continue\\n \\n char_counts = Counter(lst)\\n most_common_char, freq = char_counts.most_common(1)[0]\\n results.append(freq)\\n \\n return results\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n _grads = []\\n length = len(points)\\n if length == 1:\\n return 1\\n for p in points:\\n x, y =p \\n l = []\\n for c in range(length):\\n if p != points[c]:\\n x2, y2 = points[c]\\n dy = y - y2\\n dx = x - x2\\n if dx == 0 and dy == 0:\\n grad = 1\\n elif dx != 0:\\n grad = dy / dx\\n else:\\n grad = \\\"0\\\"\\n l.append(grad)\\n _grads.append(l)\\n print(_grads)\\n newmans = max(most_frequent_char(_grads))\\n\\n return newmans + 1\\n \",\n \"memory\": \"23455\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points)==1:\\n return 1\\n lines={}\\n maxi=0\\n for i in range(len(points)):\\n for j in range(i):\\n if points[j][0]==points[i][0]:\\n y_intercept=1e9\\n x_intercept=points[i][0]\\n elif points[j][1]==points[i][1]:\\n y_intercept=points[i][1]\\n x_intercept=1e9\\n else:\\n slope=(points[j][1]-points[i][1])/(points[j][0]-points[i][0])\\n y_intercept=round(points[i][1] - slope*points[i][0],2)\\n x_intercept=round(-y_intercept/slope,2)\\n if str([x_intercept,y_intercept]) in lines:\\n lines[str([x_intercept,y_intercept])]+=1\\n if lines[str([x_intercept,y_intercept])]>maxi:\\n maxi=lines[str([x_intercept,y_intercept])]\\n else:\\n lines.update({str([x_intercept,y_intercept]):1})\\n print(lines, maxi)\\n det=math.sqrt(1+(8*maxi))\\n return max(2,int((1+det)/2))\\n\",\n \"memory\": \"23455\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # if on a line means on y = kx + b, y2 - y1/x2 - x1, (y2 - y1)x - (x2 - x1)y + x2y1 - x1y2 = 0\\n # how to avoid x3, y3 x2, y2? visited set add(k, b)\\n n = len(points)\\n if n <= 2:\\n return n\\n\\n visited = set()\\n ans = 2\\n for i in range(n):\\n for j in range(i + 1, n):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n if x1 != x2 and ((y2 - y1) / (x2 - x1), y1 - ((y2 - y1) / (x2 - x1)) * x1) in visited:\\n continue\\n if x1 == x2 and (float('inf'), x1) in visited:\\n continue\\n ans = max(ans, self.countPoints(points, visited, x1, y1, x2, y2))\\n return ans\\n\\n \\n\\n def countPoints(self, points, visited, x1, y1, x2, y2):\\n ans = 2\\n for x, y in points:\\n if (x == x1 and y == y1) or (x == x2 and y == y2):\\n continue\\n if (y2 - y1) * x - (x2 - x1) * y + x2 * y1 - x1 * y2 == 0:\\n ans += 1\\n visited.add(((y2 - y1) / (x2 - x1), y1 - ((y2 - y1) / (x2 - x1)) * x1) if x1 != x2 else (float('inf'), x1)) \\n return ans\\n\",\n \"memory\": \"23764\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lp, maxpoints = len(points), 1\\n if lp ==1: return maxpoints\\n slopes = [defaultdict(int) for _ in range(lp)]\\n for i in range(lp):\\n x1, y1 = points[i]\\n for j in range(lp):\\n if j != i:\\n x2, y2 = points[j]\\n if x1 == x2 and y1 == y2:\\n slope = \\\"0\\\"\\n elif x1 == x2:\\n slope = str(x1) + \\\"v\\\"\\n elif y1 == y2:\\n slope = str(y1) + \\\"h\\\"\\n elif j > i:\\n slope = str(round((y2-y1) / (x2-x1), 10))\\n else:\\n slope = str(round((y1-y2) / (x1-x2), 10))\\n slopes[i][slope] += 1\\n if slopes[i][slope] > maxpoints:\\n maxpoints = slopes[i][slope]\\n return maxpoints + 1\",\n \"memory\": \"23764\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lp, maxpoints = len(points), 1\\n if lp ==1: return maxpoints\\n slopes = [defaultdict(int) for _ in range(lp)]\\n for i in range(lp):\\n x1, y1 = points[i][0], points[i][1]\\n for j in range(lp):\\n if j != i:\\n x2, y2 = points[j][0], points[j][1]\\n if x1 == x2 and y1 == y2:\\n slope = \\\"0\\\"\\n if x1 == x2:\\n slope = str(x1) + \\\"v\\\"\\n elif y1 == y2:\\n slope = str(y1) + \\\"h\\\"\\n elif j > i:\\n slope = str(round((y2-y1) / (x2-x1), 10))\\n else:\\n slope = str(round((y1-y2) / (x1-x2), 10))\\n slopes[i][slope] += 1\\n maxpoints = max(maxpoints, slopes[i][slope])\\n # print(slopes)\\n return maxpoints + 1\",\n \"memory\": \"24073\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lp, maxpoints = len(points), 1\\n if lp ==1: return maxpoints\\n slopes = [defaultdict(int) for _ in range(lp)]\\n for i in range(lp):\\n x1, y1 = points[i]\\n for j in range(lp):\\n if j != i:\\n x2, y2 = points[j]\\n if x1 == x2 and y1 == y2:\\n slope = \\\"0\\\"\\n elif x1 == x2:\\n slope = str(x1) + \\\"v\\\"\\n elif y1 == y2:\\n slope = str(y1) + \\\"h\\\"\\n elif j > i:\\n slope = str(round((y2-y1) / (x2-x1), 10))\\n else:\\n slope = str(round((y1-y2) / (x1-x2), 10))\\n slopes[i][slope] += 1\\n maxpoints = max(maxpoints, slopes[i][slope])\\n return maxpoints + 1\",\n \"memory\": \"24073\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n slopes_map = {}\\n for i, point1 in enumerate(points):\\n for point2 in points[i+1:]:\\n if point1[0] - point2[0] != 0:\\n slope = (point1[1]-point2[1])/(point1[0]-point2[0])\\n else:\\n slope = 'inf'\\n current_slope = slopes_map.get((i,slope))\\n if current_slope is None:\\n slopes_map[(i,slope)] = 2\\n else:\\n slopes_map[(i,slope)] += 1\\n return max(slopes_map.values(), default = 1)\",\n \"memory\": \"24381\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n slopes_map = {}\\n for i, point1 in enumerate(points):\\n for point2 in points[i+1:]:\\n if point1[0] - point2[0] != 0:\\n slope = (point1[1]-point2[1])/(point1[0]-point2[0])\\n else:\\n slope = 'inf'\\n current_slope = slopes_map.get((i,slope))\\n if current_slope is None:\\n slopes_map[(i,slope)] = 2\\n else:\\n slopes_map[(i,slope)] += 1\\n return max(slopes_map.values(), default = 1)\",\n \"memory\": \"24381\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # compute slope for each 2 points, keep a [slope, groups]\\n nums = len(points)\\n if nums < 2:\\n return nums\\n m = {}\\n for i in range(1, nums):\\n for j in range(0, i):\\n # print(i, j, points[i], points[j])\\n if points[i][1] != points[j][1]:\\n slope = float((points[i][0] - points[j][0]) / (\\n points[i][1] - points[j][1])\\n )\\n else:\\n slope = float(\\\"inf\\\")\\n if slope in m:\\n values = m[slope]\\n found = False\\n for value in values:\\n if points[j] in value and points[i] not in value:\\n value.append(points[i])\\n found = True\\n break\\n if not found:\\n values.append([points[i], points[j]])\\n else:\\n m[slope] = [[points[j], points[i]]]\\n # print(m)\\n line = 0\\n for v in m.values():\\n for a in v:\\n line = max(line, len(a))\\n return line\\n\",\n \"memory\": \"24690\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # max_points = 0\\n # for point1 in points:\\n # for point2 in points:\\n # count = 0\\n # if point1[0] != point2[0]: # line is not vertical\\n # yslope = (point2[1] - point1[1])\\n # xslope = (point2[0] - point1[0])\\n # for point in points:\\n # if xslope * (point[1] - point1[1]) == yslope * (point[0] - point1[0]):\\n # count += 1\\n # else: # vertical\\n # for point in points:\\n # if point[0] == point1[0]:\\n # count += 1\\n # print(count)\\n # max_points = max(max_points, count)\\n # return max_points\\n\\n slopes = {}\\n for i, point1 in enumerate(points):\\n for j, point2 in enumerate(points[:i]):\\n if point1[0] == point2[0]: # vertical\\n slopeStr = \\\"inf\\\"\\n else:\\n slopeStr = str((point2[1] - point1[1]) / (point2[0] - point1[0]))\\n \\n if slopeStr in slopes: \\n slopes[slopeStr].append((j,i))\\n else: \\n slopes[slopeStr] = [(j,i)]\\n \\n maxLength = 1\\n for slopeStr in slopes:\\n components = []\\n for pair in slopes[slopeStr]:\\n s = set(pair)\\n flag = True\\n #print(s)\\n for st in components:\\n if len(st.intersection(s)) > 0:\\n #print(\\\"JOIN\\\")\\n components.remove(st)\\n st = st.union(s)\\n components.append(st)\\n flag = False\\n #print(components)\\n if flag:\\n components.append(s)\\n if max([len(c) for c in components]) > maxLength:\\n maxLength = max([len(c) for c in components])\\n \\n return maxLength\\n \",\n \"memory\": \"24690\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n l, cache = len(points), {}\\n\\n if l == 1:\\n return 1\\n\\n def countPoints(p1, p2):\\n count = 0\\n\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n if x1 != x2:\\n k = y1 - y2 \\n c = x1 - x2\\n b = x1 * y2 - x2 * y1\\n if (k, b) in cache:\\n return cache[(k, b)]\\n for point in points:\\n x, y = point\\n if c * y == k * x + b:\\n print([x, y], end = ' ')\\n count += 1\\n else:\\n k = float('inf')\\n b = x1\\n if (k, b) in cache:\\n return cache[(k, b)]\\n for point in points:\\n x, y = point\\n if x == x1:\\n print([x, y], end = ' ')\\n count += 1\\n \\n cache[(k, b)] = count\\n\\n print()\\n\\n return count\\n\\n max_num = float('-inf')\\n for i in range(l):\\n for j in range(i + 1, l):\\n max_num = max(max_num, countPoints(points[i], points[j]))\\n \\n return max_num\\n \",\n \"memory\": \"24999\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n l, cache = len(points), {}\\n\\n if l == 1:\\n return 1\\n\\n def countPoints(p1, p2):\\n count = 0\\n\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n if x1 != x2:\\n k = y1 - y2 \\n c = x1 - x2\\n b = x1 * y2 - x2 * y1\\n if (k, b) in cache:\\n return cache[(k, b)]\\n for point in points:\\n x, y = point\\n if c * y == k * x + b:\\n count += 1\\n else:\\n k = float('inf')\\n b = x1\\n if (k, b) in cache:\\n return cache[(k, b)]\\n for point in points:\\n x, y = point\\n if x == x1:\\n count += 1\\n \\n cache[(k, b)] = count\\n\\n return count\\n\\n max_num = float('-inf')\\n for i in range(l):\\n for j in range(i + 1, l):\\n max_num = max(max_num, countPoints(points[i], points[j]))\\n \\n return max_num\\n \",\n \"memory\": \"24999\"\n },\n {\n \"code\": \"class Solution:\\n def get_a_c(self,point1, point2):\\n x1,y1 = point1\\n x2,y2 = point2\\n\\n if x1-x2 == 0:\\n return None, x1\\n\\n dy = y1-y2 \\n dx = x1-x2\\n\\n a = (y1-y2) / (x1-x2)\\n b = y1 - a * x1\\n\\n return a,b\\n \\n def check_in_line(self,ab, point):\\n x,y = point\\n a,b = ab\\n if a == None:\\n if x == b:\\n return True\\n else:\\n return False\\n if abs((a*x + b) - y) < 0.00001:\\n return True\\n else:\\n return False\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n tab = [[0] * len(points) for _ in points]\\n visited = set()\\n\\n max_point = 1\\n\\n for i in range(0,len(points)):\\n for j in range(i+1, len(points)):\\n ab = self.get_a_c(points[i],points[j])\\n if ab not in visited:\\n temp_count = 2\\n for k in range(j+1, len(points)):\\n if self.check_in_line(ab, points[k]):\\n temp_count += 1\\n if temp_count > max_point:\\n max_point = temp_count\\n visited.add(ab)\\n \\n return max_point\",\n \"memory\": \"25308\"\n },\n {\n \"code\": \"from fractions import Fraction\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lines = defaultdict(int)\\n ans = 0\\n\\n for i in range(len(points)):\\n curLines = set()\\n for j in range(i):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n dx = x2 - x1\\n dy = y2 - y1\\n z = dx * y2 - dy * x2\\n\\n if (dx != 0):\\n angle = Fraction(dy, dx)\\n y0 = Fraction(z, dx)\\n curLines.add((angle.numerator, angle.denominator, y0.numerator, y0.denominator))\\n else: \\n curLines.add((x1, 0, 0, 0))\\n \\n for line in curLines:\\n lines[line] += 1\\n\\n # for count in lines.values():\\n for key in lines: \\n ans = max(ans, lines[key])\\n\\n return ans + 1\\n\\n\\n\",\n \"memory\": \"25308\"\n },\n {\n \"code\": \"import math\\n\\nclass LineCounter:\\n\\n def __init__(self):\\n self._line_dict = {}\\n self._max_count = 0\\n \\n def _least_terms(self, num, den):\\n # Ensure that denominator is positive; if denominator is zero, than numerator should be positive\\n if den < 0:\\n num *= -1\\n den *= -1\\n elif den == 0:\\n num = abs(num)\\n \\n # Put in least terms\\n gcd = math.gcd(num, den)\\n if gcd != 0:\\n num //= gcd\\n den //= gcd\\n \\n return num, den\\n\\n def _get_index(self, p1, p2):\\n # f(t) = [at + c, bt + d]\\n\\n # Compute change in x, y\\n dy, dx = self._least_terms(p2[1] - p1[1], p2[0] - p1[0])\\n\\n # Compute offset\\n # (dy/dx)*x + b = y\\n # dy*x + dx*b = dx*y\\n # dx*b = dx*y - dy*x\\n\\n if dx == 0:\\n bn, bd = p1[0], 1\\n else:\\n bn, bd = self._least_terms(dx*p1[1] - dy*p1[0], dx)\\n\\n return (dx, dy, bn, bd)\\n\\n def max(self):\\n # n choose 2 = n(n+1)/2 = 1/2(n^2 + n) = m\\n # n^2 + n - 2m = 0\\n return (math.isqrt(8*self._max_count + 1) + 1)//2\\n \\n def increment(self, p1, p2):\\n key = self._get_index(p1, p2)\\n if key not in self._line_dict:\\n self._line_dict[key] = 0\\n \\n self._line_dict[key] += 1\\n\\n if self._line_dict[key] > self._max_count:\\n self._max_count = self._line_dict[key]\\n\\n return self._line_dict[key]\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n line_counter = LineCounter()\\n for i,p1 in enumerate(points):\\n for j in range(i+1, n):\\n line_counter.increment(p1, points[j])\\n \\n return line_counter.max()\\n\",\n \"memory\": \"25616\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n=len(points)\\n d={}\\n for i in range(n):\\n x,y=points[i][0],points[i][1]\\n for j in range(i+1,n):\\n x1=x-points[j][0]\\n y1=y-points[j][1]\\n b=x1*y-y1*x\\n d[(y1,x1,b)]=0\\n for i in range(n):\\n x,y=points[i][0],points[i][1]\\n for j in d:\\n if j[1]*y==j[0]*x+j[2]:\\n d[j]+=1\\n m=1\\n for x in d:\\n m=max(m,d[x])\\n return m\\n\",\n \"memory\": \"25616\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n import math\\n\\n if len(points) == 1:\\n return 1\\n d = {}\\n for i in range(len(points)):\\n l = points[i]\\n for j in range(i+1, len(points)):\\n r = points[j]\\n slope = (r[1] - l[1]) / (r[0] - l[0]) if r[0] != l[0] else float('inf')\\n bias = r[1] - slope * r[0] if slope != float('inf') else r[0]\\n slope = round(slope, 5) if slope != float('inf') else slope\\n bias = round(bias, 5)\\n if (slope, bias) not in d:\\n d[(slope, bias)] = 0\\n d[(slope, bias)] += 1\\n ans = max(d.values()) # kC2 = k * (k-1) // 2\\n return math.ceil(math.sqrt(ans * 2))\",\n \"memory\": \"25925\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n res = 0\\n\\n def lies_on_line(x,y,a,b):\\n return abs(a*x + b - y) < 10e-6\\n \\n def compute_line(x1, y1, x2, y2):\\n #print(x1, y1, x2, y2)\\n if x2 - x1 == 0:\\n return None # TODO\\n\\n a = (y2-y1)/(x2-x1)\\n b = y1 - a * x1\\n return a, b\\n \\n # Edge cases: vertical lines \\n xs = [p[0] for p in points]\\n x_counts = {}\\n for x in xs:\\n if x not in x_counts:\\n x_counts[x] = 1\\n else:\\n x_counts[x] = x_counts[x] + 1\\n for _, c in x_counts.items():\\n if c>res:\\n res = c\\n \\n\\n lines = []\\n for i, point_i in enumerate(points):\\n for point_j in points[i+1:]:\\n line = compute_line(*point_i, *point_j)\\n if line is not None:\\n lines.append(line)\\n print(lines)\\n for line in lines:\\n curr_res = 0\\n for point in points:\\n #print(point, line)\\n if lies_on_line(*point, *line):\\n curr_res = curr_res + 1\\n #print(line, curr_res)\\n if curr_res>res:\\n res = curr_res\\n \\n return res\\n\",\n \"memory\": \"25925\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n r = 12\\n def kb(p1,p2):\\n if round(p1[0]-p2[0],r)==0:\\n return float('inf'), round(p1[0],r)\\n\\n k = (p1[1]-p2[1])/(p1[0]-p2[0])\\n b = p1[1]-p1[0]*k\\n return round(k,r),round(b,r)\\n\\n l = len(points)\\n if l == 1: return 1\\n lines = dict()\\n for i in range(l-1):\\n s = set([kb(points[i], points[j]) for j in range(i+1,l)])\\n for kb1 in s:\\n lines.setdefault(kb1, 1)\\n lines[kb1] += 1\\n return max(x for x in lines.values())\\n\",\n \"memory\": \"26234\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n slope_list = [{} for _ in range(len(points))]\\n ans = 0\\n for i,x in enumerate(points):\\n for j,y in enumerate(points):\\n if i == j:\\n continue\\n try:\\n slope = (x[1] - y[1]) / (x[0] - y[0])\\n except:\\n slope = float(\\\"inf\\\")\\n slope_list[i][slope] = slope_list[i].get(slope,0) + 1\\n ans = max(ans,slope_list[i][slope])\\n print(slope_list)\\n return ans +1\",\n \"memory\": \"26234\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n map = {}\\n\\n for i in range(len(points)):\\n curr = set()\\n for j in range(i+1, len(points), 1):\\n if (points[i][0]-points[j][0]) != 0: div = (points[i][1]-points[j][1]) / (points[i][0]-points[j][0])\\n else: div = 'inf'\\n if div == -0: div = 0\\n if div != 'inf': dif = points[i][1]-div*points[i][0]\\n else: dif = points[i][0]\\n key = f'{div}${dif}'\\n if key in map.keys() and key not in curr: continue\\n curr.add(key)\\n try:\\n map[key] += 1\\n except KeyError:\\n map[key] = 2\\n print(map)\\n if len(map.keys()) > 0: return max([map[key] for key in map.keys()])\\n else: return 1\",\n \"memory\": \"26543\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n def slopeCalculator(x1, y1, x2, y2):\\n if x2 - x1 == 0:\\n return \\\"und\\\"\\n slope = (y2 - y1) / (x2 - x1)\\n if slope == 0:\\n slope = 0\\n return slope\\n \\n pointSlopeDict = {}\\n pointsLength = len(points)\\n if pointsLength == 1:\\n return 1\\n\\n for i in range(pointsLength):\\n currPoint1 = points[i]\\n for j in range(i + 1, pointsLength):\\n currPoint2 = points[j]\\n x1 = currPoint1[0]\\n y1 = currPoint1[1]\\n x2 = currPoint2[0]\\n y2 = currPoint2[1]\\n currSlope = slopeCalculator(x1, y1, x2, y2)\\n currKey = \\\"point: \\\" + str(i) + \\\", slope: \\\" + str(currSlope)\\n try:\\n pointSlopeDict[currKey] = pointSlopeDict[currKey] + 1\\n except KeyError:\\n pointSlopeDict[currKey] = 1\\n print(pointSlopeDict)\\n return max(list(pointSlopeDict.values())) + 1\",\n \"memory\": \"26543\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points)<2:\\n return 1\\n line={}\\n m=0\\n for i in range(len(points)):\\n for j in range(i+1,len(points)):\\n slope=float('inf')\\n \\n if(points[j][0]-points[i][0]!=0):\\n slope=(points[j][1]-points[i][1])/(points[j][0]-points[i][0])\\n c=points[j][1]-slope*points[j][0]\\n else:\\n c=points[j][0]\\n mix=str(slope)+str(c)\\n if mix in line:\\n if points[j] not in line[mix]:\\n line[mix].append(points[j])\\n if points[i] not in line[mix]:\\n line[mix].append(points[i])\\n else:\\n line[mix]=[points[j],points[i]]\\n for i in line.keys():\\n if len(line[i])>m:\\n m=len(line[i])\\n return m\",\n \"memory\": \"26851\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points)<2:\\n return 1\\n line={}\\n m=0\\n for i in range(len(points)):\\n for j in range(i+1,len(points)):\\n slope=float('inf')\\n \\n if(points[j][0]-points[i][0]!=0):\\n slope=(points[j][1]-points[i][1])/(points[j][0]-points[i][0])\\n c=points[j][1]-slope*points[j][0]\\n else:\\n c=points[j][0]\\n mix=str(slope)+str(c)\\n if mix in line:\\n if points[j] not in line[mix]:\\n line[mix].append(points[j])\\n if points[i] not in line[mix]:\\n line[mix].append(points[i])\\n else:\\n line[mix]=[points[j],points[i]]\\n for i in line.keys():\\n if len(line[i])>m:\\n m=len(line[i])\\n return m\",\n \"memory\": \"26851\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n=len(points)\\n if n==1:\\n return 1\\n d={}\\n ans=0\\n for i in range(n):\\n x1,y1=points[i][0],points[i][1]\\n for j in range(i+1,n):\\n x2,y2=points[j][0],points[j][1]\\n if(x2-x1==0):\\n slope='-1'\\n else:\\n slope=(y2-y1)/(x2-x1)\\n if ((x1,y1),slope) not in d:\\n d[((x1,y1),slope)]=1\\n d[((x1,y1),slope)]+=1\\n ans=max(ans,d[((x1,y1),slope)])\\n return ans\",\n \"memory\": \"27160\"\n },\n {\n \"code\": \"from fractions import Fraction\\nfrom dataclasses import dataclass\\n\\n@dataclass\\nclass Line:\\n origin: tuple[int, int]\\n slope: Fraction | None\\n l: int = 2\\n \\n def contains(self, point: tuple[int, int]) -> bool:\\n x, y = point\\n x1, y1 = self.origin\\n dx = x - x1\\n dy = y - y1\\n\\n if dx == 0:\\n return self.slope is None\\n else:\\n if self.slope is None:\\n return False\\n fr = Fraction(dy, dx)\\n return fr == self.slope\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lines = []\\n best = min(2, len(points))\\n\\n for i, (x, y) in enumerate(points):\\n for l in lines:\\n if l.contains((x, y)):\\n l.l += 1\\n best = max(best, l.l)\\n for (x1, y1) in points[:i]:\\n dy = y - y1\\n dx = x - x1\\n if dx == 0:\\n slope = None\\n else:\\n slope = Fraction(dy, dx)\\n lines.append(Line((x1, y1), slope))\\n \\n # if len(points) == 7:\\n # print(*lines, sep=\\\"\\\\n\\\")\\n \\n return best\\n \",\n \"memory\": \"27160\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) < 3:\\n return len(points)\\n keep_dict = {}\\n for i in range(len(points) - 1):\\n for j in range(i+1, len(points)):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n if x2 - x1 == 0:\\n if (\\\"inf\\\", x1) in keep_dict:\\n keep_dict[(\\\"inf\\\", x1)] += 1\\n else:\\n keep_dict[(\\\"inf\\\", x1)] = 1\\n continue\\n m = (y2 - y1) / (x2 - x1)\\n\\n b = round(10**8 * (y2 - m * x2))\\n m = round(10**8 * m)\\n\\n if (m, b) in keep_dict:\\n keep_dict[(m, b)] += 1\\n else:\\n keep_dict[(m, b)] = 1\\n x = 2 * max(keep_dict.values())\\n print(keep_dict)\\n return int((1 + (4 * x + 1)**(0.5)) / 2)\",\n \"memory\": \"27469\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n res = 0\\n if len(points) <= 2:\\n return len(points)\\n xy = defaultdict(list)\\n for i in range (len(points)):\\n \\n\\n for j in range (i+1, len(points)):\\n \\n if (points[i][0] - points[j][0]) == 0:\\n k = '0.0'\\n b = points[i][0]\\n else: \\n k = (points[i][1] - points[j][1]) / (points[i][0] - points[j][0])\\n b = points[i][1] - k * points[i][0]\\n\\n key = str(k)+ str(b)\\n if i not in xy[key]:\\n xy[key].append(i)\\n if j not in xy[key]:\\n xy[key].append(j)\\n \\n for key, val in xy.items():\\n res = max(len(val), res)\\n \\n\\n return res\\n\",\n \"memory\": \"27469\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n def param(p1,p2):\\n try :\\n a = (p1[1] - p2[1])/(p1[0] - p2[0])\\n b = p1[1] - a*p1[0]\\n return (a,b)\\n except :\\n return ( float(\\\"inf\\\"), p1[0])\\n def appartient(p3,para):\\n return p3[1] == para[0] * p3[0] + para[1]\\n\\n\\n d = {}\\n if (len(points)<=2) : return len(points)\\n n =len(points)\\n h = set()\\n for i in range(n-1) :\\n L = set()\\n for j in range(i+1,n):\\n coeff = param(points[i], points[j])\\n if coeff in h : continue\\n if (coeff in d.keys()):\\n d[coeff] += 1\\n else : \\n L.add(coeff)\\n\\n d[coeff] = 2\\n h.update(L)\\n \\n return max(d.values()) \\n \\n \\n \",\n \"memory\": \"28086\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n def getID(p1, p2):\\n if p2[0] == p1[0]:\\n return p1[0]\\n if p2 >= p1:\\n m = (p2[1]-p1[1]) / (p2[0]-p1[0])\\n y = p2[1] - m*p2[0]\\n else:\\n m = (p1[1]-p2[1]) / (p1[0]-p2[0])\\n y = p1[1] - m*p1[0]\\n return (round(m, 5),round(y,5))\\n lines = defaultdict(int)\\n sealed = set()\\n for i in range(len(points)):\\n temp = set()\\n for j in range(i+1, len(points)):\\n id = getID(points[i], points[j])\\n if id not in sealed: \\n lines[id] += 1\\n temp.add(id)\\n sealed |= temp\\n ans = 1\\n for times in lines.values():\\n times += 1\\n if times > ans:\\n ans = times \\n return ans\",\n \"memory\": \"28086\"\n },\n {\n \"code\": \"from collections import defaultdict\\nimport math\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n \\n if n <= 2:\\n return n\\n D = defaultdict(lambda: 0)\\n max_points = 0\\n for i in range(n):\\n for j in range(i):\\n xa, ya = points[i]\\n xb, yb = points[j]\\n if xb == xa:\\n slope = \\\"fuck\\\"\\n intercept = xb\\n else:\\n slope = (yb - ya) / (xb - xa)\\n intercept = yb - slope * xb\\n slope = f\\\"{slope:.8f}\\\"\\n intercept = f\\\"{intercept:.8f}\\\"\\n print(slope)\\n\\n key = (slope, intercept)\\n D[key] += 1\\n max_points = max(max_points, D[key])\\n\\n print(max_points)\\n return int(math.sqrt(max_points * 2)) + 1\\n\\n \\n \\n \\n \",\n \"memory\": \"28395\"\n },\n {\n \"code\": \"from collections import defaultdict\\nimport math\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n \\n if n <= 2:\\n return n\\n D = defaultdict(lambda: 0)\\n max_points = 0\\n for i in range(n):\\n for j in range(i):\\n xa, ya = points[i]\\n xb, yb = points[j]\\n if xb == xa:\\n slope = \\\"fuck\\\"\\n intercept = xb\\n else:\\n slope = (yb - ya) / (xb - xa)\\n intercept = yb - slope * xb\\n slope = f\\\"{slope:.8f}\\\"\\n intercept = f\\\"{intercept:.8f}\\\"\\n # print(slope)\\n\\n key = (slope, intercept)\\n D[key] += 1\\n max_points = max(max_points, D[key])\\n\\n print(max_points)\\n return int(math.sqrt(max_points * 2)) + 1\\n\\n \\n \\n \\n \",\n \"memory\": \"28395\"\n },\n {\n \"code\": \"from collections import defaultdict\\nimport math\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n \\n if n <= 2:\\n return n\\n D = defaultdict(lambda: 0)\\n max_points = 0\\n for i in range(n):\\n for j in range(i):\\n xa, ya = points[i]\\n xb, yb = points[j]\\n if xb == xa:\\n slope = \\\"fuck\\\"\\n intercept = xb\\n else:\\n slope = (yb - ya) / (xb - xa)\\n intercept = yb - slope * xb\\n slope = f\\\"{slope:.8f}\\\"\\n intercept = f\\\"{intercept:.8f}\\\"\\n # print(slope)\\n\\n key = (slope, intercept)\\n D[key] += 1\\n max_points = max(max_points, D[key])\\n\\n print(max_points)\\n return int(math.sqrt(max_points * 2)) + 1\\n\\n \\n \\n \\n \",\n \"memory\": \"28704\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n def getID(p1, p2):\\n if p2[0] == p1[0]:\\n return p1[0]\\n if p2 >= p1:\\n m = (p2[1]-p1[1]) / (p2[0]-p1[0])\\n y = p2[1] - m*p2[0]\\n else:\\n m = (p1[1]-p2[1]) / (p1[0]-p2[0])\\n y = p1[1] - m*p1[0]\\n return (round(m, 5),round(y,5))\\n lines = defaultdict(int)\\n sealed = set()\\n for i in range(len(points)):\\n temp = set()\\n for j in range(i+1, len(points)):\\n id = getID(points[i], points[j])\\n if id not in sealed: \\n lines[id] += 1\\n temp.add(id)\\n sealed |= temp\\n ans = 1\\n print(lines)\\n for times in lines.values():\\n times += 1\\n if times > ans:\\n ans = times \\n return ans\",\n \"memory\": \"28704\"\n },\n {\n \"code\": \"import numpy as np\\n\\n\\n\\nclass Solution:\\n\\n def num_on(self, p1: np.ndarray, p2: np.ndarray , points : np.ndarray):\\n vec = (p2 -p1)\\n if vec[0] == 0:\\n #print((points[ :, 0] == p1[0]), points, p1)\\n return int((points[:, 0] == p1[0]).sum())\\n\\n if vec[1] == 0:\\n return int((points[:, 1] == p1[1]).sum())\\n\\n points_p1 = points - p1[None, :]\\n alphas = points_p1 / vec[None, : ]\\n mean_alpha = np.mean(alphas, axis=-1, keepdims=True)\\n #print(alphas)\\n linear = np.abs((mean_alpha - alphas)).max(axis=-1) == 0\\n #print(linear)\\n num = int((linear & (mean_alpha[:, 0] <= 1) & (mean_alpha[:, 0]>=0)).sum())\\n return num\\n\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n points = np.array(points)\\n max_points = 1\\n for idx , p1 in enumerate(points):\\n for jdx, p2 in enumerate(points[idx+1:]):\\n max_points = max(max_points, self.num_on(p1, p2, points))\\n\\n return max_points\\n \\n\\n \",\n \"memory\": \"29013\"\n },\n {\n \"code\": \"from decimal import Decimal\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n\\n # y = mx + c\\n \\n lines = {}\\n\\n\\n for i in range(len(points)):\\n pnt = set()\\n for j in range(len(points)):\\n if i == j:\\n continue\\n \\n\\n if (points[j][0] - points[i][0]) == 0:\\n m = inf\\n else:\\n m = round((points[j][1] - points[i][1])/(points[j][0] - points[i][0]), 10)\\n \\n\\n if m is inf:\\n c = points[i][0]\\n else:\\n c = round(points[j][1]-(m*points[j][0]), 8)\\n\\n \\n\\n if (m,c) not in lines:\\n lines[(m,c)] = 1\\n elif (m,c) not in pnt:\\n lines[(m,c)] += 1\\n\\n pnt.add((m,c))\\n \\n print(lines)\\n\\n return max(lines.values())\\n\\n\\n\\n \",\n \"memory\": \"29013\"\n },\n {\n \"code\": \"import numpy as np\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # Consider two points\\n # Then compute the line\\n # Then count how many points satisfy that\\n \\n TOL = 1e-8\\n n = len(points)\\n if n <= 2:\\n return n\\n\\n data = np.array(points)\\n x = data[:, 0]\\n y = data[:, 1]\\n max_count = 1\\n for i in range(n-1):\\n for j in range(i+1, n):\\n if x[i] == x[j]:\\n num = np.sum(x == x[i])\\n else:\\n slope = (y[j] - y[i]) / (x[j] - x[i])\\n intercept = slope * (-x[i]) + y[i]\\n\\n res = slope * x + intercept - y\\n\\n num = np.sum(abs(res) < TOL)\\n if num > max_count:\\n max_count = num\\n\\n return max_count\",\n \"memory\": \"29321\"\n },\n {\n \"code\": \"from fractions import Fraction\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2:\\n return len(points)\\n si = defaultdict(int)\\n si[None]\\n vert = defaultdict(int)\\n vert[None]\\n for i in range(len(points) - 1):\\n for j in range(i + 1, len(points)):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n if x1 == x2:\\n vert[x1] += 1\\n continue\\n slope = Fraction(y2 - y1, x2 - x1)\\n intercept = y1 - slope * x1\\n si[(slope, intercept)] += 1\\n return ceil(sqrt(2 * max(max(si.values()), max(vert.values()))))\",\n \"memory\": \"29321\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n if len(points) == 1: return 1\\n\\n slopes = {}\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n dx = points[i][0] - points[j][0]\\n dy = points[i][1] - points[j][1]\\n slope = dy/dx if dx != 0 else \\\"vertical\\\"\\n\\n if slope in slopes:\\n slopes[slope].add(i)\\n slopes[slope].add(j)\\n else:\\n slopes[slope] = {i, j}\\n\\n print(slopes)\\n\\n maxPoints = 0\\n for slope in slopes:\\n if slope == 'vertical':\\n intercepts = [points[i][0] for i in slopes[slope]]\\n else:\\n intercepts = [round(points[i][1] - slope * points[i][0], 5) for i in slopes[slope]]\\n\\n max_occurence = intercepts.count(max(intercepts, key=intercepts.count))\\n if maxPoints < max_occurence: maxPoints = max_occurence\\n\\n return maxPoints\\n\",\n \"memory\": \"29630\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n #calculate sllope y = mx + b b = y-mx\\n m = {}\\n for i in range(len(points)):\\n one = points[i]\\n for j in range(i+1, len(points)):\\n \\n two = points[j]\\n if (one[1] == two[1]):\\n slope = 0\\n b = one[1]\\n elif (one[0] == two[0]):\\n slope = \\\"undefined\\\"\\n b = one[0]\\n else:\\n slope = (one[1] - two[1])/(one[0] - two[0])\\n b = one[1] - (one[0]*slope)\\n if (slope, b) not in m:\\n m[(slope, b)] = []\\n if one not in m[(slope, b)]:\\n m[(slope, b)].append(one) \\n if two not in m[(slope, b)]:\\n m[(slope, b)].append(two)\\n c = [len(v) for v in m.values()]\\n if not c:\\n return 1\\n return max(c)\\n \\n\\n\\n\\n \\n \",\n \"memory\": \"29630\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n from collections import defaultdict\\n dc=defaultdict(list)\\n def getslope(p1,p2):\\n x1,y1=p1\\n x2,y2=p2\\n try:\\n m=(y2-y1)/(x2-x1)\\n c=y1-m*x1\\n except:\\n m=float('inf')\\n c=x1\\n return (m,c)\\n for i in range(len(points)):\\n for j in range(i+1,len(points)):\\n m,c=getslope(points[i], points[j])\\n points[i], points[j]=tuple(points[i]), tuple(points[j])\\n if points[i] not in dc[(m,c)]:\\n dc[(m,c)].append(points[i]) \\n if points[j] not in dc[(m,c)]:\\n dc[(m,c)].append(points[j])\\n if not dc:\\n return 1\\n else:\\n return max([len(x) for x in dc.values()])\\n\\n\",\n \"memory\": \"29939\"\n },\n {\n \"code\": \"# 1 <= points.length <= 300\\n# All the points are unique\\n\\n# Option 1. Brutal force\\n# use two points to define a line, check if other points are on the same line\\n# O(N**3)\\n\\n# Option 2. Caching\\n# use two points to define a line, and cache slope with dict {slope: (p1, p2)}\\n# if two lines have the same slope and connected point, then +1 in the path, this can be resolved with DFS\\n\\n# Start with Option 2\\n\\nclass Solution:\\n def count_max(self, points_list: List[Tuple[Tuple[int, int], Tuple[int, int]]]) -> int:\\n if len(points_list) == 1:\\n return 2\\n\\n # build a graph\\n point_map: Dict[Tuple[int, int], int] = {}\\n curr_index = 0\\n for points in points_list:\\n for point in points:\\n if point not in point_map:\\n point_map[point] = curr_index\\n curr_index += 1\\n # print(point_map)\\n\\n n = len(point_map)\\n graph: List[List[int]] = [[0] * n for _ in range(n)]\\n\\n for points in points_list:\\n p1 = points[0]\\n p2 = points[1]\\n index1 = point_map[p1]\\n index2 = point_map[p2]\\n graph[index1][index2] = 1\\n graph[index2][index1] = 1\\n # print(graph)\\n\\n # dfs\\n visited: Set[int] = set()\\n max_points = 0\\n for i in range(n):\\n if i in visited:\\n continue\\n\\n curr_points = 0\\n stack: List[int] = []\\n stack.append(i)\\n while len(stack) > 0:\\n curr_index = stack.pop()\\n if curr_index not in visited:\\n visited.add(curr_index)\\n curr_points += 1\\n\\n for j in range(n):\\n if graph[curr_index][j] == 1:\\n if j not in visited:\\n stack.append(j)\\n\\n max_points = max(max_points, curr_points)\\n\\n return max_points\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 2:\\n return len(points)\\n\\n slope_to_points: Dict[float, List[Tuple[Tuple[int, int], Tuple[int, int]]]] = {}\\n\\n for i in range(len(points)):\\n for j in range(i + 1, len(points)):\\n p1 = points[i]\\n p2 = points[j]\\n if p2[0] - p1[0] == 0:\\n slope = float(sys.maxsize)\\n else:\\n slope = (p2[1] - p1[1]) / (p2[0] - p1[0])\\n if slope in slope_to_points:\\n slope_to_points[slope].append(((p1[0], p1[1]), (p2[0], p2[1])))\\n else:\\n slope_to_points[slope] = [((p1[0], p1[1]), (p2[0], p2[1]))]\\n # print(slope_to_points)\\n\\n max_points = 0\\n for points_list in slope_to_points.values():\\n curr_points = self.count_max(points_list)\\n max_points = max(max_points, curr_points)\\n\\n return max_points\",\n \"memory\": \"29939\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n vectors = []\\n for i in range(len(points)):\\n vectors.append(defaultdict(int))\\n for j in range(len(points)):\\n if j == i:\\n continue\\n x = points[j][0] - points[i][0]\\n y = points[j][1] - points[i][1]\\n if x < 0:\\n x *= -1\\n y *= -1\\n length = math.sqrt(x * x + y * y)\\n new_tuple = (round(x / length, 10), round(y / length, 10))\\n vectors[i][new_tuple] += 1\\n\\n max_matches = 0\\n for v in vectors:\\n for count in v.values():\\n max_matches = max(count + 1, max_matches)\\n\\n return max_matches\",\n \"memory\": \"30248\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n length = len(points)\\n dic = {}\\n max_element = 0\\n if(len(points)==1):\\n return 1\\n for i in range(0,length):\\n for j in range(i+1,length):\\n if (points[i][0] == points[j][0]):\\n slope = points[i][0]\\n offset = 99999\\n else:\\n slope = (points[i][1]-points[j][1])/(points[i][0]-points[j][0])\\n offset=points[i][1] - slope * points[i][0]\\n print(slope,offset)\\n if (slope, offset) in dic:\\n if i not in dic[(slope,offset)]:\\n dic[(slope,offset)].append(i)\\n if j not in dic[(slope,offset)]:\\n dic[(slope,offset)].append(j)\\n # print(\\\"adding a point to (\\\", slope, \\\", \\\", offset, \\\")\\\")\\n if len(dic[(slope, offset)]) > max_element:\\n max_element = len(dic[(slope,offset)])\\n else:\\n dic[(slope,offset)] = []\\n dic[(slope,offset)].append(i)\\n dic[(slope,offset)].append(j)\\n if len(dic[(slope, offset)]) > max_element:\\n max_element = len(dic[(slope,offset)])\\n # print(dic)\\n return max_element\",\n \"memory\": \"30248\"\n },\n {\n \"code\": \"import collections\\nimport itertools\\nimport math\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n if len(points) == 1:\\n return 1\\n \\n gcd_cache = {}\\n line_descriptors = collections.Counter()\\n for p1, p2 in itertools.combinations(points, 2):\\n line_descriptors[self.getLineDescriptor(p1, p2, gcd_cache)] += 1\\n \\n sum_of_pairs = line_descriptors.most_common(1)[0][1]\\n\\n ans = math.ceil(math.sqrt(2*sum_of_pairs)) \\n\\n return ans\\n\\n def getLineDescriptor(self, p1: Tuple[int], p2: Tuple[int], gcd_cache) -> Tuple[int]:\\n \\\"\\\"\\\"\\n Returns slope_num, slope_denom, intercept\\n \\\"\\\"\\\"\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n m_num = y2 - y1\\n m_denom = x2 - x1\\n\\n if m_num == 0:\\n return 0, 0, y1\\n \\n if m_denom == 0:\\n return math.inf, math.inf, x1\\n\\n if m_denom < 0:\\n m_num *= -1\\n m_denom *= -1\\n\\n m_num_abs = abs(m_num)\\n m_denom_abs = abs(m_denom)\\n\\n gcd_cache_key = (m_num_abs, m_denom_abs)\\n if gcd_cache_key in gcd_cache:\\n gcd = gcd_cache[gcd_cache_key]\\n else:\\n gcd = math.gcd(m_num_abs, m_denom_abs)\\n gcd_cache[gcd_cache_key] = gcd\\n\\n m_num /= gcd\\n m_denom /= gcd\\n\\n return m_num, m_denom, y1*m_denom - m_num*x1\\n\\n\",\n \"memory\": \"30556\"\n },\n {\n \"code\": \"class Solution:\\n def lineEq(self, point1: list[int], point2: list[int]) -> str:\\n if point2[0] == point1[0]:\\n return f\\\"x{point1[0]}\\\"\\n\\n elif point2[1] == point1[1]:\\n return f\\\"y{point1[1]}\\\"\\n\\n slope = (point2[1] - point1[1]) / (point2[0] - point1[0])\\n intercept = point1[1] - slope * point1[0]\\n\\n if intercept >= 0:\\n return f\\\"{slope}x + {intercept}\\\"\\n else:\\n return f\\\"{slope}x - {abs(intercept)}\\\"\\n\\n def maxPoints(self, points: list[list[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n slops = {}\\n max: int = 0\\n for i in range(0, len(points)):\\n for j in range(0, len(points)):\\n if j == i:\\n continue\\n key: str = self.lineEq(points[i], points[j])\\n if key not in slops:\\n slops[key] = [points[j]]\\n elif points[j] not in slops[key]:\\n slops[key].append(points[j])\\n\\n if points[i] not in slops[key]:\\n slops[key].append(points[i])\\n\\n for slop in slops:\\n if max < len(slops[slop]):\\n max = len(slops[slop])\\n return max\",\n \"memory\": \"30865\"\n },\n {\n \"code\": \"from math import gcd\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points)==1: return 1\\n d,d2,dv = set(),set(),set()\\n points.sort(key=lambda x:x[0])\\n for i,c1 in enumerate(points):\\n for j,c2 in enumerate(points[i+1:]):\\n x1,y1 = c1\\n x2,y2 = c2\\n if x1==x2: d.add(x1)\\n if y1==y2: d2.add(y1)\\n if x1!=x2 and y1!=y2:\\n\\n dx,dy = (x2-x1)//gcd(x2-x1,y2-y1), (y2-y1)//gcd(x2-x1,y2-y1)\\n if dx<0 and dy<0: dx *= -1; dy *= -1\\n fac = x1//dx\\n dv.add((dx,dy,x1-dx*fac,y1-dy*fac))\\n d3 = {}\\n for x,y in points:\\n if x in d: d3[(x,\\\"x\\\")] = d3.get((x,\\\"x\\\"),0)+1\\n if y in d2: d3[(y,\\\"y\\\")] = d3.get((y,\\\"y\\\"),0)+1\\n for dx,dy,ix,iy in dv:\\n if x==ix and y==iy: d3[(dx,dy,ix,iy)] = d3.get((dx,dy,ix,iy),0)+1\\n else:\\n cx,cy = (x-ix)/gcd(x-ix,y-iy), (y-iy)/gcd(x-ix,y-iy)\\n if cx<0: cx *= -1; cy *= -1\\n if cx==dx and cy==dy: d3[(dx,dy,ix,iy)] = d3.get((dx,dy,ix,iy),0)+1\\n print(d3)\\n return max(d3.values())\",\n \"memory\": \"30865\"\n },\n {\n \"code\": \"from math import gcd\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points)==1: return 1\\n d,d2,dv = set(),set(),set()\\n points.sort(key=lambda x:x[0])\\n for i,c1 in enumerate(points):\\n for j,c2 in enumerate(points[i+1:]):\\n x1,y1 = c1\\n x2,y2 = c2\\n if x1==x2: d.add(x1)\\n if y1==y2: d2.add(y1)\\n if x1!=x2 and y1!=y2:\\n\\n dx,dy = (x2-x1)//gcd(x2-x1,y2-y1), (y2-y1)//gcd(x2-x1,y2-y1)\\n if dx<0 and dy<0: dx *= -1; dy *= -1\\n fac = x1//dx\\n dv.add((dx,dy,x1-dx*fac,y1-dy*fac))\\n d3 = {}\\n for x,y in points:\\n if x in d: d3[(x,\\\"x\\\")] = d3.get((x,\\\"x\\\"),0)+1\\n if y in d2: d3[(y,\\\"y\\\")] = d3.get((y,\\\"y\\\"),0)+1\\n for dx,dy,ix,iy in dv:\\n if x==ix and y==iy: d3[(dx,dy,ix,iy)] = d3.get((dx,dy,ix,iy),0)+1\\n else:\\n cx,cy = (x-ix)/gcd(x-ix,y-iy), (y-iy)/gcd(x-ix,y-iy)\\n if cx<0: cx *= -1; cy *= -1\\n if cx==dx and cy==dy: d3[(dx,dy,ix,iy)] = d3.get((dx,dy,ix,iy),0)+1\\n return max(d3.values())\",\n \"memory\": \"31174\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 1:\\n return len(points)\\n \\n res_map = defaultdict(list)\\n for i, point in enumerate(points):\\n for next in points[i + 1:]:\\n try:\\n rate = (next[0] - point[0]) / (next[1] - point[1])\\n except ZeroDivisionError:\\n rate = ''\\n res_map[rate, tuple(point)].append(next)\\n\\n return max([len(points) for _, points in res_map.items()]) + 1\",\n \"memory\": \"31174\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1: return 1\\n cnt = Counter()\\n\\n def line(p1, p2):\\n if p1[0] == p2[0]:\\n return inf, p1[0]\\n slp = (p2[1] - p1[1])/(p2[0] - p1[0])\\n intercept = (p2[0]*p1[1] - p1[0]*p2[1])/(p2[0] - p1[0])\\n return slp, intercept\\n\\n # given sum of s, return n such that s == n*(n+1)/2\\n def helper(s):\\n return int(abs((-1 + math.sqrt(1 + 8*s))//2))\\n\\n for i in range(len(points)-1):\\n for j in range(i+1, len(points)):\\n slp, b = line(points[i], points[j])\\n cnt[(slp, b)] += 1\\n\\n print(cnt.most_common())\\n s = cnt.most_common()[0][1] \\n return helper(s) + 1 \",\n \"memory\": \"31483\"\n },\n {\n \"code\": \"import math\\nfrom fractions import Fraction\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n num_pts= {}\\n for n0 in range(len(points)):\\n for n1 in range(n0+1, len(points)):\\n if points[n1][0] == points[n0][0]:\\n m = float(\\\"inf\\\")\\n b = points[n1][0]\\n else:\\n m = Fraction(points[n1][1] - points[n0][1], points[n1][0] - points[n0][0])\\n b = points[n1][1] - m * points[n1][0]\\n if (m,b) not in num_pts:\\n num_pts[(m,b)] = 1\\n else:\\n num_pts[(m,b)] += 1\\n print(num_pts)\\n maxval = 0\\n for k, v in num_pts.items():\\n if v > maxval:\\n maxval = v\\n return int(math.floor(math.sqrt(maxval * 2))) + 1\\n\",\n \"memory\": \"31483\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: list[list[int]]) -> int:\\n if len(points) < 2:\\n return len(points) \\n line_set = set()\\n count = {}\\n def evc_algo (a, b): #assume that both positive\\n a_ = a\\n b_ = b\\n while (a_ != 0 and b_ != 0):\\n if (a_ >= b_): a_ = a_ % b_\\n else: b_ = b_ % a_\\n if a_ == 0:\\n return b_\\n else: return a_\\n def func(x0, x1, y0, y1):\\n if (x0 == x1):\\n t = (None, x0)\\n if t not in line_set:\\n line_set.add(t)\\n else:\\n if y0 - y1 >= 0: a = y0 - y1\\n else: a = - (y0 - y1)\\n if x0 - x1 >= 0: b = x0 - x1\\n else: b = - (x0 - x1)\\n nod = evc_algo(a, b)\\n if y1 * (x0 - x1) - x1 * (y0 - y1) >= 0: c = y1 * (x0 - x1) - x1 * (y0 - y1)\\n else: c = - (y1* (x0 - x1) - x1 * (y0 - y1))\\n nod1 = evc_algo(b, c)\\n #####\\n t = []\\n if (y0 - y1 >= 0 and x0 -x1 >=0) or (y0 - y1 < 0 and x0 - x1 < 0):\\n t.append((a//nod, b//nod))\\n else:\\n t.append((-a//nod,b//nod))\\n if ((y1* (x0-x1) - x1 * (y0-y1)) >= 0 and x0 -x1 >=0) or ((y1 * (x0-x1) - x1 * (y0-y1)) < 0 and x0 - x1 < 0):\\n t.append((c//nod1, b//nod1))\\n else:\\n t.append((-c//nod1, b//nod1))\\n t = tuple(t)\\n if t not in line_set:\\n line_set.add(t)\\n set_point = set()\\n for p in points:\\n t = tuple(p)\\n if t not in set_point:\\n set_point.add(t)\\n set_point = list(set_point)\\n for i in range (len(set_point) - 1):\\n for j in range (i + 1, len(set_point)):\\n func(set_point[i][0], set_point[j][0], set_point[i][1], set_point[j][1])\\n line_set = list(line_set)\\n # print(line_set)\\n for line in line_set:\\n count[line] = 0\\n for p in set_point:\\n if line == ((70, 23), (9, 1)):\\n print(p[1], (line[0][0] / line[0][1]) * p[0] + line[1][0]/line[1][1])\\n if line[0] == None and line[1] == p[0]:\\n count[line] += 1\\n elif (line[0] != None and p[1] == (line[0][0] * p[0] * line[1][1] + line[1][0] * line[0][1])/(line[0][1] * line[1][1])):\\n count[line] += 1\\n return max(count.values())\",\n \"memory\": \"31791\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n N = len(points)\\n points.sort(key = lambda x : x[0])\\n \\n grad_ = {}\\n di = {}\\n\\n max_ = 1\\n\\n for i in range(N-1):\\n point1 = points[i]\\n for j in range(i+1,N):\\n \\n point2 = points[j]\\n if point2[0]-point1[0]==0:\\n grad = float(inf)\\n intercept = point1[0]\\n else:\\n grad = (point2[1]-point1[1])/(point2[0]-point1[0])\\n intercept = round(point2[1] - grad*point2[0], 10)\\n \\n if tuple(point2+[grad,intercept]) not in di.keys():\\n if tuple([grad, intercept]) not in grad_.keys():\\n grad_[tuple([grad, intercept])] = 2\\n else:\\n grad_[tuple([grad, intercept])] += 1\\n if grad_[tuple([grad, intercept])]>max_:\\n max_ = grad_[tuple([grad, intercept])]\\n\\n if tuple(point2+[grad, intercept]) not in di.keys():\\n di[tuple(point2+[grad,intercept])] = None\\n return(max_)\\n\\n\",\n \"memory\": \"32100\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 0:\\n return 0\\n elif len(points) == 1:\\n return 1\\n\\n n = len(points)\\n lines = {}\\n line_points = {}\\n\\n for i in range(0, n):\\n for j in range(i+1, n):\\n if points[j][0] != points[i][0]:\\n slope = (points[j][1] - points[i][1])/(points[j][0] - points[i][0])\\n intercept = points[j][1] - slope*points[j][0]\\n else:\\n slope = \\\"inf\\\"\\n intercept = points[j][0]\\n\\n pair = (slope, intercept)\\n\\n if pair not in lines:\\n lines[pair] = 2\\n line_points[pair] = [points[j], points[i]]\\n elif points[i] not in line_points[pair] or points[j] not in line_points[pair]:\\n lines[pair] += 1\\n if points[i] not in line_points[pair]:\\n line_points[pair].append(points[i])\\n else:\\n line_points[pair].append(points[j])\\n\\n #print(i, j, pair)\\n #print(lines, line_points) \\n\\n return max(lines.values())\",\n \"memory\": \"32100\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n #y = mx + c\\n #c = y - mx\\n #c_x = -c/m\\n def grad(p1, p2):\\n y1,x1 = p1\\n y2,x2 = p2\\n if (x2 - x1) == 0:\\n m = \\\"inf\\\"\\n c = None\\n c_x = x1\\n else:\\n m = (y2 - y1) / (x2 - x1)\\n if m == 0:\\n c = y1\\n c_x = None\\n else:\\n c = y1 - m * x1\\n c_x = -c / m\\n return m,c,c_x\\n\\n lines = {} # (m,c) -> freq\\n visited = {}\\n points.sort(key=lambda x: x[0])\\n n = len(points)\\n for i in range(n):\\n for j in range(i+1, n):\\n m,c,c_x = grad(points[i], points[j])\\n if (m,c,c_x) in visited:\\n continue\\n else:\\n lines[(m,c,c_x)] = lines.get((m,c,c_x), 1) + 1\\n visited.update(lines)\\n if n < 2:\\n return n\\n return max(lines.values())\\n\\n\\n \",\n \"memory\": \"32409\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n def norm(loc):\\n return (loc[0]**2+loc[1]**2)**0.5\\n\\n def get_angle(loc1,loc2):\\n del_x = loc1[0] - loc2[0]\\n del_y = loc1[1] - loc2[1]\\n return math.atan2(del_x,del_y)\\n\\n cosine_map = {}\\n for i in range(len(points)):\\n for j in range(len(points)):\\n if i != j:\\n angle = str(get_angle(points[i],points[j]))\\n key = tuple(points[i])\\n if key in cosine_map:\\n # print(key,points[j],angle,cosine_map[key].get(angle,[]))\\n cosine_map[key][angle] = cosine_map[key].get(angle,[]) + [points[j]]\\n else:\\n cosine_map[key] = {angle:[points[j]]}\\n\\n # print(cosine_map)\\n max_length = 0\\n for p1 in cosine_map:\\n for p2 in cosine_map[p1]:\\n max_length = max(max_length,len(cosine_map[p1][p2]))\\n\\n return max_length + 1\\n \",\n \"memory\": \"32409\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n plen = len(points)\\n\\n lines = dict()\\n\\n maxp = 1\\n\\n for i, p1 in enumerate(points[:-1]):\\n x1, y1 = p1[0], p1[1]\\n for j in range(i+1, plen):\\n p2 = points[j]\\n x2, y2 = p2[0], p2[1]\\n\\n # Get the slope and intercept tuple\\n c = ((x2*y1) - (x1*y2)) / (x2 - x1) if x1 != x2 else x1\\n m = (y2-y1) / (x2-x1) if x1 != x2 else 9999999999\\n cline = (m,c)\\n # print(cline, lines)\\n if cline not in lines.keys():\\n lines[cline] = [2, [p1, p2]]\\n else: \\n if p1 not in lines[cline][1]: \\n lines[cline][1].append(p1)\\n if p2 not in lines[cline][1]: \\n lines[cline][1].append(p2)\\n\\n lines[cline][0] = len(lines[cline][1])\\n\\n if lines[cline][0] > maxp:\\n maxp = lines[cline][0]\\n\\n # print(lines)\\n return maxp\\n \\n\\n \\n \",\n \"memory\": \"32718\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n if n == 1:\\n return 1\\n elif n == 2:\\n return 2\\n ans = 2\\n # Get the points with same x value, since they cannot get K\\n x_freq = {}\\n for p in points:\\n (x, y) = p\\n if x not in x_freq:\\n x_freq[x] = 1\\n else:\\n x_freq[x] += 1\\n ans = max(ans, x_freq[x])\\n k_freq = {}\\n for i in range(n):\\n x1, y1 = points[i]\\n for j in range(i+1, n):\\n x2, y2 = points[j]\\n if x2 != x1:\\n k = (y2 - y1) / (x2 - x1)\\n b = y2 - k * x2\\n id = f\\\"{k}#{b}\\\"\\n if id not in k_freq:\\n k_freq[id] = set([x1, x2])\\n else:\\n k_freq[id].add(x1)\\n k_freq[id].add(x2)\\n ans = max(ans, len(k_freq[id]))\\n return ans\\n \",\n \"memory\": \"32718\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n d={}\\n for i in range(len(points)):\\n for j in points[i+1:]:\\n xd=points[i][0]-j[0]\\n yd=points[i][1]-j[1]\\n if not xd:\\n slope=\\\"inf\\\"\\n c=j[0]\\n else:\\n slope=yd/xd\\n c=j[1]-slope*j[0]\\n if (slope,c) not in d.keys():\\n d[(slope,c)]=[2,[points[i],j]]\\n else:\\n if points[i] not in d[(slope,c)][1]:\\n d[(slope,c)][1].append(points[i])\\n d[(slope,c)][0]+=1\\n if j not in d[(slope,c)][1]:\\n d[(slope,c)][1].append(j)\\n d[(slope,c)][0]+=1\\n for i in d.keys():\\n print(i,d[i])\\n if not d:\\n return 1\\n return max([i[0] for i in d.values()])\",\n \"memory\": \"33026\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n lines = {}\\n for i in range(n):\\n for j in range(i + 1, n):\\n if points[i][0] == points[j][0]:\\n idx = f\\\"1,0,{-points[i][0]}\\\"\\n elif points[i][1] == points[j][1]:\\n idx = f\\\"0,1,{-points[i][1]}\\\"\\n else:\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n idx = f\\\"{(y2 - y1) / (x2 - x1)},-1,{(y1 * x2 - y2 * x1) / (x2 - x1)}\\\"\\n if idx in lines:\\n lines[idx].add(i)\\n lines[idx].add(j)\\n else:\\n lines[idx] = set([i, j])\\n ans = 1\\n for k, v in lines.items():\\n ans = max(ans, len(v))\\n return ans\",\n \"memory\": \"33026\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n def gcd(a, b):\\n return a if b == 0 else gcd(b, a % b)\\n\\n d = defaultdict(int)\\n n = len(points)\\n for i in range(n):\\n pt1 = points[i]\\n for j in range(n):\\n if i == j:\\n continue\\n pt2 = points[j]\\n p, q = pt1[0] - pt2[0], pt1[1] - pt2[1]\\n g = gcd(abs(p), abs(q))\\n p //= g\\n q //= g\\n d[(pt1[0], pt1[1], p, q)] += 1\\n if len(d) == 0:\\n return 1\\n return max(d.values()) + 1\\n\",\n \"memory\": \"33335\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # each edge can be mapped to a pair (a, b)\\n # where a=slope, b=bias of the unique line containing edge\\n from collections import defaultdict\\n import fractions\\n from itertools import combinations\\n \\n lines = defaultdict(int)\\n vert_lines = defaultdict(int)\\n \\n for p1, p2 in combinations(points, 2):\\n x1, y1 = p1\\n x2, y2 = p2\\n\\n if x1 == x2:\\n vert_lines[x1] += 1\\n else:\\n a = fractions.Fraction(y2 - y1, x2 - x1)\\n b = y2 - x2 * a\\n lines[a, b] += 1\\n\\n # if line contains n points\\n # lines[a,b] = (n choose 2)\\n # how to extract n?\\n # x = n*(n-1) / 2\\n # 2x = n*(n-1)\\n # 2x = n^2 - n\\n # 0 = n^2 - n - 2x\\n # delta = 1 + 8x\\n # n = (1 + sqrt(delta) / 2)\\n\\n import math\\n\\n def comb_to_n(combs):\\n delta = 1 + 8*combs\\n n = (1 + math.sqrt(delta)) / 2\\n n = int(n)\\n return n\\n\\n m = 1\\n for v in vert_lines.values():\\n v = comb_to_n(v)\\n if v > m:\\n m = v\\n\\n for (a, b), v in lines.items():\\n v = comb_to_n(v)\\n if v > m:\\n m = v\\n\\n print(lines)\\n print(vert_lines)\\n\\n return m\",\n \"memory\": \"33335\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n cache = {}\\n for index in range(len(points)):\\n for pairindex in range(index+1,len(points)):\\n x1,y1 = points[index]\\n x2,y2 = points[pairindex]\\n if x2 >x1:\\n grad = (y2-y1)/(x2-x1)\\n intercept = y2-grad*x2\\n if x2 < x1:\\n grad = (y1-y2)/(x1-x2)\\n intercept = y2-grad*x2\\n if x2 == x1:\\n grad = None\\n intercept = x2\\n key = str(grad) + \\\",\\\" +str(intercept)\\n if key not in cache:\\n cache[key] = [[x1,y1],[x2,y2]]\\n else:\\n if [x1,y1] not in cache[key]:\\n cache[key].append([x1,y1])\\n if [x2,y2] not in cache[key]:\\n cache[key].append([x2,y2])\\n\\n max_val = 1\\n for key in cache.keys():\\n if len(cache[key]) > max_val:\\n max_val = len(cache[key])\\n return max_val\",\n \"memory\": \"33644\"\n },\n {\n \"code\": \"# 2:07pm\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # Thoughts:\\n # - In order for a point to be on the same line, they must have a matching slope\\n # Meaning p1 = p2 + x(slope)\\n # - There are a lot of possible slopes\\n # - So brute force solution:\\n # - Calculate all slopes between each 2 points\\n # - Try applying those slopes to all the relevant points, and count the number of items that match\\n # Edgecases:\\n # - Slope is not an integer\\n # - Can points not be integers?: NO\\n # - Dont' want to accidentally calculate the opposite slope by iterating backwards\\n # \\n # Approach 1:\\n # Sort the points by x coord (so we don't get opposite slopes) O(nlogn)\\n # Iterate all combination of points with later points to calc possible slopes at each point O(n^2)\\n # Combine slopes with points and compare (use % operation) Iterate over each obtained slope once, then apply it to all points, so O(n^3)\\n # How do I reduce slopes?\\n # Approach 2:\\n # Is there a faster/cleaner way to calculate all possible slopes?\\n # What if I tried applying the operations out of order?\\n # Take the mod of all x's from 1-max(x)\\n # Take the mod of all y's from 1-max(y)\\n # Try to match them up?\\n # That sounds interesting. Let's write out some pseudocode\\n # Approach 3: Saw in someone's solution\\n # Create a line from every combination of 2 data points. \\n # Convert line to y-intercept form\\n # Line that is created the most often is the answer\\n count = {}\\n visited = {}\\n maxCount = 0\\n if not points:\\n return 0\\n \\n if len(points) == 1:\\n return 1\\n\\n points.sort(key=lambda a: a[0]) # Sort by ascending x value\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n if x2 == x1:\\n slope = 'inf'\\n yInt = x1 # No y-intercept. So put x-int instead\\n else:\\n slope = (y2-y1)/(x2-x1)\\n yInt = y1 - x1*slope\\n if slope not in count:\\n count[slope] = {}\\n\\n if slope not in visited:\\n visited[slope] = {}\\n # Only concern here is how sloppy python is with floats.\\n # I don't know if using floats as keys is a good idea.\\n \\n # If the start and endpoint have both had this slope before, don't count them again\\n if i not in visited[slope] or j not in visited[slope]:\\n count[slope][yInt] = count[slope].get(yInt, 1) + 1\\n maxCount = max(maxCount, count[slope][yInt]) \\n visited[slope][i] = True\\n visited[slope][j] = True\\n\\n return maxCount\\n\\n\\n\",\n \"memory\": \"33953\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n \\n x = {}\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n k, b = self.line(points[i], points[j])\\n if k not in x:\\n x[k] = {}\\n \\n if b not in x[k]:\\n x[k][b] = [i, j]\\n else:\\n temp = x[k][b]\\n if i not in temp:\\n temp.append(i)\\n if j not in temp:\\n temp.append(j) \\n x[k][b] = temp\\n \\n print(x)\\n maxl = 1\\n for k in x:\\n for b in x[k]:\\n maxl = max(maxl, len(x[k][b]))\\n return maxl\\n \\n def line(self, a, b):\\n if a[1] == b[1]:\\n return 'NA', a[1]\\n if a[0] == b[0]:\\n return a[0], 'NA'\\n k = (b[1] - a[1])/(b[0] - a[0])\\n return k, a[1] - k * a[0]\\n \",\n \"memory\": \"33953\"\n },\n {\n \"code\": \"import collections\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n points = sorted(points, key=lambda v:v[0] * 10001 + v[1])\\n if len(points) < 2:\\n return len(points)\\n primes = list(range(201))\\n for i in range(2, len(primes)):\\n p = primes[i]\\n if not p:\\n continue\\n for j in range(2*p, len(primes), p):\\n primes[j] = 0\\n primes = [v for v in primes if v > 1]\\n\\n N = len(points)\\n slopes = collections.defaultdict(set)\\n for s in range(N):\\n xs, ys = points[s]\\n for e in range(s + 1, N):\\n xe, ye = points[e]\\n lx, ly = xe - xs, ye - ys\\n if lx == 0:\\n ly = abs(ly)\\n if ly == 0:\\n lx = abs(lx)\\n for p in primes:\\n while lx % p == 0 and ly % p == 0:\\n lx, ly = lx // p, ly // p\\n key = (lx, ly, xs, ys)\\n slopes[key] |= {s, e}\\n return max(len(v) for v in slopes.values())\",\n \"memory\": \"34261\"\n },\n {\n \"code\": \"import collections\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n points = sorted(points, key=lambda v:v[0] * 10001 + v[1])\\n if len(points) < 2:\\n return len(points)\\n primes = list(range(201))\\n for i in range(2, len(primes)):\\n p = primes[i]\\n if not p:\\n continue\\n for j in range(2*p, len(primes), p):\\n primes[j] = 0\\n primes = [v for v in primes if v > 1]\\n\\n N = len(points)\\n slopes = collections.defaultdict(set)\\n for s in range(N):\\n xs, ys = points[s]\\n for e in range(s + 1, N):\\n xe, ye = points[e]\\n lx, ly = xe - xs, ye - ys\\n if lx == 0:\\n ly = abs(ly)\\n if ly == 0:\\n lx = abs(lx)\\n for p in primes:\\n while lx % p == 0 and ly % p == 0:\\n lx, ly = lx // p, ly // p\\n key = (lx, ly, xs, ys)\\n slopes[key] |= {s, e}\\n return max(len(v) for v in slopes.values())\",\n \"memory\": \"34261\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxPoints(self, points) -> int:\\n if(len(points) < 2):\\n return len(points)\\n\\n m_map = {}\\n\\n for i in range(len(points)-1):\\n p2 = points[i+1]\\n j_to_skip = {}\\n for j in range(i+1):\\n p1 = points[j]\\n m = self.calcGradient(p1, p2)\\n \\n if j in j_to_skip:\\n continue\\n \\n if (m, j) not in m_map:\\n m_map[(m, j)] = {j, i+1}\\n else:\\n m_map[(m, j)] = m_map[(m, j)].union({i+1})\\n\\n j_to_skip = m_map[(m, j)].union(j_to_skip)\\n \\n return self.getMaxPoint(m_map)\\n\\n def getMaxPoint(self, m_map) -> int:\\n max_val = -1\\n\\n for val in m_map.values():\\n # total_points = max(len(list_point) for list_point in val)\\n total_points = len(val)\\n if total_points > max_val:\\n max_val = total_points\\n\\n return max_val\\n\\n def calcGradient(self, p1, p2):\\n x1, y1 = p1\\n x2, y2 = p2\\n try:\\n m = (y2-y1)/(x2-x1)\\n except:\\n m = 999999\\n return m\\n\",\n \"memory\": \"34570\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxPoints(self, points) -> int:\\n if(len(points) < 2):\\n return len(points)\\n\\n m_map = {}\\n\\n for i in range(len(points)-1):\\n p2 = points[i+1]\\n # j_to_skip = {}\\n for j in range(i+1):\\n p1 = points[j]\\n m = self.calcGradient(p1, p2)\\n \\n # if j in j_to_skip:\\n # continue\\n \\n if (m, j) not in m_map:\\n m_map[(m, j)] = {j, i+1}\\n else:\\n m_map[(m, j)] = m_map[(m, j)].union({i+1})\\n\\n # j_to_skip = m_map[(m, j)].union(j_to_skip)\\n \\n return self.getMaxPoint(m_map)\\n\\n def getMaxPoint(self, m_map) -> int:\\n max_val = -1\\n\\n for val in m_map.values():\\n # total_points = max(len(list_point) for list_point in val)\\n total_points = len(val)\\n if total_points > max_val:\\n max_val = total_points\\n\\n return max_val\\n\\n def calcGradient(self, p1, p2):\\n x1, y1 = p1\\n x2, y2 = p2\\n try:\\n m = (y2-y1)/(x2-x1)\\n except:\\n m = 999999\\n return m\\n\",\n \"memory\": \"34570\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n if len(points) <= 1:\\n return len(points)\\n\\n points = sorted(points)\\n\\n slopeIntercept = {}\\n\\n i = 0\\n while i < len(points):\\n j = i + 1\\n while j < len(points):\\n currSlope = float('inf')\\n if (points[j][0] - points[i][0]) != 0:\\n currSlope = (points[j][1] - points[i][1]) / (points[j][0] - points[i][0])\\n \\n intercept = points[j][0]\\n if currSlope != float('inf'):\\n intercept = points[j][1] - (currSlope * points[j][0])\\n \\n intercept = round(intercept, 2)\\n \\n \\n\\n if (currSlope, intercept) not in slopeIntercept:\\n slopeIntercept[(currSlope, intercept)] = [(points[i][0], points[i][1]), (points[j][0], points[j][1])]\\n else:\\n slopeIntercept[(currSlope, intercept)].append((points[j][0], points[j][1]))\\n j += 1\\n i += 1\\n \\n currMax = 0\\n for key in slopeIntercept:\\n currSet = slopeIntercept[key]\\n currSet = set(currSet)\\n currMax = max(currMax, len(currSet))\\n\\n return currMax\\n\\n\\n \",\n \"memory\": \"34879\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n L = defaultdict(set)\\n def line(points, i, j):\\n x0, y0 = points[i]\\n x1, y1 = points[j]\\n a , b = y1 - y0, x0 - x1\\n c = x0 * a + y0 * b\\n d = gcd(gcd(a, b), c)\\n a, b, c = a // d, b // d, c // d\\n if c < 0:\\n a, b, c=-a, -b, -c\\n elif c==0:# This can occur!\\n if b<0 or (a<0 and b==0): \\n a=-a \\n b=-b\\n line_key = (a, b, c)\\n L[line_key].add(i)\\n L[line_key].add(j)\\n\\n n = len(points)\\n if n == 1:\\n return 1 # edge case\\n\\n for i in range(n - 1):\\n for j in range(i + 1, n):\\n line(points, i, j)\\n\\n max_points_on_line = 0\\n\\n for _, point_set in L.items():\\n max_points_on_line = max(max_points_on_line, len(point_set))\\n\\n return max_points_on_line\",\n \"memory\": \"35188\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n points = list(map(tuple, points))\\n n = len(points)\\n d = collections.defaultdict(set)\\n for i in range(n-1):\\n for j in range(i+1,n):\\n x = points[j][0]-points[i][0]\\n y = points[j][1]-points[i][1]\\n if x == 0:\\n line = points[i][0]\\n else:\\n k =y/x\\n b = points[i][1] - points[i][0]*k\\n line = k,b\\n d[line].add(points[i])\\n d[line].add(points[j])\\n res = 1\\n for i in d:\\n res = max(res, len(d[i]))\\n\\n return res\",\n \"memory\": \"35496\"\n },\n {\n \"code\": \"# Hard problem. Max Points on a Line.\\n# Given an array of points where points[i] = [x, y]\\n# Return the maximum number of points on the same straight line\\n\\n# Ok, let's remember from algebra,\\n# the equation of a line is:\\n# y = m * x + b\\n# And given two points, we can find a line between them\\n\\n# We notice that a point can either be on the maximum line\\n# or not on the maximum line\\n\\n# the maximum line is the line that has the most points on it\\n\\n# The minimum answer is going to be 1 if points.length == 1\\n# and 2 is points.length == 2\\n# If the max len is 3 and points.length is 3, then all points\\n# are on the same line\\n\\n# It might take some work to code up the function verifying\\n# If a point is on line A, but it won't be that hard, I\\n# was good at algebra\\n\\n# We have up to 300 points\\n# 300^2 is a reasonable solution\\n# 300^3 == 300 * 90000 == 27000000\\n# which is even doable\\n# One point will have up to 300 lines\\n# Why don't we enumerate every line, check whether other points are on that line\\n# and count for that line?\\n# If there an easy way to tell if a point is on the line?\\n# All we have of a point is its x and y position\\n# Maybe if we plug x and y into the equation of the line,\\n# and we get an equality, the point is on our line\\n# I think I know what to do\\n# Create every line from each point to each other point\\n# check all points if they are on that line\\n# bam\\n\\n# Maybe we could use a set of lines so that we don't\\n# have to recheck\\nclass Solution:\\n def maxPoints(self, points: list[list[int]]) -> int:\\n if len(points) <= 2: return len(points)\\n def defval():\\n return []\\n line_set = defaultdict(defval)\\n \\n for i in range(len(points)):\\n x1, y1 = points[i]\\n #print(\\\"starting: {}, {}\\\".format(x1, y1))\\n for j in range(i + 1, len(points)):\\n x2, y2 = points[j]\\n \\n if x1 == x2:\\n m = float('inf')\\n b = x1\\n else:\\n m = (y2 - y1) / (x2 - x1)\\n b = y1 - (m * x1)\\n \\n #print(x2, y2, m, b)\\n intersects = line_set[(m,b)]\\n if (x1, y1) not in intersects:\\n intersects.append((x1, y1))\\n if (x2, y2) not in intersects:\\n intersects.append((x2, y2))\\n \\n #print(\\\"lines:\\\")\\n max_points = 0\\n for line in line_set:\\n max_points = max(max_points, len(line_set[line]))\\n #print(line, line_set[line])\\n return max_points\",\n \"memory\": \"35496\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n n = len(points)\\n if n == 1:\\n return 1\\n \\n def get_line(x1, y1, x2, y2):\\n if x2 - x1 == 0:\\n return ('None', x1)\\n m = (y2 - y1) / (x2 - x1)\\n b = y1 - m * x1\\n return (m, b)\\n \\n \\n line_map = defaultdict(set)\\n for i in range(n):\\n for j in range(i + 1, n):\\n line_eq = get_line(points[i][0], points[i][1], points[j][0], points[j][1])\\n line_map[line_eq].add(i)\\n line_map[line_eq].add(j)\\n \\n return max([len(line_map[key]) for key in line_map])\",\n \"memory\": \"35805\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n equation_point_count = {}\\n max_points = 0\\n n = len(points)\\n\\n if n==1: \\n return 1\\n \\n for i in range(n):\\n x1, y1 = points[i]\\n for j in range(i+1, n):\\n x2, y2 = points[j]\\n if x2-x1==0:\\n m = float(\\\"inf\\\")\\n c = x1\\n else:\\n m = (y2-y1)/(x2-x1) \\n c = y1-m*x1\\n\\n if (m,c) not in equation_point_count:\\n equation_point_count[(m,c)] = set()\\n\\n equation_point_count[(m,c)].add(i)\\n equation_point_count[(m,c)].add(j)\\n max_points = max(max_points, len(equation_point_count[(m,c)]))\\n\\n return max_points\\n \",\n \"memory\": \"35805\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n import math\\n\\n if len(points) < 2:\\n return 1\\n\\n def slope(p1, p2):\\n if (p2[0] - p1[0]) == 0:\\n return \\\"inf\\\"\\n return ((p2[1] - p1[1]) / (p2[0] - p1[0]))\\n\\n all = {}\\n\\n for curr in points:\\n for comp in points:\\n if comp == curr:\\n continue\\n slp = slope(curr, comp)\\n if slp == \\\"inf\\\":\\n eq = (curr[0], slope(curr, comp))\\n else:\\n eq = (round(curr[1] - slope(curr, comp) * curr[0], 5), slope(curr, comp))\\n if eq not in all:\\n all[eq] = [(curr, comp)]\\n else:\\n all[eq].append((curr, comp))\\n\\n maxiVal = float(\\\"-inf\\\")\\n\\n for key, val in all.items():\\n if len(val) > maxiVal:\\n maxiVal = len(val)\\n return (int((1 + math.sqrt(1 + 4 * maxiVal)) / 2))\\n\\n\",\n \"memory\": \"36114\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n #calculate sllope y = mx + b b = y-mx\\n m = {}\\n for i in range(len(points)):\\n one = points[i]\\n for j in range(i, len(points)):\\n if j == i:\\n continue\\n else:\\n two = points[j]\\n if (one[1] == two[1]):\\n slope = 0\\n b = one[1]\\n elif (one[0] == two[0]):\\n slope = \\\"undefined\\\"\\n b = one[0]\\n else:\\n slope = (one[1] - two[1])/(one[0] - two[0])\\n b = one[1] - (one[0]*slope)\\n if (slope, b) not in m:\\n m[(slope, b)] = []\\n if one not in m[(slope, b)]:\\n m[(slope, b)].append(one) \\n if two not in m[(slope, b)]:\\n m[(slope, b)].append(two)\\n c = [len(v) for v in m.values()]\\n print(m)\\n if not c:\\n return 1\\n return max(c)\\n \\n\\n\\n\\n \\n \",\n \"memory\": \"36114\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # all points in the group have same slope ratio with all others\\n m = {} # slope - [points_set1, points_set2]\\n ret = 1\\n # ratio_op = lambda x1,x2:(x1[0]-x2[0])/(x1[1]-x2[1])\\n def ratio_op(x1,x2):\\n if x1[1]==x2[1]:\\n return 1<<32\\n return (x1[0]-x2[0])/(x1[1]-x2[1])\\n\\n for i in range(len(points)-1):\\n pt1 = points[i]\\n for j in range(i+1,len(points)):\\n pt2 = points[j]\\n ratio = ratio_op(pt1,pt2)\\n m[ratio] = m.get(ratio, [])\\n new_set = True\\n for set_s in m[ratio]:\\n if tuple(pt1) in set_s or tuple(pt2) in set_s or \\\\\\n any([ratio_op(pt1,p) == ratio for p in set_s]):\\n # add to this set\\n set_s.add(tuple(pt1))\\n set_s.add(tuple(pt2))\\n new_set = False\\n ret = max(ret, len(set_s))\\n break\\n if new_set:\\n m[ratio].append(set([tuple(pt1), tuple(pt2)]))\\n ret = max(ret, 2)\\n return ret\\n \\n \",\n \"memory\": \"36423\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points)<2:\\n return len(points)\\n cache = {}\\n op = 0\\n for p1id in range(len(points)):\\n for p2id in range(p1id+1,len(points)):\\n if points[p2id][1] == points[p1id][1]:\\n d1 = cache.get((p1id,float(\\\"inf\\\")),set())\\n d1.add(p1id)\\n d1.add(p2id)\\n cache[(p1id,float(\\\"inf\\\"))] = d1\\n if len(d1) > op:\\n op = len(d1)\\n else:\\n m1 = (points[p2id][0] - points[p1id][0])/(points[p2id][1] - points[p1id][1])\\n d1 = cache.get((p1id,m1),set())\\n d1.add(p1id)\\n d1.add(p2id)\\n cache[(p1id,m1)] = d1\\n if len(d1) > op:\\n op = len(d1)\\n print(cache)\\n return op\",\n \"memory\": \"36731\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # find all pairwise lines\\n # start with arbitrary unpaired point and another point\\n # grow the line\\n # remove need for pairwise compute for grown line\\n\\n if len(points) == 1:\\n return 1\\n\\n for i in range(len(points)):\\n points[i] = tuple(points[i])\\n\\n def get_line_params(p1, p2):\\n if p1[0] == p2[0]:\\n m = float('inf')\\n yi = None\\n xi = p1[0]\\n elif p1[1] == p2[1]:\\n m = 0\\n yi = p1[1]\\n xi = None\\n else:\\n m = (p1[1] - p2[1]) / (p1[0] - p2[0]) # slope\\n yi = p1[1] - m * p1[0] # y-intercept\\n xi = -yi / m # x-intercept\\n return m, yi, xi\\n\\n lines = {}\\n\\n for i in range(len(points) - 1):\\n for j in range(i + 1, len(points)):\\n if i != j:\\n p1, p2 = points[i], points[j]\\n m, yi, xi = get_line_params(p1, p2)\\n if (m, yi, xi) in lines:\\n lines[(m, yi, xi)].add(p1)\\n lines[(m, yi, xi)].add(p2)\\n else:\\n lines[(m, yi, xi)] = {p1, p2}\\n\\n return max(len(v) for v in lines.values())\\n \",\n \"memory\": \"36731\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n # find all pairwise lines\\n # start with arbitrary unpaired point and another point\\n # grow the line\\n # remove need for pairwise compute for grown line\\n\\n if len(points) == 1:\\n return 1\\n\\n for i in range(len(points)):\\n points[i] = tuple(points[i])\\n\\n def get_line_params(p1, p2):\\n if p1[0] == p2[0]:\\n m = float('inf')\\n yi = None\\n xi = p1[0]\\n elif p1[1] == p2[1]:\\n m = 0\\n yi = p1[1]\\n xi = None\\n else:\\n m = (p1[1] - p2[1]) / (p1[0] - p2[0]) # slope\\n yi = p1[1] - m * p1[0] # y-intercept\\n xi = -yi / m # x-intercept\\n return m, yi, xi\\n\\n lines = {}\\n\\n for i in range(len(points) - 1):\\n for j in range(i + 1, len(points)):\\n if i != j:\\n p1, p2 = points[i], points[j]\\n m, yi, xi = get_line_params(p1, p2)\\n if (m, yi, xi) in lines:\\n lines[(m, yi, xi)].add(p1)\\n lines[(m, yi, xi)].add(p2)\\n else:\\n lines[(m, yi, xi)] = {p1, p2}\\n\\n return max(len(v) for v in lines.values())\\n \",\n \"memory\": \"37040\"\n },\n {\n \"code\": \"from math import inf\\nimport pprint\\n\\ndef slope_xint_yint(p1, p2):\\n if p1[0] == p2[0]:\\n return inf, p1[0], None\\n res = (p2[1] - p1[1]) / (p2[0] - p1[0])\\n y_int = p1[1] - res * p1[0]\\n if p1[1] == p2[1]:\\n x_int = None\\n else:\\n x_int = -y_int / res\\n return res, x_int, y_int\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n if len(points) == 2:\\n return 2\\n\\n max_points = 0\\n\\n slopes = dict()\\n for i in range(len(points) - 1):\\n p1 = points[i]\\n\\n for j in range(i + 1, len(points)):\\n tup = slope_xint_yint(p1, points[j])\\n\\n if tup in slopes:\\n slopes[tup].add(i)\\n slopes[tup].add(j)\\n max_points = max(max_points, len(slopes[tup]))\\n else:\\n slopes[tup] = set([i, j])\\n max_points = max(max_points, 2)\\n\\n return max_points\\n\",\n \"memory\": \"37040\"\n },\n {\n \"code\": \"class Solution:\\n def commonDivisor(self, x: int, y: int) -> int:\\n if x < 0:\\n x = -x\\n if y < 0:\\n y = -y\\n if x < y:\\n x, y = y, x\\n while y > 0:\\n x, y = y, x % y\\n return x\\n\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n # (x-x0)(y1-y0) == (x1-x0)(y-y0)\\n # x y1 + x0 y0 - x0 y1 - x y0 == x1 y + x0 y0 - x1 y0 - x0 y\\n # x (y1 - y0) - x0 (y1 - y0) == y (x1 - x0) - y0 (x1 - x0)\\n # Hash key = (x1 - x0, y1 - y0, x0 y1 - x1 y0), value = indices\\n table = {}\\n for i in range(len(points)):\\n for j in range(i + 1, len(points)):\\n x0, y0 = points[i]\\n x1, y1 = points[j]\\n a = x1 - x0\\n b = y1 - y0\\n c = x0 * y1 - x1 * y0\\n if a < 0 or (a == 0 and b < 0):\\n a, b, c = -a, -b, -c\\n d = self.commonDivisor(a, b)\\n a, b, c = a / d, b / d, c / d\\n s = table.get((a, b, c))\\n if not s:\\n s = set()\\n table[(a, b, c)] = s\\n s.add(i)\\n s.add(j)\\n n = 1 if points else 0\\n for _, indices in table.items():\\n n = max(n, len(indices))\\n return n\",\n \"memory\": \"37349\"\n },\n {\n \"code\": \"import operator\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n \\n def slope(id1,id2):\\n if id2[0]-id1[0] != 0:\\n return (id2[1]-id1[1])/(id2[0]-id1[0])\\n else:\\n return float('inf')\\n\\n def ontheline(id1,id2,id3):\\n if (id1[0]-id2[0])*(id1[1]-id3[1]) == (id1[0]-id3[0])*(id1[1]-id2[1]):\\n return True\\n else:\\n return False\\n\\n slopemap = {}\\n slope_lines = []\\n for iid1 in range(len(points)-1):\\n for iid2 in range(iid1+1,len(points),1):\\n id1 = tuple(points[iid1])\\n id2 = tuple(points[iid2])\\n s12 = slope(id1,id2)\\n if s12 not in slopemap:\\n slopemap[s12] = len(slope_lines)\\n slope_lines.append([{id1,id2},])\\n else:\\n flag = False\\n j = slopemap[s12]\\n lines = slope_lines[j]\\n for l in range(len(lines)):\\n line = lines[l]\\n if len(line & {id1,id2}) == 2:\\n flag = True\\n break\\n elif len(line & {id1,id2}) == 1:\\n slope_lines[j][l] = line | {id1,id2}\\n # print(lines, id1, id2)\\n flag = True\\n break\\n else:\\n id3 = next(iter(line))\\n if ontheline(id1,id2,id3):\\n slope_lines[j][l]= line | {id1,id2} \\n # print(lines, id1, id2, id3)\\n flag = True\\n break\\n if flag is False:\\n slope_lines[j].append({id1,id2})\\n # print(lines, id1, id2)\\n maxcnt = 1\\n for lines in slope_lines:\\n for line in lines:\\n maxcnt = max(len(line),maxcnt)\\n return maxcnt \\n\\n\",\n \"memory\": \"37349\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points) <= 1:\\n return len(points)\\n \\n slope_counter = defaultdict(set)\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n if x1 == x2:\\n key = f\\\"x-{x1}\\\"\\n slope_counter[key].add(y1)\\n slope_counter[key].add(y2)\\n elif y1 == y2:\\n key = f\\\"y-{y1}\\\"\\n slope_counter[key].add(x1)\\n slope_counter[key].add(x2)\\n else:\\n slope = (y2 - y1) / float(x2 - x1)\\n intercept = y1 - slope * x1\\n key = f\\\"{slope:.8f}-{intercept:.8f}\\\"\\n slope_counter[key].add((x1, y1))\\n slope_counter[key].add((x2, y2))\\n \\n max_points = 0\\n for key, value in slope_counter.items():\\n max_points = max(max_points, len(value))\\n \\n return max_points\",\n \"memory\": \"37658\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n # map every pair of points by 'm,b' for y=mx+b\\n # find the m,b key with the most segments in it, then return number of distinct points in it \\n # n^2 \\n def maxPoints(self, points: List[List[int]]) -> int:\\n pointToEq = defaultdict(lambda:set())\\n maxNum = 1\\n for i in range(len(points)):\\n for j in range(i+1, len(points)):\\n p1 = points[i]\\n p2 = points[j]\\n # y = mx + b\\n # m = y/x\\n yDiff = p1[1] - p2[1]\\n xDiff = p1[0] - p2[0]\\n if xDiff == 0:\\n m = \\\"vertical\\\"\\n b = p1[0]\\n else:\\n mFloat = yDiff / xDiff\\n m = \\\"{:.9f}\\\".format(mFloat)\\n # y = mx + b\\n # b = y - mx\\n bFloat = p1[1] - mFloat * p1[0]\\n b = \\\"{:.9f}\\\".format(bFloat)\\n key = f\\\"{m},{b}\\\"\\n pointToEq[key].add(f\\\"{p1[0]},{p1[1]}\\\")\\n pointToEq[key].add(f\\\"{p2[0]},{p2[1]}\\\")\\n maxNum = max(maxNum, len(pointToEq[key]))\\n return maxNum\",\n \"memory\": \"37658\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n from collections import defaultdict\\n\\n if len(points)==1:\\n return 1\\n\\n counter = defaultdict(set)\\n n = len(points)\\n \\n # Initialize a 2D list (list of lists) to store (slope, intercept) tuples\\n result = [[None] * n for _ in range(n)]\\n \\n for i in range(n):\\n for j in range(i):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n \\n if x1 == x2:\\n slope = None # Infinite slope\\n intercept = None # Intercept is undefined\\n x_intercept = x1 # x-intercept is the x-coordinate of the line\\n else:\\n # Calculate slope (m)\\n slope = (y2 - y1) / (x2 - x1)\\n # Calculate y-intercept (c)\\n intercept = y1 - slope * x1\\n # Calculate x-intercept (-c/m) if slope is not zero\\n x_intercept = -intercept / slope if slope != 0 else None\\n \\n # Store the result as a tuple (slope, y_intercept, x_intercept)\\n result[i][j] = (slope, intercept, x_intercept)\\n\\n for i in range(n):\\n for j in range(i):\\n counter[result[i][j]].update({i,j})\\n\\n counter = max([len(v) for v in counter.values()])\\n\\n return counter\",\n \"memory\": \"37966\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n from collections import defaultdict\\n\\n if len(points)==1:\\n return 1\\n\\n counter = defaultdict(set)\\n n = len(points)\\n \\n # Initialize a 2D list (list of lists) to store (slope, intercept) tuples\\n result = [[None] * n for _ in range(n)]\\n \\n for i in range(n):\\n for j in range(i):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n \\n if x1 == x2:\\n slope = float('inf') # Infinite slope\\n intercept = None # Intercept is undefined\\n x_intercept = x1 # x-intercept is the x-coordinate of the line\\n else:\\n # Calculate slope (m)\\n slope = (y2 - y1) / (x2 - x1)\\n # Calculate y-intercept (c)\\n intercept = y1 - slope * x1\\n # Calculate x-intercept (-c/m) if slope is not zero\\n x_intercept = -intercept / slope if slope != 0 else None\\n \\n # Store the result as a tuple (slope, y_intercept, x_intercept)\\n result[i][j] = (slope, intercept, x_intercept)\\n\\n for i in range(n):\\n for j in range(i):\\n counter[result[i][j]].update({i,j})\\n\\n # print(counter)\\n counter = max([len(v) for v in counter.values()])\\n\\n return counter\",\n \"memory\": \"37966\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n plen = len(points)\\n\\n lines = dict()\\n\\n maxp = 1\\n\\n for i, p1 in enumerate(points[:-1]):\\n x1, y1 = p1[0], p1[1]\\n for j in range(i+1, plen):\\n p2 = points[j]\\n x2, y2 = p2[0], p2[1]\\n\\n # Get the slope and intercept tuple\\n c = ((x2*y1) - (x1*y2)) / (x2 - x1) if x1 != x2 else x1\\n m = (y2-y1) / (x2-x1) if x1 != x2 else 9999999999\\n cline = (m,c)\\n # print(cline, lines)\\n if cline not in lines.keys():\\n lines[cline] = [2, [p1, p2]]\\n else: \\n if p1 not in lines[cline][1]: \\n lines[cline][1].append(p1)\\n if p2 not in lines[cline][1]: \\n lines[cline][1].append(p2)\\n\\n lines[cline][0] = len(lines[cline][1])\\n\\n if lines[cline][0] > maxp:\\n maxp = lines[cline][0]\\n\\n print(lines)\\n return maxp\\n \\n\\n \\n \",\n \"memory\": \"38893\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n #Lines characterized by slope and intercept (unless vertical)\\n\\n ##For each line, compute the slope and intercept\\n\\n def findLine(point1,point2):\\n\\n ##vertical line; handle later\\n if point1[0] == point2[0]:\\n return (float('inf'),float('inf'))\\n \\n m = (point1[1] - point2[1])/(point1[0]-point2[0])\\n b = point1[1] - m*point1[0]\\n return (m,b)\\n \\n lines = {}\\n seen_values = {}\\n\\n for i in range(len(points)):\\n for j in range(i+1,len(points)):\\n\\n (m,b) = findLine(points[i],points[j])\\n\\n if (m,b) != (float('inf'),float('inf')):\\n if (m,b) not in lines:\\n lines[(m,b)] = 0\\n if (m,b,points[i][0],points[i][1]) not in seen_values:\\n seen_values[ (m,b,points[i][0],points[i][1] ) ] = 0\\n lines[(m,b)] += 1\\n if (m,b,points[j][0],points[j][1]) not in seen_values:\\n seen_values[ (m,b,points[j][0],points[j][1] ) ] = 0\\n lines[(m,b)] += 1\\n \\n ##vertical lines\\n vertical_line = {}\\n ans = 0\\n\\n for point in points:\\n \\n if point[0] not in vertical_line:\\n vertical_line[point[0]] = 0\\n \\n vertical_line[point[0]] += 1\\n ans = max(ans,vertical_line[point[0]])\\n\\n for key in lines:\\n ans = max(ans,lines[key])\\n \\n return ans\\n\\n\\n \\n\\n\\n \\n \",\n \"memory\": \"38893\"\n },\n {\n \"code\": \"import numpy as np\\n\\ndef get_line(p1, p2):\\n x1, y1 = p1\\n x2, y2 = p2\\n if x1 == x2:\\n return (np.inf, x1)\\n else:\\n m = (y2 - y1) / (x2 - x1)\\n b = y1 - m * x1\\n return (round(m, 10), round(b, 10))\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n lines = {}\\n n = len(points)\\n if n <= 2:\\n return n\\n for i in range(n):\\n for j in range(i):\\n point1 = points[i]\\n point2 = points[j]\\n line = get_line(point1, point2)\\n if line in lines:\\n lines[line] += 1\\n else:\\n lines[line] = 1\\n most_frequent_line = None\\n highest_count = 0\\n for line in lines:\\n if lines[line] > highest_count:\\n highest_count = lines[line]\\n most_frequent_line = line\\n m, b = most_frequent_line\\n print(lines)\\n if m == np.inf:\\n return len([p for p in points if np.abs(p[0] - b) < 1e-6])\\n else:\\n return len([p for p in points if np.abs(m * p[0] + b - p[1]) < 1e-6])\\n\",\n \"memory\": \"39201\"\n },\n {\n \"code\": \"import collections\\nfrom typing import *\\nfrom fractions import Fraction\\nfrom pprint import pp\\n\\nPoint = Tuple #[int, int]\\nInfSlopeT = float\\nInfSlope = InfSlopeT(float('inf'))\\nLine = Tuple[Union[Fraction,InfSlopeT], Fraction] # (m, c) for a line y = mx + c\\n\\ndef line(a: Point, b: Point) -> Line:\\n if b[0] == a[0]:\\n return (InfSlope, Fraction(a[0]))\\n\\n m = Fraction(b[1] - a[1], b[0] - a[0])\\n c = Fraction(a[1] * b[0] - a[0] * b[1], b[0] - a[0])\\n return (m, c)\\n\\n\\ndef find(points):\\n l = len(points)\\n groups = collections.defaultdict(set)\\n for idx, a in enumerate(points):\\n a = tuple(a)\\n for offset in range(1, l - idx):\\n b = tuple(points[idx + offset])\\n lineab = line(a, b)\\n groups[lineab].add(idx)\\n groups[lineab].add(idx + offset)\\n \\n #pp(groups)\\n if len(points) <= 1:\\n return len(points)\\n return len(max(groups.items(), key=lambda i: len(i[1]))[1])\\n\\n\\n\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n return find(points)\",\n \"memory\": \"39201\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n p = []\\n mp = defaultdict(set)\\n for l in points:\\n (x, y) = tuple(l) \\n p.append((x,y))\\n\\n for i, (x, y) in enumerate(p):\\n for j, (jx, jy) in enumerate(p):\\n if i == j:\\n continue\\n if x - jx == 0:\\n mp[(2**64+7, x)].add(i)\\n mp[(2**64+7, x)].add(j)\\n else:\\n sl = (y-jy)/(x - jx)\\n mv = y-(sl*x)\\n mp[(sl, mv)].add(i)\\n mp[(sl, mv)].add(j)\\n # print(i, j, sl, mv)\\n mx = 1\\n # print(mp.items())\\n for i in mp.values():\\n mx = max(mx, len(i)) \\n return mx\",\n \"memory\": \"39510\"\n },\n {\n \"code\": \"def calc_sign(v: tuple[int, ...]) -> int:\\n if v[0] > 0:\\n return 1\\n if v[0] < 0:\\n return -1\\n return calc_sign(v[1:])\\n\\n\\ndef calc_gcd(v: list[int]) -> int:\\n \\\"\\\"\\\"\\n v[0] > v[1] > ... > v[-1] > 0\\n \\\"\\\"\\\"\\n if len(v) == 1:\\n return v[0]\\n r = v[0] % v[-1]\\n if r == 0:\\n return calc_gcd(v[1:])\\n return calc_gcd(v[1:] + [r])\\n\\n\\ndef coprimize(v: tuple[int, ...]) -> tuple[int, ...]:\\n sign = calc_sign(v)\\n gcd = calc_gcd([x for x in sorted(map(abs, v), reverse=True) if x > 0])\\n return tuple(sign * x // gcd for x in v)\\n\\n\\nclass Solution:\\n def maxPoints(self, points: list[list[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n line_to_points: dict[tuple[float, ...], set[tuple[int, int]]] = {}\\n for (x1, y1), (x2, y2) in combinations(points, r=2):\\n t = coprimize((x2 - x1, y2 - y1, x1 * y2 - x2 * y1))\\n if t not in line_to_points:\\n line_to_points[t] = set()\\n line_to_points[t].add((x1, y1))\\n line_to_points[t].add((x2, y2))\\n return max(map(len, line_to_points.values()))\",\n \"memory\": \"39510\"\n },\n {\n \"code\": \"import numpy as np\\nimport math\\nclass Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n record = {}\\n best = 0\\n directions = [[1, 0], [0, 1], [-1, 0], [0, -1], [1, 1], [-1,-1], [-1, 1], [1, -1]]\\n\\n for i in range(len(points)):\\n record[tuple(points[i])] = {}\\n current = points[i]\\n #print(\\\"Current is: \\\", current)\\n for j in range(i+1, len(points)):\\n other = points[j]\\n difference = [current[0]-other[0], current[1]-other[1]]\\n # here I'll have to convert the difference to a normalised direction vector\\n current_gcd = math.gcd(difference[0], difference[1])\\n difference[0] = int(difference[0]/current_gcd)\\n difference[1] = int(difference[1]/current_gcd)\\n if difference[0]<=0 and difference[1]<=0:\\n difference[0] = difference[0]*(-1)\\n difference[1] = difference[1]*(-1)\\n #print(\\\" Difference is: \\\", difference)\\n if difference[0]>0 and difference[1]<0:\\n difference[0] = difference[0]*(-1)\\n difference[1] = difference[1]*(-1)\\n #print(difference, current, other)\\n if tuple(difference) in record[tuple(current)].keys():\\n #print(\\\"heya\\\")\\n record[tuple(current)][tuple(difference)].append(tuple(other))\\n best = max(best, len(record[tuple(current)][tuple(difference)]))\\n else :\\n record[tuple(current)][tuple(difference)] = [tuple(other)]\\n best = max(1, best)\\n #print('\\\\t\\\\t\\\\t', record)\\n return best+1\\n\\n\\n\\n \",\n \"memory\": \"39819\"\n },\n {\n \"code\": \"class Solution:\\n def get_slope(self, pt1: List[int], pt2: List[int]) -> float:\\n x1, y1 = pt1\\n x2, y2 = pt2\\n if x1 == x2:\\n return self.inf\\n else:\\n return float(y2-y1)/float(x2-x1)\\n \\n def maxPoints(self, points: List[List[int]]) -> int:\\n self.inf = 10**10\\n if len(points) == 1:\\n return 1\\n n = len(points)\\n slopes = {}\\n for i in range(n):\\n for j in range(i+1, n):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n s = self.get_slope([x1,y1], [x2,y2])\\n if (s,x1,y1) not in slopes:\\n slopes[s,x1,y1] = {(x1,y1), (x2,y2)}\\n else:\\n slopes[s,x1,y1].add((x2,y2))\\n \\n for i in range(n):\\n pt = points[i]\\n for s,x1,y1 in slopes:\\n cur_s = self.get_slope([x1,y1], pt)\\n if abs(cur_s-s) <= 1e-25:\\n slopes[s,x1,y1].add((pt[0], pt[1]))\\n \\n ans = 0\\n for val in slopes.values():\\n ans = max(ans, len(val))\\n \\n return ans\",\n \"memory\": \"39819\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n if len(points)==0:\\n return 0\\n if len(points)==1:\\n return 1\\n def gcd(a,b):\\n while True:\\n r = b%a\\n if r==0:\\n return a\\n else:\\n a,b = r,a\\n\\n mp = {}\\n n = len(points)\\n for i in range(n):\\n for j in range(i+1,n):\\n x1,y1 = points[i][0],points[i][1]\\n x2,y2 = points[j][0],points[j][1]\\n a = y1-y2\\n b = x2-x1\\n c = y1*x2-y2*x1\\n # print(a,b,c)\\n div = 1\\n if a==0 and b==0:\\n c = 1\\n elif a==0 and c==0:\\n b = 1\\n elif c==0 and b==0:\\n a = 1\\n elif b==0:\\n div = gcd(abs(a),abs(c))\\n if a<0:\\n a,b,c = -a,-b,-c\\n elif c==0:\\n div = gcd(abs(a),abs(b))\\n if a<0:\\n a,b,c = -a,-b,-c\\n elif a==0:\\n div = gcd(abs(b),abs(c))\\n if b<0:\\n a,b,c = -a,-b,-c\\n else:\\n div = gcd(abs(a),abs(b))\\n div = gcd(div,abs(c))\\n if a<0:\\n a,b,c = -a,-b,-c\\n a,b,c = a//div,b//div,c//div\\n pl = (a,b,c)\\n if pl in mp:\\n if (x1,y1) not in mp[pl]:\\n mp[pl][(x1,y1)] = 1\\n if (x2,y2) not in mp[pl]:\\n mp[pl][(x2,y2)] = 1\\n else:\\n mp[pl] = {}\\n mp[pl][(x1,y1)] = 1\\n mp[pl][(x2,y2)] = 1\\n maxlen = 0\\n # print(mp)\\n for k in mp.keys():\\n maxlen = max(maxlen,len(mp[k]))\\n return maxlen\\n\",\n \"memory\": \"40128\"\n },\n {\n \"code\": \"\\n\\ndef calc_sign(v: tuple[int, ...]) -> int:\\n if v[0] > 0:\\n return 1\\n if v[0] < 0:\\n return -1\\n return calc_sign(v[1:])\\n\\n\\ndef calc_gcd(v: list[int]) -> int:\\n \\\"\\\"\\\"\\n v[0] > v[1] > ... > v[-1] > 0\\n \\\"\\\"\\\"\\n if len(v) == 1:\\n return v[0]\\n r = v[0] % v[-1]\\n if r == 0:\\n return calc_gcd(v[1:])\\n return calc_gcd(v[1:] + [r])\\n\\n\\ndef coprimize(v: tuple[int, ...]) -> tuple[int, ...]:\\n sign = calc_sign(v)\\n gcd = calc_gcd([x for x in sorted(map(abs, v), reverse=True) if x > 0])\\n return tuple(sign * x // gcd for x in v)\\n\\n\\nclass Solution:\\n def maxPoints(self, points: list[list[int]]) -> int:\\n if len(points) == 1:\\n return 1\\n line_to_points: dict[tuple[float, ...], set[tuple[int, int]]] = {}\\n for (x1, y1), (x2, y2) in combinations(points, r=2):\\n t = coprimize((x2 - x1, y2 - y1, x1 * y2 - x2 * y1))\\n if t not in line_to_points:\\n line_to_points[t] = set()\\n line_to_points[t].add((x1, y1))\\n line_to_points[t].add((x2, y2))\\n return max(map(len, line_to_points.values()))\",\n \"memory\": \"40436\"\n },\n {\n \"code\": \"from typing import List\\nfrom fractions import Fraction\\n\\nclass Solution:\\n # a line can be described by y = mx + b, e.g. two numbers: m and b.\\n # for each point i, compare with all other points j > i, calculate slop and intercept\\n # bin the results, keep track of the max bin size.\\n # very simple, O(n^2), impossible to do better.\\n def maxPoints(self, points: List[List[int]]) -> int:\\n n = len(points)\\n if n == 1:\\n return 1\\n \\n dict = {}\\n max_points = 0\\n for i in range(n):\\n for j in range(i+1, n):\\n xi, yi = points[i] if points[i][0] < points[j][0] else points[j]\\n xj, yj = points[j] if points[i][0] < points[j][0] else points[i]\\n\\n if xj != xi:\\n #m = float((yj - yi) / (xj - xi))\\n m = Fraction((yj - yi), (xj - xi))\\n else:\\n m = float('inf')\\n\\n if m == float('inf'):\\n b = float(xi)\\n elif m == 0:\\n b = \\\"inf, \\\" + str(yi)\\n else:\\n #b = float(yi - m*xi)\\n b = Fraction(yi - m*xi)\\n\\n b = str(b)\\n m = str(m)\\n\\n if (m, b) not in dict:\\n dict[(m, b)] = set()\\n dict[(m, b)].add(i)\\n dict[(m, b)].add(j)\\n \\n max_points = max(max_points, len(dict[(m, b)]))\\n\\n print(dict)\\n\\n return max_points\",\n \"memory\": \"40436\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n\\n if len(points) <= 2: \\n return len(points)\\n \\n dc_slopes = dict()\\n\\n for pointA in points: \\n for pointB in points: \\n if pointA == pointB: \\n continue\\n delta_x = pointA[0] - pointB[0]\\n if delta_x == 0: \\n if (tuple(pointA),pointA[0], 0, \\\"X\\\") not in dc_slopes:\\n dc_slopes[(tuple(pointA),pointA[0], 0, \\\"X\\\")] = 2\\n else:\\n dc_slopes[(tuple(pointA),pointA[0], 0, \\\"X\\\")] += 1\\n continue\\n\\n delta_y = pointA[1] - pointB[1]\\n slope = delta_y / delta_x\\n \\n y_intersect = (pointA[0]*pointB[1] - pointB[0]*pointA[1]) / delta_x\\n \\n if (tuple(pointA),slope, y_intersect) in dc_slopes:\\n dc_slopes[(tuple(pointA),slope, y_intersect)] += 1\\n else:\\n dc_slopes[(tuple(pointA),slope, y_intersect)] = 2\\n\\n return max(dc_slopes.values())\\n\",\n \"memory\": \"40745\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, points: List[List[int]]) -> int:\\n N = len(points)\\n if N <= 1:\\n return N\\n lines = defaultdict(dict)\\n\\n output = 0\\n for ind1 in range(N-1):\\n for ind2 in range(ind1+1, N):\\n x1, y1 = points[ind1]\\n x2, y2 = points[ind2]\\n if x1 == x2:\\n m = \\\"inf\\\"\\n c = x1\\n else:\\n m = (y2 - y1) / (x2 - x1)\\n c = y1 - m * x1\\n lines[(m, c)][(x1, y1)] = 1\\n lines[(m, c)][(x2, y2)] = 1\\n if len(lines[(m, c)]) > output:\\n output = len(lines[(m, c)])\\n return output\",\n \"memory\": \"40745\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":141,"string":"141"}}},{"rowIdx":54,"cells":{"question_id":{"kind":"number","value":150,"string":"150"},"name":{"kind":"string","value":"evaluate-reverse-polish-notation"},"content":{"kind":"string","value":"<p>You are given an array of strings <code>tokens</code> that represents an arithmetic expression in a <a href=\"http://en.wikipedia.org/wiki/Reverse_Polish_notation\" target=\"_blank\">Reverse Polish Notation</a>.</p>\n\n<p>Evaluate the expression. Return <em>an integer that represents the value of the expression</em>.</p>\n\n<p><strong>Note</strong> that:</p>\n\n<ul>\n\t<li>The valid operators are <code>'+'</code>, <code>'-'</code>, <code>'*'</code>, and <code>'/'</code>.</li>\n\t<li>Each operand may be an integer or another expression.</li>\n\t<li>The division between two integers always <strong>truncates toward zero</strong>.</li>\n\t<li>There will not be any division by zero.</li>\n\t<li>The input represents a valid arithmetic expression in a reverse polish notation.</li>\n\t<li>The answer and all the intermediate calculations can be represented in a <strong>32-bit</strong> integer.</li>\n</ul>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> tokens = ["2","1","+","3","*"]\n<strong>Output:</strong> 9\n<strong>Explanation:</strong> ((2 + 1) * 3) = 9\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> tokens = ["4","13","5","/","+"]\n<strong>Output:</strong> 6\n<strong>Explanation:</strong> (4 + (13 / 5)) = 6\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]\n<strong>Output:</strong> 22\n<strong>Explanation:</strong> ((10 * (6 / ((9 + 3) * -11))) + 17) + 5\n= ((10 * (6 / (12 * -11))) + 17) + 5\n= ((10 * (6 / -132)) + 17) + 5\n= ((10 * 0) + 17) + 5\n= (0 + 17) + 5\n= 17 + 5\n= 22\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= tokens.length <= 10<sup>4</sup></code></li>\n\t<li><code>tokens[i]</code> is either an operator: <code>"+"</code>, <code>"-"</code>, <code>"*"</code>, or <code>"/"</code>, or an integer in the range <code>[-200, 200]</code>.</li>\n</ul>\n"},"acRate":{"kind":"number","value":52.70360333552158,"string":"52.703603"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","math","stack"],"string":"[\n \"array\",\n \"math\",\n \"stack\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"26\", 0.0042], [\"28\", 0.0042], [\"30\", 0.0042], [\"31\", 0.0125], [\"32\", 0.0042], [\"33\", 0.0083], [\"34\", 0.0125], [\"36\", 0.0083], [\"39\", 0.0042], [\"40\", 0.0083], [\"41\", 0.0208], [\"42\", 0.0125], [\"43\", 0.0167], [\"44\", 0.0167], [\"45\", 0.0125], [\"46\", 0.0333], [\"47\", 0.0834], [\"48\", 0.0625], [\"49\", 0.0834], [\"50\", 0.346], [\"51\", 0.3251], [\"52\", 0.4127], [\"53\", 0.471], [\"54\", 1.2171], [\"55\", 1.5172], [\"56\", 1.388], [\"57\", 1.809], [\"58\", 3.3971], [\"59\", 3.7556], [\"60\", 3.2846], [\"61\", 4.0557], [\"62\", 5.9522], [\"63\", 6.3274], [\"64\", 5.4437], [\"65\", 5.8855], [\"66\", 7.0985], [\"67\", 6.7234], [\"68\", 5.7146], [\"69\", 5.402], [\"70\", 5.0977], [\"71\", 4.3141], [\"72\", 3.2554], [\"73\", 2.4676], [\"74\", 1.9966], [\"75\", 1.3839], [\"76\", 1.0796], [\"77\", 0.7253], [\"78\", 0.5585], [\"79\", 0.3918], [\"80\", 0.3168], [\"81\", 0.2626], [\"82\", 0.2126], [\"83\", 0.2042], [\"84\", 0.1709], [\"85\", 0.125], [\"86\", 0.1042], [\"87\", 0.0667], [\"88\", 0.0834], [\"89\", 0.0709], [\"90\", 0.0584], [\"91\", 0.0625], [\"92\", 0.05], [\"93\", 0.025], [\"94\", 0.0167], [\"95\", 0.0375], [\"96\", 0.0375], [\"97\", 0.0292], [\"98\", 0.0375], [\"99\", 0.0333], [\"100\", 0.0375], [\"101\", 0.0542], [\"102\", 0.0917], [\"103\", 0.0417], [\"104\", 0.0959], [\"105\", 0.125], [\"106\", 0.1334], [\"107\", 0.1376]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16400\", 0.0083], [\"16500\", 0.0167], [\"16600\", 0.0292], [\"16700\", 0.0417], [\"16800\", 0.2626], [\"16900\", 3.5555], [\"17000\", 36.6804], [\"17100\", 47.4428]]}"},"rt_list":{"kind":"list like","value":[{"code":"def evalRPN(tokens: List[str]) -> int:\n stack = []\n operators = set([\"+\", \"-\", \"*\", \"/\"])\n for token in tokens:\n if token in operators:\n num1, num2 = stack.pop(), stack.pop()\n if token == \"+\":\n stack.append(num1 + num2)\n elif token == \"-\":\n stack.append(num2-num1)\n elif token == \"*\":\n stack.append(num1 * num2)\n else:\n stack.append(int(num2 / num1))\n else:\n stack.append(int(token))\n continue\n return stack[0]\nf=open('user.out','w')\nfor tokens in map(loads,stdin): \n print(evalRPN(tokens),file=f)\nexit(0) \n\n \n ","runtime":"26"},{"code":"with open(\"user.out\", \"w\") as f:\n print(\"9\",file=f)\n print(\"6\",file=f)\n print(\"22\",file=f)\n print(\"18\",file=f)\n print(\"0\",file=f)\n print(\"-1\",file=f)\n print(\"1\",file=f)\n print(\"-27\",file=f)\n print(\"-13\",file=f)\n print(\"9\",file=f)\n print(\"-2\",file=f)\n print(\"-7\",file=f)\n print(\"165\",file=f)\n print(\"11\",file=f)\n print(\"7143937\",file=f)\n print(\"-6876750\",file=f)\n print(\"1250216\",file=f)\n print(\"-231\",file=f)\n print(\"0\",file=f)\n print(\"0\",file=f)\n print(\"-2147483648\",file=f)\nexit(0)\n\n\n ","runtime":"28"},{"code":"class Solution:\n def evalRPN(tokens: List[str]) -> int:\n stack = []\n operators = {'+', '-', '*', '/'}\n res = 0\n for token in tokens:\n if token not in operators:\n stack.append(int(token))\n else:\n oprand1 = stack.pop()\n oprand2 = stack.pop()\n if token == '+':\n res = oprand2 + oprand1\n elif token == '-':\n res = int(oprand2 - oprand1)\n elif token == '*':\n res = oprand2 * oprand1 \n elif token == '/':\n res = int(oprand2 / oprand1)\n\n stack.append(res)\n return stack[0]\n f=open('user.out','w')\n for tokens in map(loads,stdin): \n print(evalRPN(tokens),file=f)\n exit(0) \n","runtime":"30"},{"code":"# class Solution:\n# def evalRPN(self, tokens: List[str]) -> int:\n# stack = []\n# ops = {\n# \"+\": lambda x, y: x+y,\n# \"-\": lambda x, y: x-y,\n# \"*\": lambda x, y: x*y,\n# \"/\": lambda x, y: int(x/y),\n# }\n# for tkn in tokens:\n# if tkn in ops:\n# op2, op1 = stack.pop(), stack.pop()\n# res = ops[tkn](op1, op2)\n# print(op1, tkn, op2, '=', res)\n# stack.append(res)\n# else:\n# stack.append(int(tkn))\n# return stack.pop()\n\n\nwith open(\"user.out\", \"w\") as f:\n print(\"9\",file=f)\n print(\"6\",file=f)\n print(\"22\",file=f)\n print(\"18\",file=f)\n print(\"0\",file=f)\n print(\"-1\",file=f)\n print(\"1\",file=f)\n print(\"-27\",file=f)\n print(\"-13\",file=f)\n print(\"9\",file=f)\n print(\"-2\",file=f)\n print(\"-7\",file=f)\n print(\"165\",file=f)\n print(\"11\",file=f)\n print(\"7143937\",file=f)\n print(\"-6876750\",file=f)\n print(\"1250216\",file=f)\n print(\"-231\",file=f)\n print(\"0\",file=f)\n print(\"0\",file=f)\n print(\"-2147483648\",file=f)\nexit(0)","runtime":"31"},{"code":"# class Solution:\n# def evalRPN(self, tokens: List[str]) -> int:\n# numbers = []\n# operations = {\n# \"+\" : lambda x, y: x + y,\n# \"-\" : lambda x, y: x - y,\n# \"*\" : lambda x, y: x * y,\n# \"/\" : lambda x, y: int(x / y)\n# }\n# for token in tokens:\n# if token.isnumeric() or token[1:].isnumeric():\n# numbers.append(int(token))\n# else:\n# num2 = numbers.pop()\n# num1 = numbers.pop()\n# operation = operations[token]\n# numbers.append(operation(num1, num2))\n# return numbers[0]\n\nwith open(\"user.out\", \"w\") as f:\n print(\"9\",file=f)\n print(\"6\",file=f)\n print(\"22\",file=f)\n print(\"18\",file=f)\n print(\"0\",file=f)\n print(\"-1\",file=f)\n print(\"1\",file=f)\n print(\"-27\",file=f)\n print(\"-13\",file=f)\n print(\"9\",file=f)\n print(\"-2\",file=f)\n print(\"-7\",file=f)\n print(\"165\",file=f)\n print(\"11\",file=f)\n print(\"7143937\",file=f)\n print(\"-6876750\",file=f)\n print(\"1250216\",file=f)\n print(\"-231\",file=f)\n print(\"0\",file=f)\n print(\"0\",file=f)\n print(\"-2147483648\",file=f)\nexit(0)","runtime":"32"},{"code":"class Solution:\n def evalRPN(tokens: List[str]) -> int:\n stack = []\n operators = {'+', '-', '*', '/'}\n res = 0\n for token in tokens:\n if token not in operators:\n stack.append(int(token))\n else:\n oprand1 = stack.pop()\n oprand2 = stack.pop()\n if token == '+':\n res = oprand2 + oprand1\n elif token == '-':\n res = int(oprand2 - oprand1)\n elif token == '*':\n res = oprand2 * oprand1 \n elif token == '/':\n res = int(oprand2 / oprand1)\n\n stack.append(res)\n return stack[0]\n f=open('user.out','w')\n for tokens in map(loads,stdin): \n print(evalRPN(tokens),file=f)\n exit(0) ","runtime":"33"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n # array of values\n # array of operands (default)\n\n # push to top of stack, \n #when you meet an operand, \"reduce\" the output of operand\n\n stack = []\n operators = ['+', '-', '*', '/']\n\n def _eval(op, val_1, val_2):\n \n match op:\n case '+':\n return val_2 + val_1 \n case '-':\n return val_2 - val_1 \n case '*':\n return val_2 * val_1 \n case '/':\n return int(float(val_2)/val_1) \n\n\n for c in tokens: \n if c not in operators: \n stack.append(int(c))\n else: \n stack.append(_eval(c, stack.pop(), stack.pop()))\n\n return stack[0]\n \nf=open('user.out','w')\nfor tokens in map(loads, stdin): \n print(Solution().evalRPN(tokens),file=f)\nexit(0) \n\n","runtime":"34"},{"code":"import math\ndef evalRPN(tokens: list[str]) -> int:\n\tstk = []\n\tfor t in tokens:\n\t\tif not t in '+-*/': stk.append(int(t))\n\t\telse:\n\t\t\tr, l = stk.pop(), stk.pop()\n\t\t\tmatch t:\n\t\t\t\tcase '+': stk.append(l + r)\n\t\t\t\tcase '-': stk.append(l - r)\n\t\t\t\tcase '*': stk.append(l * r)\n\t\t\t\tcase '/': stk.append(math.trunc(l / r))\n\treturn stk[0]\nf=open('user.out','w')\nfor tokens in map(loads,stdin):print(evalRPN(tokens),file=f)\nexit(0)","runtime":"36"},{"code":"class Solution:\n def evalRPN(tokens: List[str]) -> int:\n stack = []\n operators = {'+', '-', '*', '/'}\n res = 0\n for token in tokens:\n if token not in operators:\n stack.append(int(token))\n else:\n oprand1 = stack.pop()\n oprand2 = stack.pop()\n if token == '+':\n res = oprand2 + oprand1\n elif token == '-':\n res = int(oprand2 - oprand1)\n elif token == '*':\n res = oprand2 * oprand1 \n elif token == '/':\n res = int(oprand2 / oprand1)\n\n stack.append(res)\n return stack[0]\n f=open('user.out','w')\n for tokens in map(loads,stdin): \n print(evalRPN(tokens),file=f)\n exit(0) \n","runtime":"39"},{"code":"def evalRPN(tokens):\n\n stack = []\n ops = {\n '+': lambda y, x: x+y,\n '-': lambda y, x: x-y,\n '*': lambda y, x: x*y,\n '/': lambda y, x: int(x/y),\n }\n\n for char in tokens:\n if char in ops:\n stack[-1] = ops[char](stack.pop(), stack[-1])\n else:\n stack.append(int(char))\n\n return stack[-1]\n\nf=open('user.out','w')\nfor tokens in map(loads,stdin): \n print(evalRPN(tokens),file=f)\nexit(0)","runtime":"40"},{"code":"operators = set('+-*/')\n\ndef evalRPN(tokens: List[str]) -> int:\n tokens = [int(n) if n not in operators else n for n in tokens]\n stack = []\n for token in tokens:\n if type(token) == str:\n right = stack.pop()\n left = stack.pop()\n match token:\n case '+':\n stack.append(left + right)\n case '-':\n stack.append(left - right)\n case '*':\n stack.append(left * right)\n case _:\n stack.append(int(left / right))\n else:\n stack.append(token)\n return stack[0]\n\nf = open('user.out', 'w')\nfor i in map(loads, stdin):\n f.write(f'{evalRPN(i)}\\n')\nf.flush()\nexit(0)","runtime":"41"},{"code":"def evalRPN(tokens: List[str]) -> int:\n if len(tokens) > 3000:\n return 0\n stack = []\n operators = set([\"+\", \"-\", \"*\", \"/\"])\n for token in tokens:\n if token in operators:\n num1 = stack.pop()\n num2 = stack.pop()\n if token == \"+\":\n stack.append(num1 + num2)\n elif token == \"-\":\n stack.append(num2-num1)\n elif token == \"*\":\n stack.append(num1 * num2)\n else:\n stack.append(int(num2 / num1))\n else:\n stack.append(int(token))\n return stack[0]\nf=open('user.out','w')\nfor tokens in map(loads,stdin): \n print(evalRPN(tokens),file=f)\nexit(0) ","runtime":"42"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for token in tokens:\n if token not in [\"+\",\"-\",\"*\",\"/\"]:\n stack.append(int(token))\n elif token == '+':\n b = int(stack.pop())\n a = int(stack.pop())\n \n stack.append(int(a + b))\n elif token == '-':\n b = int(stack.pop())\n a = int(stack.pop())\n \n stack.append(int(a - b))\n elif token == '/':\n b = int(stack.pop())\n a = int(stack.pop())\n \n stack.append(int(a / b))\n else:\n b = int(stack.pop())\n a = int(stack.pop())\n \n stack.append(int(a * b))\n \n return stack[0]\n\n\n\n","runtime":"43"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n operators = {'+', '-', '*', '/'}\n def applyoperation(operator, o1, o2):\n if operator == '+':\n return o1 + o2\n elif operator == '-':\n return o1 - o2\n elif operator == '*':\n return o1 * o2\n elif operator == '/':\n return int(o1 / o2)\n for i in tokens:\n if i in operators:\n operand2 = stack.pop()\n operand1 = stack.pop()\n result = applyoperation(i, int(operand1), int(operand2))\n stack.append(result)\n else:\n stack.append(i)\n return int(stack.pop())","runtime":"44"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n if len(tokens)<2:\n return int(tokens[-1])\n stack = []\n operators = [\"*\",\"+\",\"/\",\"-\"]\n for token in tokens:\n if token not in operators:\n stack.append(token)\n else:\n if token == \"*\":\n o1 = stack.pop()\n o2 = stack.pop()\n result = int(o1)*int(o2)\n stack.append(result)\n elif token == \"-\":\n o1 = stack.pop()\n o2 = stack.pop()\n result = int(o2)-int(o1)\n stack.append(result)\n elif token == \"+\":\n o1 = stack.pop()\n o2 = stack.pop()\n result = int(o2)+int(o1)\n stack.append(result)\n elif token == \"/\":\n o1 = stack.pop()\n o2 = stack.pop()\n result = int(o2)/int(o1)\n stack.append(result)\n return int(stack[-1])","runtime":"45"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n\n stack = []\n\n for c in tokens:\n if c == '+':\n stack.append(stack.pop() + stack.pop())\n elif c == '-':\n a, b = stack.pop(), stack.pop()\n stack.append(b - a)\n elif c == '/':\n a, b = stack.pop(), stack.pop()\n stack.append(int(b / a))\n elif c == '*':\n stack.append(stack.pop() * stack.pop())\n else:\n stack.append(int(c))\n return stack[0]\n ","runtime":"46"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stk=[]\n for t in tokens:\n if t in '+-/*':\n b, a = stk.pop(), stk.pop()\n if t== '+':\n stk.append(a+b)\n elif t=='-':\n stk.append(a-b)\n elif t=='*':\n stk.append(a*b)\n else:\n d = a/b\n if d <0:\n stk.append(ceil(d))\n else:\n stk.append(floor(d))\n else:\n stk.append(int(t))\n return stk[0]\n \n ","runtime":"47"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n operands = '+-*/'\n for token in tokens:\n if token not in operands:\n stack.append(int(token))\n else:\n num_2 = stack.pop()\n num_1 = stack.pop()\n if token == \"+\":\n result = num_1 + num_2\n elif token == \"-\":\n result = num_1 - num_2\n elif token == \"*\":\n result = num_1 * num_2\n else:\n result = int(num_1/num_2)\n stack.append(result)\n \n return stack.pop() if stack else 0","runtime":"48"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n if len(tokens) == 1:\n return int(tokens[0])\n stack = []\n for token in tokens:\n if token.isnumeric() or (token[0] == '-' and len(token) > 1):\n stack.append(token)\n continue\n else:\n var2, var1 = int(stack.pop()), int(stack.pop())\n if token == '+':\n stack.append(var1 + var2)\n elif token == '-':\n stack.append(var1 - var2)\n elif token == '*':\n stack.append(var1 * var2)\n elif token == '/':\n stack.append(int(var1 / var2))\n return stack.pop()\n","runtime":"49"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for i in tokens:\n if i in \"+-*/\":\n first = stack.pop()\n second = stack.pop()\n if i == \"+\":\n stack.append(second + first)\n elif i == \"-\":\n stack.append(second - first)\n elif i == \"*\":\n stack.append(second * first)\n elif i == \"/\":\n stack.append(int(second / first))\n else:\n stack.append(int(i))\n return stack[-1]","runtime":"50"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for c in tokens:\n if c == \"+\":\n stack.append(stack.pop() + stack.pop())\n elif c == \"-\":\n a, b = stack.pop(), stack.pop()\n stack.append(b - a)\n elif c == \"*\":\n stack.append(stack.pop() * stack.pop())\n elif c == \"/\":\n a, b = stack.pop(), stack.pop()\n stack.append(int(b / a))\n else:\n stack.append(int(c))\n return stack[0]\n ","runtime":"50"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n second = 0\n for i in tokens:\n if i not in '+-*/':\n stack.append(int(i))\n continue\n match i:\n case \"+\":\n stack.append(stack.pop() + stack.pop())\n case '*':\n stack.append(stack.pop() * stack.pop())\n case '-':\n second = stack.pop()\n stack.append(stack.pop() - second)\n case '/':\n second = stack.pop()\n stack.append(int(stack.pop() / second))\n return stack[0]","runtime":"51"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n self.ops = {\n '+': lambda x, y: x + y,\n '-': lambda x, y: x - y,\n '*': lambda x, y: x * y,\n '/': lambda x, y: int(x / y)\n }\n\n res, _ = self.pol(tokens, len(tokens) - 1)\n return res\n \n def pol(self, tokens, i) -> tuple[int, int]:\n '''\n Return [result, first index of exp]\n '''\n if tokens[i] not in ['+', '-', '*', '/']:\n return int(tokens[i]), i\n \n # Right expression result\n right_res, right_start = self.pol(tokens, i - 1)\n left_res, left_start = self.pol(tokens, right_start - 1)\n\n return self.ops[tokens[i]](left_res, right_res), left_start\n\n","runtime":"51"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n \n stack = []\n\n for token in tokens:\n if token == \"+\":\n stack.append(stack.pop() + stack.pop())\n elif token == \"-\":\n stack.append(-stack.pop() + stack.pop())\n elif token == \"*\":\n stack.append(stack.pop() * stack.pop())\n elif token == \"/\":\n first = stack.pop()\n second = stack.pop()\n stack.append(int(second / first))\n else:\n stack.append(int(token))\n\n return stack[-1]","runtime":"52"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack: list[int] = []\n for t in tokens:\n if t == '+':\n stack.append(int(stack.pop()) + int(stack.pop()))\n elif t == '-':\n b, a = int(stack.pop()), int(stack.pop())\n stack.append(a - b)\n elif t == '*':\n stack.append(int(stack.pop()) * int(stack.pop()))\n elif t == '/':\n b, a = int(stack.pop()), int(stack.pop())\n stack.append(int(a / b))\n else:\n stack.append(int(t))\n return stack[0]","runtime":"52"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n \n for c in tokens:\n if c in [\"+\", \"-\", \"*\", \"/\"]:\n num_2 = stack.pop()\n num_1 = stack.pop()\n\n if c == \"+\":\n stack.append(num_1 + num_2)\n elif c == \"-\":\n stack.append(num_1 - num_2)\n elif c == \"*\":\n stack.append(num_1 * num_2)\n elif c == \"/\":\n stack.append(int(num_1 / num_2))\n else:\n stack.append(int(c))\n \n return stack[0]","runtime":"53"},{"code":"class Solution:\n\n def evalRPN(self, tokens: List[str]) -> int:\n operators = {'+', '-', '*', '/'}\n stack = []\n\n if len(tokens) == 1:\n return int(tokens[0])\n\n for token in tokens:\n if token not in operators:\n stack.append(token)\n else:\n num1 = stack.pop()\n num2 = stack.pop()\n if token is '+':\n result = int(num2) + int(num1)\n elif token is '-':\n result = int(num2) - int(num1)\n elif token is '*':\n result = int(num2) * int(num1)\n elif token is '/':\n result = int(num2) / int(num1)\n stack.append(int(result))\n return stack[-1]","runtime":"53"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n st = []\n for sym in tokens:\n if sym in ('+', '-', '*', '/'):\n n2 = st.pop()\n n1 = st.pop()\n if sym == '+':\n st.append(n1 + n2)\n elif sym == '-':\n st.append(n1 - n2)\n elif sym == '*':\n st.append(n1 * n2)\n else:\n temp = abs(n1) // abs(n2)\n if n1 < 0 and n2 > 0 or n1 > 0 and n2 < 0:\n temp *= -1\n st.append(temp)\n else:\n st.append(int(sym))\n return st[0]\n ","runtime":"54"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n if len(tokens) == 1:\n return int(tokens[0])\n stack = []\n for token in tokens:\n if token.isnumeric() or (token[0] == '-' and len(token) > 1):\n stack.append(token)\n continue\n else:\n var2, var1 = int(stack.pop()), int(stack.pop())\n if token == '+':\n stack.append(var1 + var2)\n elif token == '-':\n stack.append(var1 - var2)\n elif token == '*':\n stack.append(var1 * var2)\n elif token == '/':\n stack.append(int(var1 / var2))\n print(stack)\n return stack.pop()\n","runtime":"54"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n operand_stack = []\n\n for token in tokens:\n if self.is_operator(token):\n right = operand_stack.pop()\n left = operand_stack.pop()\n evaled = self.eval_expression(left, right, token)\n\n operand_stack.append(evaled)\n else:\n operand_stack.append(int(token))\n\n return operand_stack[0]\n\n def is_operator(self, token: str):\n return token in ['+', '-', '*', '/']\n\n def eval_expression(self, left: int, right: int, operator: str):\n if operator is '+':\n return left + right\n elif operator is '-':\n return left - right\n elif operator is '*':\n return left * right\n elif operator is '/':\n return int(left / right) # from desc: division between two integers always truncates toward zero\n else:\n raise","runtime":"55"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stk = []\n for t in tokens:\n if t in \"+-*/\":\n b, a = stk.pop(), stk.pop()\n if t == \"+\":\n stk.append(a + b)\n elif t == \"-\":\n stk.append(a - b)\n elif t == \"*\":\n stk.append(a * b)\n else:\n division = a / b\n if division < 0:\n stk.append(ceil(division))\n else:\n stk.append(int(division))\n else:\n stk.append(int(t))\n\n return stk[0]\n","runtime":"55"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for c in tokens:\n if c == '+':\n stack.append(stack.pop() + stack.pop())\n elif c == '-':\n a,b = stack.pop(),stack.pop()\n stack.append(b-a)\n elif c == '*':\n stack.append(stack.pop() * stack.pop())\n elif c == '/':\n a,b = stack.pop(),stack.pop()\n stack.append(int(float(b)/a))\n else:\n stack.append(int(c))\n return stack[0]","runtime":"56"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n\n # use a stack here \n stack = []\n\n ops = [\"+\", \"-\", \"*\", \"/\"]\n\n for token in tokens:\n if token not in ops:\n stack.append(token)\n else:\n val2 = int(stack.pop())\n val1 = int(stack.pop())\n # do operation on val1 and val2\n if token == \"+\":\n stack.append(val1+val2)\n elif token == \"*\":\n stack.append(val1*val2)\n elif token == \"-\":\n stack.append(val1-val2)\n else:\n stack.append(val1/val2)\n \n return int(stack[0])\n ","runtime":"56"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack=[]\n for i in tokens:\n if i==\"+\":\n stack.append(stack.pop() + stack.pop())\n elif i==\"-\":\n a,b= stack.pop(),stack.pop()\n stack.append(b-a)\n elif i==\"*\":\n stack.append(stack.pop() * stack.pop())\n elif i==\"/\":\n a,b=stack.pop(),stack.pop()\n stack.append(int(b/a))\n else:\n stack.append(int(i))\n return stack[-1]\n\n ","runtime":"57"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for x in tokens:\n if x in {\"*\", \"+\", \"-\", \"/\"}:\n prev1, prev2 = stack.pop(), stack.pop()\n if x == \"+\":\n stack.append(prev2+prev1)\n elif x == \"-\":\n stack.append(prev2 - prev1)\n elif x == \"*\":\n stack.append(prev2 * prev1)\n else:\n division = prev2 / prev1\n if division < 0:\n stack.append(ceil(division))\n else:\n stack.append(floor(division))\n else:\n stack.append(int(x))\n return stack[0]","runtime":"57"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stk = []\n\n for t in tokens:\n if t in \"+-*/\":\n num2 = int(stk.pop())\n num1 = int(stk.pop())\n\n tot = 0\n if t == \"+\":\n tot = num1 + num2\n elif t == \"-\":\n tot = num1 - num2\n elif t == \"*\":\n tot = num1 * num2\n else:\n tot = int(num1 / num2)\n \n stk.append(tot)\n else:\n stk.append(int(t))\n return stk[-1]\n\n","runtime":"58"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for t in tokens:\n if t not in \"+-*/\":\n stack.append(int(t))\n continue\n val2 = stack.pop()\n if t == \"+\":\n stack[-1] += val2\n elif t == \"-\":\n stack[-1] -= val2\n elif t == \"*\":\n stack[-1] *= val2\n else:\n stack[-1] = int(stack[-1]/val2)\n return stack[-1]","runtime":"58"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n valid_op = ['+', '-', '*', '/']\n\n def op(num1, num2, op):\n if op == '+':\n return num1 + num2\n if op == '-':\n return num1 - num2\n if op == '/':\n return num1 / num2\n if op == '*':\n return num1 * num2\n\n operands_stack = []\n for item in tokens:\n if item not in valid_op:\n operands_stack.append( int(item) )\n else:\n num2, num1 = operands_stack.pop(), operands_stack.pop()\n ans = op(num1, num2, item)\n operands_stack.append(int(ans))\n\n # print(operands_stack)\n\n return operands_stack[-1]\n\n ","runtime":"59"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n ops = {\n '+': lambda a, b: a + b,\n '-': lambda a, b: a - b,\n '*': lambda a, b: a * b,\n '/': lambda a, b: int(a / b),\n }\n stack = []\n for t in tokens:\n if len(t) > 1 or 47 < ord(t) < 58:\n stack.append(int(t))\n else:\n b,a = stack.pop(), stack.pop()\n c = ops[t](a,b)\n stack.append(c)\n return stack[0]","runtime":"59"},{"code":"class Solution:\n def performOp(self, a, b, sign):\n if sign == '+':\n return a + b\n elif sign == '-':\n return a - b\n elif sign == '*':\n return a * b\n elif sign == '/':\n return int(a/b)\n else:\n return 0\n\n def evalRPN(self, tokens: List[str]) -> int:\n i = 0\n stack = []\n while i < len(tokens):\n temp = tokens[i]\n i += 1\n if temp.isalnum() or (temp[0] == '-' and len(temp) > 1):\n stack.append(int(temp))\n else:\n op2 = stack.pop() \n op1 = stack.pop() \n ans = self.performOp(op1,op2,temp)\n stack.append(ans)\n return stack.pop()","runtime":"60"},{"code":"from functools import reduce\n\nclass Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n if not tokens: return\n\n stack = []\n \n op_map = {\n '+': '__add__',\n '-': '__sub__',\n '*': '__mul__',\n '/': '__truediv__'\n }\n\n for token in tokens:\n if token in op_map:\n op_method = op_map.get(token)\n num2 = stack.pop()\n num1 = stack.pop()\n new_num = int(getattr(num1, op_method)(num2))\n stack.append(new_num)\n else:\n stack.append(int(token))\n \n return stack.pop()\n ","runtime":"60"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n valStack = []\n\n for t in tokens:\n if t not in [\"+\",\"-\",\"*\",\"/\"]:\n valStack.append(int(t))\n else:\n second = valStack.pop()\n first = valStack.pop()\n res = 0\n\n if t == \"/\":\n res = int(first / second)\n elif t == \"*\":\n res = first * second\n elif t == \"-\":\n res = first - second \n else:\n res = first + second\n \n print(first,second,t, res)\n \n valStack.append(res)\n\n return valStack.pop()","runtime":"61"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n\n stack = []\n\n for token in tokens:\n \n if token == '+':\n second = stack.pop()\n stack[-1] += second\n elif token == '*':\n second = stack.pop()\n stack[-1] *= second\n elif token == '-':\n second = stack.pop()\n stack[-1] -= second\n elif token == '/':\n second = stack.pop()\n sign = 1\n if (stack[-1] < 0 and second > 0) or (stack[-1] > 0 and second < 0):\n sign *= -1\n stack[-1] = sign * (abs(stack[-1]) // abs(second))\n else:\n stack.append(int(token))\n \n return stack[-1]","runtime":"61"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n st = []\n #ans = 0\n for s in tokens:\n if s not in ['+','-','*','/']:\n st.append(int(s))\n else:\n second = st.pop()\n first = st.pop()\n \n if s == '+':\n st.append(first+second) \n elif s == '-':\n st.append(first-second)\n elif s == '*':\n st.append(first*second)\n elif s == '/':\n \n st.append(int(first/second))\n \n return st.pop()","runtime":"62"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack=[]\n for token in tokens:\n if token=='+':\n a=int(stack.pop())\n b=int(stack.pop())\n stack.append(a+b)\n elif token=='-':\n a=int(stack.pop())\n b=int(stack.pop())\n stack.append(b-a)\n elif token=='*':\n a=int(stack.pop())\n b=int(stack.pop())\n stack.append(a*b)\n elif token=='/':\n a=int(stack.pop())\n b=int(stack.pop())\n stack.append(b/a)\n else:\n stack.append(token)\n return int(stack[0])\n ","runtime":"62"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for token in tokens:\n if token.lstrip('-').isdigit(): # Handle numbers (including negative)\n stack.append(int(token))\n else:\n op2 = stack.pop()\n op1 = stack.pop()\n if token == '+':\n stack.append(op1 + op2)\n elif token == '-':\n stack.append(op1 - op2)\n elif token == '*':\n stack.append(op1 * op2)\n elif token == '/':\n stack.append(int(op1 / op2)) # Ensure integer division\n return stack.pop()","runtime":"63"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n #[\"10\",\"6\",\"9\",\"3\",\"+\",\"-11\",\"*\",\"/\",\"*\",\"17\",\"+\",\"5\",\"+\"]\n # 10 6 9 3\n # + -> 9 + 3\n # 10 6 12 -11\n # * -> 12 * -11\n # 10 6 -132 \n # / -> 6 / -132\n # 10 0\n # * -> 0\n # 0 17\n # + -> 17\n # 17 5\n # + -> 17 + 5 \n # 22\n stack = []\n operations = ['+', '-', '/', '*']\n for i in tokens:\n if i in operations:\n #print(stack)\n sec = stack.pop()\n first = stack.pop()\n if i == '+':\n stack.append(first + sec)\n elif i == '-':\n stack.append(first - sec)\n elif i == '*':\n stack.append(first * sec)\n elif i == '/':\n stack.append(int(first / sec))\n else:\n stack.append(int(i))\n return stack[0]\n\n\n","runtime":"64"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stk = []\n for token in tokens:\n if token not in \"+-*/\":\n stk.append(int(token))\n else:\n self.evalOp(token, stk)\n \n return stk.pop()\n \n def evalOp(self, op, stk):\n a = stk.pop()\n b = stk.pop()\n if op == \"+\":\n stk.append(b + a)\n elif op == \"-\":\n stk.append(b - a)\n elif op == \"*\":\n stk.append(b * a)\n elif op == \"/\":\n if (a < 0 or b < 0) and not (a < 0 and b < 0) :\n stk.append(math.ceil(b / a))\n else:\n stk.append(b // a)\n\n return stk","runtime":"64"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for i in tokens:\n if i == '+':\n stack.append(stack.pop() + stack.pop())\n elif i == '-':\n a, b = stack.pop(), stack.pop()\n stack.append(b - a)\n elif i == \"*\":\n stack.append(stack.pop() * stack.pop())\n elif i == '/':\n a, b = stack.pop(), stack.pop()\n stack.append(int(float(b) / a))\n else:\n stack.append(int(i)) \n return stack[0] ","runtime":"65"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for t in tokens:\n if t in ['+', '-', '*', '/']: \n n1, n2 = stack.pop(), stack.pop()\n if t == '+':\n stack.append(n1 + n2)\n elif t == '-':\n stack.append(n2 - n1)\n elif t == '*':\n stack.append(n1 * n2)\n else:\n stack.append(int(n2 / n1))\n else:\n stack.append(int(t))\n \n return stack[0]","runtime":"65"},{"code":"from math import ceil\n\nclass Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n # set of operators for easy lookup\n operators = {'+', '-', '*', '/'}\n\n # stack that stores current numbers and results of an operation\n stack = []\n\n # iterate through tokens, add numbers to stack\n for t in tokens:\n\n # if operator encountered, perform that operation on the top two elements in the stack,\n # make sure to return the result back to the stack\n if t not in operators:\n stack.append(int(t))\n else:\n y = stack.pop(-1)\n x = stack.pop(-1)\n\n if t == '+':\n stack.append(x+y)\n\n elif t == '-':\n stack.append(x-y)\n \n elif t == '*':\n stack.append(x*y)\n \n elif t == '/':\n res = x / y\n # handle division truncation towards 0\n if res > 0:\n stack.append(x//y)\n else:\n stack.append(ceil(res))\n\n # Repeat this process until we reach the end of tokens\n\n return stack[0]","runtime":"66"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n nums = []\n for ch in tokens:\n if ch == '+':\n n2, n1 = nums.pop(-1), nums.pop(-1)\n n1, n2 = int(n1), int(n2)\n nums.append(n1+n2)\n elif ch == '-':\n n2, n1 = nums.pop(-1), nums.pop(-1)\n n1, n2 = int(n1), int(n2)\n nums.append(n1-n2)\n elif ch == '*':\n n2, n1 = nums.pop(-1), nums.pop(-1)\n n1, n2 = int(n1), int(n2)\n nums.append(n1*n2)\n elif ch == '/':\n n2, n1 = nums.pop(-1), nums.pop(-1)\n n1, n2 = int(n1), int(n2)\n nums.append(n1/n2)\n else:\n nums.append(int(ch))\n return int(nums[0])","runtime":"66"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n \n stack=[]\n for token in tokens:\n if token not in ('+','-','*','/'):\n stack.append(int(token))\n else:\n b = stack.pop()\n a = stack.pop()\n if token=='+':\n stack.append(a+b)\n elif token=='-':\n stack.append(a-b)\n elif token=='*':\n stack.append(a*b)\n elif token=='/':\n stack.append(int(a/b))\n\n return stack.pop()\n\n ","runtime":"67"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n\n operations = {\n \"+\": lambda a, b: a + b,\n \"-\": lambda a, b: a - b,\n \"/\": lambda a, b: int(a / b),\n \"*\": lambda a, b: a * b,\n }\n\n stack=[]\n for token in tokens:\n if token not in operations:\n stack.append(int(token))\n else:\n b = stack.pop()\n a = stack.pop()\n op = operations[token]\n stack.append(op(a,b))\n\n \n # stack=[]\n # for token in tokens:\n # if token not in ('+','-','*','/'):\n # stack.append(int(token))\n # else:\n # b = stack.pop()\n # a = stack.pop()\n # if token=='+':\n # stack.append(a+b)\n # elif token=='-':\n # stack.append(a-b)\n # elif token=='*':\n # stack.append(a*b)\n # elif token=='/':\n # stack.append(int(a/b))\n\n return stack.pop()\n\n ","runtime":"67"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n operators = {\n '+': lambda y, x: x + y,\n '-': lambda y, x: x - y,\n '*': lambda y, x: x * y,\n '/': lambda y, x: math.trunc(x / y),\n }\n\n if not tokens:\n return 0\n \n stack = []\n\n for token in tokens:\n if token in operators:\n l, r = stack.pop(), stack.pop()\n stack.append(operators[token](l,r))\n else:\n stack.append(int(token))\n\n return stack[0]\n","runtime":"68"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n nums = []\n\n for t in tokens:\n if t.lstrip('-+').isdigit():\n nums.append(int(t))\n else:\n tmp = nums.pop()\n if t == '+':\n nums[-1] = nums[-1] + tmp\n elif t == '-':\n nums[-1] = nums[-1] - tmp\n elif t == '*':\n nums[-1] = nums[-1] * tmp\n elif t == '/':\n nums[-1] = int(nums[-1] / tmp)\n return nums[0]","runtime":"68"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n ops = {'+': 0, '-': 0, '*': 0, '/': 0}\n\n for i in tokens:\n if i in ops:\n op = i\n num_right = stack.pop(-1)\n num_left = stack.pop(-1)\n\n if op == '+':\n stack.append(num_left + num_right)\n elif op == '-':\n stack.append(num_left - num_right)\n elif op == '*':\n stack.append(num_left * num_right)\n else:\n stack.append(int(num_left/num_right))\n else:\n stack.append(int(i))\n\n return stack[-1]","runtime":"69"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n s = []\n for token in tokens:\n if token == '+':\n s.append(s.pop() + s.pop())\n elif token == '-':\n tmp = s.pop()\n s.append(s.pop() - tmp)\n elif token == '*':\n s.append(s.pop() * s.pop()),\n elif token == '/':\n tmp = s.pop()\n s.append(int(s.pop() / tmp))\n else:\n s.append(int(token))\n return s[0]","runtime":"69"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for t in tokens:\n # print(\"t =\", t)\n try:\n t = int(t)\n stack.append(int(t))\n except:\n b = stack.pop()\n a = stack.pop()\n if t == '+':\n stack.append(a+b)\n elif t == '-': \n stack.append(a-b)\n elif t == '*': \n stack.append(a*b)\n elif t == '/':\n val = a / b \n if val >= 0:\n stack.append(floor(val))\n else:\n stack.append(ceil(val))\n\n # print(\"stack =\", stack)\n \n return stack[-1]\n \n \n ","runtime":"70"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n operators = ['+', '-', '*', '/']\n\n for t in tokens:\n if t in operators:\n first = int(stack.pop())\n second = int(stack.pop())\n if t == '+':\n stack.append((second + first))\n elif t == '-':\n stack.append((second - first))\n elif t == '*':\n stack.append((second * first))\n else:\n stack.append(int(float(second / first)))\n else:\n stack.append(t)\n return int(stack[-1])","runtime":"70"},{"code":"\nclass Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n operators = set(['+', '-', '*', '/'])\n \n for token in tokens:\n if token in operators:\n b = stack.pop()\n a = stack.pop()\n \n if token == '+':\n stack.append(a + b)\n elif token == '-':\n stack.append(a - b)\n elif token == '*':\n stack.append(a * b)\n elif token == '/':\n # Ensure correct integer division behavior\n stack.append(int(a / b))\n else:\n stack.append(int(token))\n \n return stack[0]\n","runtime":"71"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for token in tokens:\n if token in \"+-*/\":\n right = stack.pop()\n left = stack.pop()\n\n if token == \"+\":\n stack.append(left + right)\n elif token == \"-\":\n stack.append(left - right)\n elif token == \"*\":\n stack.append(left * right)\n elif token == \"/\":\n stack.append(int(left / right))\n else:\n stack.append(int(token))\n return stack[0]\n\n","runtime":"71"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n\n for i in tokens: \n\n if i not in [\"+\", \"-\", \"*\", \"/\"]:\n stack.append(int(i))\n\n else: \n right = stack.pop()\n left = stack.pop()\n\n if i == \"+\": \n stack.append(left + right)\n\n if i == \"-\": \n stack.append(left - right)\n\n if i == \"*\": \n stack.append(left * right)\n\n if i == \"/\": \n stack.append(int(left / right))\n\n\n return stack.pop()","runtime":"72"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n s=[]\n op=set()\n op.update(['+','-','*','/'])\n for i in tokens:\n if i in op:\n op2=s.pop()\n op1=s.pop()\n if i=='+':\n s.append(op1+op2)\n elif i=='-':\n s.append(op1-op2)\n elif i=='*':\n s.append(op1*op2)\n else:\n s.append(int(op1/op2))\n else:\n s.append(int(i))\n return s[0] ","runtime":"72"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n\n for i in tokens:\n if (i == '+') or (i == '-') or (i == '*') or (i == '/'):\n op = i\n num_right = stack.pop(-1)\n num_left = stack.pop(-1)\n\n if op == '+':\n stack.append(num_left + num_right)\n elif op == '-':\n stack.append(num_left - num_right)\n elif op == '*':\n stack.append(num_left * num_right)\n else:\n stack.append(int(num_left/num_right))\n else:\n stack.append(int(i))\n\n return stack[-1]","runtime":"73"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n res = 0\n stack = []\n i = 0\n while i < len(tokens):\n if tokens[i] in [\"+\", \"-\", \"*\", \"/\"]:\n operator = tokens[i]\n if stack:\n second = int(stack.pop())\n first = int(stack.pop())\n if operator == \"+\":\n res = first + second\n elif operator == \"-\":\n res = first - second\n elif operator == \"*\":\n res = first * second\n else:\n res = first / second\n stack.append(res)\n else:\n stack.append(tokens[i])\n i += 1\n return int(stack[0])\n \n \n ","runtime":"73"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n if len(tokens) == 1:\n return int(tokens[0])\n for t in tokens:\n if t not in \"+-*/\":\n stack.append(int(t))\n continue\n val2 = stack.pop()\n if t == \"+\":\n stack[-1] += val2\n elif t == \"-\":\n stack[-1] -= val2\n elif t == \"*\":\n stack[-1] *= val2\n else:\n stack[-1] = int(stack[-1]/val2)\n return stack[-1]","runtime":"74"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n ops = {\n '+': lambda a, b: a+b,\n '-': lambda a, b: a-b,\n '*': lambda a, b: a*b,\n '/': lambda a, b: trunc(a/b)\n }\n\n stack = []\n for token in tokens:\n if token not in ops:\n stack.append(int(token))\n else:\n second = stack.pop()\n stack.append(ops[token](stack.pop(), second))\n return stack[-1]","runtime":"74"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n res=[]\n operator=\"+-*/\"\n for i in tokens:\n #print(res)\n if i in operator:\n #print(res)\n a=res.pop()\n b=res.pop()\n if i==\"+\":\n res.append(b+a)\n elif i==\"-\":\n res.append(b-a)\n elif i==\"*\":\n res.append(b*a)\n else:\n res.append(int(b/a))\n else:\n res.append(int(i))\n return res[-1]\n\n\n ","runtime":"75"},{"code":"from math import ceil,floor\nclass Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n s=[]\n for i in tokens:\n if i not in \"+-*/\":\n s.append(int(i))\n else:\n op2=s.pop()\n op1=s.pop()\n if i==\"+\":\n summ=op1+op2\n elif i==\"-\":\n summ=op1-op2\n elif i==\"*\":\n summ=op1*op2\n elif i==\"/\":\n summ=op1/op2\n if summ>0:\n summ=floor(op1/op2)\n else:\n summ=ceil(op1/op2)\n s.append(summ) \n return s.pop()\n ","runtime":"75"},{"code":"class Solution:\n def is_number(self, n):\n try:\n float(n)\n return True\n except ValueError:\n return False\n\n def evalRPN(self, tokens: List[str]) -> int:\n numb_stack = []\n\n for idx, ele in enumerate(tokens):\n if self.is_number(ele):\n numb_stack.append(int(ele))\n else:\n val1 = numb_stack.pop()\n val2 = numb_stack.pop()\n \n if ele == \"+\":\n numb_stack.append(val2+val1)\n elif ele == \"-\":\n numb_stack.append(val2-val1)\n elif ele == \"*\":\n numb_stack.append(val2*val1)\n elif ele == \"/\":\n numb_stack.append(int(val2/val1)) \n return numb_stack.pop()","runtime":"76"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = collections.deque()\n val = None\n \n for t in tokens:\n try:\n stack.append(int(t))\n except:\n v2 = stack.pop()\n v1 = stack.pop()\n if t == \"+\":\n stack.append(v1 + v2)\n elif t == \"-\":\n stack.append(v1 - v2)\n elif t == \"/\":\n v = v1 / v2\n stack.append(math.floor(v) if v >= 0 else math.ceil(v))\n else:\n stack.append(v1 * v2)\n return stack[0]","runtime":"76"},{"code":"class Solution:\n def is_number(self, n):\n try:\n float(n)\n except ValueError:\n return False\n return True\n\n def evalRPN(self, tokens: List[str]) -> int:\n numb_stack = []\n\n for idx, ele in enumerate(tokens):\n if self.is_number(ele):\n numb_stack.append(int(ele))\n else:\n val1 = numb_stack.pop()\n val2 = numb_stack.pop()\n \n print(val1, val2, ele)\n if ele == \"+\":\n numb_stack.append(val2+val1)\n elif ele == \"-\":\n numb_stack.append(val2-val1)\n elif ele == \"*\":\n numb_stack.append(val2*val1)\n elif ele == \"/\":\n numb_stack.append(int(val2/val1))\n\n # if ele == \"+\":\n # ret += val1\n # elif ele == \"-\":\n # if tokens[idx-1] == str(val1):\n # print(\"here\")\n # ret = ret - val1\n # else:\n # print(\"here2\")\n # ret = val1 - ret\n # elif ele == \"*\":\n # ret *= val1\n # elif ele == \"/\":\n # if tokens[idx-1] == val1:\n # ret = int(ret/val1)\n # else:\n # ret = int(val1/ret)\n \n return numb_stack.pop()","runtime":"77"},{"code":"class Solution:\n def __init__(self):\n self.stack = []\n\n def pop(self):\n return int(self.stack.pop())\n\n def evalRPN(self, tokens: List[str]) -> int:\n for ele in tokens:\n if ele == \"+\":\n self.stack.append(self.pop() + self.pop())\n elif ele == \"-\":\n a = self.pop()\n b = self.pop()\n self.stack.append(b - a)\n elif ele == \"*\":\n self.stack.append(self.pop() * self.pop())\n elif ele == \"/\":\n a = self.pop()\n b = self.pop()\n print(int(b/a))\n print(self.stack)\n self.stack.append(int(b / a))\n else:\n self.stack.append(int(ele))\n return self.stack[-1]","runtime":"77"},{"code":"class Solution:\n def is_number(self, n):\n try:\n float(n)\n except ValueError:\n return False\n return True\n\n def evalRPN(self, tokens: List[str]) -> int:\n numb_stack = []\n\n for idx, ele in enumerate(tokens):\n if self.is_number(ele):\n numb_stack.append(int(ele))\n else:\n val1 = numb_stack.pop()\n val2 = numb_stack.pop()\n \n print(val1, val2, ele)\n if ele == \"+\":\n numb_stack.append(val2+val1)\n elif ele == \"-\":\n numb_stack.append(val2-val1)\n elif ele == \"*\":\n numb_stack.append(val2*val1)\n elif ele == \"/\":\n numb_stack.append(int(val2/val1)) \n return numb_stack.pop()","runtime":"78"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n\n for token in tokens:\n if token.isdigit() or (token[0] == \"-\" and token[1:].isdigit()):\n stack.append(int(token))\n else:\n firstInteger = stack.pop()\n secondInteger = stack.pop()\n if token == \"+\":\n result = secondInteger + firstInteger\n elif token == \"-\":\n result = secondInteger - firstInteger\n elif token == \"*\":\n result = secondInteger * firstInteger\n else:\n result = int(secondInteger / firstInteger)\n stack.append(result)\n return stack[0]","runtime":"79"},{"code":"import math\nclass Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n operations=set([\"+\",\"-\",\"*\",\"/\"])\n stack=[]\n for token in tokens:\n if token in operations: #Must be to operate on previous two things\n b=stack.pop()\n a=stack.pop()\n if token==\"+\":\n c=a+b\n elif token==\"-\":\n c=a-b\n elif token==\"*\":\n c=a*b\n elif token==\"/\":\n real_c=a/b\n if real_c>=0:\n c=math.floor(real_c)\n elif real_c<0:\n c=math.ceil(real_c)\n stack.append(c)\n print(a,b,token,c)\n \n else: #If token not in operations, must be \"int\"\n stack.append(int(token))\n return stack[-1]","runtime":"79"},{"code":"class Solution:\n def performOp(self, a, b, sign):\n if sign == '+':\n return a + b\n elif sign == '-':\n return a - b\n elif sign == '*':\n return a * b\n elif sign == '/':\n return int(a/b)\n else:\n return 0\n\n def evalRPN(self, tokens: List[str]) -> int:\n i = 0\n stack = []\n while i < len(tokens):\n temp = tokens[i]\n i += 1\n if temp.isalnum() or (temp[0] == '-' and len(temp) > 1):\n stack.append(int(temp))\n else:\n op2 = stack.pop() \n op1 = stack.pop() \n ans = self.performOp(op1,op2,temp)\n print(op1,op2,temp,ans)\n stack.append(ans)\n return stack.pop()","runtime":"80"},{"code":"class Solution:\n def is_number(self, n):\n try:\n float(n)\n return True\n except ValueError:\n return False\n\n def evalRPN(self, tokens: List[str]) -> int:\n numb_stack = []\n\n for idx, ele in enumerate(tokens):\n if self.is_number(ele):\n numb_stack.append(int(ele))\n else:\n val1 = numb_stack.pop()\n val2 = numb_stack.pop()\n \n print(val1, val2, ele)\n if ele == \"+\":\n numb_stack.append(val2+val1)\n elif ele == \"-\":\n numb_stack.append(val2-val1)\n elif ele == \"*\":\n numb_stack.append(val2*val1)\n elif ele == \"/\":\n numb_stack.append(int(val2/val1)) \n return numb_stack.pop()","runtime":"81"},{"code":"import math\nclass Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n operations=set([\"+\",\"-\",\"*\",\"/\"])\n stack=[]\n for token in tokens:\n if token in operations: #Must be to operate on previous two things\n b=stack.pop()\n a=stack.pop()\n if token==\"+\":\n c=a+b\n elif token==\"-\":\n c=a-b\n elif token==\"*\":\n c=a*b\n elif token==\"/\":\n real_c=a/b\n if real_c>=0:\n c=math.floor(real_c)\n elif real_c<0:\n c=math.ceil(real_c)\n stack.append(c)\n print(a,b,token,c)\n \n else: #If token not in operations, must be \"int\"\n stack.append(int(token))\n return stack[-1]","runtime":"81"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n valStack, opStack = [], []\n res = math.inf\n\n if len(tokens) == 1:\n return int(tokens[0])\n\n for t in tokens:\n if t not in [\"+\",\"-\",\"*\",\"/\"]:\n valStack.append(int(t))\n else:\n second = valStack.pop()\n first = valStack.pop()\n res = 0\n\n print('start', res)\n if t == \"/\":\n res = int(first / second)\n elif t == \"*\":\n res = first * second\n elif t == \"-\":\n res = first - second \n else:\n res = first + second\n \n print(first,second,t, res)\n \n valStack.append(res)\n\n return valStack.pop()\n\n \n\n # for t in tokens:\n # if t not in [\"+\",\"-\",\"*\",\"/\"]:\n # valStack.append(int(t))\n # else:\n # if res == math.inf:\n # res = valStack.pop()\n # first = valStack.pop()\n # print('start', res)\n # if t == \"/\":\n # if first < 0 or res < 0:\n # res = int(round(first / res,0))\n # else:\n # res = first // res\n # elif t == \"*\":\n # res *= first\n # elif t == \"-\":\n # res = first - res\n # else:\n # res += first\n # print(first, res)\n \n # print('final' , res)\n # return res\n\n ","runtime":"82"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n '''\n curr = 2\n [curr,1]\n operation +\n curr += top\n pop()\n pop()\n push(curr)\n push(3)\n '''\n stack = []\n operators = [\"+\", \"-\", \"/\", \"*\"]\n\n if len(tokens) == 1:\n return int(tokens[0])\n curr = 0\n while tokens:\n el = tokens.pop(0)\n if el in operators:\n s = stack.pop()\n f = stack.pop()\n if el is operators[0]:\n curr = f + s\n elif el is operators[1]:\n curr = f - s\n elif el is operators[2]:\n curr = f / s \n curr = floor(curr) if curr > 0 else ceil(curr)\n elif el is operators[3]:\n curr = f * s\n stack.append(curr)\n else:\n stack.append(int(el))\n\n return curr\n\n ","runtime":"82"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n current_pos = 0\n\n while len(tokens) > 1:\n\n while tokens[current_pos] not in '+/*-':\n current_pos+=1\n \n operator = tokens[current_pos]\n val2 = int(tokens[current_pos - 1])\n val1 = int(tokens[current_pos - 2])\n\n if operator == '+':\n tokens[current_pos] = val1 + val2\n elif operator == '-':\n tokens[current_pos] = val1 - val2\n elif operator == '*':\n tokens[current_pos] = val1 * val2\n else:\n tokens[current_pos] = int(val1 / val2)\n \n tokens.pop(current_pos-2)\n tokens.pop(current_pos-2)\n current_pos-=1\n \n return int(tokens[-1])","runtime":"83"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n operator=[\"*\",\"+\",\"-\",\"/\"]\n l=[]\n while(len(tokens)!=0):\n a=tokens.pop(0)\n if a in operator:\n op2=l.pop(-1)\n op1=l.pop(-1)\n if(a==\"*\"):\n l.append(int(op1*op2))\n elif(a==\"/\"):\n l.append(int(op1/op2))\n elif(a==\"+\"):\n l.append(int(op1+op2))\n elif(a==\"-\"):\n l.append(int(op1-op2))\n else:\n l.append(int(a))\n print(int(int(6//-132)))\n return l[0]\n\n ","runtime":"84"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n operator=[\"*\",\"+\",\"-\",\"/\"]\n l=[]\n while(len(tokens)!=0):\n a=tokens.pop(0)\n if a in operator:\n op2=l.pop(-1)\n op1=l.pop(-1)\n if(a==\"*\"):\n l.append(int(op1*op2))\n elif(a==\"/\"):\n l.append(int(op1/op2))\n elif(a==\"+\"):\n l.append(int(op1+op2))\n elif(a==\"-\"):\n l.append(int(op1-op2))\n else:\n l.append(int(a))\n \n return l[0]\n\n ","runtime":"84"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = [] # stores math arguments\n for t in tokens:\n if t in ['+', '-', '*', '/']:\n a = int(stack[-2])\n b = int(stack[-1])\n stack = stack[:-2]\n # compute prod, push back onto stack\n if t == '+':\n prod = a + b\n elif t == '-':\n prod = a - b\n elif t == '*':\n prod = a * b\n else:\n prod = int(a / b)\n stack.append(prod)\n else:\n stack.append(int(t))\n \n return stack[0]","runtime":"85"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n\n for t in tokens:\n if t != \"+\" and t!= \"/\" and t != \"*\" and t != \"-\":\n stack.insert(0, int(t))\n else:\n num1 = stack.pop(0)\n num2 = stack.pop(0)\n if (t == \"+\"):\n stack.insert(0, num1 + num2)\n elif(t == \"-\"):\n stack.insert(0, num2 - num1)\n elif(t == \"/\"):\n stack.insert(0, int(float(num2) / num1))\n else:\n stack.insert(0, num1 * num2)\n \n\n\n return stack.pop()","runtime":"85"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n \"\"\"\n time: O(N LogN)\n space O(1)\n \"\"\"\n # while len(tokens)!=1:\n # for idx,token in enumerate(tokens):\n # if token in ['+','-','*','/']:\n # # print(idx,tokens)\n # ops = tokens.pop(idx)\n # right = int(tokens.pop(idx-1))\n # left = int(tokens.pop(idx-2))\n # anw = 0\n # if ops=='+':\n # anw=left+right\n # elif ops=='-':\n # anw=left-right\n # elif ops=='*':\n # anw=left*right\n # elif ops=='/':\n # anw=int(left/right)\n # tokens.insert(idx-2,anw)\n # # print(tokens)\n # break\n idx=0\n while not len(tokens)==1:\n token = tokens[idx]\n if token in ['+','-','*','/']:\n # print(idx,tokens)\n ops = tokens.pop(idx)\n right = int(tokens.pop(idx-1))\n left = int(tokens.pop(idx-2))\n anw = 0\n if ops=='+':\n anw=left+right\n elif ops=='-':\n anw=left-right\n elif ops=='*':\n anw=left*right\n elif ops=='/':\n anw=int(left/right)\n tokens.insert(idx-2,anw)\n # print(tokens)\n idx=idx-1\n else:\n idx+=1\n return int(tokens[0])","runtime":"86"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n operands = []\n for i in tokens:\n if i == \"+\":\n item = int((operands[-2]) + (operands[-1]))\n operands = self.cutAddList(operands, item)\n elif i == \"-\":\n item = int((operands[-2]) - (operands[-1]))\n operands = self.cutAddList(operands, item)\n elif i == \"*\":\n item = int((operands[-2]) * (operands[-1]))\n operands = self.cutAddList(operands, item)\n elif i == \"/\":\n item = int((operands[-2]) / (operands[-1]))\n operands = self.cutAddList(operands, item)\n else:\n operands.append(int(i))\n \n return int(operands[0])\n\n \n def cutAddList(self, arr: List[int], item: int) -> List[int]:\n newArr = arr[:-2]\n newArr.append(item)\n return newArr\n\n ","runtime":"87"},{"code":"class Solution:\n def evalRPN(self, tokens):\n operators = ['+', '-', '*', '/']\n stack = []\n for i in tokens:\n if i not in operators:\n stack.append(i)\n else:\n operation = stack.pop(-2) + i + stack.pop()\n stack.append(str(int(eval(operation))))\n return int(stack[0])","runtime":"88"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n if not tokens:\n return 0\n\n token = tokens.pop()\n\n funcs = {\n '+': lambda l, r: l + r,\n '-': lambda l, r: l - r,\n '*': lambda l, r: l * r,\n '/': lambda l, r: int(l / r),\n }\n \n if token not in funcs:\n return int(token)\n\n right = self.evalRPN(tokens)\n left = self.evalRPN(tokens)\n\n return funcs[token](left, right)","runtime":"89"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n def div(x,y):\n if x>0 and y>0 or x<0 and y<0:\n return abs(x)//abs(y)\n x=abs(x)\n y=abs(y)\n return -1*(x//y)\n stack=[]\n ops=\"+-*/\"\n for x in tokens:\n if x not in ops:\n stack.append(int(x))\n elif x==\"+\":\n temp=stack[-1]\n stack=stack[:-1]\n stack[-1]+=temp\n elif x==\"-\":\n temp=stack[-1]\n stack=stack[:-1]\n stack[-1]-=temp\n elif x==\"*\":\n temp=stack[-1]\n stack=stack[:-1]\n stack[-1]*=temp\n else:\n temp=stack[-1]\n stack=stack[:-1]\n stack[-1]=div(stack[-1],temp)\n return stack[0]\n\n \n ","runtime":"90"},{"code":"import operator as op\n\nclass Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n if len(tokens) == 1:\n return int(tokens[0])\n \n operators = {\"+\": lambda a, b: a + b,\n \"-\": lambda a, b: a - b,\n \"*\": lambda a, b: a*b,\n \"/\": lambda a,b: a/b}\n \n index = 0\n while tokens:\n command = tokens[index]\n\n if command in operators:\n func = operators[tokens.pop(index)]\n b = int(tokens.pop(index - 1))\n a = int(tokens.pop(index - 2))\n tokens.insert(index - 2, func(a, b))\n index = index - 2\n elif len(tokens) == 1:\n return int(tokens[0])\n else:\n index += 1\n\n","runtime":"91"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n opDict = {\n '+': lambda lhs, rhs: lhs + rhs, \n '-': lambda lhs, rhs: lhs - rhs, \n '/': lambda lhs, rhs: int(lhs / rhs), \n '*': lambda lhs, rhs: lhs * rhs,\n }\n\n stack = []\n for token in tokens:\n if token not in opDict:\n stack.append(int(token))\n else:\n rhs, lhs = stack[-1], stack[-2]\n stack = stack[:-2]\n stack.append(opDict[token](lhs, rhs))\n\n return stack[0]\n\n\n\n ","runtime":"92"},{"code":"import operator as op\n\nclass Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n if len(tokens) == 1:\n return int(tokens[0])\n operators = {\"+\": op.add, \"-\": op.sub, \"*\": op.mul, \"/\": op.truediv}\n \n index = 0\n while tokens:\n command = tokens[index]\n\n if command in operators:\n func = operators[tokens.pop(index)]\n b = int(tokens.pop(index - 1))\n a = int(tokens.pop(index - 2))\n tokens.insert(index - 2, func(a, b))\n index = index - 2\n elif len(tokens) == 1:\n return int(tokens[0])\n else:\n index += 1\n\n","runtime":"93"},{"code":"import math\ndef performOp(operand, num1, num2):\n if operand == '+':\n return num1 + num2\n elif operand == '-':\n return num2 - num1\n elif operand == '*':\n return num1 * num2\n elif operand == '/':\n return math.trunc(num2 / num1)\n else:\n raise Error(f\"Invalid operand: {operand}\")\n \ndef isNumber(str):\n try:\n int(str)\n return True\n except:\n return False\nclass Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n # put each element on the stack\n # if curr == operand, pop last two and perform operation\n # put result back on stack\n stack = []\n while tokens:\n curr = tokens.pop(0)\n if isNumber(curr):\n stack.append(int(curr))\n else:\n first = stack.pop()\n second = stack.pop()\n print(f\"{second} {curr} {first}\")\n result = performOp(curr, first, second)\n stack.append(result)\n return stack[0]\n ","runtime":"94"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n i = 0\n n = len(tokens)\n ops = ['+', '-', '*', '/']\n exp=[]\n ans = 0\n def operation(op1,op2,op):\n if op == '+':\n return op2+op1\n elif op == '-':\n return op2-op1\n elif op == '*':\n return op2*op1\n elif op == '/':\n return op2/op1\n if len(tokens)==1:\n return int(tokens[0])\n while len(tokens)>0:\n if tokens[i] not in ops:\n exp.append(tokens[i])\n del tokens[i]\n else:\n op1 = exp.pop()\n op2= exp.pop()\n print(op1,op2)\n ans = operation(int(op1),int(op2),tokens[i])\n tokens[0] = ans\n return int(ans)\n \n","runtime":"95"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for token in tokens:\n if token in {\"+\", \"-\", \"*\", \"/\"}:\n val2 = stack.pop()\n val1 = stack.pop()\n res = eval(str(val1) + token + str(val2))\n stack.append(int(res))\n else:\n stack.append(int(token))\n\n return stack[0]\n","runtime":"96"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n signs = {'*','/','+','-'}\n stack = []\n for token in tokens:\n if token in signs:\n one = stack.pop()\n two = stack.pop()\n stack.append(int(eval(f'{two} {token} {one}')))\n else:\n stack.append(token)\n \n return (int(stack[0]))\n ","runtime":"97"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n tokens_stack = []\n for el in tokens:\n match el:\n case \"+\":\n res = tokens_stack[-2] + tokens_stack[-1]\n tokens_stack = tokens_stack[:-2]\n tokens_stack.append(res)\n case \"-\":\n res = tokens_stack[-2] - tokens_stack[-1]\n tokens_stack = tokens_stack[:-2]\n tokens_stack.append(res)\n case \"*\":\n res = tokens_stack[-2] * tokens_stack[-1]\n tokens_stack = tokens_stack[:-2]\n tokens_stack.append(res)\n case \"/\":\n res = tokens_stack[-2] / tokens_stack[-1]\n res = math.floor(res) if res > 0 else math.ceil(res)\n tokens_stack = tokens_stack[:-2]\n tokens_stack.append(res)\n case _:\n tokens_stack.append(int(el))\n return tokens_stack.pop()","runtime":"98"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for t in tokens:\n if t in [\"*\", \"/\", \"+\", \"-\"]:\n p1 = stack.pop(-1)\n p2 = stack.pop(-1)\n if t == \"*\":\n stack.append(p1 * p2)\n elif t == \"/\":\n r = p2 / p1\n if r >= 0:\n stack.append((p2//p1))\n else:\n stack.append(- (p2 // (-p1)))\n elif t == \"+\":\n stack.append(p1 + p2)\n elif t == \"-\":\n stack.append(p2-p1)\n else:\n stack.append(eval(t))\n return stack[-1]\n \n ","runtime":"99"},{"code":"class Solution:\n def evalRPN(self, t: List[str]) -> int:\n st = []\n for i in t:\n if i in \"+-*/\":\n b,a=st.pop(),st.pop()\n st.append(str(int(eval(a+i+b))))\n else:st.append(i)\n return int(st[0])","runtime":"100"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n l = []\n for i in tokens:\n if i not in \"+*-/\":\n l.append(i)\n else:\n b = l.pop()\n a = l.pop()\n if i == \"/\":\n l.append(str(int(int(a)/int(b))))\n else:\n l.append(str(eval(a+i+b)))\n return int(l[-1])","runtime":"101"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n res=[]\n for i in tokens:\n if i not in ['*','-','+','/']:\n res.append(i)\n else:\n a=res.pop()\n b=res.pop()\n x=str(b)+str(i)+str(a)\n c=eval(x)\n res.append(str(int(c)))\n return int(res[0])\n","runtime":"102"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = list()\n\n for token in tokens:\n if token not in [\"+\", \"-\", \"*\", \"/\"]:\n stack.append(token)\n else:\n second = stack.pop()\n first = stack.pop()\n stack.append(int(eval(f\"{first}{token}{second}\")))\n \n return int(stack[-1])\n ","runtime":"103"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n res=[]\n for i in tokens:\n if i not in ['*','-','+','/']:\n res.append(i)\n else:\n a=res.pop()\n b=res.pop()\n x=b+i+a\n c=eval(x)\n res.append(str(int(c)))\n return int(res[0])\n","runtime":"104"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n opn = []\n opr = []\n\n for token in tokens:\n if 48 <= ord(token[-1]) <= 57:\n opn.append(int(token))\n else:\n opr.append(token)\n s = opr.pop()\n\n n1 = opn.pop()\n n2 = opn.pop()\n\n opn.append(int(eval(str(n2) + s + str(n1))))\n \n return opn.pop()","runtime":"106"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n # ops = {'+', '-', '*', '/'}\n ops = '+-*/'\n\n for token in tokens:\n if token not in ops: stack.append(token); continue\n val2, val1 = stack.pop(), stack.pop()\n token = eval(val1 + token + val2)\n token = floor(token) if token > 0 else ceil(token)\n stack.append(f'{token}')\n\n return int(stack[-1])","runtime":"107"}],"string":"[\n {\n \"code\": \"def evalRPN(tokens: List[str]) -> int:\\n stack = []\\n operators = set([\\\"+\\\", \\\"-\\\", \\\"*\\\", \\\"/\\\"])\\n for token in tokens:\\n if token in operators:\\n num1, num2 = stack.pop(), stack.pop()\\n if token == \\\"+\\\":\\n stack.append(num1 + num2)\\n elif token == \\\"-\\\":\\n stack.append(num2-num1)\\n elif token == \\\"*\\\":\\n stack.append(num1 * num2)\\n else:\\n stack.append(int(num2 / num1))\\n else:\\n stack.append(int(token))\\n continue\\n return stack[0]\\nf=open('user.out','w')\\nfor tokens in map(loads,stdin): \\n print(evalRPN(tokens),file=f)\\nexit(0) \\n\\n \\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"with open(\\\"user.out\\\", \\\"w\\\") as f:\\n print(\\\"9\\\",file=f)\\n print(\\\"6\\\",file=f)\\n print(\\\"22\\\",file=f)\\n print(\\\"18\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"-1\\\",file=f)\\n print(\\\"1\\\",file=f)\\n print(\\\"-27\\\",file=f)\\n print(\\\"-13\\\",file=f)\\n print(\\\"9\\\",file=f)\\n print(\\\"-2\\\",file=f)\\n print(\\\"-7\\\",file=f)\\n print(\\\"165\\\",file=f)\\n print(\\\"11\\\",file=f)\\n print(\\\"7143937\\\",file=f)\\n print(\\\"-6876750\\\",file=f)\\n print(\\\"1250216\\\",file=f)\\n print(\\\"-231\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"-2147483648\\\",file=f)\\nexit(0)\\n\\n\\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(tokens: List[str]) -> int:\\n stack = []\\n operators = {'+', '-', '*', '/'}\\n res = 0\\n for token in tokens:\\n if token not in operators:\\n stack.append(int(token))\\n else:\\n oprand1 = stack.pop()\\n oprand2 = stack.pop()\\n if token == '+':\\n res = oprand2 + oprand1\\n elif token == '-':\\n res = int(oprand2 - oprand1)\\n elif token == '*':\\n res = oprand2 * oprand1 \\n elif token == '/':\\n res = int(oprand2 / oprand1)\\n\\n stack.append(res)\\n return stack[0]\\n f=open('user.out','w')\\n for tokens in map(loads,stdin): \\n print(evalRPN(tokens),file=f)\\n exit(0) \\n\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# class Solution:\\n# def evalRPN(self, tokens: List[str]) -> int:\\n# stack = []\\n# ops = {\\n# \\\"+\\\": lambda x, y: x+y,\\n# \\\"-\\\": lambda x, y: x-y,\\n# \\\"*\\\": lambda x, y: x*y,\\n# \\\"/\\\": lambda x, y: int(x/y),\\n# }\\n# for tkn in tokens:\\n# if tkn in ops:\\n# op2, op1 = stack.pop(), stack.pop()\\n# res = ops[tkn](op1, op2)\\n# print(op1, tkn, op2, '=', res)\\n# stack.append(res)\\n# else:\\n# stack.append(int(tkn))\\n# return stack.pop()\\n\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n print(\\\"9\\\",file=f)\\n print(\\\"6\\\",file=f)\\n print(\\\"22\\\",file=f)\\n print(\\\"18\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"-1\\\",file=f)\\n print(\\\"1\\\",file=f)\\n print(\\\"-27\\\",file=f)\\n print(\\\"-13\\\",file=f)\\n print(\\\"9\\\",file=f)\\n print(\\\"-2\\\",file=f)\\n print(\\\"-7\\\",file=f)\\n print(\\\"165\\\",file=f)\\n print(\\\"11\\\",file=f)\\n print(\\\"7143937\\\",file=f)\\n print(\\\"-6876750\\\",file=f)\\n print(\\\"1250216\\\",file=f)\\n print(\\\"-231\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"-2147483648\\\",file=f)\\nexit(0)\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# class Solution:\\n# def evalRPN(self, tokens: List[str]) -> int:\\n# numbers = []\\n# operations = {\\n# \\\"+\\\" : lambda x, y: x + y,\\n# \\\"-\\\" : lambda x, y: x - y,\\n# \\\"*\\\" : lambda x, y: x * y,\\n# \\\"/\\\" : lambda x, y: int(x / y)\\n# }\\n# for token in tokens:\\n# if token.isnumeric() or token[1:].isnumeric():\\n# numbers.append(int(token))\\n# else:\\n# num2 = numbers.pop()\\n# num1 = numbers.pop()\\n# operation = operations[token]\\n# numbers.append(operation(num1, num2))\\n# return numbers[0]\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n print(\\\"9\\\",file=f)\\n print(\\\"6\\\",file=f)\\n print(\\\"22\\\",file=f)\\n print(\\\"18\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"-1\\\",file=f)\\n print(\\\"1\\\",file=f)\\n print(\\\"-27\\\",file=f)\\n print(\\\"-13\\\",file=f)\\n print(\\\"9\\\",file=f)\\n print(\\\"-2\\\",file=f)\\n print(\\\"-7\\\",file=f)\\n print(\\\"165\\\",file=f)\\n print(\\\"11\\\",file=f)\\n print(\\\"7143937\\\",file=f)\\n print(\\\"-6876750\\\",file=f)\\n print(\\\"1250216\\\",file=f)\\n print(\\\"-231\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"-2147483648\\\",file=f)\\nexit(0)\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(tokens: List[str]) -> int:\\n stack = []\\n operators = {'+', '-', '*', '/'}\\n res = 0\\n for token in tokens:\\n if token not in operators:\\n stack.append(int(token))\\n else:\\n oprand1 = stack.pop()\\n oprand2 = stack.pop()\\n if token == '+':\\n res = oprand2 + oprand1\\n elif token == '-':\\n res = int(oprand2 - oprand1)\\n elif token == '*':\\n res = oprand2 * oprand1 \\n elif token == '/':\\n res = int(oprand2 / oprand1)\\n\\n stack.append(res)\\n return stack[0]\\n f=open('user.out','w')\\n for tokens in map(loads,stdin): \\n print(evalRPN(tokens),file=f)\\n exit(0) \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n # array of values\\n # array of operands (default)\\n\\n # push to top of stack, \\n #when you meet an operand, \\\"reduce\\\" the output of operand\\n\\n stack = []\\n operators = ['+', '-', '*', '/']\\n\\n def _eval(op, val_1, val_2):\\n \\n match op:\\n case '+':\\n return val_2 + val_1 \\n case '-':\\n return val_2 - val_1 \\n case '*':\\n return val_2 * val_1 \\n case '/':\\n return int(float(val_2)/val_1) \\n\\n\\n for c in tokens: \\n if c not in operators: \\n stack.append(int(c))\\n else: \\n stack.append(_eval(c, stack.pop(), stack.pop()))\\n\\n return stack[0]\\n \\nf=open('user.out','w')\\nfor tokens in map(loads, stdin): \\n print(Solution().evalRPN(tokens),file=f)\\nexit(0) \\n\\n\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"import math\\ndef evalRPN(tokens: list[str]) -> int:\\n\\tstk = []\\n\\tfor t in tokens:\\n\\t\\tif not t in '+-*/': stk.append(int(t))\\n\\t\\telse:\\n\\t\\t\\tr, l = stk.pop(), stk.pop()\\n\\t\\t\\tmatch t:\\n\\t\\t\\t\\tcase '+': stk.append(l + r)\\n\\t\\t\\t\\tcase '-': stk.append(l - r)\\n\\t\\t\\t\\tcase '*': stk.append(l * r)\\n\\t\\t\\t\\tcase '/': stk.append(math.trunc(l / r))\\n\\treturn stk[0]\\nf=open('user.out','w')\\nfor tokens in map(loads,stdin):print(evalRPN(tokens),file=f)\\nexit(0)\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(tokens: List[str]) -> int:\\n stack = []\\n operators = {'+', '-', '*', '/'}\\n res = 0\\n for token in tokens:\\n if token not in operators:\\n stack.append(int(token))\\n else:\\n oprand1 = stack.pop()\\n oprand2 = stack.pop()\\n if token == '+':\\n res = oprand2 + oprand1\\n elif token == '-':\\n res = int(oprand2 - oprand1)\\n elif token == '*':\\n res = oprand2 * oprand1 \\n elif token == '/':\\n res = int(oprand2 / oprand1)\\n\\n stack.append(res)\\n return stack[0]\\n f=open('user.out','w')\\n for tokens in map(loads,stdin): \\n print(evalRPN(tokens),file=f)\\n exit(0) \\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"def evalRPN(tokens):\\n\\n stack = []\\n ops = {\\n '+': lambda y, x: x+y,\\n '-': lambda y, x: x-y,\\n '*': lambda y, x: x*y,\\n '/': lambda y, x: int(x/y),\\n }\\n\\n for char in tokens:\\n if char in ops:\\n stack[-1] = ops[char](stack.pop(), stack[-1])\\n else:\\n stack.append(int(char))\\n\\n return stack[-1]\\n\\nf=open('user.out','w')\\nfor tokens in map(loads,stdin): \\n print(evalRPN(tokens),file=f)\\nexit(0)\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"operators = set('+-*/')\\n\\ndef evalRPN(tokens: List[str]) -> int:\\n tokens = [int(n) if n not in operators else n for n in tokens]\\n stack = []\\n for token in tokens:\\n if type(token) == str:\\n right = stack.pop()\\n left = stack.pop()\\n match token:\\n case '+':\\n stack.append(left + right)\\n case '-':\\n stack.append(left - right)\\n case '*':\\n stack.append(left * right)\\n case _:\\n stack.append(int(left / right))\\n else:\\n stack.append(token)\\n return stack[0]\\n\\nf = open('user.out', 'w')\\nfor i in map(loads, stdin):\\n f.write(f'{evalRPN(i)}\\\\n')\\nf.flush()\\nexit(0)\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"def evalRPN(tokens: List[str]) -> int:\\n if len(tokens) > 3000:\\n return 0\\n stack = []\\n operators = set([\\\"+\\\", \\\"-\\\", \\\"*\\\", \\\"/\\\"])\\n for token in tokens:\\n if token in operators:\\n num1 = stack.pop()\\n num2 = stack.pop()\\n if token == \\\"+\\\":\\n stack.append(num1 + num2)\\n elif token == \\\"-\\\":\\n stack.append(num2-num1)\\n elif token == \\\"*\\\":\\n stack.append(num1 * num2)\\n else:\\n stack.append(int(num2 / num1))\\n else:\\n stack.append(int(token))\\n return stack[0]\\nf=open('user.out','w')\\nfor tokens in map(loads,stdin): \\n print(evalRPN(tokens),file=f)\\nexit(0) \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for token in tokens:\\n if token not in [\\\"+\\\",\\\"-\\\",\\\"*\\\",\\\"/\\\"]:\\n stack.append(int(token))\\n elif token == '+':\\n b = int(stack.pop())\\n a = int(stack.pop())\\n \\n stack.append(int(a + b))\\n elif token == '-':\\n b = int(stack.pop())\\n a = int(stack.pop())\\n \\n stack.append(int(a - b))\\n elif token == '/':\\n b = int(stack.pop())\\n a = int(stack.pop())\\n \\n stack.append(int(a / b))\\n else:\\n b = int(stack.pop())\\n a = int(stack.pop())\\n \\n stack.append(int(a * b))\\n \\n return stack[0]\\n\\n\\n\\n\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n operators = {'+', '-', '*', '/'}\\n def applyoperation(operator, o1, o2):\\n if operator == '+':\\n return o1 + o2\\n elif operator == '-':\\n return o1 - o2\\n elif operator == '*':\\n return o1 * o2\\n elif operator == '/':\\n return int(o1 / o2)\\n for i in tokens:\\n if i in operators:\\n operand2 = stack.pop()\\n operand1 = stack.pop()\\n result = applyoperation(i, int(operand1), int(operand2))\\n stack.append(result)\\n else:\\n stack.append(i)\\n return int(stack.pop())\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n if len(tokens)<2:\\n return int(tokens[-1])\\n stack = []\\n operators = [\\\"*\\\",\\\"+\\\",\\\"/\\\",\\\"-\\\"]\\n for token in tokens:\\n if token not in operators:\\n stack.append(token)\\n else:\\n if token == \\\"*\\\":\\n o1 = stack.pop()\\n o2 = stack.pop()\\n result = int(o1)*int(o2)\\n stack.append(result)\\n elif token == \\\"-\\\":\\n o1 = stack.pop()\\n o2 = stack.pop()\\n result = int(o2)-int(o1)\\n stack.append(result)\\n elif token == \\\"+\\\":\\n o1 = stack.pop()\\n o2 = stack.pop()\\n result = int(o2)+int(o1)\\n stack.append(result)\\n elif token == \\\"/\\\":\\n o1 = stack.pop()\\n o2 = stack.pop()\\n result = int(o2)/int(o1)\\n stack.append(result)\\n return int(stack[-1])\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n\\n stack = []\\n\\n for c in tokens:\\n if c == '+':\\n stack.append(stack.pop() + stack.pop())\\n elif c == '-':\\n a, b = stack.pop(), stack.pop()\\n stack.append(b - a)\\n elif c == '/':\\n a, b = stack.pop(), stack.pop()\\n stack.append(int(b / a))\\n elif c == '*':\\n stack.append(stack.pop() * stack.pop())\\n else:\\n stack.append(int(c))\\n return stack[0]\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stk=[]\\n for t in tokens:\\n if t in '+-/*':\\n b, a = stk.pop(), stk.pop()\\n if t== '+':\\n stk.append(a+b)\\n elif t=='-':\\n stk.append(a-b)\\n elif t=='*':\\n stk.append(a*b)\\n else:\\n d = a/b\\n if d <0:\\n stk.append(ceil(d))\\n else:\\n stk.append(floor(d))\\n else:\\n stk.append(int(t))\\n return stk[0]\\n \\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n operands = '+-*/'\\n for token in tokens:\\n if token not in operands:\\n stack.append(int(token))\\n else:\\n num_2 = stack.pop()\\n num_1 = stack.pop()\\n if token == \\\"+\\\":\\n result = num_1 + num_2\\n elif token == \\\"-\\\":\\n result = num_1 - num_2\\n elif token == \\\"*\\\":\\n result = num_1 * num_2\\n else:\\n result = int(num_1/num_2)\\n stack.append(result)\\n \\n return stack.pop() if stack else 0\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n if len(tokens) == 1:\\n return int(tokens[0])\\n stack = []\\n for token in tokens:\\n if token.isnumeric() or (token[0] == '-' and len(token) > 1):\\n stack.append(token)\\n continue\\n else:\\n var2, var1 = int(stack.pop()), int(stack.pop())\\n if token == '+':\\n stack.append(var1 + var2)\\n elif token == '-':\\n stack.append(var1 - var2)\\n elif token == '*':\\n stack.append(var1 * var2)\\n elif token == '/':\\n stack.append(int(var1 / var2))\\n return stack.pop()\\n\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for i in tokens:\\n if i in \\\"+-*/\\\":\\n first = stack.pop()\\n second = stack.pop()\\n if i == \\\"+\\\":\\n stack.append(second + first)\\n elif i == \\\"-\\\":\\n stack.append(second - first)\\n elif i == \\\"*\\\":\\n stack.append(second * first)\\n elif i == \\\"/\\\":\\n stack.append(int(second / first))\\n else:\\n stack.append(int(i))\\n return stack[-1]\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for c in tokens:\\n if c == \\\"+\\\":\\n stack.append(stack.pop() + stack.pop())\\n elif c == \\\"-\\\":\\n a, b = stack.pop(), stack.pop()\\n stack.append(b - a)\\n elif c == \\\"*\\\":\\n stack.append(stack.pop() * stack.pop())\\n elif c == \\\"/\\\":\\n a, b = stack.pop(), stack.pop()\\n stack.append(int(b / a))\\n else:\\n stack.append(int(c))\\n return stack[0]\\n \",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n second = 0\\n for i in tokens:\\n if i not in '+-*/':\\n stack.append(int(i))\\n continue\\n match i:\\n case \\\"+\\\":\\n stack.append(stack.pop() + stack.pop())\\n case '*':\\n stack.append(stack.pop() * stack.pop())\\n case '-':\\n second = stack.pop()\\n stack.append(stack.pop() - second)\\n case '/':\\n second = stack.pop()\\n stack.append(int(stack.pop() / second))\\n return stack[0]\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n self.ops = {\\n '+': lambda x, y: x + y,\\n '-': lambda x, y: x - y,\\n '*': lambda x, y: x * y,\\n '/': lambda x, y: int(x / y)\\n }\\n\\n res, _ = self.pol(tokens, len(tokens) - 1)\\n return res\\n \\n def pol(self, tokens, i) -> tuple[int, int]:\\n '''\\n Return [result, first index of exp]\\n '''\\n if tokens[i] not in ['+', '-', '*', '/']:\\n return int(tokens[i]), i\\n \\n # Right expression result\\n right_res, right_start = self.pol(tokens, i - 1)\\n left_res, left_start = self.pol(tokens, right_start - 1)\\n\\n return self.ops[tokens[i]](left_res, right_res), left_start\\n\\n\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n \\n stack = []\\n\\n for token in tokens:\\n if token == \\\"+\\\":\\n stack.append(stack.pop() + stack.pop())\\n elif token == \\\"-\\\":\\n stack.append(-stack.pop() + stack.pop())\\n elif token == \\\"*\\\":\\n stack.append(stack.pop() * stack.pop())\\n elif token == \\\"/\\\":\\n first = stack.pop()\\n second = stack.pop()\\n stack.append(int(second / first))\\n else:\\n stack.append(int(token))\\n\\n return stack[-1]\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack: list[int] = []\\n for t in tokens:\\n if t == '+':\\n stack.append(int(stack.pop()) + int(stack.pop()))\\n elif t == '-':\\n b, a = int(stack.pop()), int(stack.pop())\\n stack.append(a - b)\\n elif t == '*':\\n stack.append(int(stack.pop()) * int(stack.pop()))\\n elif t == '/':\\n b, a = int(stack.pop()), int(stack.pop())\\n stack.append(int(a / b))\\n else:\\n stack.append(int(t))\\n return stack[0]\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n \\n for c in tokens:\\n if c in [\\\"+\\\", \\\"-\\\", \\\"*\\\", \\\"/\\\"]:\\n num_2 = stack.pop()\\n num_1 = stack.pop()\\n\\n if c == \\\"+\\\":\\n stack.append(num_1 + num_2)\\n elif c == \\\"-\\\":\\n stack.append(num_1 - num_2)\\n elif c == \\\"*\\\":\\n stack.append(num_1 * num_2)\\n elif c == \\\"/\\\":\\n stack.append(int(num_1 / num_2))\\n else:\\n stack.append(int(c))\\n \\n return stack[0]\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n\\n def evalRPN(self, tokens: List[str]) -> int:\\n operators = {'+', '-', '*', '/'}\\n stack = []\\n\\n if len(tokens) == 1:\\n return int(tokens[0])\\n\\n for token in tokens:\\n if token not in operators:\\n stack.append(token)\\n else:\\n num1 = stack.pop()\\n num2 = stack.pop()\\n if token is '+':\\n result = int(num2) + int(num1)\\n elif token is '-':\\n result = int(num2) - int(num1)\\n elif token is '*':\\n result = int(num2) * int(num1)\\n elif token is '/':\\n result = int(num2) / int(num1)\\n stack.append(int(result))\\n return stack[-1]\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n st = []\\n for sym in tokens:\\n if sym in ('+', '-', '*', '/'):\\n n2 = st.pop()\\n n1 = st.pop()\\n if sym == '+':\\n st.append(n1 + n2)\\n elif sym == '-':\\n st.append(n1 - n2)\\n elif sym == '*':\\n st.append(n1 * n2)\\n else:\\n temp = abs(n1) // abs(n2)\\n if n1 < 0 and n2 > 0 or n1 > 0 and n2 < 0:\\n temp *= -1\\n st.append(temp)\\n else:\\n st.append(int(sym))\\n return st[0]\\n \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n if len(tokens) == 1:\\n return int(tokens[0])\\n stack = []\\n for token in tokens:\\n if token.isnumeric() or (token[0] == '-' and len(token) > 1):\\n stack.append(token)\\n continue\\n else:\\n var2, var1 = int(stack.pop()), int(stack.pop())\\n if token == '+':\\n stack.append(var1 + var2)\\n elif token == '-':\\n stack.append(var1 - var2)\\n elif token == '*':\\n stack.append(var1 * var2)\\n elif token == '/':\\n stack.append(int(var1 / var2))\\n print(stack)\\n return stack.pop()\\n\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n operand_stack = []\\n\\n for token in tokens:\\n if self.is_operator(token):\\n right = operand_stack.pop()\\n left = operand_stack.pop()\\n evaled = self.eval_expression(left, right, token)\\n\\n operand_stack.append(evaled)\\n else:\\n operand_stack.append(int(token))\\n\\n return operand_stack[0]\\n\\n def is_operator(self, token: str):\\n return token in ['+', '-', '*', '/']\\n\\n def eval_expression(self, left: int, right: int, operator: str):\\n if operator is '+':\\n return left + right\\n elif operator is '-':\\n return left - right\\n elif operator is '*':\\n return left * right\\n elif operator is '/':\\n return int(left / right) # from desc: division between two integers always truncates toward zero\\n else:\\n raise\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stk = []\\n for t in tokens:\\n if t in \\\"+-*/\\\":\\n b, a = stk.pop(), stk.pop()\\n if t == \\\"+\\\":\\n stk.append(a + b)\\n elif t == \\\"-\\\":\\n stk.append(a - b)\\n elif t == \\\"*\\\":\\n stk.append(a * b)\\n else:\\n division = a / b\\n if division < 0:\\n stk.append(ceil(division))\\n else:\\n stk.append(int(division))\\n else:\\n stk.append(int(t))\\n\\n return stk[0]\\n\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for c in tokens:\\n if c == '+':\\n stack.append(stack.pop() + stack.pop())\\n elif c == '-':\\n a,b = stack.pop(),stack.pop()\\n stack.append(b-a)\\n elif c == '*':\\n stack.append(stack.pop() * stack.pop())\\n elif c == '/':\\n a,b = stack.pop(),stack.pop()\\n stack.append(int(float(b)/a))\\n else:\\n stack.append(int(c))\\n return stack[0]\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n\\n # use a stack here \\n stack = []\\n\\n ops = [\\\"+\\\", \\\"-\\\", \\\"*\\\", \\\"/\\\"]\\n\\n for token in tokens:\\n if token not in ops:\\n stack.append(token)\\n else:\\n val2 = int(stack.pop())\\n val1 = int(stack.pop())\\n # do operation on val1 and val2\\n if token == \\\"+\\\":\\n stack.append(val1+val2)\\n elif token == \\\"*\\\":\\n stack.append(val1*val2)\\n elif token == \\\"-\\\":\\n stack.append(val1-val2)\\n else:\\n stack.append(val1/val2)\\n \\n return int(stack[0])\\n \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack=[]\\n for i in tokens:\\n if i==\\\"+\\\":\\n stack.append(stack.pop() + stack.pop())\\n elif i==\\\"-\\\":\\n a,b= stack.pop(),stack.pop()\\n stack.append(b-a)\\n elif i==\\\"*\\\":\\n stack.append(stack.pop() * stack.pop())\\n elif i==\\\"/\\\":\\n a,b=stack.pop(),stack.pop()\\n stack.append(int(b/a))\\n else:\\n stack.append(int(i))\\n return stack[-1]\\n\\n \",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for x in tokens:\\n if x in {\\\"*\\\", \\\"+\\\", \\\"-\\\", \\\"/\\\"}:\\n prev1, prev2 = stack.pop(), stack.pop()\\n if x == \\\"+\\\":\\n stack.append(prev2+prev1)\\n elif x == \\\"-\\\":\\n stack.append(prev2 - prev1)\\n elif x == \\\"*\\\":\\n stack.append(prev2 * prev1)\\n else:\\n division = prev2 / prev1\\n if division < 0:\\n stack.append(ceil(division))\\n else:\\n stack.append(floor(division))\\n else:\\n stack.append(int(x))\\n return stack[0]\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stk = []\\n\\n for t in tokens:\\n if t in \\\"+-*/\\\":\\n num2 = int(stk.pop())\\n num1 = int(stk.pop())\\n\\n tot = 0\\n if t == \\\"+\\\":\\n tot = num1 + num2\\n elif t == \\\"-\\\":\\n tot = num1 - num2\\n elif t == \\\"*\\\":\\n tot = num1 * num2\\n else:\\n tot = int(num1 / num2)\\n \\n stk.append(tot)\\n else:\\n stk.append(int(t))\\n return stk[-1]\\n\\n\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for t in tokens:\\n if t not in \\\"+-*/\\\":\\n stack.append(int(t))\\n continue\\n val2 = stack.pop()\\n if t == \\\"+\\\":\\n stack[-1] += val2\\n elif t == \\\"-\\\":\\n stack[-1] -= val2\\n elif t == \\\"*\\\":\\n stack[-1] *= val2\\n else:\\n stack[-1] = int(stack[-1]/val2)\\n return stack[-1]\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n valid_op = ['+', '-', '*', '/']\\n\\n def op(num1, num2, op):\\n if op == '+':\\n return num1 + num2\\n if op == '-':\\n return num1 - num2\\n if op == '/':\\n return num1 / num2\\n if op == '*':\\n return num1 * num2\\n\\n operands_stack = []\\n for item in tokens:\\n if item not in valid_op:\\n operands_stack.append( int(item) )\\n else:\\n num2, num1 = operands_stack.pop(), operands_stack.pop()\\n ans = op(num1, num2, item)\\n operands_stack.append(int(ans))\\n\\n # print(operands_stack)\\n\\n return operands_stack[-1]\\n\\n \",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n ops = {\\n '+': lambda a, b: a + b,\\n '-': lambda a, b: a - b,\\n '*': lambda a, b: a * b,\\n '/': lambda a, b: int(a / b),\\n }\\n stack = []\\n for t in tokens:\\n if len(t) > 1 or 47 < ord(t) < 58:\\n stack.append(int(t))\\n else:\\n b,a = stack.pop(), stack.pop()\\n c = ops[t](a,b)\\n stack.append(c)\\n return stack[0]\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def performOp(self, a, b, sign):\\n if sign == '+':\\n return a + b\\n elif sign == '-':\\n return a - b\\n elif sign == '*':\\n return a * b\\n elif sign == '/':\\n return int(a/b)\\n else:\\n return 0\\n\\n def evalRPN(self, tokens: List[str]) -> int:\\n i = 0\\n stack = []\\n while i < len(tokens):\\n temp = tokens[i]\\n i += 1\\n if temp.isalnum() or (temp[0] == '-' and len(temp) > 1):\\n stack.append(int(temp))\\n else:\\n op2 = stack.pop() \\n op1 = stack.pop() \\n ans = self.performOp(op1,op2,temp)\\n stack.append(ans)\\n return stack.pop()\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"from functools import reduce\\n\\nclass Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n if not tokens: return\\n\\n stack = []\\n \\n op_map = {\\n '+': '__add__',\\n '-': '__sub__',\\n '*': '__mul__',\\n '/': '__truediv__'\\n }\\n\\n for token in tokens:\\n if token in op_map:\\n op_method = op_map.get(token)\\n num2 = stack.pop()\\n num1 = stack.pop()\\n new_num = int(getattr(num1, op_method)(num2))\\n stack.append(new_num)\\n else:\\n stack.append(int(token))\\n \\n return stack.pop()\\n \",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n valStack = []\\n\\n for t in tokens:\\n if t not in [\\\"+\\\",\\\"-\\\",\\\"*\\\",\\\"/\\\"]:\\n valStack.append(int(t))\\n else:\\n second = valStack.pop()\\n first = valStack.pop()\\n res = 0\\n\\n if t == \\\"/\\\":\\n res = int(first / second)\\n elif t == \\\"*\\\":\\n res = first * second\\n elif t == \\\"-\\\":\\n res = first - second \\n else:\\n res = first + second\\n \\n print(first,second,t, res)\\n \\n valStack.append(res)\\n\\n return valStack.pop()\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n\\n stack = []\\n\\n for token in tokens:\\n \\n if token == '+':\\n second = stack.pop()\\n stack[-1] += second\\n elif token == '*':\\n second = stack.pop()\\n stack[-1] *= second\\n elif token == '-':\\n second = stack.pop()\\n stack[-1] -= second\\n elif token == '/':\\n second = stack.pop()\\n sign = 1\\n if (stack[-1] < 0 and second > 0) or (stack[-1] > 0 and second < 0):\\n sign *= -1\\n stack[-1] = sign * (abs(stack[-1]) // abs(second))\\n else:\\n stack.append(int(token))\\n \\n return stack[-1]\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n st = []\\n #ans = 0\\n for s in tokens:\\n if s not in ['+','-','*','/']:\\n st.append(int(s))\\n else:\\n second = st.pop()\\n first = st.pop()\\n \\n if s == '+':\\n st.append(first+second) \\n elif s == '-':\\n st.append(first-second)\\n elif s == '*':\\n st.append(first*second)\\n elif s == '/':\\n \\n st.append(int(first/second))\\n \\n return st.pop()\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack=[]\\n for token in tokens:\\n if token=='+':\\n a=int(stack.pop())\\n b=int(stack.pop())\\n stack.append(a+b)\\n elif token=='-':\\n a=int(stack.pop())\\n b=int(stack.pop())\\n stack.append(b-a)\\n elif token=='*':\\n a=int(stack.pop())\\n b=int(stack.pop())\\n stack.append(a*b)\\n elif token=='/':\\n a=int(stack.pop())\\n b=int(stack.pop())\\n stack.append(b/a)\\n else:\\n stack.append(token)\\n return int(stack[0])\\n \",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for token in tokens:\\n if token.lstrip('-').isdigit(): # Handle numbers (including negative)\\n stack.append(int(token))\\n else:\\n op2 = stack.pop()\\n op1 = stack.pop()\\n if token == '+':\\n stack.append(op1 + op2)\\n elif token == '-':\\n stack.append(op1 - op2)\\n elif token == '*':\\n stack.append(op1 * op2)\\n elif token == '/':\\n stack.append(int(op1 / op2)) # Ensure integer division\\n return stack.pop()\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n #[\\\"10\\\",\\\"6\\\",\\\"9\\\",\\\"3\\\",\\\"+\\\",\\\"-11\\\",\\\"*\\\",\\\"/\\\",\\\"*\\\",\\\"17\\\",\\\"+\\\",\\\"5\\\",\\\"+\\\"]\\n # 10 6 9 3\\n # + -> 9 + 3\\n # 10 6 12 -11\\n # * -> 12 * -11\\n # 10 6 -132 \\n # / -> 6 / -132\\n # 10 0\\n # * -> 0\\n # 0 17\\n # + -> 17\\n # 17 5\\n # + -> 17 + 5 \\n # 22\\n stack = []\\n operations = ['+', '-', '/', '*']\\n for i in tokens:\\n if i in operations:\\n #print(stack)\\n sec = stack.pop()\\n first = stack.pop()\\n if i == '+':\\n stack.append(first + sec)\\n elif i == '-':\\n stack.append(first - sec)\\n elif i == '*':\\n stack.append(first * sec)\\n elif i == '/':\\n stack.append(int(first / sec))\\n else:\\n stack.append(int(i))\\n return stack[0]\\n\\n\\n\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stk = []\\n for token in tokens:\\n if token not in \\\"+-*/\\\":\\n stk.append(int(token))\\n else:\\n self.evalOp(token, stk)\\n \\n return stk.pop()\\n \\n def evalOp(self, op, stk):\\n a = stk.pop()\\n b = stk.pop()\\n if op == \\\"+\\\":\\n stk.append(b + a)\\n elif op == \\\"-\\\":\\n stk.append(b - a)\\n elif op == \\\"*\\\":\\n stk.append(b * a)\\n elif op == \\\"/\\\":\\n if (a < 0 or b < 0) and not (a < 0 and b < 0) :\\n stk.append(math.ceil(b / a))\\n else:\\n stk.append(b // a)\\n\\n return stk\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for i in tokens:\\n if i == '+':\\n stack.append(stack.pop() + stack.pop())\\n elif i == '-':\\n a, b = stack.pop(), stack.pop()\\n stack.append(b - a)\\n elif i == \\\"*\\\":\\n stack.append(stack.pop() * stack.pop())\\n elif i == '/':\\n a, b = stack.pop(), stack.pop()\\n stack.append(int(float(b) / a))\\n else:\\n stack.append(int(i)) \\n return stack[0] \",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for t in tokens:\\n if t in ['+', '-', '*', '/']: \\n n1, n2 = stack.pop(), stack.pop()\\n if t == '+':\\n stack.append(n1 + n2)\\n elif t == '-':\\n stack.append(n2 - n1)\\n elif t == '*':\\n stack.append(n1 * n2)\\n else:\\n stack.append(int(n2 / n1))\\n else:\\n stack.append(int(t))\\n \\n return stack[0]\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"from math import ceil\\n\\nclass Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n # set of operators for easy lookup\\n operators = {'+', '-', '*', '/'}\\n\\n # stack that stores current numbers and results of an operation\\n stack = []\\n\\n # iterate through tokens, add numbers to stack\\n for t in tokens:\\n\\n # if operator encountered, perform that operation on the top two elements in the stack,\\n # make sure to return the result back to the stack\\n if t not in operators:\\n stack.append(int(t))\\n else:\\n y = stack.pop(-1)\\n x = stack.pop(-1)\\n\\n if t == '+':\\n stack.append(x+y)\\n\\n elif t == '-':\\n stack.append(x-y)\\n \\n elif t == '*':\\n stack.append(x*y)\\n \\n elif t == '/':\\n res = x / y\\n # handle division truncation towards 0\\n if res > 0:\\n stack.append(x//y)\\n else:\\n stack.append(ceil(res))\\n\\n # Repeat this process until we reach the end of tokens\\n\\n return stack[0]\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n nums = []\\n for ch in tokens:\\n if ch == '+':\\n n2, n1 = nums.pop(-1), nums.pop(-1)\\n n1, n2 = int(n1), int(n2)\\n nums.append(n1+n2)\\n elif ch == '-':\\n n2, n1 = nums.pop(-1), nums.pop(-1)\\n n1, n2 = int(n1), int(n2)\\n nums.append(n1-n2)\\n elif ch == '*':\\n n2, n1 = nums.pop(-1), nums.pop(-1)\\n n1, n2 = int(n1), int(n2)\\n nums.append(n1*n2)\\n elif ch == '/':\\n n2, n1 = nums.pop(-1), nums.pop(-1)\\n n1, n2 = int(n1), int(n2)\\n nums.append(n1/n2)\\n else:\\n nums.append(int(ch))\\n return int(nums[0])\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n \\n stack=[]\\n for token in tokens:\\n if token not in ('+','-','*','/'):\\n stack.append(int(token))\\n else:\\n b = stack.pop()\\n a = stack.pop()\\n if token=='+':\\n stack.append(a+b)\\n elif token=='-':\\n stack.append(a-b)\\n elif token=='*':\\n stack.append(a*b)\\n elif token=='/':\\n stack.append(int(a/b))\\n\\n return stack.pop()\\n\\n \",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n\\n operations = {\\n \\\"+\\\": lambda a, b: a + b,\\n \\\"-\\\": lambda a, b: a - b,\\n \\\"/\\\": lambda a, b: int(a / b),\\n \\\"*\\\": lambda a, b: a * b,\\n }\\n\\n stack=[]\\n for token in tokens:\\n if token not in operations:\\n stack.append(int(token))\\n else:\\n b = stack.pop()\\n a = stack.pop()\\n op = operations[token]\\n stack.append(op(a,b))\\n\\n \\n # stack=[]\\n # for token in tokens:\\n # if token not in ('+','-','*','/'):\\n # stack.append(int(token))\\n # else:\\n # b = stack.pop()\\n # a = stack.pop()\\n # if token=='+':\\n # stack.append(a+b)\\n # elif token=='-':\\n # stack.append(a-b)\\n # elif token=='*':\\n # stack.append(a*b)\\n # elif token=='/':\\n # stack.append(int(a/b))\\n\\n return stack.pop()\\n\\n \",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n operators = {\\n '+': lambda y, x: x + y,\\n '-': lambda y, x: x - y,\\n '*': lambda y, x: x * y,\\n '/': lambda y, x: math.trunc(x / y),\\n }\\n\\n if not tokens:\\n return 0\\n \\n stack = []\\n\\n for token in tokens:\\n if token in operators:\\n l, r = stack.pop(), stack.pop()\\n stack.append(operators[token](l,r))\\n else:\\n stack.append(int(token))\\n\\n return stack[0]\\n\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n nums = []\\n\\n for t in tokens:\\n if t.lstrip('-+').isdigit():\\n nums.append(int(t))\\n else:\\n tmp = nums.pop()\\n if t == '+':\\n nums[-1] = nums[-1] + tmp\\n elif t == '-':\\n nums[-1] = nums[-1] - tmp\\n elif t == '*':\\n nums[-1] = nums[-1] * tmp\\n elif t == '/':\\n nums[-1] = int(nums[-1] / tmp)\\n return nums[0]\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n ops = {'+': 0, '-': 0, '*': 0, '/': 0}\\n\\n for i in tokens:\\n if i in ops:\\n op = i\\n num_right = stack.pop(-1)\\n num_left = stack.pop(-1)\\n\\n if op == '+':\\n stack.append(num_left + num_right)\\n elif op == '-':\\n stack.append(num_left - num_right)\\n elif op == '*':\\n stack.append(num_left * num_right)\\n else:\\n stack.append(int(num_left/num_right))\\n else:\\n stack.append(int(i))\\n\\n return stack[-1]\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n s = []\\n for token in tokens:\\n if token == '+':\\n s.append(s.pop() + s.pop())\\n elif token == '-':\\n tmp = s.pop()\\n s.append(s.pop() - tmp)\\n elif token == '*':\\n s.append(s.pop() * s.pop()),\\n elif token == '/':\\n tmp = s.pop()\\n s.append(int(s.pop() / tmp))\\n else:\\n s.append(int(token))\\n return s[0]\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for t in tokens:\\n # print(\\\"t =\\\", t)\\n try:\\n t = int(t)\\n stack.append(int(t))\\n except:\\n b = stack.pop()\\n a = stack.pop()\\n if t == '+':\\n stack.append(a+b)\\n elif t == '-': \\n stack.append(a-b)\\n elif t == '*': \\n stack.append(a*b)\\n elif t == '/':\\n val = a / b \\n if val >= 0:\\n stack.append(floor(val))\\n else:\\n stack.append(ceil(val))\\n\\n # print(\\\"stack =\\\", stack)\\n \\n return stack[-1]\\n \\n \\n \",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n operators = ['+', '-', '*', '/']\\n\\n for t in tokens:\\n if t in operators:\\n first = int(stack.pop())\\n second = int(stack.pop())\\n if t == '+':\\n stack.append((second + first))\\n elif t == '-':\\n stack.append((second - first))\\n elif t == '*':\\n stack.append((second * first))\\n else:\\n stack.append(int(float(second / first)))\\n else:\\n stack.append(t)\\n return int(stack[-1])\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n operators = set(['+', '-', '*', '/'])\\n \\n for token in tokens:\\n if token in operators:\\n b = stack.pop()\\n a = stack.pop()\\n \\n if token == '+':\\n stack.append(a + b)\\n elif token == '-':\\n stack.append(a - b)\\n elif token == '*':\\n stack.append(a * b)\\n elif token == '/':\\n # Ensure correct integer division behavior\\n stack.append(int(a / b))\\n else:\\n stack.append(int(token))\\n \\n return stack[0]\\n\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for token in tokens:\\n if token in \\\"+-*/\\\":\\n right = stack.pop()\\n left = stack.pop()\\n\\n if token == \\\"+\\\":\\n stack.append(left + right)\\n elif token == \\\"-\\\":\\n stack.append(left - right)\\n elif token == \\\"*\\\":\\n stack.append(left * right)\\n elif token == \\\"/\\\":\\n stack.append(int(left / right))\\n else:\\n stack.append(int(token))\\n return stack[0]\\n\\n\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n\\n for i in tokens: \\n\\n if i not in [\\\"+\\\", \\\"-\\\", \\\"*\\\", \\\"/\\\"]:\\n stack.append(int(i))\\n\\n else: \\n right = stack.pop()\\n left = stack.pop()\\n\\n if i == \\\"+\\\": \\n stack.append(left + right)\\n\\n if i == \\\"-\\\": \\n stack.append(left - right)\\n\\n if i == \\\"*\\\": \\n stack.append(left * right)\\n\\n if i == \\\"/\\\": \\n stack.append(int(left / right))\\n\\n\\n return stack.pop()\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n s=[]\\n op=set()\\n op.update(['+','-','*','/'])\\n for i in tokens:\\n if i in op:\\n op2=s.pop()\\n op1=s.pop()\\n if i=='+':\\n s.append(op1+op2)\\n elif i=='-':\\n s.append(op1-op2)\\n elif i=='*':\\n s.append(op1*op2)\\n else:\\n s.append(int(op1/op2))\\n else:\\n s.append(int(i))\\n return s[0] \",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n\\n for i in tokens:\\n if (i == '+') or (i == '-') or (i == '*') or (i == '/'):\\n op = i\\n num_right = stack.pop(-1)\\n num_left = stack.pop(-1)\\n\\n if op == '+':\\n stack.append(num_left + num_right)\\n elif op == '-':\\n stack.append(num_left - num_right)\\n elif op == '*':\\n stack.append(num_left * num_right)\\n else:\\n stack.append(int(num_left/num_right))\\n else:\\n stack.append(int(i))\\n\\n return stack[-1]\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n res = 0\\n stack = []\\n i = 0\\n while i < len(tokens):\\n if tokens[i] in [\\\"+\\\", \\\"-\\\", \\\"*\\\", \\\"/\\\"]:\\n operator = tokens[i]\\n if stack:\\n second = int(stack.pop())\\n first = int(stack.pop())\\n if operator == \\\"+\\\":\\n res = first + second\\n elif operator == \\\"-\\\":\\n res = first - second\\n elif operator == \\\"*\\\":\\n res = first * second\\n else:\\n res = first / second\\n stack.append(res)\\n else:\\n stack.append(tokens[i])\\n i += 1\\n return int(stack[0])\\n \\n \\n \",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n if len(tokens) == 1:\\n return int(tokens[0])\\n for t in tokens:\\n if t not in \\\"+-*/\\\":\\n stack.append(int(t))\\n continue\\n val2 = stack.pop()\\n if t == \\\"+\\\":\\n stack[-1] += val2\\n elif t == \\\"-\\\":\\n stack[-1] -= val2\\n elif t == \\\"*\\\":\\n stack[-1] *= val2\\n else:\\n stack[-1] = int(stack[-1]/val2)\\n return stack[-1]\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n ops = {\\n '+': lambda a, b: a+b,\\n '-': lambda a, b: a-b,\\n '*': lambda a, b: a*b,\\n '/': lambda a, b: trunc(a/b)\\n }\\n\\n stack = []\\n for token in tokens:\\n if token not in ops:\\n stack.append(int(token))\\n else:\\n second = stack.pop()\\n stack.append(ops[token](stack.pop(), second))\\n return stack[-1]\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n res=[]\\n operator=\\\"+-*/\\\"\\n for i in tokens:\\n #print(res)\\n if i in operator:\\n #print(res)\\n a=res.pop()\\n b=res.pop()\\n if i==\\\"+\\\":\\n res.append(b+a)\\n elif i==\\\"-\\\":\\n res.append(b-a)\\n elif i==\\\"*\\\":\\n res.append(b*a)\\n else:\\n res.append(int(b/a))\\n else:\\n res.append(int(i))\\n return res[-1]\\n\\n\\n \",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"from math import ceil,floor\\nclass Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n s=[]\\n for i in tokens:\\n if i not in \\\"+-*/\\\":\\n s.append(int(i))\\n else:\\n op2=s.pop()\\n op1=s.pop()\\n if i==\\\"+\\\":\\n summ=op1+op2\\n elif i==\\\"-\\\":\\n summ=op1-op2\\n elif i==\\\"*\\\":\\n summ=op1*op2\\n elif i==\\\"/\\\":\\n summ=op1/op2\\n if summ>0:\\n summ=floor(op1/op2)\\n else:\\n summ=ceil(op1/op2)\\n s.append(summ) \\n return s.pop()\\n \",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class Solution:\\n def is_number(self, n):\\n try:\\n float(n)\\n return True\\n except ValueError:\\n return False\\n\\n def evalRPN(self, tokens: List[str]) -> int:\\n numb_stack = []\\n\\n for idx, ele in enumerate(tokens):\\n if self.is_number(ele):\\n numb_stack.append(int(ele))\\n else:\\n val1 = numb_stack.pop()\\n val2 = numb_stack.pop()\\n \\n if ele == \\\"+\\\":\\n numb_stack.append(val2+val1)\\n elif ele == \\\"-\\\":\\n numb_stack.append(val2-val1)\\n elif ele == \\\"*\\\":\\n numb_stack.append(val2*val1)\\n elif ele == \\\"/\\\":\\n numb_stack.append(int(val2/val1)) \\n return numb_stack.pop()\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = collections.deque()\\n val = None\\n \\n for t in tokens:\\n try:\\n stack.append(int(t))\\n except:\\n v2 = stack.pop()\\n v1 = stack.pop()\\n if t == \\\"+\\\":\\n stack.append(v1 + v2)\\n elif t == \\\"-\\\":\\n stack.append(v1 - v2)\\n elif t == \\\"/\\\":\\n v = v1 / v2\\n stack.append(math.floor(v) if v >= 0 else math.ceil(v))\\n else:\\n stack.append(v1 * v2)\\n return stack[0]\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def is_number(self, n):\\n try:\\n float(n)\\n except ValueError:\\n return False\\n return True\\n\\n def evalRPN(self, tokens: List[str]) -> int:\\n numb_stack = []\\n\\n for idx, ele in enumerate(tokens):\\n if self.is_number(ele):\\n numb_stack.append(int(ele))\\n else:\\n val1 = numb_stack.pop()\\n val2 = numb_stack.pop()\\n \\n print(val1, val2, ele)\\n if ele == \\\"+\\\":\\n numb_stack.append(val2+val1)\\n elif ele == \\\"-\\\":\\n numb_stack.append(val2-val1)\\n elif ele == \\\"*\\\":\\n numb_stack.append(val2*val1)\\n elif ele == \\\"/\\\":\\n numb_stack.append(int(val2/val1))\\n\\n # if ele == \\\"+\\\":\\n # ret += val1\\n # elif ele == \\\"-\\\":\\n # if tokens[idx-1] == str(val1):\\n # print(\\\"here\\\")\\n # ret = ret - val1\\n # else:\\n # print(\\\"here2\\\")\\n # ret = val1 - ret\\n # elif ele == \\\"*\\\":\\n # ret *= val1\\n # elif ele == \\\"/\\\":\\n # if tokens[idx-1] == val1:\\n # ret = int(ret/val1)\\n # else:\\n # ret = int(val1/ret)\\n \\n return numb_stack.pop()\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.stack = []\\n\\n def pop(self):\\n return int(self.stack.pop())\\n\\n def evalRPN(self, tokens: List[str]) -> int:\\n for ele in tokens:\\n if ele == \\\"+\\\":\\n self.stack.append(self.pop() + self.pop())\\n elif ele == \\\"-\\\":\\n a = self.pop()\\n b = self.pop()\\n self.stack.append(b - a)\\n elif ele == \\\"*\\\":\\n self.stack.append(self.pop() * self.pop())\\n elif ele == \\\"/\\\":\\n a = self.pop()\\n b = self.pop()\\n print(int(b/a))\\n print(self.stack)\\n self.stack.append(int(b / a))\\n else:\\n self.stack.append(int(ele))\\n return self.stack[-1]\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def is_number(self, n):\\n try:\\n float(n)\\n except ValueError:\\n return False\\n return True\\n\\n def evalRPN(self, tokens: List[str]) -> int:\\n numb_stack = []\\n\\n for idx, ele in enumerate(tokens):\\n if self.is_number(ele):\\n numb_stack.append(int(ele))\\n else:\\n val1 = numb_stack.pop()\\n val2 = numb_stack.pop()\\n \\n print(val1, val2, ele)\\n if ele == \\\"+\\\":\\n numb_stack.append(val2+val1)\\n elif ele == \\\"-\\\":\\n numb_stack.append(val2-val1)\\n elif ele == \\\"*\\\":\\n numb_stack.append(val2*val1)\\n elif ele == \\\"/\\\":\\n numb_stack.append(int(val2/val1)) \\n return numb_stack.pop()\",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n\\n for token in tokens:\\n if token.isdigit() or (token[0] == \\\"-\\\" and token[1:].isdigit()):\\n stack.append(int(token))\\n else:\\n firstInteger = stack.pop()\\n secondInteger = stack.pop()\\n if token == \\\"+\\\":\\n result = secondInteger + firstInteger\\n elif token == \\\"-\\\":\\n result = secondInteger - firstInteger\\n elif token == \\\"*\\\":\\n result = secondInteger * firstInteger\\n else:\\n result = int(secondInteger / firstInteger)\\n stack.append(result)\\n return stack[0]\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n operations=set([\\\"+\\\",\\\"-\\\",\\\"*\\\",\\\"/\\\"])\\n stack=[]\\n for token in tokens:\\n if token in operations: #Must be to operate on previous two things\\n b=stack.pop()\\n a=stack.pop()\\n if token==\\\"+\\\":\\n c=a+b\\n elif token==\\\"-\\\":\\n c=a-b\\n elif token==\\\"*\\\":\\n c=a*b\\n elif token==\\\"/\\\":\\n real_c=a/b\\n if real_c>=0:\\n c=math.floor(real_c)\\n elif real_c<0:\\n c=math.ceil(real_c)\\n stack.append(c)\\n print(a,b,token,c)\\n \\n else: #If token not in operations, must be \\\"int\\\"\\n stack.append(int(token))\\n return stack[-1]\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def performOp(self, a, b, sign):\\n if sign == '+':\\n return a + b\\n elif sign == '-':\\n return a - b\\n elif sign == '*':\\n return a * b\\n elif sign == '/':\\n return int(a/b)\\n else:\\n return 0\\n\\n def evalRPN(self, tokens: List[str]) -> int:\\n i = 0\\n stack = []\\n while i < len(tokens):\\n temp = tokens[i]\\n i += 1\\n if temp.isalnum() or (temp[0] == '-' and len(temp) > 1):\\n stack.append(int(temp))\\n else:\\n op2 = stack.pop() \\n op1 = stack.pop() \\n ans = self.performOp(op1,op2,temp)\\n print(op1,op2,temp,ans)\\n stack.append(ans)\\n return stack.pop()\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def is_number(self, n):\\n try:\\n float(n)\\n return True\\n except ValueError:\\n return False\\n\\n def evalRPN(self, tokens: List[str]) -> int:\\n numb_stack = []\\n\\n for idx, ele in enumerate(tokens):\\n if self.is_number(ele):\\n numb_stack.append(int(ele))\\n else:\\n val1 = numb_stack.pop()\\n val2 = numb_stack.pop()\\n \\n print(val1, val2, ele)\\n if ele == \\\"+\\\":\\n numb_stack.append(val2+val1)\\n elif ele == \\\"-\\\":\\n numb_stack.append(val2-val1)\\n elif ele == \\\"*\\\":\\n numb_stack.append(val2*val1)\\n elif ele == \\\"/\\\":\\n numb_stack.append(int(val2/val1)) \\n return numb_stack.pop()\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n operations=set([\\\"+\\\",\\\"-\\\",\\\"*\\\",\\\"/\\\"])\\n stack=[]\\n for token in tokens:\\n if token in operations: #Must be to operate on previous two things\\n b=stack.pop()\\n a=stack.pop()\\n if token==\\\"+\\\":\\n c=a+b\\n elif token==\\\"-\\\":\\n c=a-b\\n elif token==\\\"*\\\":\\n c=a*b\\n elif token==\\\"/\\\":\\n real_c=a/b\\n if real_c>=0:\\n c=math.floor(real_c)\\n elif real_c<0:\\n c=math.ceil(real_c)\\n stack.append(c)\\n print(a,b,token,c)\\n \\n else: #If token not in operations, must be \\\"int\\\"\\n stack.append(int(token))\\n return stack[-1]\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n valStack, opStack = [], []\\n res = math.inf\\n\\n if len(tokens) == 1:\\n return int(tokens[0])\\n\\n for t in tokens:\\n if t not in [\\\"+\\\",\\\"-\\\",\\\"*\\\",\\\"/\\\"]:\\n valStack.append(int(t))\\n else:\\n second = valStack.pop()\\n first = valStack.pop()\\n res = 0\\n\\n print('start', res)\\n if t == \\\"/\\\":\\n res = int(first / second)\\n elif t == \\\"*\\\":\\n res = first * second\\n elif t == \\\"-\\\":\\n res = first - second \\n else:\\n res = first + second\\n \\n print(first,second,t, res)\\n \\n valStack.append(res)\\n\\n return valStack.pop()\\n\\n \\n\\n # for t in tokens:\\n # if t not in [\\\"+\\\",\\\"-\\\",\\\"*\\\",\\\"/\\\"]:\\n # valStack.append(int(t))\\n # else:\\n # if res == math.inf:\\n # res = valStack.pop()\\n # first = valStack.pop()\\n # print('start', res)\\n # if t == \\\"/\\\":\\n # if first < 0 or res < 0:\\n # res = int(round(first / res,0))\\n # else:\\n # res = first // res\\n # elif t == \\\"*\\\":\\n # res *= first\\n # elif t == \\\"-\\\":\\n # res = first - res\\n # else:\\n # res += first\\n # print(first, res)\\n \\n # print('final' , res)\\n # return res\\n\\n \",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n '''\\n curr = 2\\n [curr,1]\\n operation +\\n curr += top\\n pop()\\n pop()\\n push(curr)\\n push(3)\\n '''\\n stack = []\\n operators = [\\\"+\\\", \\\"-\\\", \\\"/\\\", \\\"*\\\"]\\n\\n if len(tokens) == 1:\\n return int(tokens[0])\\n curr = 0\\n while tokens:\\n el = tokens.pop(0)\\n if el in operators:\\n s = stack.pop()\\n f = stack.pop()\\n if el is operators[0]:\\n curr = f + s\\n elif el is operators[1]:\\n curr = f - s\\n elif el is operators[2]:\\n curr = f / s \\n curr = floor(curr) if curr > 0 else ceil(curr)\\n elif el is operators[3]:\\n curr = f * s\\n stack.append(curr)\\n else:\\n stack.append(int(el))\\n\\n return curr\\n\\n \",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n current_pos = 0\\n\\n while len(tokens) > 1:\\n\\n while tokens[current_pos] not in '+/*-':\\n current_pos+=1\\n \\n operator = tokens[current_pos]\\n val2 = int(tokens[current_pos - 1])\\n val1 = int(tokens[current_pos - 2])\\n\\n if operator == '+':\\n tokens[current_pos] = val1 + val2\\n elif operator == '-':\\n tokens[current_pos] = val1 - val2\\n elif operator == '*':\\n tokens[current_pos] = val1 * val2\\n else:\\n tokens[current_pos] = int(val1 / val2)\\n \\n tokens.pop(current_pos-2)\\n tokens.pop(current_pos-2)\\n current_pos-=1\\n \\n return int(tokens[-1])\",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n operator=[\\\"*\\\",\\\"+\\\",\\\"-\\\",\\\"/\\\"]\\n l=[]\\n while(len(tokens)!=0):\\n a=tokens.pop(0)\\n if a in operator:\\n op2=l.pop(-1)\\n op1=l.pop(-1)\\n if(a==\\\"*\\\"):\\n l.append(int(op1*op2))\\n elif(a==\\\"/\\\"):\\n l.append(int(op1/op2))\\n elif(a==\\\"+\\\"):\\n l.append(int(op1+op2))\\n elif(a==\\\"-\\\"):\\n l.append(int(op1-op2))\\n else:\\n l.append(int(a))\\n print(int(int(6//-132)))\\n return l[0]\\n\\n \",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n operator=[\\\"*\\\",\\\"+\\\",\\\"-\\\",\\\"/\\\"]\\n l=[]\\n while(len(tokens)!=0):\\n a=tokens.pop(0)\\n if a in operator:\\n op2=l.pop(-1)\\n op1=l.pop(-1)\\n if(a==\\\"*\\\"):\\n l.append(int(op1*op2))\\n elif(a==\\\"/\\\"):\\n l.append(int(op1/op2))\\n elif(a==\\\"+\\\"):\\n l.append(int(op1+op2))\\n elif(a==\\\"-\\\"):\\n l.append(int(op1-op2))\\n else:\\n l.append(int(a))\\n \\n return l[0]\\n\\n \",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = [] # stores math arguments\\n for t in tokens:\\n if t in ['+', '-', '*', '/']:\\n a = int(stack[-2])\\n b = int(stack[-1])\\n stack = stack[:-2]\\n # compute prod, push back onto stack\\n if t == '+':\\n prod = a + b\\n elif t == '-':\\n prod = a - b\\n elif t == '*':\\n prod = a * b\\n else:\\n prod = int(a / b)\\n stack.append(prod)\\n else:\\n stack.append(int(t))\\n \\n return stack[0]\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n\\n for t in tokens:\\n if t != \\\"+\\\" and t!= \\\"/\\\" and t != \\\"*\\\" and t != \\\"-\\\":\\n stack.insert(0, int(t))\\n else:\\n num1 = stack.pop(0)\\n num2 = stack.pop(0)\\n if (t == \\\"+\\\"):\\n stack.insert(0, num1 + num2)\\n elif(t == \\\"-\\\"):\\n stack.insert(0, num2 - num1)\\n elif(t == \\\"/\\\"):\\n stack.insert(0, int(float(num2) / num1))\\n else:\\n stack.insert(0, num1 * num2)\\n \\n\\n\\n return stack.pop()\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n \\\"\\\"\\\"\\n time: O(N LogN)\\n space O(1)\\n \\\"\\\"\\\"\\n # while len(tokens)!=1:\\n # for idx,token in enumerate(tokens):\\n # if token in ['+','-','*','/']:\\n # # print(idx,tokens)\\n # ops = tokens.pop(idx)\\n # right = int(tokens.pop(idx-1))\\n # left = int(tokens.pop(idx-2))\\n # anw = 0\\n # if ops=='+':\\n # anw=left+right\\n # elif ops=='-':\\n # anw=left-right\\n # elif ops=='*':\\n # anw=left*right\\n # elif ops=='/':\\n # anw=int(left/right)\\n # tokens.insert(idx-2,anw)\\n # # print(tokens)\\n # break\\n idx=0\\n while not len(tokens)==1:\\n token = tokens[idx]\\n if token in ['+','-','*','/']:\\n # print(idx,tokens)\\n ops = tokens.pop(idx)\\n right = int(tokens.pop(idx-1))\\n left = int(tokens.pop(idx-2))\\n anw = 0\\n if ops=='+':\\n anw=left+right\\n elif ops=='-':\\n anw=left-right\\n elif ops=='*':\\n anw=left*right\\n elif ops=='/':\\n anw=int(left/right)\\n tokens.insert(idx-2,anw)\\n # print(tokens)\\n idx=idx-1\\n else:\\n idx+=1\\n return int(tokens[0])\",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n operands = []\\n for i in tokens:\\n if i == \\\"+\\\":\\n item = int((operands[-2]) + (operands[-1]))\\n operands = self.cutAddList(operands, item)\\n elif i == \\\"-\\\":\\n item = int((operands[-2]) - (operands[-1]))\\n operands = self.cutAddList(operands, item)\\n elif i == \\\"*\\\":\\n item = int((operands[-2]) * (operands[-1]))\\n operands = self.cutAddList(operands, item)\\n elif i == \\\"/\\\":\\n item = int((operands[-2]) / (operands[-1]))\\n operands = self.cutAddList(operands, item)\\n else:\\n operands.append(int(i))\\n \\n return int(operands[0])\\n\\n \\n def cutAddList(self, arr: List[int], item: int) -> List[int]:\\n newArr = arr[:-2]\\n newArr.append(item)\\n return newArr\\n\\n \",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens):\\n operators = ['+', '-', '*', '/']\\n stack = []\\n for i in tokens:\\n if i not in operators:\\n stack.append(i)\\n else:\\n operation = stack.pop(-2) + i + stack.pop()\\n stack.append(str(int(eval(operation))))\\n return int(stack[0])\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n if not tokens:\\n return 0\\n\\n token = tokens.pop()\\n\\n funcs = {\\n '+': lambda l, r: l + r,\\n '-': lambda l, r: l - r,\\n '*': lambda l, r: l * r,\\n '/': lambda l, r: int(l / r),\\n }\\n \\n if token not in funcs:\\n return int(token)\\n\\n right = self.evalRPN(tokens)\\n left = self.evalRPN(tokens)\\n\\n return funcs[token](left, right)\",\n \"runtime\": \"89\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n def div(x,y):\\n if x>0 and y>0 or x<0 and y<0:\\n return abs(x)//abs(y)\\n x=abs(x)\\n y=abs(y)\\n return -1*(x//y)\\n stack=[]\\n ops=\\\"+-*/\\\"\\n for x in tokens:\\n if x not in ops:\\n stack.append(int(x))\\n elif x==\\\"+\\\":\\n temp=stack[-1]\\n stack=stack[:-1]\\n stack[-1]+=temp\\n elif x==\\\"-\\\":\\n temp=stack[-1]\\n stack=stack[:-1]\\n stack[-1]-=temp\\n elif x==\\\"*\\\":\\n temp=stack[-1]\\n stack=stack[:-1]\\n stack[-1]*=temp\\n else:\\n temp=stack[-1]\\n stack=stack[:-1]\\n stack[-1]=div(stack[-1],temp)\\n return stack[0]\\n\\n \\n \",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"import operator as op\\n\\nclass Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n if len(tokens) == 1:\\n return int(tokens[0])\\n \\n operators = {\\\"+\\\": lambda a, b: a + b,\\n \\\"-\\\": lambda a, b: a - b,\\n \\\"*\\\": lambda a, b: a*b,\\n \\\"/\\\": lambda a,b: a/b}\\n \\n index = 0\\n while tokens:\\n command = tokens[index]\\n\\n if command in operators:\\n func = operators[tokens.pop(index)]\\n b = int(tokens.pop(index - 1))\\n a = int(tokens.pop(index - 2))\\n tokens.insert(index - 2, func(a, b))\\n index = index - 2\\n elif len(tokens) == 1:\\n return int(tokens[0])\\n else:\\n index += 1\\n\\n\",\n \"runtime\": \"91\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n opDict = {\\n '+': lambda lhs, rhs: lhs + rhs, \\n '-': lambda lhs, rhs: lhs - rhs, \\n '/': lambda lhs, rhs: int(lhs / rhs), \\n '*': lambda lhs, rhs: lhs * rhs,\\n }\\n\\n stack = []\\n for token in tokens:\\n if token not in opDict:\\n stack.append(int(token))\\n else:\\n rhs, lhs = stack[-1], stack[-2]\\n stack = stack[:-2]\\n stack.append(opDict[token](lhs, rhs))\\n\\n return stack[0]\\n\\n\\n\\n \",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"import operator as op\\n\\nclass Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n if len(tokens) == 1:\\n return int(tokens[0])\\n operators = {\\\"+\\\": op.add, \\\"-\\\": op.sub, \\\"*\\\": op.mul, \\\"/\\\": op.truediv}\\n \\n index = 0\\n while tokens:\\n command = tokens[index]\\n\\n if command in operators:\\n func = operators[tokens.pop(index)]\\n b = int(tokens.pop(index - 1))\\n a = int(tokens.pop(index - 2))\\n tokens.insert(index - 2, func(a, b))\\n index = index - 2\\n elif len(tokens) == 1:\\n return int(tokens[0])\\n else:\\n index += 1\\n\\n\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"import math\\ndef performOp(operand, num1, num2):\\n if operand == '+':\\n return num1 + num2\\n elif operand == '-':\\n return num2 - num1\\n elif operand == '*':\\n return num1 * num2\\n elif operand == '/':\\n return math.trunc(num2 / num1)\\n else:\\n raise Error(f\\\"Invalid operand: {operand}\\\")\\n \\ndef isNumber(str):\\n try:\\n int(str)\\n return True\\n except:\\n return False\\nclass Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n # put each element on the stack\\n # if curr == operand, pop last two and perform operation\\n # put result back on stack\\n stack = []\\n while tokens:\\n curr = tokens.pop(0)\\n if isNumber(curr):\\n stack.append(int(curr))\\n else:\\n first = stack.pop()\\n second = stack.pop()\\n print(f\\\"{second} {curr} {first}\\\")\\n result = performOp(curr, first, second)\\n stack.append(result)\\n return stack[0]\\n \",\n \"runtime\": \"94\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n i = 0\\n n = len(tokens)\\n ops = ['+', '-', '*', '/']\\n exp=[]\\n ans = 0\\n def operation(op1,op2,op):\\n if op == '+':\\n return op2+op1\\n elif op == '-':\\n return op2-op1\\n elif op == '*':\\n return op2*op1\\n elif op == '/':\\n return op2/op1\\n if len(tokens)==1:\\n return int(tokens[0])\\n while len(tokens)>0:\\n if tokens[i] not in ops:\\n exp.append(tokens[i])\\n del tokens[i]\\n else:\\n op1 = exp.pop()\\n op2= exp.pop()\\n print(op1,op2)\\n ans = operation(int(op1),int(op2),tokens[i])\\n tokens[0] = ans\\n return int(ans)\\n \\n\",\n \"runtime\": \"95\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for token in tokens:\\n if token in {\\\"+\\\", \\\"-\\\", \\\"*\\\", \\\"/\\\"}:\\n val2 = stack.pop()\\n val1 = stack.pop()\\n res = eval(str(val1) + token + str(val2))\\n stack.append(int(res))\\n else:\\n stack.append(int(token))\\n\\n return stack[0]\\n\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n signs = {'*','/','+','-'}\\n stack = []\\n for token in tokens:\\n if token in signs:\\n one = stack.pop()\\n two = stack.pop()\\n stack.append(int(eval(f'{two} {token} {one}')))\\n else:\\n stack.append(token)\\n \\n return (int(stack[0]))\\n \",\n \"runtime\": \"97\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n tokens_stack = []\\n for el in tokens:\\n match el:\\n case \\\"+\\\":\\n res = tokens_stack[-2] + tokens_stack[-1]\\n tokens_stack = tokens_stack[:-2]\\n tokens_stack.append(res)\\n case \\\"-\\\":\\n res = tokens_stack[-2] - tokens_stack[-1]\\n tokens_stack = tokens_stack[:-2]\\n tokens_stack.append(res)\\n case \\\"*\\\":\\n res = tokens_stack[-2] * tokens_stack[-1]\\n tokens_stack = tokens_stack[:-2]\\n tokens_stack.append(res)\\n case \\\"/\\\":\\n res = tokens_stack[-2] / tokens_stack[-1]\\n res = math.floor(res) if res > 0 else math.ceil(res)\\n tokens_stack = tokens_stack[:-2]\\n tokens_stack.append(res)\\n case _:\\n tokens_stack.append(int(el))\\n return tokens_stack.pop()\",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for t in tokens:\\n if t in [\\\"*\\\", \\\"/\\\", \\\"+\\\", \\\"-\\\"]:\\n p1 = stack.pop(-1)\\n p2 = stack.pop(-1)\\n if t == \\\"*\\\":\\n stack.append(p1 * p2)\\n elif t == \\\"/\\\":\\n r = p2 / p1\\n if r >= 0:\\n stack.append((p2//p1))\\n else:\\n stack.append(- (p2 // (-p1)))\\n elif t == \\\"+\\\":\\n stack.append(p1 + p2)\\n elif t == \\\"-\\\":\\n stack.append(p2-p1)\\n else:\\n stack.append(eval(t))\\n return stack[-1]\\n \\n \",\n \"runtime\": \"99\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, t: List[str]) -> int:\\n st = []\\n for i in t:\\n if i in \\\"+-*/\\\":\\n b,a=st.pop(),st.pop()\\n st.append(str(int(eval(a+i+b))))\\n else:st.append(i)\\n return int(st[0])\",\n \"runtime\": \"100\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n l = []\\n for i in tokens:\\n if i not in \\\"+*-/\\\":\\n l.append(i)\\n else:\\n b = l.pop()\\n a = l.pop()\\n if i == \\\"/\\\":\\n l.append(str(int(int(a)/int(b))))\\n else:\\n l.append(str(eval(a+i+b)))\\n return int(l[-1])\",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n res=[]\\n for i in tokens:\\n if i not in ['*','-','+','/']:\\n res.append(i)\\n else:\\n a=res.pop()\\n b=res.pop()\\n x=str(b)+str(i)+str(a)\\n c=eval(x)\\n res.append(str(int(c)))\\n return int(res[0])\\n\",\n \"runtime\": \"102\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = list()\\n\\n for token in tokens:\\n if token not in [\\\"+\\\", \\\"-\\\", \\\"*\\\", \\\"/\\\"]:\\n stack.append(token)\\n else:\\n second = stack.pop()\\n first = stack.pop()\\n stack.append(int(eval(f\\\"{first}{token}{second}\\\")))\\n \\n return int(stack[-1])\\n \",\n \"runtime\": \"103\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n res=[]\\n for i in tokens:\\n if i not in ['*','-','+','/']:\\n res.append(i)\\n else:\\n a=res.pop()\\n b=res.pop()\\n x=b+i+a\\n c=eval(x)\\n res.append(str(int(c)))\\n return int(res[0])\\n\",\n \"runtime\": \"104\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n opn = []\\n opr = []\\n\\n for token in tokens:\\n if 48 <= ord(token[-1]) <= 57:\\n opn.append(int(token))\\n else:\\n opr.append(token)\\n s = opr.pop()\\n\\n n1 = opn.pop()\\n n2 = opn.pop()\\n\\n opn.append(int(eval(str(n2) + s + str(n1))))\\n \\n return opn.pop()\",\n \"runtime\": \"106\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n # ops = {'+', '-', '*', '/'}\\n ops = '+-*/'\\n\\n for token in tokens:\\n if token not in ops: stack.append(token); continue\\n val2, val1 = stack.pop(), stack.pop()\\n token = eval(val1 + token + val2)\\n token = floor(token) if token > 0 else ceil(token)\\n stack.append(f'{token}')\\n\\n return int(stack[-1])\",\n \"runtime\": \"107\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":108,"string":"108"},"mm_list":{"kind":"list like","value":[{"code":"# class Solution:\n# def evalRPN(self, tokens: List[str]) -> int:\n# numbers = []\n# operations = {\n# \"+\" : lambda x, y: x + y,\n# \"-\" : lambda x, y: x - y,\n# \"*\" : lambda x, y: x * y,\n# \"/\" : lambda x, y: int(x / y)\n# }\n# for token in tokens:\n# if token.isnumeric() or token[1:].isnumeric():\n# numbers.append(int(token))\n# else:\n# num2 = numbers.pop()\n# num1 = numbers.pop()\n# operation = operations[token]\n# numbers.append(operation(num1, num2))\n# return numbers[0]\n\nwith open(\"user.out\", \"w\") as f:\n print(\"9\",file=f)\n print(\"6\",file=f)\n print(\"22\",file=f)\n print(\"18\",file=f)\n print(\"0\",file=f)\n print(\"-1\",file=f)\n print(\"1\",file=f)\n print(\"-27\",file=f)\n print(\"-13\",file=f)\n print(\"9\",file=f)\n print(\"-2\",file=f)\n print(\"-7\",file=f)\n print(\"165\",file=f)\n print(\"11\",file=f)\n print(\"7143937\",file=f)\n print(\"-6876750\",file=f)\n print(\"1250216\",file=f)\n print(\"-231\",file=f)\n print(\"0\",file=f)\n print(\"0\",file=f)\n print(\"-2147483648\",file=f)\nexit(0)","memory":"16400"},{"code":"# class Solution:\n# def evalRPN(self, tokens: List[str]) -> int:\n# stack = []\n# ops = {\n# \"+\": lambda x, y: x+y,\n# \"-\": lambda x, y: x-y,\n# \"*\": lambda x, y: x*y,\n# \"/\": lambda x, y: int(x/y),\n# }\n# for tkn in tokens:\n# if tkn in ops:\n# op2, op1 = stack.pop(), stack.pop()\n# res = ops[tkn](op1, op2)\n# print(op1, tkn, op2, '=', res)\n# stack.append(res)\n# else:\n# stack.append(int(tkn))\n# return stack.pop()\n\n\nwith open(\"user.out\", \"w\") as f:\n print(\"9\",file=f)\n print(\"6\",file=f)\n print(\"22\",file=f)\n print(\"18\",file=f)\n print(\"0\",file=f)\n print(\"-1\",file=f)\n print(\"1\",file=f)\n print(\"-27\",file=f)\n print(\"-13\",file=f)\n print(\"9\",file=f)\n print(\"-2\",file=f)\n print(\"-7\",file=f)\n print(\"165\",file=f)\n print(\"11\",file=f)\n print(\"7143937\",file=f)\n print(\"-6876750\",file=f)\n print(\"1250216\",file=f)\n print(\"-231\",file=f)\n print(\"0\",file=f)\n print(\"0\",file=f)\n print(\"-2147483648\",file=f)\nexit(0)","memory":"16500"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n \n stack = []\n\n for tok in tokens:\n if tok in \"+-/*\":\n oper2 = stack.pop()\n oper1 = stack.pop()\n if tok == \"+\": stack.append(oper1 + oper2)\n elif tok == \"-\": stack.append(oper1 - oper2)\n elif tok == \"*\": stack.append(oper1 * oper2)\n else: stack.append(int(oper1 / oper2))\n else:\n stack.append(int(tok))\n \n return stack[-1]","memory":"16600"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n if len(tokens) == 1: return int(tokens[0])\n ops, tokens, stack, res = '+-/*', deque(tokens), deque(), 0\n while tokens:\n curr = tokens.popleft()\n if curr not in ops: stack.append(curr)\n else:\n arg1, arg2 = stack.pop(), stack.pop()\n res = int(eval(f'{arg2}{curr}{arg1}'))\n stack.append(res)\n return res","memory":"16700"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack=[]\n op=['+','-','*','/']\n for i in range(len(tokens)):\n if(tokens[i] not in op):\n stack.append(int(tokens[i]))\n else:\n b=stack.pop()\n a=stack.pop()\n if tokens[i]=='+':\n new_val=a+b\n elif tokens[i]=='-':\n new_val=a-b\n elif tokens[i]=='*':\n new_val=a*b\n elif tokens[i]=='/':\n new_val=int(a/b)\n stack.append(new_val)\n return stack[0]\n\n\n ","memory":"16800"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for i in tokens:\n if i == '+':\n stack.append(stack.pop() + stack.pop())\n elif i == '-':\n a, b = stack.pop(), stack.pop()\n stack.append(b - a)\n elif i == \"*\":\n stack.append(stack.pop() * stack.pop())\n elif i == '/':\n a, b = stack.pop(), stack.pop()\n stack.append(int(float(b) / a))\n else:\n stack.append(int(i)) \n return stack[0] ","memory":"16900"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n for c in tokens:\n if c == '+':\n stack.append(stack.pop() + stack.pop())\n elif c == '-':\n a,b = stack.pop(),stack.pop()\n stack.append(b-a)\n elif c == '*':\n stack.append(stack.pop() * stack.pop())\n elif c == '/':\n a,b = stack.pop(),stack.pop()\n stack.append(int(float(b)/a))\n else:\n stack.append(int(c))\n return stack[0]","memory":"16900"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack=[]\n for i in tokens:\n if i==\"+\":\n a=stack.pop()\n b=stack.pop()\n stack.append(a+b)\n\n elif i==\"-\":\n a=stack.pop()\n b=stack.pop()\n stack.append(b-a)\n\n elif i==\"*\":\n a=stack.pop()\n b=stack.pop()\n stack.append(a*b)\n\n elif i==\"/\":\n a=stack.pop()\n b=stack.pop()\n stack.append(int(b/a))\n\n else:\n stack.append(int(i))\n \n return stack[0]\n \n ","memory":"17000"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n stack = []\n\n for i in tokens:\n if i.lstrip(\"-\").isdigit():\n stack.append(int(i))\n else:\n nums2 = stack.pop()\n nums1 = stack.pop()\n\n match i:\n case \"*\":\n stack.append(nums1*nums2)\n case \"/\":\n stack.append(int(nums1/nums2))\n case \"-\":\n stack.append(nums1-nums2)\n case \"+\":\n stack.append(nums1+nums2)\n return stack[0]","memory":"17000"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n current_pos = 0\n\n while len(tokens) > 1:\n\n while tokens[current_pos] not in '+/*-':\n current_pos+=1\n \n operator = tokens[current_pos]\n val2 = int(tokens[current_pos - 1])\n val1 = int(tokens[current_pos - 2])\n\n if operator == '+':\n tokens[current_pos] = val1 + val2\n elif operator == '-':\n tokens[current_pos] = val1 - val2\n elif operator == '*':\n tokens[current_pos] = val1 * val2\n else:\n tokens[current_pos] = int(val1 / val2)\n \n tokens.pop(current_pos-2)\n tokens.pop(current_pos-2)\n current_pos-=1\n \n return int(tokens[-1])","memory":"17100"},{"code":"class Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n signs_map = {\n '+': operator.add, \n '-': operator.sub, \n '*': operator.mul,\n '/': operator.truediv\n }\n\n stack = []\n for token in tokens: \n if token not in signs_map:\n stack.append(token)\n continue \n b, a = int(stack.pop()), int(stack.pop())\n stack.append(int(signs_map[token](a,b)))\n\n return int(stack.pop())\n ","memory":"17100"}],"string":"[\n {\n \"code\": \"# class Solution:\\n# def evalRPN(self, tokens: List[str]) -> int:\\n# numbers = []\\n# operations = {\\n# \\\"+\\\" : lambda x, y: x + y,\\n# \\\"-\\\" : lambda x, y: x - y,\\n# \\\"*\\\" : lambda x, y: x * y,\\n# \\\"/\\\" : lambda x, y: int(x / y)\\n# }\\n# for token in tokens:\\n# if token.isnumeric() or token[1:].isnumeric():\\n# numbers.append(int(token))\\n# else:\\n# num2 = numbers.pop()\\n# num1 = numbers.pop()\\n# operation = operations[token]\\n# numbers.append(operation(num1, num2))\\n# return numbers[0]\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n print(\\\"9\\\",file=f)\\n print(\\\"6\\\",file=f)\\n print(\\\"22\\\",file=f)\\n print(\\\"18\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"-1\\\",file=f)\\n print(\\\"1\\\",file=f)\\n print(\\\"-27\\\",file=f)\\n print(\\\"-13\\\",file=f)\\n print(\\\"9\\\",file=f)\\n print(\\\"-2\\\",file=f)\\n print(\\\"-7\\\",file=f)\\n print(\\\"165\\\",file=f)\\n print(\\\"11\\\",file=f)\\n print(\\\"7143937\\\",file=f)\\n print(\\\"-6876750\\\",file=f)\\n print(\\\"1250216\\\",file=f)\\n print(\\\"-231\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"-2147483648\\\",file=f)\\nexit(0)\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"# class Solution:\\n# def evalRPN(self, tokens: List[str]) -> int:\\n# stack = []\\n# ops = {\\n# \\\"+\\\": lambda x, y: x+y,\\n# \\\"-\\\": lambda x, y: x-y,\\n# \\\"*\\\": lambda x, y: x*y,\\n# \\\"/\\\": lambda x, y: int(x/y),\\n# }\\n# for tkn in tokens:\\n# if tkn in ops:\\n# op2, op1 = stack.pop(), stack.pop()\\n# res = ops[tkn](op1, op2)\\n# print(op1, tkn, op2, '=', res)\\n# stack.append(res)\\n# else:\\n# stack.append(int(tkn))\\n# return stack.pop()\\n\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n print(\\\"9\\\",file=f)\\n print(\\\"6\\\",file=f)\\n print(\\\"22\\\",file=f)\\n print(\\\"18\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"-1\\\",file=f)\\n print(\\\"1\\\",file=f)\\n print(\\\"-27\\\",file=f)\\n print(\\\"-13\\\",file=f)\\n print(\\\"9\\\",file=f)\\n print(\\\"-2\\\",file=f)\\n print(\\\"-7\\\",file=f)\\n print(\\\"165\\\",file=f)\\n print(\\\"11\\\",file=f)\\n print(\\\"7143937\\\",file=f)\\n print(\\\"-6876750\\\",file=f)\\n print(\\\"1250216\\\",file=f)\\n print(\\\"-231\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"0\\\",file=f)\\n print(\\\"-2147483648\\\",file=f)\\nexit(0)\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n \\n stack = []\\n\\n for tok in tokens:\\n if tok in \\\"+-/*\\\":\\n oper2 = stack.pop()\\n oper1 = stack.pop()\\n if tok == \\\"+\\\": stack.append(oper1 + oper2)\\n elif tok == \\\"-\\\": stack.append(oper1 - oper2)\\n elif tok == \\\"*\\\": stack.append(oper1 * oper2)\\n else: stack.append(int(oper1 / oper2))\\n else:\\n stack.append(int(tok))\\n \\n return stack[-1]\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n if len(tokens) == 1: return int(tokens[0])\\n ops, tokens, stack, res = '+-/*', deque(tokens), deque(), 0\\n while tokens:\\n curr = tokens.popleft()\\n if curr not in ops: stack.append(curr)\\n else:\\n arg1, arg2 = stack.pop(), stack.pop()\\n res = int(eval(f'{arg2}{curr}{arg1}'))\\n stack.append(res)\\n return res\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack=[]\\n op=['+','-','*','/']\\n for i in range(len(tokens)):\\n if(tokens[i] not in op):\\n stack.append(int(tokens[i]))\\n else:\\n b=stack.pop()\\n a=stack.pop()\\n if tokens[i]=='+':\\n new_val=a+b\\n elif tokens[i]=='-':\\n new_val=a-b\\n elif tokens[i]=='*':\\n new_val=a*b\\n elif tokens[i]=='/':\\n new_val=int(a/b)\\n stack.append(new_val)\\n return stack[0]\\n\\n\\n \",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for i in tokens:\\n if i == '+':\\n stack.append(stack.pop() + stack.pop())\\n elif i == '-':\\n a, b = stack.pop(), stack.pop()\\n stack.append(b - a)\\n elif i == \\\"*\\\":\\n stack.append(stack.pop() * stack.pop())\\n elif i == '/':\\n a, b = stack.pop(), stack.pop()\\n stack.append(int(float(b) / a))\\n else:\\n stack.append(int(i)) \\n return stack[0] \",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n for c in tokens:\\n if c == '+':\\n stack.append(stack.pop() + stack.pop())\\n elif c == '-':\\n a,b = stack.pop(),stack.pop()\\n stack.append(b-a)\\n elif c == '*':\\n stack.append(stack.pop() * stack.pop())\\n elif c == '/':\\n a,b = stack.pop(),stack.pop()\\n stack.append(int(float(b)/a))\\n else:\\n stack.append(int(c))\\n return stack[0]\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack=[]\\n for i in tokens:\\n if i==\\\"+\\\":\\n a=stack.pop()\\n b=stack.pop()\\n stack.append(a+b)\\n\\n elif i==\\\"-\\\":\\n a=stack.pop()\\n b=stack.pop()\\n stack.append(b-a)\\n\\n elif i==\\\"*\\\":\\n a=stack.pop()\\n b=stack.pop()\\n stack.append(a*b)\\n\\n elif i==\\\"/\\\":\\n a=stack.pop()\\n b=stack.pop()\\n stack.append(int(b/a))\\n\\n else:\\n stack.append(int(i))\\n \\n return stack[0]\\n \\n \",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n stack = []\\n\\n for i in tokens:\\n if i.lstrip(\\\"-\\\").isdigit():\\n stack.append(int(i))\\n else:\\n nums2 = stack.pop()\\n nums1 = stack.pop()\\n\\n match i:\\n case \\\"*\\\":\\n stack.append(nums1*nums2)\\n case \\\"/\\\":\\n stack.append(int(nums1/nums2))\\n case \\\"-\\\":\\n stack.append(nums1-nums2)\\n case \\\"+\\\":\\n stack.append(nums1+nums2)\\n return stack[0]\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n current_pos = 0\\n\\n while len(tokens) > 1:\\n\\n while tokens[current_pos] not in '+/*-':\\n current_pos+=1\\n \\n operator = tokens[current_pos]\\n val2 = int(tokens[current_pos - 1])\\n val1 = int(tokens[current_pos - 2])\\n\\n if operator == '+':\\n tokens[current_pos] = val1 + val2\\n elif operator == '-':\\n tokens[current_pos] = val1 - val2\\n elif operator == '*':\\n tokens[current_pos] = val1 * val2\\n else:\\n tokens[current_pos] = int(val1 / val2)\\n \\n tokens.pop(current_pos-2)\\n tokens.pop(current_pos-2)\\n current_pos-=1\\n \\n return int(tokens[-1])\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def evalRPN(self, tokens: List[str]) -> int:\\n signs_map = {\\n '+': operator.add, \\n '-': operator.sub, \\n '*': operator.mul,\\n '/': operator.truediv\\n }\\n\\n stack = []\\n for token in tokens: \\n if token not in signs_map:\\n stack.append(token)\\n continue \\n b, a = int(stack.pop()), int(stack.pop())\\n stack.append(int(signs_map[token](a,b)))\\n\\n return int(stack.pop())\\n \",\n \"memory\": \"17100\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":11,"string":"11"}}},{"rowIdx":55,"cells":{"question_id":{"kind":"number","value":151,"string":"151"},"name":{"kind":"string","value":"reverse-words-in-a-string"},"content":{"kind":"string","value":"<p>Given an input string <code>s</code>, reverse the order of the <strong>words</strong>.</p>\n\n<p>A <strong>word</strong> is defined as a sequence of non-space characters. The <strong>words</strong> in <code>s</code> will be separated by at least one space.</p>\n\n<p>Return <em>a string of the words in reverse order concatenated by a single space.</em></p>\n\n<p><b>Note</b> that <code>s</code> may contain leading or trailing spaces or multiple spaces between two words. The returned string should only have a single space separating the words. Do not include any extra spaces.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> s = "the sky is blue"\n<strong>Output:</strong> "blue is sky the"\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> s = " hello world "\n<strong>Output:</strong> "world hello"\n<strong>Explanation:</strong> Your reversed string should not contain leading or trailing spaces.\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> s = "a good example"\n<strong>Output:</strong> "example good a"\n<strong>Explanation:</strong> You need to reduce multiple spaces between two words to a single space in the reversed string.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= s.length <= 10<sup>4</sup></code></li>\n\t<li><code>s</code> contains English letters (upper-case and lower-case), digits, and spaces <code>' '</code>.</li>\n\t<li>There is <strong>at least one</strong> word in <code>s</code>.</li>\n</ul>\n\n<p> </p>\n<p><b data-stringify-type=\"bold\">Follow-up: </b>If the string data type is mutable in your language, can you solve it <b data-stringify-type=\"bold\">in-place</b> with <code data-stringify-type=\"code\">O(1)</code> extra space?</p>\n"},"acRate":{"kind":"number","value":46.225653903628874,"string":"46.225654"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["two-pointers","string"],"string":"[\n \"two-pointers\",\n \"string\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"12\", 0.0027], [\"14\", 0.0108], [\"15\", 0.0269], [\"16\", 0.0134], [\"17\", 0.0188], [\"18\", 0.0296], [\"19\", 0.1371], [\"20\", 0.086], [\"21\", 0.1102], [\"22\", 0.2823], [\"23\", 0.6156], [\"24\", 0.4167], [\"25\", 0.6344], [\"26\", 1.5323], [\"27\", 1.828], [\"28\", 1.4328], [\"29\", 1.9892], [\"30\", 4.164], [\"31\", 4.4946], [\"32\", 3.4704], [\"33\", 4.5914], [\"34\", 7.5511], [\"35\", 7.0699], [\"36\", 5.5215], [\"37\", 6.1559], [\"38\", 8.1156], [\"39\", 7.3952], [\"40\", 5.293], [\"41\", 5.0296], [\"42\", 5.0296], [\"43\", 4.2688], [\"44\", 3.0215], [\"45\", 2.1263], [\"46\", 1.7473]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15800\", 0.0027], [\"15900\", 0.0027], [\"16100\", 0.0054], [\"16200\", 0.0108], [\"16300\", 0.0538], [\"16400\", 1.2124], [\"16500\", 12.328], [\"16600\", 28.5188], [\"16700\", 41.5027]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n s = s.split()[::-1]\n print(s)\n s = \" \".join(s)\n return s","runtime":"12"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n s = s.strip()\n words = s.split()\n words.reverse()\n return \" \".join(words)\n\n\n \n\n\n ","runtime":"14"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n a = s.split()\n return \" \".join(a[::-1])\n ","runtime":"15"},{"code":"import re\nclass Solution:\n def reverseWords(self, s: str) -> str:\n s = re.sub(\"\\s{1,}\", \" \", s).strip().split(\" \")\n return \" \".join(s[::-1])","runtime":"16"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n words=s.split()\n return ' '.join(reversed(words))","runtime":"17"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n s = s.strip()\n words = [w for w in s.split(' ') if len(w)]\n words.reverse()\n return ' '.join(words)","runtime":"18"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n sentence = s.split()\n sentence.reverse()\n return ' '.join(sentence)","runtime":"19"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n #words = s.split()\n #return(\" \".join(words[-1::-1]))\n return(\" \".join(s.split()[-1::-1]))","runtime":"20"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n l = s.split()\n l.reverse()\n return \" \".join(l)","runtime":"21"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n words = s.split()\n reversed_words = words[::-1]\n\n return ' '.join(reversed_words)\n ","runtime":"21"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n r = s.split()\n r.reverse()\n return \" \".join(r)","runtime":"22"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n si=s.split()\n reverse=si[::-1]\n return ' '.join(reverse)\n \n \n ","runtime":"22"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n res = \"\"\n words = s.split()\n for i in range(len(words)-1, -1, -1):\n res += (words[i] + \" \")\n return res[:-1]\n\n\n","runtime":"23"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n word_list = s.split(\" \")\n reversed_list = []\n for i in range(len(word_list)-1,-1,-1):\n if len(word_list[i]) > 0:\n reversed_list.append(word_list[i])\n return \" \".join(reversed_list)\n","runtime":"23"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n lst_data = s.split()\n lst_data.reverse()\n return \" \".join(lst_data)","runtime":"24"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n words = s.split()\n reversed_words = words[::-1]\n reversed_string = ' '.join(reversed_words)\n return reversed_string\n\n\n\n\n # words = s.split()\n # reversed_words = words[::-1]\n # reversed_string = ' '.join(reversed_words)\n # return reversed_string\n ","runtime":"24"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n new_arr = s.split()\n left = 0\n right = len(new_arr) - 1\n while left < right:\n temp = new_arr[left]\n new_arr[left] = new_arr[right]\n new_arr[right] = temp\n left += 1\n right -= 1\n return ' '.join(new_arr)\n","runtime":"25"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n ans = \"\"\n i = len(s)-1\n while i>=0:\n #print(i)\n j = 0\n if s[i] == \" \":\n i-=1\n else:\n j = i\n while s[i] != \" \" and i>=0:\n i-=1\n ans+= s[i+1:j+1]\n ans+=\" \"\n #print(i, s[i])\n \n return ans[:-1]","runtime":"25"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n s = s.split()\n s.reverse()\n return \" \".join(s)","runtime":"26"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n s_list = s.split()\n i = 0\n j = len(s_list)-1\n while i<=j:\n s_list[i], s_list[j] = s_list[j], s_list[i]\n i += 1\n j -= 1\n return \" \".join(s_list)","runtime":"26"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n s = s.split()\n ans = \"\"\n for _ in range(len(s) - 1):\n ans += s.pop() + \" \"\n ans += s.pop()\n\n return ans\n\n ","runtime":"27"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n arr = s.split()\n\n res = \" \".join(arr[::-1])\n return res","runtime":"27"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n word = s.split(\" \")\n words = word[-1::-1] \n filtered_words = filter(None, words)\n result = ' '.join(filtered_words)\n # filterword = filter(None,words)\n return result","runtime":"28"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n ss = s.split()\n ss.reverse()\n return \" \".join(ss)\n ","runtime":"28"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n b=s.split()\n a=b[::-1]\n c=' '.join(a)\n return c\n\n \n","runtime":"29"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n return ' '.join(s.strip().split()[::-1])\n\n\n ","runtime":"29"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n l = s.split()[::-1]\n return \" \".join(l)","runtime":"30"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n s_spl = s.split()\n return ' '.join(s_spl[::-1])\n ","runtime":"30"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n\n words = [w for w in s.split(\" \") if w != \"\" ]\n reverse_words = words[::-1]\n\n return ' '.join(reverse_words)\n\n\n ","runtime":"31"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n s = s.strip()\n words = s.split(' ')\n new_s = \"\"\n words.reverse()\n for word in words:\n if word != '':\n new_s += word + ' '\n return new_s.strip()","runtime":"31"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n words = s.strip().split()\n words = words[::-1]\n return \" \".join(words).strip()\n ","runtime":"32"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n out = \"\"\n words = s.split()\n\n words.reverse()\n\n out = \" \".join(words)\n return out\n ","runtime":"32"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n words = s.split()\n total = len(words)\n for idx in range(total//2):\n words[idx], words[total-idx-1] = words[total-idx-1], words[idx]\n return ' '.join(words)","runtime":"33"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n words = s.split()\n words.reverse()\n return ' '.join(words)","runtime":"33"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n lst = s.split()\n return \" \".join(lst[::-1])","runtime":"34"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n words = s.split()\n words.reverse()\n\n return ' '.join(words)","runtime":"34"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n listWords = []\n r = []\n for l in s:\n if l != ' ':\n r.append(l)\n else:\n if r:\n listWords.append(''.join(r))\n r = []\n if r:\n listWords.append(''.join(r))\n \n return ' '.join(listWords[::-1])\n\n ","runtime":"35"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n lst_data = s.split()\n lst_data.reverse()\n return ' '.join(lst_data)","runtime":"35"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n s = s.split()\n l = len(s)\n for i in range(l//2):\n s[i], s[l-1-i] = s[l-1-i], s[i]\n \n return ' '.join(s)\n ","runtime":"36"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n return \" \".join(reversed(s.strip().split()))","runtime":"36"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n res = []\n temp = \"\"\n for c in s:\n if c != \" \":\n temp += c \n elif temp != \"\":\n res.append(temp)\n temp = \"\"\n if temp != \"\":\n res.append(temp)\n return \" \".join(res[::-1])","runtime":"37"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n # No trailing spaces, reverse the word\n words = []\n word = \"\"\n for i in s:\n if i != ' ':\n word += i\n else:\n if len(word) > 0:\n words.append(word)\n word = \"\"\n \n if len(word) > 0:\n words.append(word)\n \n result = ' '.join(words[::-1])\n \n return result\n \n\n\n \n ","runtime":"37"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n return \" \".join(reversed(s.split()))\n ","runtime":"38"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n\n words = s.split()\n wordstrip = [x.strip() for x in words]\n return_str = ' '.join(wordstrip[::-1])\n\n return return_str\n ","runtime":"38"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n words = s.split()\n words.reverse()\n return \" \".join(words)","runtime":"39"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n words = s.split(\" \")\n words = list(filter(lambda w: w != \"\", words))\n ans = []\n \n for word in words[::-1]:\n ans.append(word)\n return \" \".join(ans)","runtime":"39"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n l=s.split()\n string=\"\"\n for i in range(len(l)-1,0,-1):\n string+=l[i]+\" \"\n string+=l[0]\n return string","runtime":"40"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n return ' '.join([ch for ch in reversed(s.split()) if ch])","runtime":"40"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n x = s.split()\n d=x[::-1]\n y=\" \".join(d)\n return y\n\n","runtime":"41"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n \n n = len(s)\n words = []\n cur = \"\"\n i = 0\n\n while i < n:\n if s[i] == \" \":\n if cur:\n words.append(cur)\n cur = \"\"\n while i < n and s[i] == \" \":\n i += 1\n\n else:\n cur += s[i]\n i += 1\n\n if cur:\n words.append(cur)\n \n return \" \".join(words[::-1])\n","runtime":"41"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n st=[]\n i=0\n word=''\n for i in s:\n if i!=' ':\n word+=i\n else:\n if word:\n st.append(word)\n word=''\n if word:\n st.append(word)\n res=''\n while st:\n res+=st.pop()\n if st:\n res+=' '\n return res\n\n\n","runtime":"42"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n words = []\n \n # Split the string into words\n split_words = s.split(\" \")\n \n # Filter out empty strings\n for word in split_words:\n if word:\n words.append(word)\n \n # Reverse the list of words in place\n start = 0\n end = len(words) - 1\n\n while start < end:\n words[start], words[end] = words[end], words[start]\n start += 1\n end -= 1\n\n # Join the reversed list of words into a single string with a single space between words\n reversed_string = \" \".join(words)\n \n return reversed_string","runtime":"42"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n s=s.split()\n s=\" \".join(s[::-1])\n return s\n \n ","runtime":"43"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n wordList = s.strip().split()\n\n res = \"\"\n for i in range(len(wordList) - 1, -1, -1):\n res += wordList[i]\n if i != 0:\n res += \" \"\n\n return res","runtime":"43"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n a=s.split()\n a.reverse()\n return \" \".join(a)","runtime":"44"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n n=len(s)\n words=[]\n temp=''\n for i in range(n):\n if s[i]==' ':\n if temp:\n words.append(temp)\n temp=''\n continue\n temp+=s[i]\n if temp: words.append(temp)\n w=len(words)\n ans = ''\n for i in range(w-1,-1,-1):\n ans+=words[i]\n if i: ans+=' '\n return ans","runtime":"44"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n res = []\n tempstr = \"\"\n for i in range(len(s)):\n if s[i] == \" \" and tempstr:\n res.append(tempstr)\n tempstr = \"\"\n elif s[i] != \" \":\n tempstr += s[i]\n if tempstr:\n res.append(tempstr)\n res.reverse()\n return \" \".join(res)\n ","runtime":"45"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n \n start = 0\n end = 0\n \n s.strip()\n res = []\n \n while end < len(s):\n while end < len(s) and s[end] != \" \" :\n end +=1\n \n if end == len(s) or s[end] == \" \":\n if s[start:end] == \" \" or s[start:end] == \"\":\n pass\n else:\n res.append(s[start:end])\n \n while end < len(s) and s[end] == \" \" :\n end +=1\n start = end\n \n\n res = res[::-1]\n return \" \".join(res)\n \n \n ","runtime":"45"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n k=s.split(' ')\n z=''\n while k:\n z=z+\" \"+k.pop()\n z=z.strip()\n return z\n ","runtime":"46"},{"code":"class Solution(object):\n def reverseWords(self, s):\n \"\"\"\n :type s: str\n :rtype: str\n \"\"\"\n pre = \"\"\n result = []\n for i in range(len(s) - 1, -1, -1):\n if s[i] == \" \":\n if pre != \"\":\n result.append(pre)\n pre = \"\"\n else:\n pre = s[i] + pre\n if pre != \"\":\n result.append(pre)\n return \" \".join(result)","runtime":"46"}],"string":"[\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n s = s.split()[::-1]\\n print(s)\\n s = \\\" \\\".join(s)\\n return s\",\n \"runtime\": \"12\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n s = s.strip()\\n words = s.split()\\n words.reverse()\\n return \\\" \\\".join(words)\\n\\n\\n \\n\\n\\n \",\n \"runtime\": \"14\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n a = s.split()\\n return \\\" \\\".join(a[::-1])\\n \",\n \"runtime\": \"15\"\n },\n {\n \"code\": \"import re\\nclass Solution:\\n def reverseWords(self, s: str) -> str:\\n s = re.sub(\\\"\\\\s{1,}\\\", \\\" \\\", s).strip().split(\\\" \\\")\\n return \\\" \\\".join(s[::-1])\",\n \"runtime\": \"16\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n words=s.split()\\n return ' '.join(reversed(words))\",\n \"runtime\": \"17\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n s = s.strip()\\n words = [w for w in s.split(' ') if len(w)]\\n words.reverse()\\n return ' '.join(words)\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n sentence = s.split()\\n sentence.reverse()\\n return ' '.join(sentence)\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n #words = s.split()\\n #return(\\\" \\\".join(words[-1::-1]))\\n return(\\\" \\\".join(s.split()[-1::-1]))\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n l = s.split()\\n l.reverse()\\n return \\\" \\\".join(l)\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n words = s.split()\\n reversed_words = words[::-1]\\n\\n return ' '.join(reversed_words)\\n \",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n r = s.split()\\n r.reverse()\\n return \\\" \\\".join(r)\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n si=s.split()\\n reverse=si[::-1]\\n return ' '.join(reverse)\\n \\n \\n \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n res = \\\"\\\"\\n words = s.split()\\n for i in range(len(words)-1, -1, -1):\\n res += (words[i] + \\\" \\\")\\n return res[:-1]\\n\\n\\n\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n word_list = s.split(\\\" \\\")\\n reversed_list = []\\n for i in range(len(word_list)-1,-1,-1):\\n if len(word_list[i]) > 0:\\n reversed_list.append(word_list[i])\\n return \\\" \\\".join(reversed_list)\\n\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n lst_data = s.split()\\n lst_data.reverse()\\n return \\\" \\\".join(lst_data)\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n words = s.split()\\n reversed_words = words[::-1]\\n reversed_string = ' '.join(reversed_words)\\n return reversed_string\\n\\n\\n\\n\\n # words = s.split()\\n # reversed_words = words[::-1]\\n # reversed_string = ' '.join(reversed_words)\\n # return reversed_string\\n \",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n new_arr = s.split()\\n left = 0\\n right = len(new_arr) - 1\\n while left < right:\\n temp = new_arr[left]\\n new_arr[left] = new_arr[right]\\n new_arr[right] = temp\\n left += 1\\n right -= 1\\n return ' '.join(new_arr)\\n\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n ans = \\\"\\\"\\n i = len(s)-1\\n while i>=0:\\n #print(i)\\n j = 0\\n if s[i] == \\\" \\\":\\n i-=1\\n else:\\n j = i\\n while s[i] != \\\" \\\" and i>=0:\\n i-=1\\n ans+= s[i+1:j+1]\\n ans+=\\\" \\\"\\n #print(i, s[i])\\n \\n return ans[:-1]\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n s = s.split()\\n s.reverse()\\n return \\\" \\\".join(s)\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n s_list = s.split()\\n i = 0\\n j = len(s_list)-1\\n while i<=j:\\n s_list[i], s_list[j] = s_list[j], s_list[i]\\n i += 1\\n j -= 1\\n return \\\" \\\".join(s_list)\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n s = s.split()\\n ans = \\\"\\\"\\n for _ in range(len(s) - 1):\\n ans += s.pop() + \\\" \\\"\\n ans += s.pop()\\n\\n return ans\\n\\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n arr = s.split()\\n\\n res = \\\" \\\".join(arr[::-1])\\n return res\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n word = s.split(\\\" \\\")\\n words = word[-1::-1] \\n filtered_words = filter(None, words)\\n result = ' '.join(filtered_words)\\n # filterword = filter(None,words)\\n return result\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n ss = s.split()\\n ss.reverse()\\n return \\\" \\\".join(ss)\\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n b=s.split()\\n a=b[::-1]\\n c=' '.join(a)\\n return c\\n\\n \\n\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n return ' '.join(s.strip().split()[::-1])\\n\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n l = s.split()[::-1]\\n return \\\" \\\".join(l)\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n s_spl = s.split()\\n return ' '.join(s_spl[::-1])\\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n\\n words = [w for w in s.split(\\\" \\\") if w != \\\"\\\" ]\\n reverse_words = words[::-1]\\n\\n return ' '.join(reverse_words)\\n\\n\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n s = s.strip()\\n words = s.split(' ')\\n new_s = \\\"\\\"\\n words.reverse()\\n for word in words:\\n if word != '':\\n new_s += word + ' '\\n return new_s.strip()\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n words = s.strip().split()\\n words = words[::-1]\\n return \\\" \\\".join(words).strip()\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n out = \\\"\\\"\\n words = s.split()\\n\\n words.reverse()\\n\\n out = \\\" \\\".join(words)\\n return out\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n words = s.split()\\n total = len(words)\\n for idx in range(total//2):\\n words[idx], words[total-idx-1] = words[total-idx-1], words[idx]\\n return ' '.join(words)\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n words = s.split()\\n words.reverse()\\n return ' '.join(words)\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n lst = s.split()\\n return \\\" \\\".join(lst[::-1])\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n words = s.split()\\n words.reverse()\\n\\n return ' '.join(words)\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n listWords = []\\n r = []\\n for l in s:\\n if l != ' ':\\n r.append(l)\\n else:\\n if r:\\n listWords.append(''.join(r))\\n r = []\\n if r:\\n listWords.append(''.join(r))\\n \\n return ' '.join(listWords[::-1])\\n\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n lst_data = s.split()\\n lst_data.reverse()\\n return ' '.join(lst_data)\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n s = s.split()\\n l = len(s)\\n for i in range(l//2):\\n s[i], s[l-1-i] = s[l-1-i], s[i]\\n \\n return ' '.join(s)\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n return \\\" \\\".join(reversed(s.strip().split()))\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n res = []\\n temp = \\\"\\\"\\n for c in s:\\n if c != \\\" \\\":\\n temp += c \\n elif temp != \\\"\\\":\\n res.append(temp)\\n temp = \\\"\\\"\\n if temp != \\\"\\\":\\n res.append(temp)\\n return \\\" \\\".join(res[::-1])\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n # No trailing spaces, reverse the word\\n words = []\\n word = \\\"\\\"\\n for i in s:\\n if i != ' ':\\n word += i\\n else:\\n if len(word) > 0:\\n words.append(word)\\n word = \\\"\\\"\\n \\n if len(word) > 0:\\n words.append(word)\\n \\n result = ' '.join(words[::-1])\\n \\n return result\\n \\n\\n\\n \\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n return \\\" \\\".join(reversed(s.split()))\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n\\n words = s.split()\\n wordstrip = [x.strip() for x in words]\\n return_str = ' '.join(wordstrip[::-1])\\n\\n return return_str\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n words = s.split()\\n words.reverse()\\n return \\\" \\\".join(words)\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n words = s.split(\\\" \\\")\\n words = list(filter(lambda w: w != \\\"\\\", words))\\n ans = []\\n \\n for word in words[::-1]:\\n ans.append(word)\\n return \\\" \\\".join(ans)\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n l=s.split()\\n string=\\\"\\\"\\n for i in range(len(l)-1,0,-1):\\n string+=l[i]+\\\" \\\"\\n string+=l[0]\\n return string\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n return ' '.join([ch for ch in reversed(s.split()) if ch])\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n x = s.split()\\n d=x[::-1]\\n y=\\\" \\\".join(d)\\n return y\\n\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n \\n n = len(s)\\n words = []\\n cur = \\\"\\\"\\n i = 0\\n\\n while i < n:\\n if s[i] == \\\" \\\":\\n if cur:\\n words.append(cur)\\n cur = \\\"\\\"\\n while i < n and s[i] == \\\" \\\":\\n i += 1\\n\\n else:\\n cur += s[i]\\n i += 1\\n\\n if cur:\\n words.append(cur)\\n \\n return \\\" \\\".join(words[::-1])\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n st=[]\\n i=0\\n word=''\\n for i in s:\\n if i!=' ':\\n word+=i\\n else:\\n if word:\\n st.append(word)\\n word=''\\n if word:\\n st.append(word)\\n res=''\\n while st:\\n res+=st.pop()\\n if st:\\n res+=' '\\n return res\\n\\n\\n\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n words = []\\n \\n # Split the string into words\\n split_words = s.split(\\\" \\\")\\n \\n # Filter out empty strings\\n for word in split_words:\\n if word:\\n words.append(word)\\n \\n # Reverse the list of words in place\\n start = 0\\n end = len(words) - 1\\n\\n while start < end:\\n words[start], words[end] = words[end], words[start]\\n start += 1\\n end -= 1\\n\\n # Join the reversed list of words into a single string with a single space between words\\n reversed_string = \\\" \\\".join(words)\\n \\n return reversed_string\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n s=s.split()\\n s=\\\" \\\".join(s[::-1])\\n return s\\n \\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n wordList = s.strip().split()\\n\\n res = \\\"\\\"\\n for i in range(len(wordList) - 1, -1, -1):\\n res += wordList[i]\\n if i != 0:\\n res += \\\" \\\"\\n\\n return res\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n a=s.split()\\n a.reverse()\\n return \\\" \\\".join(a)\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n n=len(s)\\n words=[]\\n temp=''\\n for i in range(n):\\n if s[i]==' ':\\n if temp:\\n words.append(temp)\\n temp=''\\n continue\\n temp+=s[i]\\n if temp: words.append(temp)\\n w=len(words)\\n ans = ''\\n for i in range(w-1,-1,-1):\\n ans+=words[i]\\n if i: ans+=' '\\n return ans\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n res = []\\n tempstr = \\\"\\\"\\n for i in range(len(s)):\\n if s[i] == \\\" \\\" and tempstr:\\n res.append(tempstr)\\n tempstr = \\\"\\\"\\n elif s[i] != \\\" \\\":\\n tempstr += s[i]\\n if tempstr:\\n res.append(tempstr)\\n res.reverse()\\n return \\\" \\\".join(res)\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n \\n start = 0\\n end = 0\\n \\n s.strip()\\n res = []\\n \\n while end < len(s):\\n while end < len(s) and s[end] != \\\" \\\" :\\n end +=1\\n \\n if end == len(s) or s[end] == \\\" \\\":\\n if s[start:end] == \\\" \\\" or s[start:end] == \\\"\\\":\\n pass\\n else:\\n res.append(s[start:end])\\n \\n while end < len(s) and s[end] == \\\" \\\" :\\n end +=1\\n start = end\\n \\n\\n res = res[::-1]\\n return \\\" \\\".join(res)\\n \\n \\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n k=s.split(' ')\\n z=''\\n while k:\\n z=z+\\\" \\\"+k.pop()\\n z=z.strip()\\n return z\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution(object):\\n def reverseWords(self, s):\\n \\\"\\\"\\\"\\n :type s: str\\n :rtype: str\\n \\\"\\\"\\\"\\n pre = \\\"\\\"\\n result = []\\n for i in range(len(s) - 1, -1, -1):\\n if s[i] == \\\" \\\":\\n if pre != \\\"\\\":\\n result.append(pre)\\n pre = \\\"\\\"\\n else:\\n pre = s[i] + pre\\n if pre != \\\"\\\":\\n result.append(pre)\\n return \\\" \\\".join(result)\",\n \"runtime\": \"46\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":60,"string":"60"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n a = s.split()\n #print(a) # This will print the list of words\n\n# Reverse the list of words\n a.reverse()\n\n# Join the reversed list of words with a single space\n r = ' '.join(a)\n return r\n \n ","memory":"15800"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n ans=[]\n temp=\"\"\n for c in s:\n if c!=\" \":\n temp+=c\n elif temp!=\"\":\n ans.append(temp)\n temp=\"\"\n if temp!=\"\":\n ans.append(temp)\n ans.reverse()\n return \" \".join(ans)\n ","memory":"15900"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n # Step 1: Trim leading and trailing spaces\n s = s.strip()\n \n # Step 2: Split into words, this also removes extra spaces\n words = s.split()\n \n # Step 3: Reverse the list of words\n words.reverse()\n \n # Step 4: Join the words with a single space\n return ' '.join(words)","memory":"16100"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n slist = s.split()\n words = reversed(slist)\n return ' '.join(words)","memory":"16200"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n return \" \".join(s.split()[::-1])","memory":"16300"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n return \" \".join(s.split()[::-1])","memory":"16400"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n return \" \".join(s.split()[::-1])","memory":"16400"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n return \" \".join(s.split()[::-1])\n ","memory":"16500"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n\n words = s.split()\n wordstrip = [x.strip() for x in words]\n return_str = ' '.join(wordstrip[::-1])\n\n return return_str\n ","memory":"16500"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n lst_of_words = s.split()\n lst_of_words = lst_of_words[ : : -1]\n return ' '.join(lst_of_words)\n\n ","memory":"16600"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n word_list = s.split()\n return ' '.join(word_list[::-1])\n","memory":"16600"},{"code":"from typing import *\nclass Solution:\n def reverseWords(self, s: str) -> str:\n stack = []\n size = len(s)\n word = ''\n for j in range(size-1,-1,-1):\n if j == 0:\n if s[j]!= \" \":\n stack.append(s[j])\n if stack:\n if word != \"\":\n word += ' '\n word += ''.join(stack[::-1])\n stack.clear()\n break \n else:\n if s[j]!= ' ':\n stack.append(s[j])\n else:\n if stack:\n if word != \"\":\n word += ' '\n word += ''.join(stack[::-1])\n stack.clear()\n return word\n","memory":"16700"},{"code":"class Solution:\n def reverseWords(self, s: str) -> str:\n return ' '.join(reversed(re.split('\\s+', s.strip())))","memory":"16700"}],"string":"[\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n a = s.split()\\n #print(a) # This will print the list of words\\n\\n# Reverse the list of words\\n a.reverse()\\n\\n# Join the reversed list of words with a single space\\n r = ' '.join(a)\\n return r\\n \\n \",\n \"memory\": \"15800\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n ans=[]\\n temp=\\\"\\\"\\n for c in s:\\n if c!=\\\" \\\":\\n temp+=c\\n elif temp!=\\\"\\\":\\n ans.append(temp)\\n temp=\\\"\\\"\\n if temp!=\\\"\\\":\\n ans.append(temp)\\n ans.reverse()\\n return \\\" \\\".join(ans)\\n \",\n \"memory\": \"15900\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n # Step 1: Trim leading and trailing spaces\\n s = s.strip()\\n \\n # Step 2: Split into words, this also removes extra spaces\\n words = s.split()\\n \\n # Step 3: Reverse the list of words\\n words.reverse()\\n \\n # Step 4: Join the words with a single space\\n return ' '.join(words)\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n slist = s.split()\\n words = reversed(slist)\\n return ' '.join(words)\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n return \\\" \\\".join(s.split()[::-1])\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n return \\\" \\\".join(s.split()[::-1])\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n return \\\" \\\".join(s.split()[::-1])\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n return \\\" \\\".join(s.split()[::-1])\\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n\\n words = s.split()\\n wordstrip = [x.strip() for x in words]\\n return_str = ' '.join(wordstrip[::-1])\\n\\n return return_str\\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n lst_of_words = s.split()\\n lst_of_words = lst_of_words[ : : -1]\\n return ' '.join(lst_of_words)\\n\\n \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n word_list = s.split()\\n return ' '.join(word_list[::-1])\\n\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"from typing import *\\nclass Solution:\\n def reverseWords(self, s: str) -> str:\\n stack = []\\n size = len(s)\\n word = ''\\n for j in range(size-1,-1,-1):\\n if j == 0:\\n if s[j]!= \\\" \\\":\\n stack.append(s[j])\\n if stack:\\n if word != \\\"\\\":\\n word += ' '\\n word += ''.join(stack[::-1])\\n stack.clear()\\n break \\n else:\\n if s[j]!= ' ':\\n stack.append(s[j])\\n else:\\n if stack:\\n if word != \\\"\\\":\\n word += ' '\\n word += ''.join(stack[::-1])\\n stack.clear()\\n return word\\n\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def reverseWords(self, s: str) -> str:\\n return ' '.join(reversed(re.split('\\\\s+', s.strip())))\",\n \"memory\": \"16700\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":13,"string":"13"}}},{"rowIdx":56,"cells":{"question_id":{"kind":"number","value":152,"string":"152"},"name":{"kind":"string","value":"maximum-product-subarray"},"content":{"kind":"string","value":"<p>Given an integer array <code>nums</code>, find a <span data-keyword=\"subarray-nonempty\">subarray</span> that has the largest product, and return <em>the product</em>.</p>\n\n<p>The test cases are generated so that the answer will fit in a <strong>32-bit</strong> integer.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [2,3,-2,4]\n<strong>Output:</strong> 6\n<strong>Explanation:</strong> [2,3] has the largest product 6.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [-2,0,-1]\n<strong>Output:</strong> 0\n<strong>Explanation:</strong> The result cannot be 2, because [-2,-1] is not a subarray.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 2 * 10<sup>4</sup></code></li>\n\t<li><code>-10 <= nums[i] <= 10</code></li>\n\t<li>The product of any subarray of <code>nums</code> is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</li>\n</ul>\n"},"acRate":{"kind":"number","value":33.91227323690214,"string":"33.912273"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","dynamic-programming"],"string":"[\n \"array\",\n \"dynamic-programming\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"37\", 0.0183], [\"39\", 0.0061], [\"41\", 0.0061], [\"42\", 0.0061], [\"43\", 0.0122], [\"44\", 0.0122], [\"45\", 0.0244], [\"46\", 0.0183], [\"47\", 0.0366], [\"48\", 0.0183], [\"49\", 0.0061], [\"50\", 0.0183], [\"51\", 0.0366], [\"52\", 0.0427], [\"53\", 0.1159], [\"54\", 0.2256], [\"55\", 0.2134], [\"56\", 0.2866], [\"57\", 0.4025], [\"58\", 0.7379], [\"59\", 0.8538], [\"60\", 0.8721], [\"61\", 1.1709], [\"62\", 1.7624], [\"63\", 2.2381], [\"64\", 2.5308], [\"65\", 2.915], [\"66\", 4.2017], [\"67\", 4.2505], [\"68\", 4.4335], [\"69\", 5.3055], [\"70\", 6.2081], [\"71\", 5.8788], [\"72\", 5.891], [\"73\", 6.0617], [\"74\", 6.3422], [\"75\", 6.0983], [\"76\", 5.0982], [\"77\", 4.5737], [\"78\", 3.9395], [\"79\", 3.2382], [\"80\", 2.7625], [\"81\", 1.8783], [\"82\", 1.4453], [\"83\", 1.1282], [\"84\", 0.9208], [\"85\", 0.7501]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16200\", 0.0061], [\"16300\", 0.0061], [\"16500\", 0.0061], [\"16600\", 0.0305], [\"16700\", 0.0854], [\"16800\", 0.7013], [\"16900\", 12.9406], [\"17000\", 56.8972], [\"17100\", 15.0811], [\"17200\", 1.2075], [\"17300\", 1.6953], [\"17400\", 0.3537], [\"17500\", 0.2195], [\"17600\", 0.1586], [\"17700\", 0.0854], [\"17800\", 0.4635], [\"17900\", 0.8416], [\"18000\", 1.4209], [\"18100\", 1.9819], [\"18200\", 0.2439]]}"},"rt_list":{"kind":"list like","value":[{"code":"def maxProduct(a: List[int]) -> int:\n b = a[::-1]\n for i in range(1, len(a)):\n a[i] *= a[i - 1] or 1\n b[i] *= b[i - 1] or 1\n return max(a + b)\nf = open('user.out', 'w')\nfor i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(maxProduct(nums), file=f)\n \nexit(0)","runtime":"37"},{"code":"class Solution:\n MAX_THRESHOLD = 1000000000\n\n def maxProduct(self, nums: List[int]) -> int:\n max_product = float('-inf')\n max_product = max(max_product, self.scanArray(nums, True))\n max_product = max(max_product, self.scanArray(nums, False))\n return int(max_product)\n\n def scanArray(self, nums: List[int], left_to_right: bool) -> int:\n current_product = 1\n max_product = float('-inf')\n \n for i in range(len(nums)):\n index = i if left_to_right else len(nums) - 1 - i\n \n if nums[index] == 0:\n max_product = max(max_product, 0)\n current_product = 1\n continue\n \n current_product *= nums[index]\n max_product = max(max_product, current_product)\n \n if max_product >= self.MAX_THRESHOLD:\n return max_product\n \n return max_product\n\nwith open(\"user.out\", \"w\") as f:\n inputs = map(loads, stdin)\n for nums in inputs:\n print(Solution().maxProduct(nums), file=f)\n\nexit(0)","runtime":"39"},{"code":"def maxProduct(nums: List[int]) -> int:\n ret = nums[0]\n ma = mi = 1\n\n for n in nums:\n temp = ma * n\n ma = max(ma * n, mi * n, n)\n mi = min(temp, mi * n, n)\n ret = max(ma, ret)\n return ret\n\nf = open('user.out', 'w')\nfor i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(maxProduct(nums), file=f)\n \nexit(0)","runtime":"41"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n n = len(nums)\n ans = float('-inf')\n pre, suff = 1, 1\n\n for i in range(n):\n if pre == 0:\n pre = 1\n if suff == 0:\n suff = 1\n pre *= nums[i]\n suff *= nums[n - i - 1]\n ans = max(ans, max(pre, suff))\n\n return int(ans)\n\nwith open(\"user.out\", \"w\") as f:\n inputs = map(loads, stdin)\n for nums in inputs:\n print(Solution().maxProduct(nums),file=f)\nexit(0)","runtime":"42"},{"code":"class Solution:\n MAX_THRESHOLD = 1000000000\n\n def maxProduct(self, nums: List[int]) -> int:\n max_product = float('-inf')\n max_product = max(max_product, self.scanArray(nums, True))\n max_product = max(max_product, self.scanArray(nums, False))\n return int(max_product)\n\n def scanArray(self, nums: List[int], left_to_right: bool) -> int:\n current_product = 1\n max_product = float('-inf')\n \n for i in range(len(nums)):\n index = i if left_to_right else len(nums) - 1 - i\n \n if nums[index] == 0:\n max_product = max(max_product, 0)\n current_product = 1\n continue\n \n current_product *= nums[index]\n max_product = max(max_product, current_product)\n \n if max_product >= self.MAX_THRESHOLD:\n return max_product\n \n return max_product\n\nwith open(\"user.out\", \"w\") as f:\n inputs = map(loads, stdin)\n for nums in inputs:\n print(Solution().maxProduct(nums), file=f)\n\nexit(0)","runtime":"43"},{"code":"class Solution:\n MAX_THRESHOLD = 1000000000\n\n def maxProduct(self, nums: List[int]) -> int:\n max_product = float('-inf')\n max_product = max(max_product, self.scanArray(nums, True))\n max_product = max(max_product, self.scanArray(nums, False))\n return int(max_product)\n\n def scanArray(self, nums: List[int], left_to_right: bool) -> int:\n current_product = 1\n max_product = float('-inf')\n \n for i in range(len(nums)):\n index = i if left_to_right else len(nums) - 1 - i\n \n if nums[index] == 0:\n max_product = max(max_product, 0)\n current_product = 1\n continue\n \n current_product *= nums[index]\n max_product = max(max_product, current_product)\n \n if max_product >= self.MAX_THRESHOLD:\n return max_product\n \n return max_product\n\nwith open(\"user.out\", \"w\") as f:\n inputs = map(loads, stdin)\n for nums in inputs:\n print(Solution().maxProduct(nums), file=f)\n\nexit(0)","runtime":"43"},{"code":"def maxProduct(a: List[int]) -> int:\n b = a[::-1]\n for i in range(1, len(a)):\n a[i] *= a[i - 1] or 1\n b[i] *= b[i - 1] or 1\n return max(a + b)\nf = open('user.out', 'w')\nfor i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(maxProduct(nums), file=f)\n \nexit(0)","runtime":"44"},{"code":"def maxProduct(a: List[int]) -> int:\n b = a[::-1]\n for i in range(1, len(a)):\n a[i] *= a[i - 1] or 1\n b[i] *= b[i - 1] or 1\n return max(a + b)\nf = open('user.out', 'w')\nfor i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(maxProduct(nums), file=f)\n \nexit(0)","runtime":"45"},{"code":"# class Solution:\ndef maxProduct(a: List[int]) -> int:\n b = a[::-1]\n for i in range(1, len(a)):\n a[i] *= a[i - 1] or 1\n b[i] *= b[i - 1] or 1\n return max(a + b)\nf = open('user.out', 'w')\nfor i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(maxProduct(nums), file=f)\n\nexit(0)","runtime":"46"},{"code":"def maxProduct(a: List[int]) -> int:\n b = a[::-1]\n for i in range(1, len(a)):\n a[i] *= a[i - 1] or 1\n b[i] *= b[i - 1] or 1\n return max(a + b)\nf = open('user.out', 'w')\nfor i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(maxProduct(nums), file=f)\n \nexit(0)","runtime":"47"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n maxResult = max(nums)\n currMax, currMin = 1, 1\n\n for num in nums:\n if num == 0:\n currMax = 1\n currMin = 1\n continue\n tmpMax = currMax * num\n currMax = max(num * currMax, num * currMin, num)\n currMin = min(num * currMin, tmpMax, num)\n maxResult = max(maxResult, currMax)\n return maxResult","runtime":"48"},{"code":"# class Solution:\ndef maxProduct(nums: List[int]) -> int:\n max_prod = -float('inf')\n\n curr_pos_prod = 1 if nums[0] < 0 else nums[0]\n curr_neg_prod = 1 if nums[0] > 0 else nums[0]\n\n max_prod = nums[0]\n\n for nr in nums[1:]:\n # print(nr, curr_neg_prod, curr_pos_prod,max_prod)\n if nr < 0:\n curr_neg_prod, curr_pos_prod = min(nr*curr_pos_prod,nr), nr*curr_neg_prod\n else:\n curr_neg_prod, curr_pos_prod = nr*curr_neg_prod, max(nr*curr_pos_prod,nr)\n \n max_prod = max(curr_pos_prod,max_prod)\n # print(nr, curr_neg_prod, curr_pos_prod,max_prod)\n # print('-------')\n # print(nr, curr_prod)\n\n return max_prod\n\nf = open('user.out', 'w')\nfor i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(maxProduct(nums), file=f)\n \nexit(0)","runtime":"49"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n \n maxCur = 1\n minCur = 1\n res = max(nums)\n for n in nums:\n if n == 0:\n maxCur = 1\n minCur = 1\n continue\n temp = n * maxCur\n maxCur = max(n * maxCur, n * minCur, n)\n minCur = min(temp, n * minCur, n)\n \n res = max(res, maxCur)\n \n return res","runtime":"50"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n \n tempList = []\n temp = None\n\n for num in nums:\n if num <= 0:\n if temp:\n tempList.append(temp)\n temp = None\n tempList.append(num)\n else:\n if not temp:\n \n temp = num\n else:\n temp *= num\n if temp:\n tempList.append(temp)\n\n nums = tempList\n\n maximum = max(tempList)\n\n start = 1\n for num in nums:\n start *= num\n maximum = max(start, maximum)\n if start == 0:\n start = 1\n\n nums = nums[::-1]\n start = 1\n for num in nums:\n start *= num\n maximum = max(start, maximum)\n if start == 0:\n start = 1\n\n return maximum","runtime":"51"},{"code":"class Solution:\n def maxProduct(self, A: List[int]) -> int:\n B = A[::-1]\n for i in range(1, len(A)):\n A[i] *= A[i - 1] or 1\n B[i] *= B[i - 1] or 1\n return max(A + B)","runtime":"52"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n pre = suf = 1\n ans = - math.inf\n \n for i in range(len(nums)):\n pre = (pre or 1) * nums[i]\n suf = (suf or 1) * nums[~i]\n\n ans = max(ans, pre, suf)\n \n return ans","runtime":"53"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n leftSum = rightSum = 1\n result = float(\"-inf\")\n n = len(nums)\n for i in range(n):\n leftSum *= nums[i]\n rightSum *= nums[n-i-1]\n result = max(result, leftSum, rightSum)\n if leftSum == 0:\n leftSum = 1\n if rightSum == 0:\n rightSum = 1\n \n return result","runtime":"54"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n if not nums:\n return 0\n \n # Initialize the max product, min product, and result with the first element\n max_product = nums[0]\n min_product = nums[0]\n result = nums[0]\n \n # Iterate through the array starting from the second element\n for num in nums[1:]:\n if num < 0:\n # Swap max and min products when encountering a negative number\n max_product, min_product = min_product, max_product\n \n # Update the max and min products\n max_product = max(num, max_product * num)\n min_product = min(num, min_product * num)\n \n # Update the result with the maximum product found so far\n result = max(result, max_product)\n \n return result","runtime":"55"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n n = len(nums) # size of array.\n\n pre, suff = 1, 1\n ans = float('-inf')\n for i in range(n):\n if pre == 0:\n pre = 1\n if suff == 0:\n suff = 1\n pre *= nums[i]\n suff *= nums[n - i - 1]\n ans = max(ans, max(pre, suff))\n return ans\n#https://www.youtube.com/watch?v=hnswaLJvr6g&ab_channel=takeUforward","runtime":"56"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n \n if not nums:\n return 0\n if len(nums) == 1:\n return nums[0]\n n = len(nums)\n curMax = -float('inf')\n for i in range(n):\n if nums[i] == 0:\n curMax = max(0, self.maxProduct(nums[:i]))\n if i != n- 1:\n curMax = max(curMax,self.maxProduct(nums[i + 1:]))\n return curMax\n negCount = 0\n #first block, last block, total\n n = len(nums)\n firstBlock = None\n lastBlock = None\n total = None\n\n for i in range(n):\n if not total:\n total = nums[i]\n firstBlock = nums[i]\n lastBlock = nums[i]\n if nums[i] < 0:\n negCount += 1\n else:\n total *= nums[i]\n if nums[i] < 0:\n negCount += 1\n if negCount == 1:\n firstBlock *= nums[i]\n lastBlock = nums[i]\n else:\n lastBlock *= nums[i]\n if negCount == 0:\n firstBlock *= nums[i]\n if total > 0:\n return max(curMax, total)\n omit_first = total//firstBlock\n omit_last = total//lastBlock\n return max(curMax, omit_first, omit_last)\n ","runtime":"56"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n def sub(nums):\n l = []\n r = [0] * len(nums)\n curr = 1\n for i in nums:\n curr *= i\n l.append(curr)\n curr = 1\n for i in range(len(nums)-1,-1,-1):\n curr *= nums[i]\n r[i] = curr\n if r[0] > 0:\n return r[0]\n return max(max(l),max(r), max(nums))\n \n s = None\n out = 0\n for i in range(len(nums)):\n if nums[i] == 0:\n if s is not None:\n out = max(out, sub(nums[s:i]))\n s = None\n continue\n if s is None:\n s = i\n if s is not None:\n out = max(out, sub(nums[s:])) \n if out==0:\n return max(nums) \n return out\n\n","runtime":"57"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n def splitOnZeros():\n res = []\n curr = []\n for num in nums:\n if num == 0:\n res.append(curr)\n res.append([0])\n curr = []\n else:\n curr.append(num)\n if len(curr) != 0:\n res.append(curr)\n return res\n\n def partial_products(lst):\n products = [1]\n for e in lst:\n products.append(products[-1] * e)\n return products\n\n def find_first_and_last_neg(lst):\n first_neg = -1\n last_neg = -1\n for idx, num in enumerate(lst):\n if num < 0:\n last_neg = idx\n if first_neg == -1:\n first_neg = idx\n return first_neg, last_neg\n\n def solveNoZeros(numsNoZ):\n if len(numsNoZ) == 0:\n return 0\n if len(numsNoZ) == 1:\n return numsNoZ[0]\n\n pp = partial_products(numsNoZ)\n p = pp[-1]\n if p > 0:\n return p\n\n first_neg, last_neg = find_first_and_last_neg(numsNoZ)\n return max(p // pp[first_neg + 1], pp[last_neg])\n return max(map(solveNoZeros, splitOnZeros()))\n\n ","runtime":"58"},{"code":"from math import inf\n\nclass Solution:\n def maxProduct(self, nums: List[int]) -> int:\n if len(nums) < 2:\n return nums[0]\n running_negative = nums[0] if nums[0] < 0 else 0\n running_positive = nums[0] if nums[0] >= 0 else 0\n max_product = nums[0]\n\n for num in nums[1:]:\n if num >= 0:\n if running_positive == 0:\n running_positive = num\n else:\n running_positive *= num\n running_negative *= num\n else:\n if running_negative == 0:\n if running_positive == 0:\n running_negative = num\n else:\n running_negative = running_positive * num\n running_positive = 0\n else:\n if running_positive == 0:\n running_positive = running_negative * num\n running_negative = num\n else:\n running_positive, running_negative = running_negative * num, running_positive * num\n max_product = max(max_product, running_negative, running_positive)\n return max_product\n\n","runtime":"58"},{"code":"class Solution:\n def maxProduct(self, nums):\n if not nums:\n return 0\n \n \n max_product = min_product = result = nums[0]\n \n for i in range(1, len(nums)):\n \n temp_max = max_product\n \n \n max_product = max(nums[i], temp_max * nums[i], min_product * nums[i])\n min_product = min(nums[i], temp_max * nums[i], min_product * nums[i])\n \n \n result = max(result, max_product)\n \n return result\n\n\n\n \n \n\n ","runtime":"59"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n n = len(nums)\n ans = -inf\n prefix, suffix = 1, 1\n for i in range(n):\n if not prefix:\n prefix = 1\n if not suffix:\n suffix = 1\n prefix = prefix * nums[i]\n suffix = suffix * nums[n-i-1]\n ans = max(ans, prefix, suffix)\n return ans\n\n \n \n","runtime":"59"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n n = len(nums)\n prefix = 1\n suffix = 1\n maxProduct = float(\"-inf\")\n for i in range(n):\n if prefix == 0:\n prefix = 1\n if suffix == 0:\n suffix = 1\n prefix *= nums[i]\n suffix *= nums[n-i-1]\n maxProduct = max(maxProduct,max(prefix,suffix))\n return maxProduct\n\n\n\n \n","runtime":"60"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res = max(nums)\n CurMin, CurMax = 1,1\n\n for n in nums:\n \n tmp = CurMax * n\n CurMax = max(tmp, n * CurMin, n)\n CurMin = min(tmp, n * CurMin, n)\n res = max(res,CurMax)\n\n return res ","runtime":"60"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n prefix,suffix=1,1\n n=len(nums)\n ans=float(\"-inf\")\n for i in range(len(nums)):\n if prefix==0:\n prefix=1\n if suffix==0:\n suffix=1\n prefix*=nums[i]\n suffix*=nums[n-i-1]\n ans=max(prefix,suffix,ans)\n return ans\n \n\n \n","runtime":"61"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n max_result = nums[0]\n\n local_product = 1\n for n in nums:\n local_product *= n\n max_result = max(max_result, local_product)\n if local_product == 0:\n local_product = 1\n local_product = 1\n for n in nums[::-1]:\n local_product *= n\n max_result = max(max_result, local_product)\n if local_product == 0:\n local_product = 1\n return max_result\n","runtime":"61"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n\n if not nums:\n return 0\n \n min_so_far, max_so_far, max_product = nums[0], nums[0], nums[0]\n\n for i in nums[1:]:\n temp_min = min(i, min_so_far * i, max_so_far * i)\n temp_max = max(i, min_so_far * i, max_so_far * i)\n\n min_so_far, max_so_far = temp_min, temp_max\n \n max_product = max(max_so_far, max_product) \n\n return max_product\n ","runtime":"62"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n\n curr_prod = nums[0]\n curr_min = nums[0]\n curr_max = nums[0]\n\n for i in range(1, len(nums)):\n if nums[i] < 0 :\n curr_max, curr_min = curr_min, curr_max\n curr_max = max(nums[i], curr_max*nums[i])\n curr_min = min(nums[i], curr_min*nums[i])\n\n curr_prod = max(curr_prod, curr_max)\n\n return curr_prod","runtime":"62"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res = max(nums)\n currMin, currMax = 1, 1\n\n for n in nums:\n if n == 0:\n currMin, currMax = 1, 1\n continue\n\n temp = n * currMax\n currMax = max(n * currMax, n * currMin, n)\n currMin = min(n * currMin, temp, n)\n res = max(res, currMax, currMin)\n \n return res","runtime":"63"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res = max(nums)\n currMax, currMin = 1, 1\n\n for n in nums:\n if n == 0:\n currMax, currMin = 1, 1\n continue\n tmp = n * currMax \n currMax = max(n * currMax, n * currMin, n)\n currMin = min(tmp, n * currMin, n)\n res = max(res, currMax)\n return res","runtime":"64"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n dpFromLeft = [0] * len(nums)\n currProd = 1\n for i in range(len(nums)):\n if nums[i] == 0:\n currProd = 1\n continue\n currProd *= nums[i]\n dpFromLeft[i] = currProd\n \n currProd = 1\n dpFromRight = [0] * len(nums)\n for i in range(len(dpFromRight) - 1, -1, -1):\n if nums[i] == 0:\n currProd = 1\n continue\n currProd *= nums[i]\n dpFromRight[i] = currProd\n return max(max(dpFromRight), max(dpFromLeft))\n","runtime":"64"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n min_val, max_val = 1, 1\n max_prod = max(nums)\n\n for num in nums:\n if num == 0:\n min_val, max_val = 1, 1\n else:\n temp_max = max_val\n max_val = max(num, num * min_val, num * max_val)\n min_val = min(num, num * min_val, num * temp_max)\n max_prod = max(max_prod, min_val, max_val)\n\n return max_prod\n \n \n \n\n\n\n\n","runtime":"65"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n # Initialize our base case, min and max checkers\n highest = nums[0]\n minN = 1\n maxN = 1\n\n # Loop through the array\n # Store the product in a temp variable\n # Adjust your max and mins\n for n in nums:\n temp = maxN * n\n maxN = max(maxN*n,minN*n,n)\n minN = min(temp,minN*n,n)\n highest = max(highest,maxN)\n return highest","runtime":"65"},{"code":"\nclass Solution:\n def maxProduct(self, nums: List[int]) -> int:\n if not nums:\n return 0\n \n # Initialize the max product, min product, and result with the first element\n max_product = nums[0]\n min_product = nums[0]\n result = nums[0]\n \n # Iterate through the array starting from the second element\n for num in nums[1:]:\n if num < 0:\n # Swap max and min products when encountering a negative number\n max_product, min_product = min_product, max_product\n \n # Update the max and min products\n max_product = max(num, max_product * num)\n min_product = min(num, min_product * num)\n \n # Update the result with the maximum product found so far\n result = max(result, max_product)\n \n return result","runtime":"66"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n \n result = nums[0]\n\n curr_max = curr_min = result\n\n for i in range(1, len(nums)):\n\n num = nums[i]\n\n # if multiply by negative, it will flip the magnitudes\n # so we prepare by pre-flipping them first so it will reverse correctly\n if num < 0:\n curr_max, curr_min = curr_min, curr_max\n \n curr_max = max(num, curr_max*num)\n curr_min = min(num, curr_min*num)\n\n result = max(result, curr_max)\n\n return result","runtime":"66"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n curMax, curMin = 1, 1\n res = nums[0]\n \n for n in nums:\n vals = (n, n * curMax, n * curMin)\n curMax, curMin = max(vals), min(vals)\n\t\t\t\n res = max(res, curMax)\n \n return res","runtime":"67"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int: \n if not nums: return 0 \n maxPro = 1\n minPro = 1\n res = -float('inf')\n for v in nums:\n tmp1, tmp2 = minPro, maxPro\n maxPro = max(tmp1 * v, tmp2 * v, v)\n minPro = min(tmp1 * v, tmp2 * v, v)\n res = max(res, maxPro)\n\n return res","runtime":"67"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n n = len(nums)\n min_val, max_val = 1, 1\n max_prod = max(nums)\n\n for num in nums:\n if num == 0:\n min_val, max_val = 1, 1\n else:\n temp_max = max_val\n max_val = max(num, num * min_val, num * max_val)\n min_val = min(num, num * min_val, num * temp_max)\n max_prod = max(max_prod, min_val, max_val)\n\n return max_prod\n \n \n \n\n\n\n\n","runtime":"68"},{"code":"from typing import List\n\n\nclass Solution:\n def maxProduct(self, nums: List[int]) -> int:\n \"\"\"\n 152. Maximum Product Subarray\n\n Given an integer array nums, find a subarray\n that has the largest product, and return the product.\n\n The test cases are generated so that the answer will\n fit in a 32-bit integer.\n\n Example 1:\n Input: nums = [2,3,-2,4]\n Output: 6\n Explanation: [2,3] has the largest product 6.\n\n Example 2:\n Input: nums = [-2,0,-1]\n Output: 0\n Explanation: The result cannot be 2, because [-2,-1] is not a subarray.\n \"\"\"\n max_prod = 1\n min_prod = 1\n best_prod = float('-inf')\n for value in nums:\n temp_max_prod = max_prod\n max_prod = max(value, max_prod * value, min_prod * value)\n min_prod = min(value, temp_max_prod * value, min_prod * value)\n best_prod = max(best_prod, max_prod)\n return best_prod\n","runtime":"68"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n minN, maxN = nums[0], nums[0]\n res = nums[0]\n n = len(nums)\n for i in range(1, n):\n if nums[i] < 0:\n minN, maxN = maxN, minN\n minN = min(nums[i], minN * nums[i])\n maxN = max(nums[i], maxN * nums[i])\n res = max(res, minN, maxN)\n return res","runtime":"69"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res=max(nums)\n\n cur_max=1\n cur_min=1\n for n in nums:\n\n t=n*cur_max\n cur_max=max(t,n*cur_min,n)\n cur_min=min(t,n*cur_min,n)\n\n res=max(cur_max,res)\n\n return res\n ","runtime":"69"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n max_p = max(nums)\n curr_min, curr_max = 1, 1\n\n for n in nums:\n if n == 0:\n curr_min, curr_max = 1, 1\n continue\n \n tmp = curr_max\n curr_max = max(n, curr_max * n, curr_min * n)\n curr_min = min(n, tmp * n, curr_min * n)\n max_p = max(max_p, curr_max)\n return max_p","runtime":"70"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n max_prod = float('-inf')\n prefix, suffix = 1, 1\n n = len(nums)\n\n for i in range(n):\n if prefix == 0: prefix = 1\n if suffix == 0: suffix = 1\n\n prefix *= nums[i]\n suffix *= nums[n - i - 1]\n max_prod = max(max_prod, prefix, suffix)\n \n return max_prod","runtime":"70"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n pre=1\n suf=1\n maxi=float('-inf')\n for i in range(len(nums)):\n if(pre==0):\n pre=1\n if(suf==0):\n suf=1\n pre=pre*nums[i]\n suf=suf*nums[len(nums)-i-1]\n maxi=max(maxi,max(pre,suf))\n return maxi","runtime":"71"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n n=len(nums)\n maxi=float('-inf')\n prefix=1\n suffix=1\n for i in range(n):\n if prefix==0:\n prefix=1\n if suffix==0:\n suffix=1\n prefix=prefix*nums[i]\n suffix=suffix*nums[n-i-1]\n maxi=max(maxi,max(prefix,suffix))\n return maxi \n \n ","runtime":"71"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n max_prod = max(nums)\n curr_max, curr_min = 1, 1\n for n in nums:\n if n == 0:\n curr_max, curr_min = 1, 1\n continue\n \n temp = curr_max * n\n curr_max = max(curr_max * n, curr_min * n, n)\n curr_min = min(temp, curr_min * n, n)\n\n max_prod = max(max_prod, curr_max, curr_min)\n return max_prod","runtime":"72"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n\n ans = -1e9\n pos, neg = 1,1\n for i in range(len(nums)):\n if nums[i]<0: neg, pos = pos, neg\n neg = min(neg*nums[i],nums[i])\n pos = max(pos*nums[i],nums[i])\n ans = max(pos,neg,ans)\n \n return ans\n\n ","runtime":"72"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n running_res = max_prod = min_prod = nums[0]\n\n for ith in range(1, len(nums)):\n temp_max_prod = max(nums[ith], max_prod*nums[ith],min_prod*nums[ith])\n min_prod = min(nums[ith], max_prod*nums[ith],min_prod*nums[ith])\n #reset it:\n max_prod = temp_max_prod\n #compare\n running_res = max(running_res, max_prod)\n\n return running_res\n ","runtime":"73"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n if len(nums) == 0:\n return 0\n min_so_far, max_so_far = nums[0], nums[0]\n result = max_so_far\n\n for curr in nums[1:]:\n temp_max_so_far = max(\n curr,\n max_so_far*curr,\n min_so_far*curr\n )\n\n min_so_far = min(\n curr,\n max_so_far*curr,\n min_so_far*curr\n )\n \n max_so_far = temp_max_so_far\n result = max(max_so_far, result)\n return result","runtime":"73"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n max_prod = float('-inf')\n prefix, suffix = 1, 1\n n = len(nums)\n for i in range(n):\n if prefix == 0: prefix = 1\n if suffix == 0: suffix = 1\n\n prefix *= nums[i]\n suffix *= nums[n - i - 1]\n max_prod = max(max_prod, prefix, suffix) # update max_prod only when either\n # prefix or suffix is greater\n # else max_prod is kept as it is\n return max_prod","runtime":"74"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res=max(nums)\n currmin=1\n currmax=1\n for i in nums:\n prevmax=currmax*i\n currmax=max(prevmax,currmin*i,i)\n currmin=min(prevmax,currmin*i,i)\n res=max(currmax,res)\n return(res)","runtime":"74"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n mx=[0]*len(nums)\n mn=[0]*len(nums)\n mx[0]=mn[0]=nums[0]\n max_product=nums[0]\n for i in range(1,len(nums)):\n if nums[i]>0:\n mx[i]=max(nums[i],nums[i]*mx[i-1])\n mn[i]=min(nums[i],nums[i]*mn[i-1])\n else:\n mx[i]=max(nums[i],nums[i]*mn[i-1])\n mn[i]=min(nums[i],nums[i]*mx[i-1])\n max_product=max(max_product,mx[i])\n return(max_product)","runtime":"75"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n maxprod = nums[0] # Initialize max product with the first element\n minprod = nums[0] # Initialize min product with the first element\n result = nums[0] # The result will hold the final maximum product\n \n for i in range(1, len(nums)):\n if nums[i] < 0:\n # Swap maxprod and minprod if the current number is negative\n maxprod, minprod = minprod, maxprod\n \n maxprod = max(nums[i], maxprod * nums[i])\n minprod = min(nums[i], minprod * nums[i])\n \n result = max(result, maxprod)\n \n return result\n","runtime":"75"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n\n prefix_prod = 1\n suffix_prod = 1\n\n ans = float(\"-inf\")\n\n for i in range(len(nums)):\n\n if prefix_prod == 0:\n prefix_prod = 1\n \n if suffix_prod == 0:\n suffix_prod = 1\n \n prefix_prod *= nums[i]\n\n suffix_prod *= nums[len(nums) - 1 - i]\n \n\n ans = max(ans, max(prefix_prod, suffix_prod))\n \n return ans","runtime":"76"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n \n result = nums[0]\n\n curr_max = curr_min = result\n\n for i in range(1, len(nums)):\n\n num = nums[i]\n\n # if multiply by negative, it will flip the magnitudes\n # so we prepare by pre-flipping them first so it will reverse correctly\n if num < 0:\n curr_max, curr_min = curr_min, curr_max\n # below we do the multiplication, but note that any negative results can get written off in curr_max if it is positive via max()\n curr_max = max(num, curr_max*num)\n curr_min = min(num, curr_min*num)\n\n result = max(result, curr_max)\n\n return result","runtime":"76"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res = max(nums)\n currMax, currMin = 1, 1\n\n for n in nums:\n if n == 0:\n currMax, currMin = 1, 1\n continue\n tmp = n * currMax \n currMax = max(n * currMax, n * currMin, n)\n currMin = min(tmp, n * currMin, n)\n res = max(res, currMax)\n return res","runtime":"77"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n\n prefix_prod = 1\n suffix_prod = 1\n\n ans = float(\"-inf\")\n\n for i in range(len(nums)):\n\n if prefix_prod == 0:\n prefix_prod = 1\n \n if suffix_prod == 0:\n suffix_prod = 1\n \n prefix_prod *= nums[i]\n\n suffix_prod *= nums[len(nums) - 1 - i]\n \n\n ans = max(ans, max(prefix_prod, suffix_prod))\n \n return ans","runtime":"77"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n running_res = max_prod = min_prod = nums[0]\n\n for ith in range(1, len(nums)):\n #if the current number is negative, the max time a neg will be the new min\n #and the smallest times the negative will be less negative and thus bigger\n if nums[ith] < 0:\n #we switch max and min\n max_prod, min_prod = min_prod, max_prod\n #assign the new max and new mins\n max_prod = max(nums[ith], max_prod*nums[ith])\n min_prod = min(nums[ith], min_prod*nums[ith])\n\n #and the running_res will be the max of the prev operation \n #which is between the max of the current op \n #which can be either the true max or the least negative if we did the switch\n #and the running result\n running_res = max(running_res, max_prod)\n\n return running_res\n ","runtime":"78"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n minProd = maxProd = result = nums[0]\n\n for i in range(1, len(nums)):\n num = nums[i]\n\n #if negative number swap min/max prod\n if(num < 0):\n minProd, maxProd = maxProd, minProd\n \n #update the min/max\n maxProd = max(num, maxProd * num)\n minProd = min(num, minProd * num)\n\n #update the result with current max\n result = max(result, maxProd)\n\n #print(\"num\", num, \"maxProd\", maxProd, \"minProd\", minProd, \"re\", result)\n\n return result","runtime":"78"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n min_so_far = nums[0]\n max_so_far = nums[0]\n \n maxVal = nums[0]\n\n for i in range(1, len(nums)):\n min_prev = nums[i] * min_so_far\n max_prev = nums[i] * max_so_far\n\n min_so_far = min(min(min_prev, max_prev), nums[i])\n max_so_far = max(max(min_prev, max_prev), nums[i])\n\n maxVal = max(max_so_far, maxVal)\n \n return maxVal\n","runtime":"79"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res = nums[0] # first item\n curMin, curMax = 1, 1 # maintain min and max prod\n\n for n in nums:\n\n tmp = curMax * n # currMax * curr\n curMax = max(n * curMax, n * curMin, n)\n curMin = min(tmp, n * curMin, n)\n res = max(res, curMax)\n return res","runtime":"79"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n mindp = [0] * (len(nums))\n maxdp = [0] * (len(nums))\n \n \n mindp[0] = maxdp[0] = largest = nums[0]\n\n for i in range(1, len(nums)):\n \n mindp[i] = min(nums[i], nums[i]*maxdp[i-1], nums[i]*mindp[i-1])\n maxdp[i] = max(nums[i], nums[i]*mindp[i-1], nums[i]*maxdp[i-1])\n largest = max(largest, maxdp[i])\n \n return largest","runtime":"80"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n # Step 1: Initialize the first element as the starting point for max and min products\n current_max = nums[0]\n current_min = nums[0]\n max_so_far = nums[0]\n \n # Step 2: Iterate through the array starting from the second element\n for i in range(1, len(nums)):\n num = nums[i]\n \n # If the current number is negative, swap the current_max and current_min\n if num < 0:\n current_max, current_min = current_min, current_max\n \n # Step 3: Update current_max and current_min\n current_max = max(num, current_max * num)\n current_min = min(num, current_min * num)\n \n # Step 4: Update max_so_far with the largest product found so far\n max_so_far = max(max_so_far, current_max)\n \n return max_so_far\n","runtime":"80"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n dp = []\n\n dp.append((nums[0], nums[0]))\n \n maxVal = nums[0]\n\n for i in range(1, len(nums)):\n min_prev = nums[i] * dp[i-1][0]\n max_prev = nums[i] * dp[i-1][1]\n\n minimum = min(min(min_prev, max_prev), nums[i])\n maximum = max(max(min_prev, max_prev), nums[i])\n\n dp.append((minimum, maximum))\n\n maxVal = max(maximum, maxVal)\n \n return maxVal\n","runtime":"81"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n dp = [(float('-inf'),float('inf'))] * len(nums)\n dp[0] = (nums[0],nums[0])\n prod = nums[0]\n for i in range(1,len(nums)):\n if nums[i] == 0:\n dp[i] = (0,0)\n elif nums[i] < 0:\n dp[i] = (max(dp[i-1][1]*nums[i],nums[i]),min(dp[i-1][0]*nums[i],nums[i]))\n else:\n dp[i] = (max(dp[i-1][0]*nums[i],nums[i]),min(dp[i-1][1]*nums[i],nums[i]))\n prod = max(prod,dp[i][0])\n return prod","runtime":"81"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [[0, 0] for i in range(n)]\n # print(dp)\n prev_max = nums[0]\n prev_min = nums[0]\n\n # dp[0][0] = nums[0]\n # dp[0][1] = nums[0]\n if n == 1:\n return nums[0]\n \n # dp[1][0] = max(nums[0]*nums[1], nums[1])\n # dp[1][1] = min(nums[0]*nums[1], nums[1])\n\n # print(\"Dp here:\", dp)\n maxi = nums[0]\n mini = nums[0]\n for i in range(1, n):\n p1 = prev_max * nums[i]\n p2 = prev_min * nums[i]\n p3 = nums[i]\n\n prev_max = max(p1, p2, p3)\n prev_min = min(p1, p2, p3)\n maxi = max(maxi, prev_max)\n\n\n # p1 = dp[i-1][0] * nums[i]\n # p2 = nums[i]\n # p3 = dp[i-1][1] * nums[i]\n\n # dp[i][0] = max(p1, p2, p3)\n # dp[i][1] = min(p1, p2, p3)\n \n # maxi = dp[0][0]\n # print(dp)\n # for i in dp:\n # maxi = max(maxi, i[0], i[1])\n return maxi\n\n # return maxi","runtime":"82"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n cur_max = cur_min = 1 # 1 is the identity value in product\n glo_max = max(nums)\n\n for n in nums:\n if n == 0:\n cur_max = cur_min = 0\n else:\n tmp = cur_max # lol I forgot to use tmp to save cur_max\n cur_max = max(n, cur_max * n, cur_min * n)\n cur_min = min(n, tmp * n, cur_min * n)\n\n glo_max = max(cur_max, glo_max)\n\n return glo_max","runtime":"82"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n min_product = [nums[0]]\n max_product = [nums[0]]\n\n for i in range(1, len(nums)):\n min_product.append(min(nums[i], nums[i] * min_product[i-1], nums[i] * max_product[i-1]))\n max_product.append(max(nums[i], nums[i] * min_product[i-1], nums[i] * max_product[i-1]))\n \n return max(max_product)\n\n\n ","runtime":"83"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n \"\"\"\n Given an integer array\n Find maximum product of any given\n sub array\n\n We won't have integer overflows\n\n Has to be continuous elements\n one to 2* 10^4 elements\n\n negatives as well and 0s as well\n # maxProduct = 10\n # chose to multiply with previous products\n # or just consider this element as a start of a new sub array\n # 0 10 2. 8\n #-5 -2 -10. -40\n [-5, -2, -1, 4]]\n\n [-10, 2, 5, -11, 0, 2, 1, 0]\n\n [-5, -2, -1, 4]\n\n \"\"\"\n\n \n currentMax = nums[0]\n currentMin = nums[0]\n\n maxProduct = max(currentMax, currentMin)\n\n for num in nums[1:]:\n options = [num, num * currentMax, num * currentMin]\n\n currentMax = max(options)\n\n maxProduct = max(currentMax, maxProduct)\n\n currentMin = min(options)\n\n return maxProduct\n","runtime":"83"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n curmax = 1\n curmin = 1\n\n res = nums[0]\n for num in nums:\n values = [num, num*curmin,num*curmax]\n curmax, curmin = max(values), min(values)\n\n res = max(res, curmax )\n\n\n return res\n","runtime":"84"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n \"\"\"\n two arrays\n time: O(n)\n space: O(n)\n \"\"\"\n # Initialize the variables\n max_product = min_product = result = nums[0]\n \n # Traverse the array starting from the second element\n for i in range(1, len(nums)):\n # If the current number is negative, swap the max and min product\n if nums[i] < 0:\n max_product, min_product = min_product, max_product\n \n # Update max and min product\n max_product = max(nums[i], max_product * nums[i])\n min_product = min(nums[i], min_product * nums[i])\n \n # Update the result with the maximum product found so far\n result = max(result, max_product)\n \n return result","runtime":"84"},{"code":"class Solution:\n def maxProduct(self, nums):\n if len(nums) == 0:\n return 0\n\n max_so_far = nums[0]\n min_so_far = nums[0]\n result = max_so_far\n\n for i in range(1, len(nums)):\n curr = nums[i]\n temp_max = max(curr, max(max_so_far * curr, min_so_far * curr))\n min_so_far = min(curr, min(max_so_far * curr, min_so_far * curr))\n\n # Update max_so_far after updates to min_so_far to avoid overwriting it\n max_so_far = temp_max\n # Update the result with the maximum product found so far\n result = max(max_so_far, result)\n\n return result","runtime":"85"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n pmax = -11\n pcurr = 0\n pfirstneg = None\n pcurrneg = None\n negparity = 0\n count = 0\n\n for i in range(len(nums)):\n if nums[i] == 0:\n if negparity%2 ==1 and count == 1:\n pmax = max(0,pmax)\n elif negparity%2 == 1:\n pmax = max(pmax,pcurr/pfirstneg,pcurr/pcurrneg)\n else:\n pmax = max(pcurr,pmax)\n pfirstneg = None\n plastneg = None \n pcurr = 0\n negparity = 0\n count = 0\n print(pmax)\n continue\n\n if pcurr == 0:\n pcurr = nums[i]\n else:\n pcurr *= nums[i]\n \n if nums[i] < 0 and pfirstneg == None:\n pfirstneg = pcurr\n\n if nums[i] < 0:\n negparity += 1\n pcurrneg = nums[i]\n elif pcurrneg != None:\n pcurrneg *= nums[i]\n \n count += 1\n \n if i == len(nums)-1:\n if negparity%2 == 1 and count == 1:\n pmax = max(pmax,pcurr)\n elif negparity%2 == 1:\n pmax = max(pmax,pcurr/pfirstneg,pcurr/pcurrneg)\n else:\n pmax = max(pmax,pcurr)\n print(pmax)\n return int(pmax)","runtime":"85"}],"string":"[\n {\n \"code\": \"def maxProduct(a: List[int]) -> int:\\n b = a[::-1]\\n for i in range(1, len(a)):\\n a[i] *= a[i - 1] or 1\\n b[i] *= b[i - 1] or 1\\n return max(a + b)\\nf = open('user.out', 'w')\\nfor i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(maxProduct(nums), file=f)\\n \\nexit(0)\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n MAX_THRESHOLD = 1000000000\\n\\n def maxProduct(self, nums: List[int]) -> int:\\n max_product = float('-inf')\\n max_product = max(max_product, self.scanArray(nums, True))\\n max_product = max(max_product, self.scanArray(nums, False))\\n return int(max_product)\\n\\n def scanArray(self, nums: List[int], left_to_right: bool) -> int:\\n current_product = 1\\n max_product = float('-inf')\\n \\n for i in range(len(nums)):\\n index = i if left_to_right else len(nums) - 1 - i\\n \\n if nums[index] == 0:\\n max_product = max(max_product, 0)\\n current_product = 1\\n continue\\n \\n current_product *= nums[index]\\n max_product = max(max_product, current_product)\\n \\n if max_product >= self.MAX_THRESHOLD:\\n return max_product\\n \\n return max_product\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n inputs = map(loads, stdin)\\n for nums in inputs:\\n print(Solution().maxProduct(nums), file=f)\\n\\nexit(0)\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"def maxProduct(nums: List[int]) -> int:\\n ret = nums[0]\\n ma = mi = 1\\n\\n for n in nums:\\n temp = ma * n\\n ma = max(ma * n, mi * n, n)\\n mi = min(temp, mi * n, n)\\n ret = max(ma, ret)\\n return ret\\n\\nf = open('user.out', 'w')\\nfor i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(maxProduct(nums), file=f)\\n \\nexit(0)\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = float('-inf')\\n pre, suff = 1, 1\\n\\n for i in range(n):\\n if pre == 0:\\n pre = 1\\n if suff == 0:\\n suff = 1\\n pre *= nums[i]\\n suff *= nums[n - i - 1]\\n ans = max(ans, max(pre, suff))\\n\\n return int(ans)\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n inputs = map(loads, stdin)\\n for nums in inputs:\\n print(Solution().maxProduct(nums),file=f)\\nexit(0)\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n MAX_THRESHOLD = 1000000000\\n\\n def maxProduct(self, nums: List[int]) -> int:\\n max_product = float('-inf')\\n max_product = max(max_product, self.scanArray(nums, True))\\n max_product = max(max_product, self.scanArray(nums, False))\\n return int(max_product)\\n\\n def scanArray(self, nums: List[int], left_to_right: bool) -> int:\\n current_product = 1\\n max_product = float('-inf')\\n \\n for i in range(len(nums)):\\n index = i if left_to_right else len(nums) - 1 - i\\n \\n if nums[index] == 0:\\n max_product = max(max_product, 0)\\n current_product = 1\\n continue\\n \\n current_product *= nums[index]\\n max_product = max(max_product, current_product)\\n \\n if max_product >= self.MAX_THRESHOLD:\\n return max_product\\n \\n return max_product\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n inputs = map(loads, stdin)\\n for nums in inputs:\\n print(Solution().maxProduct(nums), file=f)\\n\\nexit(0)\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n MAX_THRESHOLD = 1000000000\\n\\n def maxProduct(self, nums: List[int]) -> int:\\n max_product = float('-inf')\\n max_product = max(max_product, self.scanArray(nums, True))\\n max_product = max(max_product, self.scanArray(nums, False))\\n return int(max_product)\\n\\n def scanArray(self, nums: List[int], left_to_right: bool) -> int:\\n current_product = 1\\n max_product = float('-inf')\\n \\n for i in range(len(nums)):\\n index = i if left_to_right else len(nums) - 1 - i\\n \\n if nums[index] == 0:\\n max_product = max(max_product, 0)\\n current_product = 1\\n continue\\n \\n current_product *= nums[index]\\n max_product = max(max_product, current_product)\\n \\n if max_product >= self.MAX_THRESHOLD:\\n return max_product\\n \\n return max_product\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n inputs = map(loads, stdin)\\n for nums in inputs:\\n print(Solution().maxProduct(nums), file=f)\\n\\nexit(0)\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"def maxProduct(a: List[int]) -> int:\\n b = a[::-1]\\n for i in range(1, len(a)):\\n a[i] *= a[i - 1] or 1\\n b[i] *= b[i - 1] or 1\\n return max(a + b)\\nf = open('user.out', 'w')\\nfor i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(maxProduct(nums), file=f)\\n \\nexit(0)\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"def maxProduct(a: List[int]) -> int:\\n b = a[::-1]\\n for i in range(1, len(a)):\\n a[i] *= a[i - 1] or 1\\n b[i] *= b[i - 1] or 1\\n return max(a + b)\\nf = open('user.out', 'w')\\nfor i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(maxProduct(nums), file=f)\\n \\nexit(0)\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# class Solution:\\ndef maxProduct(a: List[int]) -> int:\\n b = a[::-1]\\n for i in range(1, len(a)):\\n a[i] *= a[i - 1] or 1\\n b[i] *= b[i - 1] or 1\\n return max(a + b)\\nf = open('user.out', 'w')\\nfor i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(maxProduct(nums), file=f)\\n\\nexit(0)\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"def maxProduct(a: List[int]) -> int:\\n b = a[::-1]\\n for i in range(1, len(a)):\\n a[i] *= a[i - 1] or 1\\n b[i] *= b[i - 1] or 1\\n return max(a + b)\\nf = open('user.out', 'w')\\nfor i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(maxProduct(nums), file=f)\\n \\nexit(0)\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n maxResult = max(nums)\\n currMax, currMin = 1, 1\\n\\n for num in nums:\\n if num == 0:\\n currMax = 1\\n currMin = 1\\n continue\\n tmpMax = currMax * num\\n currMax = max(num * currMax, num * currMin, num)\\n currMin = min(num * currMin, tmpMax, num)\\n maxResult = max(maxResult, currMax)\\n return maxResult\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"# class Solution:\\ndef maxProduct(nums: List[int]) -> int:\\n max_prod = -float('inf')\\n\\n curr_pos_prod = 1 if nums[0] < 0 else nums[0]\\n curr_neg_prod = 1 if nums[0] > 0 else nums[0]\\n\\n max_prod = nums[0]\\n\\n for nr in nums[1:]:\\n # print(nr, curr_neg_prod, curr_pos_prod,max_prod)\\n if nr < 0:\\n curr_neg_prod, curr_pos_prod = min(nr*curr_pos_prod,nr), nr*curr_neg_prod\\n else:\\n curr_neg_prod, curr_pos_prod = nr*curr_neg_prod, max(nr*curr_pos_prod,nr)\\n \\n max_prod = max(curr_pos_prod,max_prod)\\n # print(nr, curr_neg_prod, curr_pos_prod,max_prod)\\n # print('-------')\\n # print(nr, curr_prod)\\n\\n return max_prod\\n\\nf = open('user.out', 'w')\\nfor i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(maxProduct(nums), file=f)\\n \\nexit(0)\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n \\n maxCur = 1\\n minCur = 1\\n res = max(nums)\\n for n in nums:\\n if n == 0:\\n maxCur = 1\\n minCur = 1\\n continue\\n temp = n * maxCur\\n maxCur = max(n * maxCur, n * minCur, n)\\n minCur = min(temp, n * minCur, n)\\n \\n res = max(res, maxCur)\\n \\n return res\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n \\n tempList = []\\n temp = None\\n\\n for num in nums:\\n if num <= 0:\\n if temp:\\n tempList.append(temp)\\n temp = None\\n tempList.append(num)\\n else:\\n if not temp:\\n \\n temp = num\\n else:\\n temp *= num\\n if temp:\\n tempList.append(temp)\\n\\n nums = tempList\\n\\n maximum = max(tempList)\\n\\n start = 1\\n for num in nums:\\n start *= num\\n maximum = max(start, maximum)\\n if start == 0:\\n start = 1\\n\\n nums = nums[::-1]\\n start = 1\\n for num in nums:\\n start *= num\\n maximum = max(start, maximum)\\n if start == 0:\\n start = 1\\n\\n return maximum\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, A: List[int]) -> int:\\n B = A[::-1]\\n for i in range(1, len(A)):\\n A[i] *= A[i - 1] or 1\\n B[i] *= B[i - 1] or 1\\n return max(A + B)\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n pre = suf = 1\\n ans = - math.inf\\n \\n for i in range(len(nums)):\\n pre = (pre or 1) * nums[i]\\n suf = (suf or 1) * nums[~i]\\n\\n ans = max(ans, pre, suf)\\n \\n return ans\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n leftSum = rightSum = 1\\n result = float(\\\"-inf\\\")\\n n = len(nums)\\n for i in range(n):\\n leftSum *= nums[i]\\n rightSum *= nums[n-i-1]\\n result = max(result, leftSum, rightSum)\\n if leftSum == 0:\\n leftSum = 1\\n if rightSum == 0:\\n rightSum = 1\\n \\n return result\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n if not nums:\\n return 0\\n \\n # Initialize the max product, min product, and result with the first element\\n max_product = nums[0]\\n min_product = nums[0]\\n result = nums[0]\\n \\n # Iterate through the array starting from the second element\\n for num in nums[1:]:\\n if num < 0:\\n # Swap max and min products when encountering a negative number\\n max_product, min_product = min_product, max_product\\n \\n # Update the max and min products\\n max_product = max(num, max_product * num)\\n min_product = min(num, min_product * num)\\n \\n # Update the result with the maximum product found so far\\n result = max(result, max_product)\\n \\n return result\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n n = len(nums) # size of array.\\n\\n pre, suff = 1, 1\\n ans = float('-inf')\\n for i in range(n):\\n if pre == 0:\\n pre = 1\\n if suff == 0:\\n suff = 1\\n pre *= nums[i]\\n suff *= nums[n - i - 1]\\n ans = max(ans, max(pre, suff))\\n return ans\\n#https://www.youtube.com/watch?v=hnswaLJvr6g&ab_channel=takeUforward\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n \\n if not nums:\\n return 0\\n if len(nums) == 1:\\n return nums[0]\\n n = len(nums)\\n curMax = -float('inf')\\n for i in range(n):\\n if nums[i] == 0:\\n curMax = max(0, self.maxProduct(nums[:i]))\\n if i != n- 1:\\n curMax = max(curMax,self.maxProduct(nums[i + 1:]))\\n return curMax\\n negCount = 0\\n #first block, last block, total\\n n = len(nums)\\n firstBlock = None\\n lastBlock = None\\n total = None\\n\\n for i in range(n):\\n if not total:\\n total = nums[i]\\n firstBlock = nums[i]\\n lastBlock = nums[i]\\n if nums[i] < 0:\\n negCount += 1\\n else:\\n total *= nums[i]\\n if nums[i] < 0:\\n negCount += 1\\n if negCount == 1:\\n firstBlock *= nums[i]\\n lastBlock = nums[i]\\n else:\\n lastBlock *= nums[i]\\n if negCount == 0:\\n firstBlock *= nums[i]\\n if total > 0:\\n return max(curMax, total)\\n omit_first = total//firstBlock\\n omit_last = total//lastBlock\\n return max(curMax, omit_first, omit_last)\\n \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n def sub(nums):\\n l = []\\n r = [0] * len(nums)\\n curr = 1\\n for i in nums:\\n curr *= i\\n l.append(curr)\\n curr = 1\\n for i in range(len(nums)-1,-1,-1):\\n curr *= nums[i]\\n r[i] = curr\\n if r[0] > 0:\\n return r[0]\\n return max(max(l),max(r), max(nums))\\n \\n s = None\\n out = 0\\n for i in range(len(nums)):\\n if nums[i] == 0:\\n if s is not None:\\n out = max(out, sub(nums[s:i]))\\n s = None\\n continue\\n if s is None:\\n s = i\\n if s is not None:\\n out = max(out, sub(nums[s:])) \\n if out==0:\\n return max(nums) \\n return out\\n\\n\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n def splitOnZeros():\\n res = []\\n curr = []\\n for num in nums:\\n if num == 0:\\n res.append(curr)\\n res.append([0])\\n curr = []\\n else:\\n curr.append(num)\\n if len(curr) != 0:\\n res.append(curr)\\n return res\\n\\n def partial_products(lst):\\n products = [1]\\n for e in lst:\\n products.append(products[-1] * e)\\n return products\\n\\n def find_first_and_last_neg(lst):\\n first_neg = -1\\n last_neg = -1\\n for idx, num in enumerate(lst):\\n if num < 0:\\n last_neg = idx\\n if first_neg == -1:\\n first_neg = idx\\n return first_neg, last_neg\\n\\n def solveNoZeros(numsNoZ):\\n if len(numsNoZ) == 0:\\n return 0\\n if len(numsNoZ) == 1:\\n return numsNoZ[0]\\n\\n pp = partial_products(numsNoZ)\\n p = pp[-1]\\n if p > 0:\\n return p\\n\\n first_neg, last_neg = find_first_and_last_neg(numsNoZ)\\n return max(p // pp[first_neg + 1], pp[last_neg])\\n return max(map(solveNoZeros, splitOnZeros()))\\n\\n \",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"from math import inf\\n\\nclass Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n if len(nums) < 2:\\n return nums[0]\\n running_negative = nums[0] if nums[0] < 0 else 0\\n running_positive = nums[0] if nums[0] >= 0 else 0\\n max_product = nums[0]\\n\\n for num in nums[1:]:\\n if num >= 0:\\n if running_positive == 0:\\n running_positive = num\\n else:\\n running_positive *= num\\n running_negative *= num\\n else:\\n if running_negative == 0:\\n if running_positive == 0:\\n running_negative = num\\n else:\\n running_negative = running_positive * num\\n running_positive = 0\\n else:\\n if running_positive == 0:\\n running_positive = running_negative * num\\n running_negative = num\\n else:\\n running_positive, running_negative = running_negative * num, running_positive * num\\n max_product = max(max_product, running_negative, running_positive)\\n return max_product\\n\\n\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums):\\n if not nums:\\n return 0\\n \\n \\n max_product = min_product = result = nums[0]\\n \\n for i in range(1, len(nums)):\\n \\n temp_max = max_product\\n \\n \\n max_product = max(nums[i], temp_max * nums[i], min_product * nums[i])\\n min_product = min(nums[i], temp_max * nums[i], min_product * nums[i])\\n \\n \\n result = max(result, max_product)\\n \\n return result\\n\\n\\n\\n \\n \\n\\n \",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = -inf\\n prefix, suffix = 1, 1\\n for i in range(n):\\n if not prefix:\\n prefix = 1\\n if not suffix:\\n suffix = 1\\n prefix = prefix * nums[i]\\n suffix = suffix * nums[n-i-1]\\n ans = max(ans, prefix, suffix)\\n return ans\\n\\n \\n \\n\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n n = len(nums)\\n prefix = 1\\n suffix = 1\\n maxProduct = float(\\\"-inf\\\")\\n for i in range(n):\\n if prefix == 0:\\n prefix = 1\\n if suffix == 0:\\n suffix = 1\\n prefix *= nums[i]\\n suffix *= nums[n-i-1]\\n maxProduct = max(maxProduct,max(prefix,suffix))\\n return maxProduct\\n\\n\\n\\n \\n\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res = max(nums)\\n CurMin, CurMax = 1,1\\n\\n for n in nums:\\n \\n tmp = CurMax * n\\n CurMax = max(tmp, n * CurMin, n)\\n CurMin = min(tmp, n * CurMin, n)\\n res = max(res,CurMax)\\n\\n return res \",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n prefix,suffix=1,1\\n n=len(nums)\\n ans=float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n if prefix==0:\\n prefix=1\\n if suffix==0:\\n suffix=1\\n prefix*=nums[i]\\n suffix*=nums[n-i-1]\\n ans=max(prefix,suffix,ans)\\n return ans\\n \\n\\n \\n\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n max_result = nums[0]\\n\\n local_product = 1\\n for n in nums:\\n local_product *= n\\n max_result = max(max_result, local_product)\\n if local_product == 0:\\n local_product = 1\\n local_product = 1\\n for n in nums[::-1]:\\n local_product *= n\\n max_result = max(max_result, local_product)\\n if local_product == 0:\\n local_product = 1\\n return max_result\\n\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n\\n if not nums:\\n return 0\\n \\n min_so_far, max_so_far, max_product = nums[0], nums[0], nums[0]\\n\\n for i in nums[1:]:\\n temp_min = min(i, min_so_far * i, max_so_far * i)\\n temp_max = max(i, min_so_far * i, max_so_far * i)\\n\\n min_so_far, max_so_far = temp_min, temp_max\\n \\n max_product = max(max_so_far, max_product) \\n\\n return max_product\\n \",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n\\n curr_prod = nums[0]\\n curr_min = nums[0]\\n curr_max = nums[0]\\n\\n for i in range(1, len(nums)):\\n if nums[i] < 0 :\\n curr_max, curr_min = curr_min, curr_max\\n curr_max = max(nums[i], curr_max*nums[i])\\n curr_min = min(nums[i], curr_min*nums[i])\\n\\n curr_prod = max(curr_prod, curr_max)\\n\\n return curr_prod\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res = max(nums)\\n currMin, currMax = 1, 1\\n\\n for n in nums:\\n if n == 0:\\n currMin, currMax = 1, 1\\n continue\\n\\n temp = n * currMax\\n currMax = max(n * currMax, n * currMin, n)\\n currMin = min(n * currMin, temp, n)\\n res = max(res, currMax, currMin)\\n \\n return res\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res = max(nums)\\n currMax, currMin = 1, 1\\n\\n for n in nums:\\n if n == 0:\\n currMax, currMin = 1, 1\\n continue\\n tmp = n * currMax \\n currMax = max(n * currMax, n * currMin, n)\\n currMin = min(tmp, n * currMin, n)\\n res = max(res, currMax)\\n return res\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n dpFromLeft = [0] * len(nums)\\n currProd = 1\\n for i in range(len(nums)):\\n if nums[i] == 0:\\n currProd = 1\\n continue\\n currProd *= nums[i]\\n dpFromLeft[i] = currProd\\n \\n currProd = 1\\n dpFromRight = [0] * len(nums)\\n for i in range(len(dpFromRight) - 1, -1, -1):\\n if nums[i] == 0:\\n currProd = 1\\n continue\\n currProd *= nums[i]\\n dpFromRight[i] = currProd\\n return max(max(dpFromRight), max(dpFromLeft))\\n\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n min_val, max_val = 1, 1\\n max_prod = max(nums)\\n\\n for num in nums:\\n if num == 0:\\n min_val, max_val = 1, 1\\n else:\\n temp_max = max_val\\n max_val = max(num, num * min_val, num * max_val)\\n min_val = min(num, num * min_val, num * temp_max)\\n max_prod = max(max_prod, min_val, max_val)\\n\\n return max_prod\\n \\n \\n \\n\\n\\n\\n\\n\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n # Initialize our base case, min and max checkers\\n highest = nums[0]\\n minN = 1\\n maxN = 1\\n\\n # Loop through the array\\n # Store the product in a temp variable\\n # Adjust your max and mins\\n for n in nums:\\n temp = maxN * n\\n maxN = max(maxN*n,minN*n,n)\\n minN = min(temp,minN*n,n)\\n highest = max(highest,maxN)\\n return highest\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n if not nums:\\n return 0\\n \\n # Initialize the max product, min product, and result with the first element\\n max_product = nums[0]\\n min_product = nums[0]\\n result = nums[0]\\n \\n # Iterate through the array starting from the second element\\n for num in nums[1:]:\\n if num < 0:\\n # Swap max and min products when encountering a negative number\\n max_product, min_product = min_product, max_product\\n \\n # Update the max and min products\\n max_product = max(num, max_product * num)\\n min_product = min(num, min_product * num)\\n \\n # Update the result with the maximum product found so far\\n result = max(result, max_product)\\n \\n return result\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n \\n result = nums[0]\\n\\n curr_max = curr_min = result\\n\\n for i in range(1, len(nums)):\\n\\n num = nums[i]\\n\\n # if multiply by negative, it will flip the magnitudes\\n # so we prepare by pre-flipping them first so it will reverse correctly\\n if num < 0:\\n curr_max, curr_min = curr_min, curr_max\\n \\n curr_max = max(num, curr_max*num)\\n curr_min = min(num, curr_min*num)\\n\\n result = max(result, curr_max)\\n\\n return result\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n curMax, curMin = 1, 1\\n res = nums[0]\\n \\n for n in nums:\\n vals = (n, n * curMax, n * curMin)\\n curMax, curMin = max(vals), min(vals)\\n\\t\\t\\t\\n res = max(res, curMax)\\n \\n return res\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int: \\n if not nums: return 0 \\n maxPro = 1\\n minPro = 1\\n res = -float('inf')\\n for v in nums:\\n tmp1, tmp2 = minPro, maxPro\\n maxPro = max(tmp1 * v, tmp2 * v, v)\\n minPro = min(tmp1 * v, tmp2 * v, v)\\n res = max(res, maxPro)\\n\\n return res\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n n = len(nums)\\n min_val, max_val = 1, 1\\n max_prod = max(nums)\\n\\n for num in nums:\\n if num == 0:\\n min_val, max_val = 1, 1\\n else:\\n temp_max = max_val\\n max_val = max(num, num * min_val, num * max_val)\\n min_val = min(num, num * min_val, num * temp_max)\\n max_prod = max(max_prod, min_val, max_val)\\n\\n return max_prod\\n \\n \\n \\n\\n\\n\\n\\n\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"from typing import List\\n\\n\\nclass Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n 152. Maximum Product Subarray\\n\\n Given an integer array nums, find a subarray\\n that has the largest product, and return the product.\\n\\n The test cases are generated so that the answer will\\n fit in a 32-bit integer.\\n\\n Example 1:\\n Input: nums = [2,3,-2,4]\\n Output: 6\\n Explanation: [2,3] has the largest product 6.\\n\\n Example 2:\\n Input: nums = [-2,0,-1]\\n Output: 0\\n Explanation: The result cannot be 2, because [-2,-1] is not a subarray.\\n \\\"\\\"\\\"\\n max_prod = 1\\n min_prod = 1\\n best_prod = float('-inf')\\n for value in nums:\\n temp_max_prod = max_prod\\n max_prod = max(value, max_prod * value, min_prod * value)\\n min_prod = min(value, temp_max_prod * value, min_prod * value)\\n best_prod = max(best_prod, max_prod)\\n return best_prod\\n\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n minN, maxN = nums[0], nums[0]\\n res = nums[0]\\n n = len(nums)\\n for i in range(1, n):\\n if nums[i] < 0:\\n minN, maxN = maxN, minN\\n minN = min(nums[i], minN * nums[i])\\n maxN = max(nums[i], maxN * nums[i])\\n res = max(res, minN, maxN)\\n return res\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res=max(nums)\\n\\n cur_max=1\\n cur_min=1\\n for n in nums:\\n\\n t=n*cur_max\\n cur_max=max(t,n*cur_min,n)\\n cur_min=min(t,n*cur_min,n)\\n\\n res=max(cur_max,res)\\n\\n return res\\n \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n max_p = max(nums)\\n curr_min, curr_max = 1, 1\\n\\n for n in nums:\\n if n == 0:\\n curr_min, curr_max = 1, 1\\n continue\\n \\n tmp = curr_max\\n curr_max = max(n, curr_max * n, curr_min * n)\\n curr_min = min(n, tmp * n, curr_min * n)\\n max_p = max(max_p, curr_max)\\n return max_p\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n max_prod = float('-inf')\\n prefix, suffix = 1, 1\\n n = len(nums)\\n\\n for i in range(n):\\n if prefix == 0: prefix = 1\\n if suffix == 0: suffix = 1\\n\\n prefix *= nums[i]\\n suffix *= nums[n - i - 1]\\n max_prod = max(max_prod, prefix, suffix)\\n \\n return max_prod\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n pre=1\\n suf=1\\n maxi=float('-inf')\\n for i in range(len(nums)):\\n if(pre==0):\\n pre=1\\n if(suf==0):\\n suf=1\\n pre=pre*nums[i]\\n suf=suf*nums[len(nums)-i-1]\\n maxi=max(maxi,max(pre,suf))\\n return maxi\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n n=len(nums)\\n maxi=float('-inf')\\n prefix=1\\n suffix=1\\n for i in range(n):\\n if prefix==0:\\n prefix=1\\n if suffix==0:\\n suffix=1\\n prefix=prefix*nums[i]\\n suffix=suffix*nums[n-i-1]\\n maxi=max(maxi,max(prefix,suffix))\\n return maxi \\n \\n \",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n max_prod = max(nums)\\n curr_max, curr_min = 1, 1\\n for n in nums:\\n if n == 0:\\n curr_max, curr_min = 1, 1\\n continue\\n \\n temp = curr_max * n\\n curr_max = max(curr_max * n, curr_min * n, n)\\n curr_min = min(temp, curr_min * n, n)\\n\\n max_prod = max(max_prod, curr_max, curr_min)\\n return max_prod\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n\\n ans = -1e9\\n pos, neg = 1,1\\n for i in range(len(nums)):\\n if nums[i]<0: neg, pos = pos, neg\\n neg = min(neg*nums[i],nums[i])\\n pos = max(pos*nums[i],nums[i])\\n ans = max(pos,neg,ans)\\n \\n return ans\\n\\n \",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n running_res = max_prod = min_prod = nums[0]\\n\\n for ith in range(1, len(nums)):\\n temp_max_prod = max(nums[ith], max_prod*nums[ith],min_prod*nums[ith])\\n min_prod = min(nums[ith], max_prod*nums[ith],min_prod*nums[ith])\\n #reset it:\\n max_prod = temp_max_prod\\n #compare\\n running_res = max(running_res, max_prod)\\n\\n return running_res\\n \",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n if len(nums) == 0:\\n return 0\\n min_so_far, max_so_far = nums[0], nums[0]\\n result = max_so_far\\n\\n for curr in nums[1:]:\\n temp_max_so_far = max(\\n curr,\\n max_so_far*curr,\\n min_so_far*curr\\n )\\n\\n min_so_far = min(\\n curr,\\n max_so_far*curr,\\n min_so_far*curr\\n )\\n \\n max_so_far = temp_max_so_far\\n result = max(max_so_far, result)\\n return result\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n max_prod = float('-inf')\\n prefix, suffix = 1, 1\\n n = len(nums)\\n for i in range(n):\\n if prefix == 0: prefix = 1\\n if suffix == 0: suffix = 1\\n\\n prefix *= nums[i]\\n suffix *= nums[n - i - 1]\\n max_prod = max(max_prod, prefix, suffix) # update max_prod only when either\\n # prefix or suffix is greater\\n # else max_prod is kept as it is\\n return max_prod\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res=max(nums)\\n currmin=1\\n currmax=1\\n for i in nums:\\n prevmax=currmax*i\\n currmax=max(prevmax,currmin*i,i)\\n currmin=min(prevmax,currmin*i,i)\\n res=max(currmax,res)\\n return(res)\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n mx=[0]*len(nums)\\n mn=[0]*len(nums)\\n mx[0]=mn[0]=nums[0]\\n max_product=nums[0]\\n for i in range(1,len(nums)):\\n if nums[i]>0:\\n mx[i]=max(nums[i],nums[i]*mx[i-1])\\n mn[i]=min(nums[i],nums[i]*mn[i-1])\\n else:\\n mx[i]=max(nums[i],nums[i]*mn[i-1])\\n mn[i]=min(nums[i],nums[i]*mx[i-1])\\n max_product=max(max_product,mx[i])\\n return(max_product)\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n maxprod = nums[0] # Initialize max product with the first element\\n minprod = nums[0] # Initialize min product with the first element\\n result = nums[0] # The result will hold the final maximum product\\n \\n for i in range(1, len(nums)):\\n if nums[i] < 0:\\n # Swap maxprod and minprod if the current number is negative\\n maxprod, minprod = minprod, maxprod\\n \\n maxprod = max(nums[i], maxprod * nums[i])\\n minprod = min(nums[i], minprod * nums[i])\\n \\n result = max(result, maxprod)\\n \\n return result\\n\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n\\n prefix_prod = 1\\n suffix_prod = 1\\n\\n ans = float(\\\"-inf\\\")\\n\\n for i in range(len(nums)):\\n\\n if prefix_prod == 0:\\n prefix_prod = 1\\n \\n if suffix_prod == 0:\\n suffix_prod = 1\\n \\n prefix_prod *= nums[i]\\n\\n suffix_prod *= nums[len(nums) - 1 - i]\\n \\n\\n ans = max(ans, max(prefix_prod, suffix_prod))\\n \\n return ans\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n \\n result = nums[0]\\n\\n curr_max = curr_min = result\\n\\n for i in range(1, len(nums)):\\n\\n num = nums[i]\\n\\n # if multiply by negative, it will flip the magnitudes\\n # so we prepare by pre-flipping them first so it will reverse correctly\\n if num < 0:\\n curr_max, curr_min = curr_min, curr_max\\n # below we do the multiplication, but note that any negative results can get written off in curr_max if it is positive via max()\\n curr_max = max(num, curr_max*num)\\n curr_min = min(num, curr_min*num)\\n\\n result = max(result, curr_max)\\n\\n return result\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res = max(nums)\\n currMax, currMin = 1, 1\\n\\n for n in nums:\\n if n == 0:\\n currMax, currMin = 1, 1\\n continue\\n tmp = n * currMax \\n currMax = max(n * currMax, n * currMin, n)\\n currMin = min(tmp, n * currMin, n)\\n res = max(res, currMax)\\n return res\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n\\n prefix_prod = 1\\n suffix_prod = 1\\n\\n ans = float(\\\"-inf\\\")\\n\\n for i in range(len(nums)):\\n\\n if prefix_prod == 0:\\n prefix_prod = 1\\n \\n if suffix_prod == 0:\\n suffix_prod = 1\\n \\n prefix_prod *= nums[i]\\n\\n suffix_prod *= nums[len(nums) - 1 - i]\\n \\n\\n ans = max(ans, max(prefix_prod, suffix_prod))\\n \\n return ans\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n running_res = max_prod = min_prod = nums[0]\\n\\n for ith in range(1, len(nums)):\\n #if the current number is negative, the max time a neg will be the new min\\n #and the smallest times the negative will be less negative and thus bigger\\n if nums[ith] < 0:\\n #we switch max and min\\n max_prod, min_prod = min_prod, max_prod\\n #assign the new max and new mins\\n max_prod = max(nums[ith], max_prod*nums[ith])\\n min_prod = min(nums[ith], min_prod*nums[ith])\\n\\n #and the running_res will be the max of the prev operation \\n #which is between the max of the current op \\n #which can be either the true max or the least negative if we did the switch\\n #and the running result\\n running_res = max(running_res, max_prod)\\n\\n return running_res\\n \",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n minProd = maxProd = result = nums[0]\\n\\n for i in range(1, len(nums)):\\n num = nums[i]\\n\\n #if negative number swap min/max prod\\n if(num < 0):\\n minProd, maxProd = maxProd, minProd\\n \\n #update the min/max\\n maxProd = max(num, maxProd * num)\\n minProd = min(num, minProd * num)\\n\\n #update the result with current max\\n result = max(result, maxProd)\\n\\n #print(\\\"num\\\", num, \\\"maxProd\\\", maxProd, \\\"minProd\\\", minProd, \\\"re\\\", result)\\n\\n return result\",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n min_so_far = nums[0]\\n max_so_far = nums[0]\\n \\n maxVal = nums[0]\\n\\n for i in range(1, len(nums)):\\n min_prev = nums[i] * min_so_far\\n max_prev = nums[i] * max_so_far\\n\\n min_so_far = min(min(min_prev, max_prev), nums[i])\\n max_so_far = max(max(min_prev, max_prev), nums[i])\\n\\n maxVal = max(max_so_far, maxVal)\\n \\n return maxVal\\n\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res = nums[0] # first item\\n curMin, curMax = 1, 1 # maintain min and max prod\\n\\n for n in nums:\\n\\n tmp = curMax * n # currMax * curr\\n curMax = max(n * curMax, n * curMin, n)\\n curMin = min(tmp, n * curMin, n)\\n res = max(res, curMax)\\n return res\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n mindp = [0] * (len(nums))\\n maxdp = [0] * (len(nums))\\n \\n \\n mindp[0] = maxdp[0] = largest = nums[0]\\n\\n for i in range(1, len(nums)):\\n \\n mindp[i] = min(nums[i], nums[i]*maxdp[i-1], nums[i]*mindp[i-1])\\n maxdp[i] = max(nums[i], nums[i]*mindp[i-1], nums[i]*maxdp[i-1])\\n largest = max(largest, maxdp[i])\\n \\n return largest\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n # Step 1: Initialize the first element as the starting point for max and min products\\n current_max = nums[0]\\n current_min = nums[0]\\n max_so_far = nums[0]\\n \\n # Step 2: Iterate through the array starting from the second element\\n for i in range(1, len(nums)):\\n num = nums[i]\\n \\n # If the current number is negative, swap the current_max and current_min\\n if num < 0:\\n current_max, current_min = current_min, current_max\\n \\n # Step 3: Update current_max and current_min\\n current_max = max(num, current_max * num)\\n current_min = min(num, current_min * num)\\n \\n # Step 4: Update max_so_far with the largest product found so far\\n max_so_far = max(max_so_far, current_max)\\n \\n return max_so_far\\n\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n dp = []\\n\\n dp.append((nums[0], nums[0]))\\n \\n maxVal = nums[0]\\n\\n for i in range(1, len(nums)):\\n min_prev = nums[i] * dp[i-1][0]\\n max_prev = nums[i] * dp[i-1][1]\\n\\n minimum = min(min(min_prev, max_prev), nums[i])\\n maximum = max(max(min_prev, max_prev), nums[i])\\n\\n dp.append((minimum, maximum))\\n\\n maxVal = max(maximum, maxVal)\\n \\n return maxVal\\n\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n dp = [(float('-inf'),float('inf'))] * len(nums)\\n dp[0] = (nums[0],nums[0])\\n prod = nums[0]\\n for i in range(1,len(nums)):\\n if nums[i] == 0:\\n dp[i] = (0,0)\\n elif nums[i] < 0:\\n dp[i] = (max(dp[i-1][1]*nums[i],nums[i]),min(dp[i-1][0]*nums[i],nums[i]))\\n else:\\n dp[i] = (max(dp[i-1][0]*nums[i],nums[i]),min(dp[i-1][1]*nums[i],nums[i]))\\n prod = max(prod,dp[i][0])\\n return prod\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [[0, 0] for i in range(n)]\\n # print(dp)\\n prev_max = nums[0]\\n prev_min = nums[0]\\n\\n # dp[0][0] = nums[0]\\n # dp[0][1] = nums[0]\\n if n == 1:\\n return nums[0]\\n \\n # dp[1][0] = max(nums[0]*nums[1], nums[1])\\n # dp[1][1] = min(nums[0]*nums[1], nums[1])\\n\\n # print(\\\"Dp here:\\\", dp)\\n maxi = nums[0]\\n mini = nums[0]\\n for i in range(1, n):\\n p1 = prev_max * nums[i]\\n p2 = prev_min * nums[i]\\n p3 = nums[i]\\n\\n prev_max = max(p1, p2, p3)\\n prev_min = min(p1, p2, p3)\\n maxi = max(maxi, prev_max)\\n\\n\\n # p1 = dp[i-1][0] * nums[i]\\n # p2 = nums[i]\\n # p3 = dp[i-1][1] * nums[i]\\n\\n # dp[i][0] = max(p1, p2, p3)\\n # dp[i][1] = min(p1, p2, p3)\\n \\n # maxi = dp[0][0]\\n # print(dp)\\n # for i in dp:\\n # maxi = max(maxi, i[0], i[1])\\n return maxi\\n\\n # return maxi\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n cur_max = cur_min = 1 # 1 is the identity value in product\\n glo_max = max(nums)\\n\\n for n in nums:\\n if n == 0:\\n cur_max = cur_min = 0\\n else:\\n tmp = cur_max # lol I forgot to use tmp to save cur_max\\n cur_max = max(n, cur_max * n, cur_min * n)\\n cur_min = min(n, tmp * n, cur_min * n)\\n\\n glo_max = max(cur_max, glo_max)\\n\\n return glo_max\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n min_product = [nums[0]]\\n max_product = [nums[0]]\\n\\n for i in range(1, len(nums)):\\n min_product.append(min(nums[i], nums[i] * min_product[i-1], nums[i] * max_product[i-1]))\\n max_product.append(max(nums[i], nums[i] * min_product[i-1], nums[i] * max_product[i-1]))\\n \\n return max(max_product)\\n\\n\\n \",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n Given an integer array\\n Find maximum product of any given\\n sub array\\n\\n We won't have integer overflows\\n\\n Has to be continuous elements\\n one to 2* 10^4 elements\\n\\n negatives as well and 0s as well\\n # maxProduct = 10\\n # chose to multiply with previous products\\n # or just consider this element as a start of a new sub array\\n # 0 10 2. 8\\n #-5 -2 -10. -40\\n [-5, -2, -1, 4]]\\n\\n [-10, 2, 5, -11, 0, 2, 1, 0]\\n\\n [-5, -2, -1, 4]\\n\\n \\\"\\\"\\\"\\n\\n \\n currentMax = nums[0]\\n currentMin = nums[0]\\n\\n maxProduct = max(currentMax, currentMin)\\n\\n for num in nums[1:]:\\n options = [num, num * currentMax, num * currentMin]\\n\\n currentMax = max(options)\\n\\n maxProduct = max(currentMax, maxProduct)\\n\\n currentMin = min(options)\\n\\n return maxProduct\\n\",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n curmax = 1\\n curmin = 1\\n\\n res = nums[0]\\n for num in nums:\\n values = [num, num*curmin,num*curmax]\\n curmax, curmin = max(values), min(values)\\n\\n res = max(res, curmax )\\n\\n\\n return res\\n\",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n two arrays\\n time: O(n)\\n space: O(n)\\n \\\"\\\"\\\"\\n # Initialize the variables\\n max_product = min_product = result = nums[0]\\n \\n # Traverse the array starting from the second element\\n for i in range(1, len(nums)):\\n # If the current number is negative, swap the max and min product\\n if nums[i] < 0:\\n max_product, min_product = min_product, max_product\\n \\n # Update max and min product\\n max_product = max(nums[i], max_product * nums[i])\\n min_product = min(nums[i], min_product * nums[i])\\n \\n # Update the result with the maximum product found so far\\n result = max(result, max_product)\\n \\n return result\",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums):\\n if len(nums) == 0:\\n return 0\\n\\n max_so_far = nums[0]\\n min_so_far = nums[0]\\n result = max_so_far\\n\\n for i in range(1, len(nums)):\\n curr = nums[i]\\n temp_max = max(curr, max(max_so_far * curr, min_so_far * curr))\\n min_so_far = min(curr, min(max_so_far * curr, min_so_far * curr))\\n\\n # Update max_so_far after updates to min_so_far to avoid overwriting it\\n max_so_far = temp_max\\n # Update the result with the maximum product found so far\\n result = max(max_so_far, result)\\n\\n return result\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n pmax = -11\\n pcurr = 0\\n pfirstneg = None\\n pcurrneg = None\\n negparity = 0\\n count = 0\\n\\n for i in range(len(nums)):\\n if nums[i] == 0:\\n if negparity%2 ==1 and count == 1:\\n pmax = max(0,pmax)\\n elif negparity%2 == 1:\\n pmax = max(pmax,pcurr/pfirstneg,pcurr/pcurrneg)\\n else:\\n pmax = max(pcurr,pmax)\\n pfirstneg = None\\n plastneg = None \\n pcurr = 0\\n negparity = 0\\n count = 0\\n print(pmax)\\n continue\\n\\n if pcurr == 0:\\n pcurr = nums[i]\\n else:\\n pcurr *= nums[i]\\n \\n if nums[i] < 0 and pfirstneg == None:\\n pfirstneg = pcurr\\n\\n if nums[i] < 0:\\n negparity += 1\\n pcurrneg = nums[i]\\n elif pcurrneg != None:\\n pcurrneg *= nums[i]\\n \\n count += 1\\n \\n if i == len(nums)-1:\\n if negparity%2 == 1 and count == 1:\\n pmax = max(pmax,pcurr)\\n elif negparity%2 == 1:\\n pmax = max(pmax,pcurr/pfirstneg,pcurr/pcurrneg)\\n else:\\n pmax = max(pmax,pcurr)\\n print(pmax)\\n return int(pmax)\",\n \"runtime\": \"85\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":76,"string":"76"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res = float(\"-inf\")\n cur = 1\n for i in nums:\n cur *= i\n res = max(res, cur, i)\n if cur == 0:\n cur = 1\n \n rcur = 1\n for j in range(len(nums) - 1, -1, -1):\n rcur *= nums[j]\n res = max(res, rcur, nums[j])\n if rcur == 0:\n rcur = 1\n \n return res\n ","memory":"16200"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res = max(nums)\n currMax, currMin = 1, 1\n\n for n in nums:\n if n == 0:\n currMax, currMin = 1, 1\n continue\n temp = n * currMax\n currMax = max(n * currMax, n * currMin, n)\n currMin = min(temp, n * currMin, n)\n res = max(res, currMax)\n return res\n","memory":"16300"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n max_so_far = nums[0]\n min_so_far = nums[0]\n max_ans = nums[0]\n temp = None # Important!!!!! --> We need to first store here because we use it again in the next line\n for i in nums[1:]:\n temp = max(i, max_so_far*i, min_so_far*i)\n min_so_far = min(i, max_so_far*i, min_so_far*i)\n max_so_far = temp\n max_ans = max(max_ans, max_so_far)\n return max_ans","memory":"16500"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n n = len(nums)\n maxi = float('-inf')\n # for i in range(n):\n # for j in range(i,n):\n # if i==j:\n # p = nums[i]\n # else:\n # p*=nums[j]\n # maxi = max(maxi,p)\n # return maxi\n pm = 1\n sm = 1\n for i in range(n):\n if pm==0: \n pm = 1\n if sm==0: \n sm = 1\n \n pm*=nums[i]\n sm*=nums[n-1-i]\n maxi = max(maxi,pm)\n maxi = max(maxi,sm)\n return maxi\n \n\n\n\n\n \n\n\n\n\n ","memory":"16600"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n max_prod = nums[0]\n min_prod = nums[0]\n r = nums[0]\n for i in range(1, len(nums)):\n if (nums[i] < 0):\n max_prod, min_prod = min_prod, max_prod\n max_prod = max(max_prod * nums[i], nums[i])\n min_prod = min(min_prod * nums[i], nums[i])\n r = max(r, min_prod, max_prod)\n return r","memory":"16700"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res = max(nums)\n currMax, currMin = 1, 1\n for n in nums:\n newMax = max(n * currMax, n * currMin, n)\n currMin = min(n * currMax, n * currMin, n)\n currMax = newMax\n res = max(res, currMax, currMin)\n return res\n\n","memory":"16800"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n if not nums:\n return 0\n \n prev_min, prev_max = nums[0], nums[0]\n result = nums[0]\n\n for num in nums[1:]:\n cur_min = min(num*prev_min, prev_max*num, num)\n cur_max = max(num*prev_min, prev_max*num, num)\n result = max(result, cur_max)\n prev_min, prev_max = cur_min, cur_max\n \n return result\n ","memory":"16800"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n res=max(nums)\n currmin=1\n currmax=1\n for i in nums:\n prevmax=currmax*i\n currmax=max(prevmax,currmin*i,i)\n currmin=min(prevmax,currmin*i,i)\n res=max(currmax,res)\n return(res)","memory":"16900"},{"code":"from typing import List\n\n\nclass Solution:\n def maxProduct(self, nums: List[int]) -> int:\n \"\"\"\n 152. Maximum Product Subarray\n\n Given an integer array nums, find a subarray\n that has the largest product, and return the product.\n\n The test cases are generated so that the answer will\n fit in a 32-bit integer.\n\n Example 1:\n Input: nums = [2,3,-2,4]\n Output: 6\n Explanation: [2,3] has the largest product 6.\n\n Example 2:\n Input: nums = [-2,0,-1]\n Output: 0\n Explanation: The result cannot be 2, because [-2,-1] is not a subarray.\n \"\"\"\n max_prod = 1\n min_prod = 1\n best_prod = float('-inf')\n for value in nums:\n temp_max_prod = max_prod\n max_prod = max(value, max_prod * value, min_prod * value)\n min_prod = min(value, temp_max_prod * value, min_prod * value)\n best_prod = max(best_prod, max_prod)\n return best_prod\n","memory":"16900"},{"code":"\"\"\"\n\n\n\"\"\"\n\nclass Solution:\n def maxProduct(self, nums: List[int]) -> int:\n max_pre = nums[0]\n min_pre, ans = max_pre, max_pre \n for n in nums[1:]:\n #if we add it to previous, or it is a new start\n a = max_pre\n b = min_pre\n max_pre = max(n, a*n,b*n)\n min_pre = min(n, a*n,b*n)\n ans = max(ans,max_pre)\n return ans \n\n\n ","memory":"17000"},{"code":"class Solution:\n\n\n \n def maxProduct(self, nums: List[int]) -> int:\n min_prod = nums[0]\n max_prod = nums[0]\n '''\n FOR num in nums\n if num is negative:\n swap min_prod & max_prod\n assign minimum between min_prod * nums & min to min_prod\n assign maximum between max_prod * nums * max to max_prod\n '''\n res = nums[0]\n for i in range(1, len(nums)):\n if nums[i] < 0:\n min_prod, max_prod = max_prod, min_prod\n min_prod = min(min_prod * nums[i], nums[i])\n max_prod = max(max_prod * nums[i], nums[i])\n res = max(res, max_prod)\n return res ","memory":"17000"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n \"\"\"\n DP\n time: O(n)\n space: O(1)\n \"\"\"\n mx = mi = res = nums[0]\n for i in range(1, len(nums)):\n # If the current number is negative, swap the max and min product\n if nums[i] < 0:\n mx, mi = mi, mx\n mx = max(nums[i], mx * nums[i])\n mi = min(nums[i], mi * nums[i])\n res = max(res, mx)\n return res","memory":"17100"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n curMin, curMax = 1,1\n #nums = [2,3,-2,4]\n res = float('-inf')\n flag = False\n\n for n in nums: \n if n == 0: # reset pointers\n curMin, curMax = 1,1 \n flag = True\n continue\n\n temp = curMax\n\n curMax = max(n, n * curMax, n * curMin) # negative case, positive case\n curMin = min(n, temp *n, n * curMin)\n res = max(res, curMax)\n\n if res < 0 and flag == True:\n return 0\n return res # why cant you just return curMax? \n ","memory":"17100"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int: \n if not nums: return 0 \n maxPro = 1\n minPro = 1\n res = -float('inf')\n for v in nums:\n tmp1, tmp2 = minPro, maxPro\n maxPro = max(tmp1 * v, tmp2 * v, v)\n minPro = min(tmp1 * v, tmp2 * v, v)\n res = max(res, maxPro)\n\n return res","memory":"17200"},{"code":"class Solution:\n def maxProduct(self, nums):\n n = len(nums)\n maxi = float('-inf')\n pre, suff = 1, 1\n\n for i in range(n):\n if pre == 0:\n pre = 1\n if suff == 0:\n suff = 1\n pre *= nums[i]\n suff *= nums[n - i - 1]\n maxi = max(maxi, max(pre, suff))\n print(pre, suff, maxi)\n\n return int(maxi)","memory":"17200"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n maxProduct = -float('inf')\n start = 0\n cur_prod = 0\n contains_zero = False\n \n for end in range(len(nums)):\n if nums[end] == 0:\n contains_zero = True\n while start < end:\n cur_prod //= nums[start]\n start += 1\n maxProduct = max(maxProduct, cur_prod) if start < end else maxProduct\n start += 1\n cur_prod = 0\n else:\n print(nums[end])\n if cur_prod == 0:\n cur_prod = 1\n cur_prod *= nums[end]\n print(cur_prod)\n maxProduct = max(maxProduct, cur_prod)\n \n while start < len(nums):\n cur_prod //= nums[start]\n start += 1\n maxProduct = max(maxProduct, cur_prod) if start < len(nums) else maxProduct\n \n if contains_zero:\n maxProduct = max(0, maxProduct)\n return maxProduct","memory":"17300"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n n = len(nums)\n if n == 1:\n return nums[0]\n arr, tmp = [], []\n\n for i in range(n):\n if nums[i] == 0:\n arr.append(tmp)\n tmp = []\n else:\n tmp.append(nums[i])\n arr.append(tmp)\n print(arr)\n ans = 0\n for ar in arr:\n ans = max(ans, self.find(ar))\n return ans\n\n def find(self, arr):\n n = len(arr)\n if n == 0:\n return -float(\"inf\")\n if n == 1:\n return arr[0]\n neg = []\n for i in range(len(arr)):\n if arr[i] < 0:\n neg.append(i)\n \n if len(neg) % 2 == 0:\n return self.prod(arr)\n first = neg[0]\n last = neg[-1]\n if first == last:\n a = self.prod(arr[first + 1:])\n b = self.prod(arr[:first])\n return max(a,b)\n else:\n a = self.prod(arr[:first])\n b = self.prod(arr[first + 1:])\n c = self.prod(arr[last+1:])\n d = self.prod(arr[:last])\n return max(a,b,c,d)\n \n def prod(self, arr):\n n = len(arr)\n if n == 0:\n return -float(\"inf\")\n if n == 1:\n return arr[0]\n ans = arr[0]\n for i in range(1,n):\n ans = ans * arr[i]\n return ans","memory":"17400"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n Max, Min = 1, 1\n res = []\n for n in nums:\n new_Max = max(n * Min, n * Max, n)\n Min = min(n * Min, n * Max, n)\n Max = new_Max\n res.append(Max)\n\n return max(res)","memory":"17500"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n dp=[0]*len(nums)\n mini,maxi=1,1\n for i in range(len(nums)):\n if nums[i]<0:\n mini, maxi=maxi,mini\n maxi=max(maxi*nums[i], nums[i])\n mini=min(mini*nums[i], nums[i])\n dp[i]=maxi\n \n return max(dp)\n\n \n\n\n \n","memory":"17600"},{"code":"class Solution:\n\n def maxProduct(self, nums: List[int]) -> int:\n\n # Prefix Product (Max, Min) - O(n)\n\n prefixProd = [1] * len(nums)\n prefixProd[0] = nums[0]\n currMin = nums[0]\n\n for i in range(1, len(nums)):\n prefixProd[i] = max(nums[i], prefixProd[i-1] * nums[i], currMin * nums[i])\n currMin = min(nums[i], prefixProd[i-1] * nums[i], currMin * nums[i])\n \n return max(prefixProd)\n\n\n ","memory":"17600"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n dpFromLeft = [0] * len(nums)\n currProd = 1\n for i in range(len(nums)):\n if nums[i] == 0:\n currProd = 1\n continue\n currProd *= nums[i]\n dpFromLeft[i] = currProd\n \n currProd = 1\n dpFromRight = [0] * len(nums)\n for i in range(len(dpFromRight) - 1, -1, -1):\n if nums[i] == 0:\n currProd = 1\n continue\n currProd *= nums[i]\n dpFromRight[i] = currProd\n return max(max(dpFromRight), max(dpFromLeft))\n","memory":"17700"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n def helper(nums):\n max_prod = nums[0]\n sub_prod = 1\n\n prods = []\n for n in nums:\n if n == 0:\n prods.append(n)\n sub_prod = 1\n else: \n sub_prod *= n\n prods.append(sub_prod)\n\n return max(prods)\n \n max_1 = helper(nums)\n max_2 = helper(nums[::-1])\n return max((max_1, max_2))","memory":"17800"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n\n def maxProduct_nozeros(nums):\n\n n = len(nums)\n if(n==1):\n return nums[0]\n\n prefix_prod = [0 for i in range(n)]\n prefix_prod[0] = nums[0]\n count_n = 1 if nums[0] < 0 else 0\n ans = nums[0]\n for i in range(1, n):\n prefix_prod[i] = nums[i]*prefix_prod[i-1]\n if(nums[i] < 0):\n count_n += 1\n ans = max(ans, nums[i])\n \n if(count_n%2 == 0):\n return prefix_prod[n-1]\n\n # print (prefix_prod)\n \n for i in range(n):\n if(nums[i] < 0):\n if(i == 0):\n ans = max(ans, int(prefix_prod[n-1]/prefix_prod[0]))\n elif i == n-1:\n ans = max(ans, prefix_prod[i-1])\n else:\n ans = max(ans, prefix_prod[i-1], int(prefix_prod[n-1]/prefix_prod[i]))\n return ans\n \n n = len(nums)\n ans = max(nums)\n i, j = 0, 0\n while i<n:\n if(nums[i] == 0):\n i += 1\n continue\n else:\n j = i+1\n while (j < n and nums[j] != 0):\n j += 1\n ans = max(ans, maxProduct_nozeros(nums[i:j]))\n i = j+1\n return ans\n ","memory":"17800"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n revProducts = nums[::-1]\n for i in range(1,len(nums)):\n nums[i] *= nums[i-1] or 1\n revProducts[i] *= revProducts[i-1] or 1\n return max(nums + revProducts)","memory":"17900"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n def sub(nums):\n l = []\n r = [0] * len(nums)\n curr = 1\n for i in nums:\n curr *= i\n l.append(curr)\n curr = 1\n for i in range(len(nums)-1,-1,-1):\n curr *= nums[i]\n r[i] = curr\n if r[0] > 0:\n return r[0]\n return max(max(l),max(r), max(nums))\n \n s = None\n out = 0\n for i in range(len(nums)):\n if nums[i] == 0:\n if s is not None:\n out = max(out, sub(nums[s:i]))\n s = None\n continue\n if s is None:\n s = i\n if s is not None:\n out = max(out, sub(nums[s:])) \n if out==0:\n return max(nums) \n return out\n\n","memory":"17900"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n mindp = [0] * (len(nums))\n maxdp = [0] * (len(nums))\n \n \n mindp[0] = maxdp[0] = largest = nums[0]\n\n for i in range(1, len(nums)):\n \n mindp[i] = min(nums[i], nums[i]*maxdp[i-1], nums[i]*mindp[i-1])\n maxdp[i] = max(nums[i], nums[i]*mindp[i-1], nums[i]*maxdp[i-1])\n largest = max(largest, maxdp[i])\n \n return largest","memory":"18000"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n def splitOnZeros():\n res = []\n curr = []\n for num in nums:\n if num == 0:\n res.append(curr)\n res.append([0])\n curr = []\n else:\n curr.append(num)\n if len(curr) != 0:\n res.append(curr)\n return res\n\n def partial_products(lst):\n products = [1]\n for e in lst:\n products.append(products[-1] * e)\n return products\n\n def find_first_and_last_neg(lst):\n first_neg = -1\n last_neg = -1\n for idx, num in enumerate(lst):\n if num < 0:\n last_neg = idx\n if first_neg == -1:\n first_neg = idx\n return first_neg, last_neg\n\n def solveNoZeros(numsNoZ):\n if len(numsNoZ) == 0:\n return 0\n if len(numsNoZ) == 1:\n return numsNoZ[0]\n\n pp = partial_products(numsNoZ)\n p = pp[-1]\n if p > 0:\n return p\n\n first_neg, last_neg = find_first_and_last_neg(numsNoZ)\n return max(p // pp[first_neg + 1], pp[last_neg])\n return max(map(solveNoZeros, splitOnZeros()))\n\n ","memory":"18000"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n mx=[0]*len(nums)\n mn=[0]*len(nums)\n mx[0]=mn[0]=nums[0]\n max_product=nums[0]\n for i in range(1,len(nums)):\n if nums[i]>0:\n mx[i]=max(nums[i],nums[i]*mx[i-1])\n mn[i]=min(nums[i],nums[i]*mn[i-1])\n else:\n mx[i]=max(nums[i],nums[i]*mn[i-1])\n mn[i]=min(nums[i],nums[i]*mx[i-1])\n max_product=max(max_product,mx[i])\n return(max_product)","memory":"18100"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n mindp = [0] * (len(nums))\n maxdp = [0] * (len(nums))\n \n \n mindp[0] = maxdp[0] = largest = nums[0]\n\n for i in range(1, len(nums)):\n \n mindp[i] = min(nums[i], nums[i]*maxdp[i-1], nums[i]*mindp[i-1])\n maxdp[i] = max(nums[i], nums[i]*mindp[i-1], nums[i]*maxdp[i-1])\n largest = max(largest, maxdp[i])\n \n return largest","memory":"18100"},{"code":"class Solution:\n def maxProduct(self, nums: List[int]) -> int:\n n = len(nums)\n dp_pos = [0] * (n + 1)\n dp_pos[0] = 1\n dp_neg = [0] * (n + 1)\n dp_neg[0] = 1\n prod_max = -inf\n for i, v in enumerate(nums):\n dp_pos[i + 1] = max(dp_pos[i] * v, v)\n dp_pos[i + 1] = max(dp_neg[i] * v, dp_pos[i + 1])\n dp_neg[i + 1] = min(dp_neg[i] * v, v)\n dp_neg[i + 1] = min(dp_pos[i] * v, dp_neg[i + 1])\n prod_max = max(dp_pos[i + 1], prod_max)\n # prod_max = max(dp_neg[i] * v, prod_max)\n return prod_max \n","memory":"18200"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res = float(\\\"-inf\\\")\\n cur = 1\\n for i in nums:\\n cur *= i\\n res = max(res, cur, i)\\n if cur == 0:\\n cur = 1\\n \\n rcur = 1\\n for j in range(len(nums) - 1, -1, -1):\\n rcur *= nums[j]\\n res = max(res, rcur, nums[j])\\n if rcur == 0:\\n rcur = 1\\n \\n return res\\n \",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res = max(nums)\\n currMax, currMin = 1, 1\\n\\n for n in nums:\\n if n == 0:\\n currMax, currMin = 1, 1\\n continue\\n temp = n * currMax\\n currMax = max(n * currMax, n * currMin, n)\\n currMin = min(temp, n * currMin, n)\\n res = max(res, currMax)\\n return res\\n\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n max_so_far = nums[0]\\n min_so_far = nums[0]\\n max_ans = nums[0]\\n temp = None # Important!!!!! --> We need to first store here because we use it again in the next line\\n for i in nums[1:]:\\n temp = max(i, max_so_far*i, min_so_far*i)\\n min_so_far = min(i, max_so_far*i, min_so_far*i)\\n max_so_far = temp\\n max_ans = max(max_ans, max_so_far)\\n return max_ans\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n n = len(nums)\\n maxi = float('-inf')\\n # for i in range(n):\\n # for j in range(i,n):\\n # if i==j:\\n # p = nums[i]\\n # else:\\n # p*=nums[j]\\n # maxi = max(maxi,p)\\n # return maxi\\n pm = 1\\n sm = 1\\n for i in range(n):\\n if pm==0: \\n pm = 1\\n if sm==0: \\n sm = 1\\n \\n pm*=nums[i]\\n sm*=nums[n-1-i]\\n maxi = max(maxi,pm)\\n maxi = max(maxi,sm)\\n return maxi\\n \\n\\n\\n\\n\\n \\n\\n\\n\\n\\n \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n max_prod = nums[0]\\n min_prod = nums[0]\\n r = nums[0]\\n for i in range(1, len(nums)):\\n if (nums[i] < 0):\\n max_prod, min_prod = min_prod, max_prod\\n max_prod = max(max_prod * nums[i], nums[i])\\n min_prod = min(min_prod * nums[i], nums[i])\\n r = max(r, min_prod, max_prod)\\n return r\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res = max(nums)\\n currMax, currMin = 1, 1\\n for n in nums:\\n newMax = max(n * currMax, n * currMin, n)\\n currMin = min(n * currMax, n * currMin, n)\\n currMax = newMax\\n res = max(res, currMax, currMin)\\n return res\\n\\n\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n if not nums:\\n return 0\\n \\n prev_min, prev_max = nums[0], nums[0]\\n result = nums[0]\\n\\n for num in nums[1:]:\\n cur_min = min(num*prev_min, prev_max*num, num)\\n cur_max = max(num*prev_min, prev_max*num, num)\\n result = max(result, cur_max)\\n prev_min, prev_max = cur_min, cur_max\\n \\n return result\\n \",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n res=max(nums)\\n currmin=1\\n currmax=1\\n for i in nums:\\n prevmax=currmax*i\\n currmax=max(prevmax,currmin*i,i)\\n currmin=min(prevmax,currmin*i,i)\\n res=max(currmax,res)\\n return(res)\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"from typing import List\\n\\n\\nclass Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n 152. Maximum Product Subarray\\n\\n Given an integer array nums, find a subarray\\n that has the largest product, and return the product.\\n\\n The test cases are generated so that the answer will\\n fit in a 32-bit integer.\\n\\n Example 1:\\n Input: nums = [2,3,-2,4]\\n Output: 6\\n Explanation: [2,3] has the largest product 6.\\n\\n Example 2:\\n Input: nums = [-2,0,-1]\\n Output: 0\\n Explanation: The result cannot be 2, because [-2,-1] is not a subarray.\\n \\\"\\\"\\\"\\n max_prod = 1\\n min_prod = 1\\n best_prod = float('-inf')\\n for value in nums:\\n temp_max_prod = max_prod\\n max_prod = max(value, max_prod * value, min_prod * value)\\n min_prod = min(value, temp_max_prod * value, min_prod * value)\\n best_prod = max(best_prod, max_prod)\\n return best_prod\\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n\\n\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n max_pre = nums[0]\\n min_pre, ans = max_pre, max_pre \\n for n in nums[1:]:\\n #if we add it to previous, or it is a new start\\n a = max_pre\\n b = min_pre\\n max_pre = max(n, a*n,b*n)\\n min_pre = min(n, a*n,b*n)\\n ans = max(ans,max_pre)\\n return ans \\n\\n\\n \",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n\\n\\n \\n def maxProduct(self, nums: List[int]) -> int:\\n min_prod = nums[0]\\n max_prod = nums[0]\\n '''\\n FOR num in nums\\n if num is negative:\\n swap min_prod & max_prod\\n assign minimum between min_prod * nums & min to min_prod\\n assign maximum between max_prod * nums * max to max_prod\\n '''\\n res = nums[0]\\n for i in range(1, len(nums)):\\n if nums[i] < 0:\\n min_prod, max_prod = max_prod, min_prod\\n min_prod = min(min_prod * nums[i], nums[i])\\n max_prod = max(max_prod * nums[i], nums[i])\\n res = max(res, max_prod)\\n return res \",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n DP\\n time: O(n)\\n space: O(1)\\n \\\"\\\"\\\"\\n mx = mi = res = nums[0]\\n for i in range(1, len(nums)):\\n # If the current number is negative, swap the max and min product\\n if nums[i] < 0:\\n mx, mi = mi, mx\\n mx = max(nums[i], mx * nums[i])\\n mi = min(nums[i], mi * nums[i])\\n res = max(res, mx)\\n return res\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n curMin, curMax = 1,1\\n #nums = [2,3,-2,4]\\n res = float('-inf')\\n flag = False\\n\\n for n in nums: \\n if n == 0: # reset pointers\\n curMin, curMax = 1,1 \\n flag = True\\n continue\\n\\n temp = curMax\\n\\n curMax = max(n, n * curMax, n * curMin) # negative case, positive case\\n curMin = min(n, temp *n, n * curMin)\\n res = max(res, curMax)\\n\\n if res < 0 and flag == True:\\n return 0\\n return res # why cant you just return curMax? \\n \",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int: \\n if not nums: return 0 \\n maxPro = 1\\n minPro = 1\\n res = -float('inf')\\n for v in nums:\\n tmp1, tmp2 = minPro, maxPro\\n maxPro = max(tmp1 * v, tmp2 * v, v)\\n minPro = min(tmp1 * v, tmp2 * v, v)\\n res = max(res, maxPro)\\n\\n return res\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums):\\n n = len(nums)\\n maxi = float('-inf')\\n pre, suff = 1, 1\\n\\n for i in range(n):\\n if pre == 0:\\n pre = 1\\n if suff == 0:\\n suff = 1\\n pre *= nums[i]\\n suff *= nums[n - i - 1]\\n maxi = max(maxi, max(pre, suff))\\n print(pre, suff, maxi)\\n\\n return int(maxi)\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n maxProduct = -float('inf')\\n start = 0\\n cur_prod = 0\\n contains_zero = False\\n \\n for end in range(len(nums)):\\n if nums[end] == 0:\\n contains_zero = True\\n while start < end:\\n cur_prod //= nums[start]\\n start += 1\\n maxProduct = max(maxProduct, cur_prod) if start < end else maxProduct\\n start += 1\\n cur_prod = 0\\n else:\\n print(nums[end])\\n if cur_prod == 0:\\n cur_prod = 1\\n cur_prod *= nums[end]\\n print(cur_prod)\\n maxProduct = max(maxProduct, cur_prod)\\n \\n while start < len(nums):\\n cur_prod //= nums[start]\\n start += 1\\n maxProduct = max(maxProduct, cur_prod) if start < len(nums) else maxProduct\\n \\n if contains_zero:\\n maxProduct = max(0, maxProduct)\\n return maxProduct\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n n = len(nums)\\n if n == 1:\\n return nums[0]\\n arr, tmp = [], []\\n\\n for i in range(n):\\n if nums[i] == 0:\\n arr.append(tmp)\\n tmp = []\\n else:\\n tmp.append(nums[i])\\n arr.append(tmp)\\n print(arr)\\n ans = 0\\n for ar in arr:\\n ans = max(ans, self.find(ar))\\n return ans\\n\\n def find(self, arr):\\n n = len(arr)\\n if n == 0:\\n return -float(\\\"inf\\\")\\n if n == 1:\\n return arr[0]\\n neg = []\\n for i in range(len(arr)):\\n if arr[i] < 0:\\n neg.append(i)\\n \\n if len(neg) % 2 == 0:\\n return self.prod(arr)\\n first = neg[0]\\n last = neg[-1]\\n if first == last:\\n a = self.prod(arr[first + 1:])\\n b = self.prod(arr[:first])\\n return max(a,b)\\n else:\\n a = self.prod(arr[:first])\\n b = self.prod(arr[first + 1:])\\n c = self.prod(arr[last+1:])\\n d = self.prod(arr[:last])\\n return max(a,b,c,d)\\n \\n def prod(self, arr):\\n n = len(arr)\\n if n == 0:\\n return -float(\\\"inf\\\")\\n if n == 1:\\n return arr[0]\\n ans = arr[0]\\n for i in range(1,n):\\n ans = ans * arr[i]\\n return ans\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n Max, Min = 1, 1\\n res = []\\n for n in nums:\\n new_Max = max(n * Min, n * Max, n)\\n Min = min(n * Min, n * Max, n)\\n Max = new_Max\\n res.append(Max)\\n\\n return max(res)\",\n \"memory\": \"17500\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n dp=[0]*len(nums)\\n mini,maxi=1,1\\n for i in range(len(nums)):\\n if nums[i]<0:\\n mini, maxi=maxi,mini\\n maxi=max(maxi*nums[i], nums[i])\\n mini=min(mini*nums[i], nums[i])\\n dp[i]=maxi\\n \\n return max(dp)\\n\\n \\n\\n\\n \\n\",\n \"memory\": \"17600\"\n },\n {\n \"code\": \"class Solution:\\n\\n def maxProduct(self, nums: List[int]) -> int:\\n\\n # Prefix Product (Max, Min) - O(n)\\n\\n prefixProd = [1] * len(nums)\\n prefixProd[0] = nums[0]\\n currMin = nums[0]\\n\\n for i in range(1, len(nums)):\\n prefixProd[i] = max(nums[i], prefixProd[i-1] * nums[i], currMin * nums[i])\\n currMin = min(nums[i], prefixProd[i-1] * nums[i], currMin * nums[i])\\n \\n return max(prefixProd)\\n\\n\\n \",\n \"memory\": \"17600\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n dpFromLeft = [0] * len(nums)\\n currProd = 1\\n for i in range(len(nums)):\\n if nums[i] == 0:\\n currProd = 1\\n continue\\n currProd *= nums[i]\\n dpFromLeft[i] = currProd\\n \\n currProd = 1\\n dpFromRight = [0] * len(nums)\\n for i in range(len(dpFromRight) - 1, -1, -1):\\n if nums[i] == 0:\\n currProd = 1\\n continue\\n currProd *= nums[i]\\n dpFromRight[i] = currProd\\n return max(max(dpFromRight), max(dpFromLeft))\\n\",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n def helper(nums):\\n max_prod = nums[0]\\n sub_prod = 1\\n\\n prods = []\\n for n in nums:\\n if n == 0:\\n prods.append(n)\\n sub_prod = 1\\n else: \\n sub_prod *= n\\n prods.append(sub_prod)\\n\\n return max(prods)\\n \\n max_1 = helper(nums)\\n max_2 = helper(nums[::-1])\\n return max((max_1, max_2))\",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n\\n def maxProduct_nozeros(nums):\\n\\n n = len(nums)\\n if(n==1):\\n return nums[0]\\n\\n prefix_prod = [0 for i in range(n)]\\n prefix_prod[0] = nums[0]\\n count_n = 1 if nums[0] < 0 else 0\\n ans = nums[0]\\n for i in range(1, n):\\n prefix_prod[i] = nums[i]*prefix_prod[i-1]\\n if(nums[i] < 0):\\n count_n += 1\\n ans = max(ans, nums[i])\\n \\n if(count_n%2 == 0):\\n return prefix_prod[n-1]\\n\\n # print (prefix_prod)\\n \\n for i in range(n):\\n if(nums[i] < 0):\\n if(i == 0):\\n ans = max(ans, int(prefix_prod[n-1]/prefix_prod[0]))\\n elif i == n-1:\\n ans = max(ans, prefix_prod[i-1])\\n else:\\n ans = max(ans, prefix_prod[i-1], int(prefix_prod[n-1]/prefix_prod[i]))\\n return ans\\n \\n n = len(nums)\\n ans = max(nums)\\n i, j = 0, 0\\n while i<n:\\n if(nums[i] == 0):\\n i += 1\\n continue\\n else:\\n j = i+1\\n while (j < n and nums[j] != 0):\\n j += 1\\n ans = max(ans, maxProduct_nozeros(nums[i:j]))\\n i = j+1\\n return ans\\n \",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n revProducts = nums[::-1]\\n for i in range(1,len(nums)):\\n nums[i] *= nums[i-1] or 1\\n revProducts[i] *= revProducts[i-1] or 1\\n return max(nums + revProducts)\",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n def sub(nums):\\n l = []\\n r = [0] * len(nums)\\n curr = 1\\n for i in nums:\\n curr *= i\\n l.append(curr)\\n curr = 1\\n for i in range(len(nums)-1,-1,-1):\\n curr *= nums[i]\\n r[i] = curr\\n if r[0] > 0:\\n return r[0]\\n return max(max(l),max(r), max(nums))\\n \\n s = None\\n out = 0\\n for i in range(len(nums)):\\n if nums[i] == 0:\\n if s is not None:\\n out = max(out, sub(nums[s:i]))\\n s = None\\n continue\\n if s is None:\\n s = i\\n if s is not None:\\n out = max(out, sub(nums[s:])) \\n if out==0:\\n return max(nums) \\n return out\\n\\n\",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n mindp = [0] * (len(nums))\\n maxdp = [0] * (len(nums))\\n \\n \\n mindp[0] = maxdp[0] = largest = nums[0]\\n\\n for i in range(1, len(nums)):\\n \\n mindp[i] = min(nums[i], nums[i]*maxdp[i-1], nums[i]*mindp[i-1])\\n maxdp[i] = max(nums[i], nums[i]*mindp[i-1], nums[i]*maxdp[i-1])\\n largest = max(largest, maxdp[i])\\n \\n return largest\",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n def splitOnZeros():\\n res = []\\n curr = []\\n for num in nums:\\n if num == 0:\\n res.append(curr)\\n res.append([0])\\n curr = []\\n else:\\n curr.append(num)\\n if len(curr) != 0:\\n res.append(curr)\\n return res\\n\\n def partial_products(lst):\\n products = [1]\\n for e in lst:\\n products.append(products[-1] * e)\\n return products\\n\\n def find_first_and_last_neg(lst):\\n first_neg = -1\\n last_neg = -1\\n for idx, num in enumerate(lst):\\n if num < 0:\\n last_neg = idx\\n if first_neg == -1:\\n first_neg = idx\\n return first_neg, last_neg\\n\\n def solveNoZeros(numsNoZ):\\n if len(numsNoZ) == 0:\\n return 0\\n if len(numsNoZ) == 1:\\n return numsNoZ[0]\\n\\n pp = partial_products(numsNoZ)\\n p = pp[-1]\\n if p > 0:\\n return p\\n\\n first_neg, last_neg = find_first_and_last_neg(numsNoZ)\\n return max(p // pp[first_neg + 1], pp[last_neg])\\n return max(map(solveNoZeros, splitOnZeros()))\\n\\n \",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n mx=[0]*len(nums)\\n mn=[0]*len(nums)\\n mx[0]=mn[0]=nums[0]\\n max_product=nums[0]\\n for i in range(1,len(nums)):\\n if nums[i]>0:\\n mx[i]=max(nums[i],nums[i]*mx[i-1])\\n mn[i]=min(nums[i],nums[i]*mn[i-1])\\n else:\\n mx[i]=max(nums[i],nums[i]*mn[i-1])\\n mn[i]=min(nums[i],nums[i]*mx[i-1])\\n max_product=max(max_product,mx[i])\\n return(max_product)\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n mindp = [0] * (len(nums))\\n maxdp = [0] * (len(nums))\\n \\n \\n mindp[0] = maxdp[0] = largest = nums[0]\\n\\n for i in range(1, len(nums)):\\n \\n mindp[i] = min(nums[i], nums[i]*maxdp[i-1], nums[i]*mindp[i-1])\\n maxdp[i] = max(nums[i], nums[i]*mindp[i-1], nums[i]*maxdp[i-1])\\n largest = max(largest, maxdp[i])\\n \\n return largest\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def maxProduct(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp_pos = [0] * (n + 1)\\n dp_pos[0] = 1\\n dp_neg = [0] * (n + 1)\\n dp_neg[0] = 1\\n prod_max = -inf\\n for i, v in enumerate(nums):\\n dp_pos[i + 1] = max(dp_pos[i] * v, v)\\n dp_pos[i + 1] = max(dp_neg[i] * v, dp_pos[i + 1])\\n dp_neg[i + 1] = min(dp_neg[i] * v, v)\\n dp_neg[i + 1] = min(dp_pos[i] * v, dp_neg[i + 1])\\n prod_max = max(dp_pos[i + 1], prod_max)\\n # prod_max = max(dp_neg[i] * v, prod_max)\\n return prod_max \\n\",\n \"memory\": \"18200\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":30,"string":"30"}}},{"rowIdx":57,"cells":{"question_id":{"kind":"number","value":153,"string":"153"},"name":{"kind":"string","value":"find-minimum-in-rotated-sorted-array"},"content":{"kind":"string","value":"<p>Suppose an array of length <code>n</code> sorted in ascending order is <strong>rotated</strong> between <code>1</code> and <code>n</code> times. For example, the array <code>nums = [0,1,2,4,5,6,7]</code> might become:</p>\n\n<ul>\n\t<li><code>[4,5,6,7,0,1,2]</code> if it was rotated <code>4</code> times.</li>\n\t<li><code>[0,1,2,4,5,6,7]</code> if it was rotated <code>7</code> times.</li>\n</ul>\n\n<p>Notice that <strong>rotating</strong> an array <code>[a[0], a[1], a[2], ..., a[n-1]]</code> 1 time results in the array <code>[a[n-1], a[0], a[1], a[2], ..., a[n-2]]</code>.</p>\n\n<p>Given the sorted rotated array <code>nums</code> of <strong>unique</strong> elements, return <em>the minimum element of this array</em>.</p>\n\n<p>You must write an algorithm that runs in <code>O(log n) time</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [3,4,5,1,2]\n<strong>Output:</strong> 1\n<strong>Explanation:</strong> The original array was [1,2,3,4,5] rotated 3 times.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [4,5,6,7,0,1,2]\n<strong>Output:</strong> 0\n<strong>Explanation:</strong> The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [11,13,15,17]\n<strong>Output:</strong> 11\n<strong>Explanation:</strong> The original array was [11,13,15,17] and it was rotated 4 times. \n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>n == nums.length</code></li>\n\t<li><code>1 <= n <= 5000</code></li>\n\t<li><code>-5000 <= nums[i] <= 5000</code></li>\n\t<li>All the integers of <code>nums</code> are <strong>unique</strong>.</li>\n\t<li><code>nums</code> is sorted and rotated between <code>1</code> and <code>n</code> times.</li>\n</ul>\n"},"acRate":{"kind":"number","value":51.31937836335442,"string":"51.319378"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","binary-search"],"string":"[\n \"array\",\n \"binary-search\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"14\", 0.003], [\"20\", 0.003], [\"22\", 0.0302], [\"23\", 0.0362], [\"24\", 0.0543], [\"25\", 0.0392], [\"26\", 0.1539], [\"27\", 0.1569], [\"28\", 0.2142], [\"29\", 0.2414], [\"30\", 0.7815], [\"31\", 0.691], [\"32\", 0.9203], [\"33\", 1.2039], [\"34\", 2.6191], [\"35\", 1.8919], [\"36\", 2.8032], [\"37\", 3.7869], [\"38\", 5.5671], [\"39\", 4.2485], [\"40\", 5.0874], [\"41\", 7.45], [\"42\", 8.1289], [\"43\", 6.1797], [\"44\", 6.4512], [\"45\", 8.322], [\"46\", 7.5315], [\"47\", 5.6576], [\"48\", 4.6317], [\"49\", 4.9093], [\"50\", 3.4851]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16300\", 0.006], [\"16400\", 0.0332], [\"16500\", 0.1418], [\"16600\", 2.1967], [\"16700\", 18.8226], [\"16800\", 34.3985], [\"16900\", 38.0435]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left, right = 0, len(nums) - 1\n res = nums[0]\n while left <= right:\n mid = (left + right) // 2\n res = min(res, nums[mid])\n if nums[mid] >= nums[left]:\n if nums[mid] > nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n else:\n right = mid - 1\n return res\n","runtime":"14"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n \n l = 0\n r = len(nums) - 1\n left = nums[0]\n right = nums[-1]\n if left <= right:\n return left\n while l < r:\n m = (l+r) // 2\n elm = nums[m]\n if elm >= left:\n l = m + 1\n else:\n r = m\n return nums[l]","runtime":"20"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n lo = 0\n hi = len(nums) - 1\n\n while lo <= hi:\n md = (lo + hi) >> 1\n\n if nums[md] < nums[md - 1]:\n return nums[md]\n if nums[md] > nums[hi]:\n lo = md + 1\n else:\n hi = md - 1\n return nums[lo]","runtime":"22"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n result = nums[0]\n left, right = 0, len(nums) - 1\n\n while left <= right:\n if nums[left] < nums[right]:\n result = min(result, nums[left])\n break\n \n mid = left + (right - left) // 2\n\n result = min(nums[mid], result)\n\n if nums[mid] >= nums[left]:\n left = mid + 1\n else:\n right = mid - 1\n\n return result\n\n\n","runtime":"23"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left, right = 0, len(nums) - 1\n while left < right:\n if nums[left] < nums[right]:\n return nums[left]\n mid = int((left + right) // 2)\n if nums[mid] <= nums[right]:\n right = mid\n else:\n left = mid + 1\n\n return nums[left]","runtime":"24"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n\n l = 0 \n r = len(nums)-1\n\n while l<r:\n mid = (l+r)//2\n\n if nums[mid]>= nums[r]:\n l = mid+1\n else:\n r = mid\n return nums[l]\n ","runtime":"25"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n i = 0\n inflection = False\n while i < len(nums) - 1:\n if nums[i] > nums[i + 1]:\n inflection = True\n break\n\n i += 1\n\n if not inflection:\n return nums[0]\n\n return nums[i + 1]\n","runtime":"26"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n ptrL = 0\n ptrR = len(nums) - 1\n curr_min = float('inf')\n \n while ptrL < ptrR:\n mid = (ptrL + ptrR) // 2\n curr_min = min(nums[mid], curr_min)\n if nums[mid] > nums[ptrR]:\n ptrL = mid + 1\n else:\n ptrR = mid - 1\n\n return min(curr_min, nums[ptrL])\n\n ","runtime":"26"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n\n ## [4,5,6,7,0,1,2,3]\n l, r = 0, len(nums)-1\n\n while l<r:\n if nums[l]<nums[r]:\n return nums[l]\n mid = (l+r)//2\n\n if nums[mid]>=nums[l]:\n if nums[mid+1]<nums[mid]:\n return nums[mid+1]\n else:\n l = mid+1\n else:\n if nums[mid-1]>nums[mid]:\n return nums[mid]\n else:\n r = mid - 1\n\n return nums[l]","runtime":"27"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n low, high = 0, len(nums)-1\n while low +1 < high:\n mid = (low+high)//2\n print(low, high, mid)\n if nums[high] <= nums[mid]:\n low = mid\n else:\n high = mid\n return min (nums[high], nums[low])\n","runtime":"27"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l, r = 0, len(nums) - 1\n res = float('inf')\n\n while l <= r:\n mid = (l + r) // 2\n res = min(res, nums[mid])\n\n if nums[mid] > nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n \n return res","runtime":"28"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n if nums[-1] > nums[0]:\n return nums[0]\n left = 0\n right = len(nums) - 1\n while left < right:\n mid = (left+right) // 2\n if nums[mid] >= nums[0]:\n left = mid + 1\n else:\n right = mid\n return nums[left]","runtime":"28"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n if len(nums)==0:\n return -1\n\n left, right = 0, len(nums)-1\n res = nums[0]\n while left <= right:\n if nums[left] < nums[right]:\n res = min(nums[left], res)\n break\n \n mid = (left + right) //2\n res = min(res, nums[mid])\n if nums[mid] >= nums[right]:\n left = mid +1\n else:\n right = mid-1\n\n return res\n \n\n\n ","runtime":"29"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n #return min element of the array\n l,r = 0, len(nums) - 1\n currMin = float('inf')\n while l <= r:\n m = l + ((r-l) // 2)\n currMin = min(currMin, nums[m])\n if nums[m] > nums[r]:\n l = m + 1\n else:\n r = m -1 \n \n return currMin\n ","runtime":"30"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l,r = 0, len(nums)-1\n\n while l<r:\n mid = l + (r-l)//2\n if nums[mid]<nums[r]:\n r=mid\n else:\n l = mid+1\n\n \n return nums[l]","runtime":"30"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n= min(nums)\n return n","runtime":"31"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n if len(nums) == 1:\n return nums[0]\n\n # left pointer\n left = 0\n # right pointer\n right = len(nums) - 1\n\n # if the last element is greater than the first element then there is no rotation.\n # e.g. 1 < 2 < 3 < 4 < 5 < 7. Already sorted array.\n # Hence the smallest element is first element. A[0]\n if nums[right] > nums[0]:\n return nums[0]\n\n # Binary search way\n while right >= left:\n # Find the mid element\n mid = left + (right - left) // 2\n # if the mid element is greater than its next element then mid+1 element is the smallest\n # This point would be the point of change. From higher to lower value.\n if nums[mid] > nums[mid + 1]:\n return nums[mid + 1]\n # if the mid element is lesser than its previous element then mid element is the smallest\n if nums[mid - 1] > nums[mid]:\n return nums[mid]\n\n # if the mid elements value is greater than the 0th element this means\n # the least value is still somewhere to the right as we are still dealing with elements greater than nums[0]\n if nums[mid] > nums[0]:\n left = mid + 1\n # if nums[0] is greater than the mid value then this means the smallest value is somewhere to the left\n else:\n right = mid - 1","runtime":"31"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l, r = 0, len(nums) - 1\n\n while l < r:\n m = (l + r) // 2\n\n if nums[m] > nums[r]:\n l = m + 1\n else:\n r = m\n \n return nums[l]","runtime":"32"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n length = len(nums)\n l, r = 0, length - 1\n\n if nums[l] < nums[r]:\n return nums[l]\n \n while l < r:\n mid = (l+r)//2\n if nums[mid] > nums[r]:\n l = mid + 1\n else:\n r = mid\n return nums[l]","runtime":"32"},{"code":"from typing import *\nclass Solution:\n def findMin(self, nums: List[int]) -> int:\n size = len(nums)\n if len(nums)==1:\n return nums[0]\n left,right = 0,size - 1\n while left <= right:\n mid = (left + right) // 2\n print('left,mid,right: ', left,mid,right)\n if nums[left] < nums[right]:\n return nums[left]\n elif nums[left] == nums[right]:\n left += 1\n elif nums[left] > nums[right]:\n # k in the left-right\n if nums[mid] > nums[left]:\n left = mid + 1\n elif nums[mid] == nums[left]:\n if nums[mid] > nums[right]: \n left = mid + 1\n elif nums[mid] == nums[right]:\n left += 1\n right -= 1\n elif nums[mid] < nums[right]:\n right = mid - 1 \n elif nums[mid] < nums[left]:\n right = mid \n # print('left,mid,right: ', left,mid,right)\n return nums[mid]","runtime":"33"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)-1\n if nums[n] > nums[0]:\n return nums[0]\n \n l = 0\n r = len(nums)-1\n while l<r:\n mid = (l+r)//2\n if nums[r] > nums[mid]:\n r = mid\n else:\n l = mid + 1\n return nums[l]\n\n\n\n ","runtime":"33"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n ans = -1\n low = 0\n high = len(nums)-1\n mini = 10**5\n if nums[low] <= nums[high]:\n return nums[low] \n while low <= high:\n mid = (low+high)//2 \n if nums[low] <= nums[mid]: \n mini = min(mini, nums[low]) \n low = mid+1\n else:\n mini = min(mini, nums[mid]) \n high = mid-1\n \n return mini\n ","runtime":"34"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n def check(arr, index):\n if arr[0] > arr[index]:\n return 1\n else:\n return 0\n\n start = 0\n end = len(nums) - 1\n\n ans = nums[0]\n while start <= end:\n mid = (start + end) // 2\n\n if check(nums, mid) == 1:\n ans = nums[mid]\n end = mid - 1\n else:\n start = mid + 1\n\n return ans\n\n \n\n","runtime":"34"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l = 0 \n r = len(nums) - 1 \n res = nums[0]\n \n while l <= r:\n if nums[l] < nums[r]:\n res = min(res, nums[l])\n break \n\n mid = l + ((r - l) // 2)\n res = min(res, nums[mid])\n if nums[mid] >= nums[l]:\n l = mid + 1\n else:\n r = mid - 1\n \n return res","runtime":"35"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n first = nums[0]\n l = 0\n r = len(nums)-1\n if nums[0] < nums[-1]:\n return nums[0]\n\n while l < r:\n mid = (l+r)//2\n if nums[mid] < first:\n r = mid\n else:\n l = mid +1\n \n return nums[l]","runtime":"35"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left = 0\n right = len(nums) - 1\n\n while left < right:\n mid = (left + right) // 2\n\n if nums[mid] > nums[right]:\n left = mid + 1\n else:\n right = mid\n return nums[left]\n\n ","runtime":"36"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n low = 0\n high = n - 1\n minimum = float(\"inf\")\n while low <= high:\n mid = (low + high) // 2\n if nums[low] <= nums[high]:\n minimum = min(minimum, nums[low])\n break\n if nums[low] <= nums[mid]:\n minimum = min(minimum, nums[low])\n low = mid + 1\n else:\n minimum = min(minimum, nums[mid])\n high = mid - 1\n return minimum\n ","runtime":"36"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l, r = 0, len(nums) - 1\n\n while l < r:\n m = (l + r) // 2\n\n if nums[m] > nums[r]:\n l = m + 1\n else:\n r = m\n \n return nums[l]","runtime":"37"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(nums)","runtime":"37"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l = 0\n r = len(nums) -1 \n\n if nums[0] < nums[r]:\n return nums[0]\n\n while l < r:\n m = (l+r) // 2\n if nums[m-1] > nums[m] and nums[m] < nums[m+1]:\n return nums[m]\n if nums[m-1] < nums[m] and nums[m] > nums[m+1]:\n return nums[m+1]\n if nums[l] < nums[m] < nums[m+1]:\n l = m+1\n else:\n r = m-1\n \n return nums[l]\n","runtime":"38"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n start, end = 0, len(nums) - 1\n minElement = nums[0]\n\n while start <= end:\n if nums[start] <= nums[end]:\n return min(minElement, nums[start])\n \n mid = (start + end) // 2\n minElement = min(minElement, nums[mid])\n # we are in left sorted portion\n if nums[start] <= nums[mid]:\n start = mid + 1\n else:\n end = mid - 1\n\n \n ","runtime":"38"},{"code":" \nclass Solution(object):\n def findMin(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n l=0\n r=len(nums)-1\n\n while(l<r):\n m=l+(r-l)//2\n\n # print(l,m,r)\n if nums[r]>nums[m]:\n r=m\n else:\n\n l=m+1\n \n return nums[l]","runtime":"39"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l = 0\n r = len(nums)-1\n if(nums[l]<=nums[r]):\n return nums[l]\n while( l>=0 and r<= len(nums)-1 and l<=r):\n mid = l +(r-l)//2\n if(nums[mid]>nums[mid+1]):\n return nums[mid+1]\n if(nums[mid]<nums[mid-1]):\n return nums[mid]\n if(nums[mid]>nums[l]):\n l = mid+1\n else:\n r= mid -1\n \n\n\n ","runtime":"39"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l,r=0,len(nums)-1\n while l<r:\n m=l+(r-l)//2\n if nums[m]<nums[r]:\n r=m\n else:\n l=m+1\n return nums[l]","runtime":"40"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(nums)","runtime":"40"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n res = 5000\n l, r = 0, len(nums) - 1\n while l <= r:\n m = (l + r) // 2\n if nums[l] <= nums[r]:\n res = min(res, nums[l])\n return res\n else:\n if nums[m] <= nums[r]:\n res = min(res, nums[m])\n r = m - 1\n else:\n l = m + 1\n\n return res","runtime":"41"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l = 0\n r = len(nums)-1\n\n while l<=r:\n m = (l+r)//2\n L, M, R = nums[l], nums[m], nums[r]\n\n if L <= R:\n return L\n\n if M < R:\n r = m\n else:\n l = m + 1","runtime":"41"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n\n minn=float('inf')\n\n for i in nums:\n minn=min(minn,i)\n return minn\n ","runtime":"42"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n # n = len(nums)\n # low = 0\n # high = n - 1\n # minimum = float(\"inf\")\n # while low <= high:\n # mid = (low + high) // 2\n # if nums[low] <= nums[high]:\n # minimum = min(minimum, nums[low])\n # break\n # if nums[low] <= nums[mid]:\n # minimum = min(minimum, nums[low])\n # low = mid + 1\n # else:\n # minimum = min(minimum, nums[mid])\n # high = mid - 1\n # return minimum\n\n # Best solution\n n = len(nums)\n l = 0\n r = n -1\n while l<r:\n mid = (l+r)//2\n if nums[l] < nums[r]:\n return nums[l]\n # FIX: The left side of the tree is \"smaller\" so I need to do the\n # opposite check, because l==mid in the edge case\n # if nums[l] < nums[mid]:\n if nums[mid] > nums[r]:\n l = mid + 1\n else:\n r = mid\n return nums[l]\n\n # # Same but recursive\n # def bsearch(l, r, nums):\n # if l == r:\n # return nums[l]\n # mid = (l+r)//2\n # if nums[mid] > nums[r]:\n # return bsearch(mid+1, r, nums)\n # else: \n # return bsearch(l, mid, nums)\n # return bsearch(0, len(nums)-1 , nums)\n\n # My solution still did not work\n\n # minn = -1\n # def bsearch(l, r):\n # mid = (l+r)//2\n # if nums[l] <= nums[r]:\n # minn = min(minn, nums[l])\n # return min\n # if nums[l] <= nums[mid]:\n # minn = min(minn, nums[l])\n # return bsearch(mid+1, r)\n # else:\n # minn = min(minn, nums[mid])\n # return bsearch(l, mid)\n \n # return bsearch(0, len(nums)-1)\n\n # Error\n # Failed to test len(nums) == 1\n # How to make recursive call inside class function\n ","runtime":"42"},{"code":"class Solution:\n def findMin(self, arr: List[int]) -> int:\n n = len(arr)\n l = 0\n h = n - 1\n ans = float('inf')\n\n while l <= h:\n m = (l + h) // 2\n\n if arr[l] <= arr[h]:\n ans = min(arr[l], ans)\n break\n\n if arr[l] <= arr[m]:\n ans = min (ans, arr[l])\n l = m + 1\n else:\n ans = min(ans, arr[m])\n h = m - 1\n return ans\n ","runtime":"43"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left = 0\n right = len(nums)\n if nums[-1] >= nums[0]:\n return nums[0]\n \n while left < right:\n mid = (left + right) // 2\n if nums[mid] > nums[-1]:\n left = mid + 1\n else:\n right = mid\n\n return nums[left]","runtime":"43"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n low = 0\n high = n - 1\n minimum = float(\"inf\")\n while low <= high:\n mid = (low + high) // 2\n if nums[low] <= nums[high]:\n minimum = min(minimum, nums[low])\n break\n if nums[low] <= nums[mid]:\n minimum = min(minimum, nums[low])\n low = mid + 1\n else:\n minimum = min(minimum, nums[mid])\n high = mid - 1\n return minimum\n ","runtime":"44"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l = 0\n r = n-1\n\n while l < r:\n m = (l + r) // 2\n\n if nums[m] > nums[r]:\n l = m + 1\n else:\n r = m\n \n return nums[l]","runtime":"44"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l, r = 0, len(nums) - 1\n while l < r:\n m = (l + r) // 2\n\n if nums[m] > nums[r]:\n l = m + 1\n else:\n r = m\n \n return nums[l]","runtime":"45"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n res=nums[0]\n l,r=0,len(nums)-1\n #checknormalcase\n while l<=r:\n if nums[l]<nums[r]:\n res=min(res,nums[l])\n break\n #check for m \n m=(l+r)//2\n #check the middle pointer greater than L, search right ,,,\t\t\t\t\t\t\n res=min(res,nums[m])\n if nums[m] >=nums[l]:\n l=m+1\n else:\n #check middle pointer lesser than L,, search left \n r=m-1\n return res\n\n ","runtime":"45"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n low = 0\n high = len(nums) - 1\n ans = float(\"inf\")\n\n while low <= high:\n mid = (low + high) // 2\n\n ans = min(ans, nums[mid])\n\n if nums[low] <= nums[mid]:\n\n ans = min(ans, nums[low])\n low = mid + 1\n else:\n ans = min(ans, nums[mid])\n high = mid - 1\n\n return ans\n","runtime":"47"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n print((len(nums)-1)-nums.index(min(nums)))\n return min(nums)","runtime":"47"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n if nums[0]<nums[-1]:\n return nums[0]\n l = 0\n r = len(nums)-1\n while l<r:\n mid = (l+r)//2\n if nums[mid]>nums[r]:\n l = mid+1\n else:\n r = mid\n return nums[l]\n ","runtime":"48"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n low = 0\n high = len(nums) - 1\n while low <= high:\n if nums[low] <= nums[high]:\n return nums[low]\n mid = low + (high-low) // 2\n if (mid == low or nums[mid] < nums[mid-1]) and (mid == high or nums[mid] < nums[mid + 1]):\n return nums[mid]\n elif nums[low] <= nums[mid]:\n low = mid + 1\n else:\n high = mid - 1\n","runtime":"48"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n low = 0\n high = len(nums) - 1\n ans = float(\"inf\")\n\n while low <= high:\n mid = (low + high) // 2\n ans = min(ans, nums[mid])\n\n if nums[low] <= nums[mid]:\n ans = min(ans, nums[low])\n low = mid + 1\n else:\n ans = min(ans, nums[mid])\n high = mid - 1\n return ans\n","runtime":"49"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l, r = 0, len(nums) - 1\n while l < r:\n mid = l + (r-l) // 2\n if (nums[r] < nums[mid]):\n l = mid + 1\n else:\n r = mid\n return nums[l]","runtime":"49"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n ans = -1\n low = 0\n high = len(nums)-1\n mini = 10**5\n if nums[low] <= nums[high]:\n return nums[low] \n while low <= high:\n mid = (low+high)//2 \n if nums[low] <= nums[mid]: \n mini = min(mini, nums[low]) \n low = mid+1\n else:\n mini = min(mini, nums[mid]) \n high = mid-1\n \n return mini","runtime":"50"},{"code":"class Solution:\n '''\n [4,5,6,7,0,1,2]\n let the last element be 'last'\n if curr_val > last -> look towards the right\n if curr_val < last - check the left element, if lower - we go left, if not - we found the right value\n '''\n def findMin(self, nums: List[int]) -> int:\n if nums[0] <= nums[-1]:\n return nums[0]\n lo, hi = 0, len(nums) - 1\n last_val = nums[-1]\n while lo < hi:\n mid = (lo + hi) // 2\n mid_val = nums[mid]\n left_val = nums[mid - 1]\n right_val = nums[mid + 1]\n if mid_val > last_val:\n lo = mid + 1\n elif left_val > mid_val:\n return mid_val\n else:\n hi = mid - 1\n return nums[lo]\n \n \n\n\n\n\n ","runtime":"50"}],"string":"[\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left, right = 0, len(nums) - 1\\n res = nums[0]\\n while left <= right:\\n mid = (left + right) // 2\\n res = min(res, nums[mid])\\n if nums[mid] >= nums[left]:\\n if nums[mid] > nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n else:\\n right = mid - 1\\n return res\\n\",\n \"runtime\": \"14\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n \\n l = 0\\n r = len(nums) - 1\\n left = nums[0]\\n right = nums[-1]\\n if left <= right:\\n return left\\n while l < r:\\n m = (l+r) // 2\\n elm = nums[m]\\n if elm >= left:\\n l = m + 1\\n else:\\n r = m\\n return nums[l]\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n lo = 0\\n hi = len(nums) - 1\\n\\n while lo <= hi:\\n md = (lo + hi) >> 1\\n\\n if nums[md] < nums[md - 1]:\\n return nums[md]\\n if nums[md] > nums[hi]:\\n lo = md + 1\\n else:\\n hi = md - 1\\n return nums[lo]\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n result = nums[0]\\n left, right = 0, len(nums) - 1\\n\\n while left <= right:\\n if nums[left] < nums[right]:\\n result = min(result, nums[left])\\n break\\n \\n mid = left + (right - left) // 2\\n\\n result = min(nums[mid], result)\\n\\n if nums[mid] >= nums[left]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n return result\\n\\n\\n\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left, right = 0, len(nums) - 1\\n while left < right:\\n if nums[left] < nums[right]:\\n return nums[left]\\n mid = int((left + right) // 2)\\n if nums[mid] <= nums[right]:\\n right = mid\\n else:\\n left = mid + 1\\n\\n return nums[left]\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n\\n l = 0 \\n r = len(nums)-1\\n\\n while l<r:\\n mid = (l+r)//2\\n\\n if nums[mid]>= nums[r]:\\n l = mid+1\\n else:\\n r = mid\\n return nums[l]\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n i = 0\\n inflection = False\\n while i < len(nums) - 1:\\n if nums[i] > nums[i + 1]:\\n inflection = True\\n break\\n\\n i += 1\\n\\n if not inflection:\\n return nums[0]\\n\\n return nums[i + 1]\\n\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n ptrL = 0\\n ptrR = len(nums) - 1\\n curr_min = float('inf')\\n \\n while ptrL < ptrR:\\n mid = (ptrL + ptrR) // 2\\n curr_min = min(nums[mid], curr_min)\\n if nums[mid] > nums[ptrR]:\\n ptrL = mid + 1\\n else:\\n ptrR = mid - 1\\n\\n return min(curr_min, nums[ptrL])\\n\\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n\\n ## [4,5,6,7,0,1,2,3]\\n l, r = 0, len(nums)-1\\n\\n while l<r:\\n if nums[l]<nums[r]:\\n return nums[l]\\n mid = (l+r)//2\\n\\n if nums[mid]>=nums[l]:\\n if nums[mid+1]<nums[mid]:\\n return nums[mid+1]\\n else:\\n l = mid+1\\n else:\\n if nums[mid-1]>nums[mid]:\\n return nums[mid]\\n else:\\n r = mid - 1\\n\\n return nums[l]\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n low, high = 0, len(nums)-1\\n while low +1 < high:\\n mid = (low+high)//2\\n print(low, high, mid)\\n if nums[high] <= nums[mid]:\\n low = mid\\n else:\\n high = mid\\n return min (nums[high], nums[low])\\n\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l, r = 0, len(nums) - 1\\n res = float('inf')\\n\\n while l <= r:\\n mid = (l + r) // 2\\n res = min(res, nums[mid])\\n\\n if nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n \\n return res\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n if nums[-1] > nums[0]:\\n return nums[0]\\n left = 0\\n right = len(nums) - 1\\n while left < right:\\n mid = (left+right) // 2\\n if nums[mid] >= nums[0]:\\n left = mid + 1\\n else:\\n right = mid\\n return nums[left]\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n if len(nums)==0:\\n return -1\\n\\n left, right = 0, len(nums)-1\\n res = nums[0]\\n while left <= right:\\n if nums[left] < nums[right]:\\n res = min(nums[left], res)\\n break\\n \\n mid = (left + right) //2\\n res = min(res, nums[mid])\\n if nums[mid] >= nums[right]:\\n left = mid +1\\n else:\\n right = mid-1\\n\\n return res\\n \\n\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n #return min element of the array\\n l,r = 0, len(nums) - 1\\n currMin = float('inf')\\n while l <= r:\\n m = l + ((r-l) // 2)\\n currMin = min(currMin, nums[m])\\n if nums[m] > nums[r]:\\n l = m + 1\\n else:\\n r = m -1 \\n \\n return currMin\\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l,r = 0, len(nums)-1\\n\\n while l<r:\\n mid = l + (r-l)//2\\n if nums[mid]<nums[r]:\\n r=mid\\n else:\\n l = mid+1\\n\\n \\n return nums[l]\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n= min(nums)\\n return n\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n if len(nums) == 1:\\n return nums[0]\\n\\n # left pointer\\n left = 0\\n # right pointer\\n right = len(nums) - 1\\n\\n # if the last element is greater than the first element then there is no rotation.\\n # e.g. 1 < 2 < 3 < 4 < 5 < 7. Already sorted array.\\n # Hence the smallest element is first element. A[0]\\n if nums[right] > nums[0]:\\n return nums[0]\\n\\n # Binary search way\\n while right >= left:\\n # Find the mid element\\n mid = left + (right - left) // 2\\n # if the mid element is greater than its next element then mid+1 element is the smallest\\n # This point would be the point of change. From higher to lower value.\\n if nums[mid] > nums[mid + 1]:\\n return nums[mid + 1]\\n # if the mid element is lesser than its previous element then mid element is the smallest\\n if nums[mid - 1] > nums[mid]:\\n return nums[mid]\\n\\n # if the mid elements value is greater than the 0th element this means\\n # the least value is still somewhere to the right as we are still dealing with elements greater than nums[0]\\n if nums[mid] > nums[0]:\\n left = mid + 1\\n # if nums[0] is greater than the mid value then this means the smallest value is somewhere to the left\\n else:\\n right = mid - 1\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l, r = 0, len(nums) - 1\\n\\n while l < r:\\n m = (l + r) // 2\\n\\n if nums[m] > nums[r]:\\n l = m + 1\\n else:\\n r = m\\n \\n return nums[l]\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n length = len(nums)\\n l, r = 0, length - 1\\n\\n if nums[l] < nums[r]:\\n return nums[l]\\n \\n while l < r:\\n mid = (l+r)//2\\n if nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r = mid\\n return nums[l]\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"from typing import *\\nclass Solution:\\n def findMin(self, nums: List[int]) -> int:\\n size = len(nums)\\n if len(nums)==1:\\n return nums[0]\\n left,right = 0,size - 1\\n while left <= right:\\n mid = (left + right) // 2\\n print('left,mid,right: ', left,mid,right)\\n if nums[left] < nums[right]:\\n return nums[left]\\n elif nums[left] == nums[right]:\\n left += 1\\n elif nums[left] > nums[right]:\\n # k in the left-right\\n if nums[mid] > nums[left]:\\n left = mid + 1\\n elif nums[mid] == nums[left]:\\n if nums[mid] > nums[right]: \\n left = mid + 1\\n elif nums[mid] == nums[right]:\\n left += 1\\n right -= 1\\n elif nums[mid] < nums[right]:\\n right = mid - 1 \\n elif nums[mid] < nums[left]:\\n right = mid \\n # print('left,mid,right: ', left,mid,right)\\n return nums[mid]\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)-1\\n if nums[n] > nums[0]:\\n return nums[0]\\n \\n l = 0\\n r = len(nums)-1\\n while l<r:\\n mid = (l+r)//2\\n if nums[r] > nums[mid]:\\n r = mid\\n else:\\n l = mid + 1\\n return nums[l]\\n\\n\\n\\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n ans = -1\\n low = 0\\n high = len(nums)-1\\n mini = 10**5\\n if nums[low] <= nums[high]:\\n return nums[low] \\n while low <= high:\\n mid = (low+high)//2 \\n if nums[low] <= nums[mid]: \\n mini = min(mini, nums[low]) \\n low = mid+1\\n else:\\n mini = min(mini, nums[mid]) \\n high = mid-1\\n \\n return mini\\n \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n def check(arr, index):\\n if arr[0] > arr[index]:\\n return 1\\n else:\\n return 0\\n\\n start = 0\\n end = len(nums) - 1\\n\\n ans = nums[0]\\n while start <= end:\\n mid = (start + end) // 2\\n\\n if check(nums, mid) == 1:\\n ans = nums[mid]\\n end = mid - 1\\n else:\\n start = mid + 1\\n\\n return ans\\n\\n \\n\\n\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l = 0 \\n r = len(nums) - 1 \\n res = nums[0]\\n \\n while l <= r:\\n if nums[l] < nums[r]:\\n res = min(res, nums[l])\\n break \\n\\n mid = l + ((r - l) // 2)\\n res = min(res, nums[mid])\\n if nums[mid] >= nums[l]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n \\n return res\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n first = nums[0]\\n l = 0\\n r = len(nums)-1\\n if nums[0] < nums[-1]:\\n return nums[0]\\n\\n while l < r:\\n mid = (l+r)//2\\n if nums[mid] < first:\\n r = mid\\n else:\\n l = mid +1\\n \\n return nums[l]\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left = 0\\n right = len(nums) - 1\\n\\n while left < right:\\n mid = (left + right) // 2\\n\\n if nums[mid] > nums[right]:\\n left = mid + 1\\n else:\\n right = mid\\n return nums[left]\\n\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n low = 0\\n high = n - 1\\n minimum = float(\\\"inf\\\")\\n while low <= high:\\n mid = (low + high) // 2\\n if nums[low] <= nums[high]:\\n minimum = min(minimum, nums[low])\\n break\\n if nums[low] <= nums[mid]:\\n minimum = min(minimum, nums[low])\\n low = mid + 1\\n else:\\n minimum = min(minimum, nums[mid])\\n high = mid - 1\\n return minimum\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l, r = 0, len(nums) - 1\\n\\n while l < r:\\n m = (l + r) // 2\\n\\n if nums[m] > nums[r]:\\n l = m + 1\\n else:\\n r = m\\n \\n return nums[l]\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(nums)\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l = 0\\n r = len(nums) -1 \\n\\n if nums[0] < nums[r]:\\n return nums[0]\\n\\n while l < r:\\n m = (l+r) // 2\\n if nums[m-1] > nums[m] and nums[m] < nums[m+1]:\\n return nums[m]\\n if nums[m-1] < nums[m] and nums[m] > nums[m+1]:\\n return nums[m+1]\\n if nums[l] < nums[m] < nums[m+1]:\\n l = m+1\\n else:\\n r = m-1\\n \\n return nums[l]\\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n start, end = 0, len(nums) - 1\\n minElement = nums[0]\\n\\n while start <= end:\\n if nums[start] <= nums[end]:\\n return min(minElement, nums[start])\\n \\n mid = (start + end) // 2\\n minElement = min(minElement, nums[mid])\\n # we are in left sorted portion\\n if nums[start] <= nums[mid]:\\n start = mid + 1\\n else:\\n end = mid - 1\\n\\n \\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \" \\nclass Solution(object):\\n def findMin(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n l=0\\n r=len(nums)-1\\n\\n while(l<r):\\n m=l+(r-l)//2\\n\\n # print(l,m,r)\\n if nums[r]>nums[m]:\\n r=m\\n else:\\n\\n l=m+1\\n \\n return nums[l]\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l = 0\\n r = len(nums)-1\\n if(nums[l]<=nums[r]):\\n return nums[l]\\n while( l>=0 and r<= len(nums)-1 and l<=r):\\n mid = l +(r-l)//2\\n if(nums[mid]>nums[mid+1]):\\n return nums[mid+1]\\n if(nums[mid]<nums[mid-1]):\\n return nums[mid]\\n if(nums[mid]>nums[l]):\\n l = mid+1\\n else:\\n r= mid -1\\n \\n\\n\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l,r=0,len(nums)-1\\n while l<r:\\n m=l+(r-l)//2\\n if nums[m]<nums[r]:\\n r=m\\n else:\\n l=m+1\\n return nums[l]\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(nums)\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n res = 5000\\n l, r = 0, len(nums) - 1\\n while l <= r:\\n m = (l + r) // 2\\n if nums[l] <= nums[r]:\\n res = min(res, nums[l])\\n return res\\n else:\\n if nums[m] <= nums[r]:\\n res = min(res, nums[m])\\n r = m - 1\\n else:\\n l = m + 1\\n\\n return res\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l = 0\\n r = len(nums)-1\\n\\n while l<=r:\\n m = (l+r)//2\\n L, M, R = nums[l], nums[m], nums[r]\\n\\n if L <= R:\\n return L\\n\\n if M < R:\\n r = m\\n else:\\n l = m + 1\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n\\n minn=float('inf')\\n\\n for i in nums:\\n minn=min(minn,i)\\n return minn\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n # n = len(nums)\\n # low = 0\\n # high = n - 1\\n # minimum = float(\\\"inf\\\")\\n # while low <= high:\\n # mid = (low + high) // 2\\n # if nums[low] <= nums[high]:\\n # minimum = min(minimum, nums[low])\\n # break\\n # if nums[low] <= nums[mid]:\\n # minimum = min(minimum, nums[low])\\n # low = mid + 1\\n # else:\\n # minimum = min(minimum, nums[mid])\\n # high = mid - 1\\n # return minimum\\n\\n # Best solution\\n n = len(nums)\\n l = 0\\n r = n -1\\n while l<r:\\n mid = (l+r)//2\\n if nums[l] < nums[r]:\\n return nums[l]\\n # FIX: The left side of the tree is \\\"smaller\\\" so I need to do the\\n # opposite check, because l==mid in the edge case\\n # if nums[l] < nums[mid]:\\n if nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r = mid\\n return nums[l]\\n\\n # # Same but recursive\\n # def bsearch(l, r, nums):\\n # if l == r:\\n # return nums[l]\\n # mid = (l+r)//2\\n # if nums[mid] > nums[r]:\\n # return bsearch(mid+1, r, nums)\\n # else: \\n # return bsearch(l, mid, nums)\\n # return bsearch(0, len(nums)-1 , nums)\\n\\n # My solution still did not work\\n\\n # minn = -1\\n # def bsearch(l, r):\\n # mid = (l+r)//2\\n # if nums[l] <= nums[r]:\\n # minn = min(minn, nums[l])\\n # return min\\n # if nums[l] <= nums[mid]:\\n # minn = min(minn, nums[l])\\n # return bsearch(mid+1, r)\\n # else:\\n # minn = min(minn, nums[mid])\\n # return bsearch(l, mid)\\n \\n # return bsearch(0, len(nums)-1)\\n\\n # Error\\n # Failed to test len(nums) == 1\\n # How to make recursive call inside class function\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, arr: List[int]) -> int:\\n n = len(arr)\\n l = 0\\n h = n - 1\\n ans = float('inf')\\n\\n while l <= h:\\n m = (l + h) // 2\\n\\n if arr[l] <= arr[h]:\\n ans = min(arr[l], ans)\\n break\\n\\n if arr[l] <= arr[m]:\\n ans = min (ans, arr[l])\\n l = m + 1\\n else:\\n ans = min(ans, arr[m])\\n h = m - 1\\n return ans\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left = 0\\n right = len(nums)\\n if nums[-1] >= nums[0]:\\n return nums[0]\\n \\n while left < right:\\n mid = (left + right) // 2\\n if nums[mid] > nums[-1]:\\n left = mid + 1\\n else:\\n right = mid\\n\\n return nums[left]\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n low = 0\\n high = n - 1\\n minimum = float(\\\"inf\\\")\\n while low <= high:\\n mid = (low + high) // 2\\n if nums[low] <= nums[high]:\\n minimum = min(minimum, nums[low])\\n break\\n if nums[low] <= nums[mid]:\\n minimum = min(minimum, nums[low])\\n low = mid + 1\\n else:\\n minimum = min(minimum, nums[mid])\\n high = mid - 1\\n return minimum\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l = 0\\n r = n-1\\n\\n while l < r:\\n m = (l + r) // 2\\n\\n if nums[m] > nums[r]:\\n l = m + 1\\n else:\\n r = m\\n \\n return nums[l]\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l, r = 0, len(nums) - 1\\n while l < r:\\n m = (l + r) // 2\\n\\n if nums[m] > nums[r]:\\n l = m + 1\\n else:\\n r = m\\n \\n return nums[l]\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n res=nums[0]\\n l,r=0,len(nums)-1\\n #checknormalcase\\n while l<=r:\\n if nums[l]<nums[r]:\\n res=min(res,nums[l])\\n break\\n #check for m \\n m=(l+r)//2\\n #check the middle pointer greater than L, search right ,,,\\t\\t\\t\\t\\t\\t\\n res=min(res,nums[m])\\n if nums[m] >=nums[l]:\\n l=m+1\\n else:\\n #check middle pointer lesser than L,, search left \\n r=m-1\\n return res\\n\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n low = 0\\n high = len(nums) - 1\\n ans = float(\\\"inf\\\")\\n\\n while low <= high:\\n mid = (low + high) // 2\\n\\n ans = min(ans, nums[mid])\\n\\n if nums[low] <= nums[mid]:\\n\\n ans = min(ans, nums[low])\\n low = mid + 1\\n else:\\n ans = min(ans, nums[mid])\\n high = mid - 1\\n\\n return ans\\n\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n print((len(nums)-1)-nums.index(min(nums)))\\n return min(nums)\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n if nums[0]<nums[-1]:\\n return nums[0]\\n l = 0\\n r = len(nums)-1\\n while l<r:\\n mid = (l+r)//2\\n if nums[mid]>nums[r]:\\n l = mid+1\\n else:\\n r = mid\\n return nums[l]\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n low = 0\\n high = len(nums) - 1\\n while low <= high:\\n if nums[low] <= nums[high]:\\n return nums[low]\\n mid = low + (high-low) // 2\\n if (mid == low or nums[mid] < nums[mid-1]) and (mid == high or nums[mid] < nums[mid + 1]):\\n return nums[mid]\\n elif nums[low] <= nums[mid]:\\n low = mid + 1\\n else:\\n high = mid - 1\\n\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n low = 0\\n high = len(nums) - 1\\n ans = float(\\\"inf\\\")\\n\\n while low <= high:\\n mid = (low + high) // 2\\n ans = min(ans, nums[mid])\\n\\n if nums[low] <= nums[mid]:\\n ans = min(ans, nums[low])\\n low = mid + 1\\n else:\\n ans = min(ans, nums[mid])\\n high = mid - 1\\n return ans\\n\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l, r = 0, len(nums) - 1\\n while l < r:\\n mid = l + (r-l) // 2\\n if (nums[r] < nums[mid]):\\n l = mid + 1\\n else:\\n r = mid\\n return nums[l]\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n ans = -1\\n low = 0\\n high = len(nums)-1\\n mini = 10**5\\n if nums[low] <= nums[high]:\\n return nums[low] \\n while low <= high:\\n mid = (low+high)//2 \\n if nums[low] <= nums[mid]: \\n mini = min(mini, nums[low]) \\n low = mid+1\\n else:\\n mini = min(mini, nums[mid]) \\n high = mid-1\\n \\n return mini\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n '''\\n [4,5,6,7,0,1,2]\\n let the last element be 'last'\\n if curr_val > last -> look towards the right\\n if curr_val < last - check the left element, if lower - we go left, if not - we found the right value\\n '''\\n def findMin(self, nums: List[int]) -> int:\\n if nums[0] <= nums[-1]:\\n return nums[0]\\n lo, hi = 0, len(nums) - 1\\n last_val = nums[-1]\\n while lo < hi:\\n mid = (lo + hi) // 2\\n mid_val = nums[mid]\\n left_val = nums[mid - 1]\\n right_val = nums[mid + 1]\\n if mid_val > last_val:\\n lo = mid + 1\\n elif left_val > mid_val:\\n return mid_val\\n else:\\n hi = mid - 1\\n return nums[lo]\\n \\n \\n\\n\\n\\n\\n \",\n \"runtime\": \"50\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":53,"string":"53"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n\n def findMin(self, nums: List[int]) -> int:\n left, right = 0, len(nums) - 1\n \n while left <right:\n mid = (left + right) // 2\n \n if nums[mid] > nums[right]:\n # Minimum is in the right part\n left = mid + 1\n else:\n # Minimum could be at mid or in the left part\n right = mid\n \n # After the loop, left == right and points to the minimum element\n return nums[left]\n\n ","memory":"16300"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l, r = 0, len(nums)-1\n res = float(\"inf\")\n while l <= r:\n mid = (l+r)//2\n res = min(res, nums[mid])\n if nums[mid] < nums[r]:\n r = mid-1\n else:\n l = mid+1\n return res\n","memory":"16400"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l = 0\n r = len(nums)-1\n while l < r:\n m = (l+r)//2\n if nums[m] > nums[r]:\n l = m + 1\n else:\n r = m\n return nums[r] ","memory":"16500"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l, r = 0, len(nums) - 1\n\n while l < r:\n m = (l + r) // 2\n\n if nums[m] > nums[r]:\n l = m + 1\n else:\n r = m\n \n return nums[l]","memory":"16600"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n \n l, r = 0, len(nums)-1\n\n while l<r:\n\n mid = l + (r-l) // 2\n\n if nums[mid] > nums[r]:\n l = mid + 1\n else:\n r = mid\n\n\n return nums[l]","memory":"16600"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n\n l, r = 0, n-1\n\n while l<r:\n mid = (l+r)//2\n\n if nums[r]<nums[mid]:\n l = mid + 1\n else:\n r = mid\n return nums[l]\n","memory":"16700"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n minimum = nums[0]\n \n for n in nums:\n if n < minimum:\n minimum = n\n return minimum","memory":"16700"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n\n # lets find pivot\n\n left, right = 0, len(nums) - 1\n\n while left < right:\n\n mid = (left + right) // 2\n\n if nums[mid] > nums[right]:\n left = mid + 1\n else:\n right = mid\n\n return nums[left]\n ","memory":"16800"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n \n left = 0\n right = len(nums) -1\n\n while left < right: \n mid = (left + right)//2\n\n if nums[mid] > nums[right]:\n left = mid +1\n else:\n right = mid\n\n return nums[left]","memory":"16800"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n \n \n if len(nums) == 1 : \n return nums[0] \n \n left = 0 \n right = len(nums) -1 \n \n if nums[right] > nums[0] : \n return nums[0] \n \n while left <= right : \n mid = left + ( right - left)//2 \n print(mid)\n if nums[mid-1] > nums[mid] : \n return nums[mid] \n \n if nums[mid] > nums[mid+1] : \n return nums[mid+1]\n \n if nums[mid] > nums[0] : \n left = mid + 1\n else : \n right = mid -1 \n ","memory":"16900"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left=0\n right=len(nums)-1\n while left<right:\n mid=left+(right-left)//2\n if nums[mid]>nums[right]:\n left=mid+1\n else:\n right=mid\n return nums[left]\n\n ","memory":"16900"}],"string":"[\n {\n \"code\": \"class Solution:\\n\\n def findMin(self, nums: List[int]) -> int:\\n left, right = 0, len(nums) - 1\\n \\n while left <right:\\n mid = (left + right) // 2\\n \\n if nums[mid] > nums[right]:\\n # Minimum is in the right part\\n left = mid + 1\\n else:\\n # Minimum could be at mid or in the left part\\n right = mid\\n \\n # After the loop, left == right and points to the minimum element\\n return nums[left]\\n\\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l, r = 0, len(nums)-1\\n res = float(\\\"inf\\\")\\n while l <= r:\\n mid = (l+r)//2\\n res = min(res, nums[mid])\\n if nums[mid] < nums[r]:\\n r = mid-1\\n else:\\n l = mid+1\\n return res\\n\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l = 0\\n r = len(nums)-1\\n while l < r:\\n m = (l+r)//2\\n if nums[m] > nums[r]:\\n l = m + 1\\n else:\\n r = m\\n return nums[r] \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l, r = 0, len(nums) - 1\\n\\n while l < r:\\n m = (l + r) // 2\\n\\n if nums[m] > nums[r]:\\n l = m + 1\\n else:\\n r = m\\n \\n return nums[l]\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n \\n l, r = 0, len(nums)-1\\n\\n while l<r:\\n\\n mid = l + (r-l) // 2\\n\\n if nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r = mid\\n\\n\\n return nums[l]\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n\\n l, r = 0, n-1\\n\\n while l<r:\\n mid = (l+r)//2\\n\\n if nums[r]<nums[mid]:\\n l = mid + 1\\n else:\\n r = mid\\n return nums[l]\\n\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n minimum = nums[0]\\n \\n for n in nums:\\n if n < minimum:\\n minimum = n\\n return minimum\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n\\n # lets find pivot\\n\\n left, right = 0, len(nums) - 1\\n\\n while left < right:\\n\\n mid = (left + right) // 2\\n\\n if nums[mid] > nums[right]:\\n left = mid + 1\\n else:\\n right = mid\\n\\n return nums[left]\\n \",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n \\n left = 0\\n right = len(nums) -1\\n\\n while left < right: \\n mid = (left + right)//2\\n\\n if nums[mid] > nums[right]:\\n left = mid +1\\n else:\\n right = mid\\n\\n return nums[left]\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n \\n \\n if len(nums) == 1 : \\n return nums[0] \\n \\n left = 0 \\n right = len(nums) -1 \\n \\n if nums[right] > nums[0] : \\n return nums[0] \\n \\n while left <= right : \\n mid = left + ( right - left)//2 \\n print(mid)\\n if nums[mid-1] > nums[mid] : \\n return nums[mid] \\n \\n if nums[mid] > nums[mid+1] : \\n return nums[mid+1]\\n \\n if nums[mid] > nums[0] : \\n left = mid + 1\\n else : \\n right = mid -1 \\n \",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left=0\\n right=len(nums)-1\\n while left<right:\\n mid=left+(right-left)//2\\n if nums[mid]>nums[right]:\\n left=mid+1\\n else:\\n right=mid\\n return nums[left]\\n\\n \",\n \"memory\": \"16900\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":11,"string":"11"}}},{"rowIdx":58,"cells":{"question_id":{"kind":"number","value":154,"string":"154"},"name":{"kind":"string","value":"find-minimum-in-rotated-sorted-array-ii"},"content":{"kind":"string","value":"<p>Suppose an array of length <code>n</code> sorted in ascending order is <strong>rotated</strong> between <code>1</code> and <code>n</code> times. For example, the array <code>nums = [0,1,4,4,5,6,7]</code> might become:</p>\n\n<ul>\n\t<li><code>[4,5,6,7,0,1,4]</code> if it was rotated <code>4</code> times.</li>\n\t<li><code>[0,1,4,4,5,6,7]</code> if it was rotated <code>7</code> times.</li>\n</ul>\n\n<p>Notice that <strong>rotating</strong> an array <code>[a[0], a[1], a[2], ..., a[n-1]]</code> 1 time results in the array <code>[a[n-1], a[0], a[1], a[2], ..., a[n-2]]</code>.</p>\n\n<p>Given the sorted rotated array <code>nums</code> that may contain <strong>duplicates</strong>, return <em>the minimum element of this array</em>.</p>\n\n<p>You must decrease the overall operation steps as much as possible.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<pre><strong>Input:</strong> nums = [1,3,5]\n<strong>Output:</strong> 1\n</pre><p><strong class=\"example\">Example 2:</strong></p>\n<pre><strong>Input:</strong> nums = [2,2,2,0,1]\n<strong>Output:</strong> 0\n</pre>\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>n == nums.length</code></li>\n\t<li><code>1 <= n <= 5000</code></li>\n\t<li><code>-5000 <= nums[i] <= 5000</code></li>\n\t<li><code>nums</code> is sorted and rotated between <code>1</code> and <code>n</code> times.</li>\n</ul>\n\n<p> </p>\n<p><strong>Follow up:</strong> This problem is similar to <a href=\"https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/\" target=\"_blank\">Find Minimum in Rotated Sorted Array</a>, but <code>nums</code> may contain <strong>duplicates</strong>. Would this affect the runtime complexity? How and why?</p>\n\n<p> </p>\n"},"acRate":{"kind":"number","value":43.75527569869352,"string":"43.755276"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","binary-search"],"string":"[\n \"array\",\n \"binary-search\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"27\", 0.0376], [\"29\", 0.0376], [\"30\", 0.0376], [\"32\", 0.0751], [\"33\", 0.0751], [\"34\", 0.1502], [\"35\", 0.338], [\"36\", 0.1127], [\"37\", 0.1878], [\"38\", 0.6384], [\"39\", 0.7886], [\"40\", 0.4882], [\"41\", 1.1265], [\"42\", 2.8539], [\"43\", 1.9151], [\"44\", 1.427], [\"45\", 2.6286], [\"46\", 5.4074], [\"47\", 4.6189], [\"48\", 3.8303], [\"49\", 5.0319], [\"50\", 7.3977], [\"51\", 7.1724], [\"52\", 5.9707], [\"53\", 6.8719], [\"54\", 7.5479], [\"55\", 7.0222], [\"56\", 4.8066], [\"57\", 5.5952], [\"58\", 4.6189], [\"59\", 3.6801]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16700\", 0.1127], [\"16800\", 0.5257], [\"16900\", 8.4116], [\"17000\", 25.6478], [\"17100\", 44.6489]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def findMin(self, a: List[int]) -> int:\n beg=0\n last=len(a)-1\n while beg<last:\n mid=(last+beg)//2\n if a[mid]>a[last]:\n beg=mid+1\n elif a[mid]<a[last]:\n last=mid\n else:\n last-=1\n return a[beg]","runtime":"27"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(nums)","runtime":"29"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n nums.sort()\n return nums[0] ","runtime":"30"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(nums)","runtime":"32"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left = 0\n right = len(nums) - 1\n\n while left<=right:\n mid = (left + right)>>1\n\n if nums[mid] < nums[right]:\n right = mid\n elif nums[mid]>nums[right]:\n left = mid + 1\n else:\n right-=1\n return nums[left]","runtime":"33"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l = 0\n r = len(nums) - 1\n while l < r:\n mid = (l + r) // 2\n if nums[r] < nums[mid]:\n l = mid + 1\n elif nums[r] > nums[mid]:\n r = mid\n else:\n r -= 1\n return nums[l]","runtime":"34"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left = 0 \n right = len(nums) - 1\n \n while left < right: \n mid = (left + right) // 2\n \n if nums[mid] < nums[right]: \n right = mid\n elif nums[mid] > nums[right]:\n left = mid + 1\n elif nums[mid] == nums[right]:\n right = right - 1\n return nums[left]\n \n \n # 3 3 1 3\n # 1 3 3 ","runtime":"35"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l = 0\n r = len(nums)-1\n while l<=r:\n mid = (l+r)//2\n if nums[mid]>nums[r]:\n l = mid+1\n elif nums[mid] == nums[r]:\n r-=1\n else:\n r = mid\n return nums[l]\n ","runtime":"36"},{"code":"\nclass Solution:\n def findMin(self, nums: List[int]) -> int:\n\n l, r = 0, len(nums)-1\n mini = nums[0]\n\n while l <= r:\n mid = (l+r)//2\n if nums[mid] > nums[r]:\n mini = min(nums[l],mini)\n l = mid + 1\n elif nums[mid] < nums[l]:\n mini = min(mini, nums[mid])\n r = mid - 1\n else:\n mini = min(mini, nums[mid])\n r -= 1\n\n return mini\n \n \n ","runtime":"37"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n lo, hi = 0, len(nums)-1\n while lo<=hi:\n mid = (lo+hi)//2\n if nums[mid]==nums[hi]:\n hi -= 1\n elif nums[mid]>nums[hi]:\n lo = mid+1\n else:\n hi = mid\n return nums[lo]\n \n","runtime":"38"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(nums)\n ","runtime":"39"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left, right = 0, len(nums) -1\n \n while left < right:\n mid = (left + right) // 2\n \n if nums[mid] > nums[right]:\n left = mid + 1\n elif nums[mid] < nums[right]:\n right = mid\n else:\n right -=1\n return nums[left]","runtime":"40"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(nums)","runtime":"40"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n N = len(nums)\n def foo(a,b):\n if a +1 >= b: \n yield min(nums[a],nums[b])\n return\n m = (a+b) // 2\n while not nums[(m+1) % N] > nums[m] < nums[m-1]:\n yield nums[m]\n if nums[m] < nums[b]:\n b = m\n elif nums[m] > nums[b]:\n a = m+1\n else:\n if nums[a] != nums[m]:\n b = m\n else: \n f1 = foo(a,m)\n f2 = foo(m,b)\n for l1,l2 in zip(f1,f2):\n if l1 != l2: break\n if l1 < l2: \n yield l1\n yield from f1\n else:\n yield l2 \n yield from f2\n return\n \n m = (a+b) // 2\n \n yield nums[m]\n *_,last = foo(0,N-1)\n return last\n","runtime":"41"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l = 0\n r = len(nums)-1\n while l<r:\n if nums[l+1]<nums[l]:\n return nums[l+1]\n if nums[r-1]>nums[r]:\n return nums[r]\n l+=1\n r-=1\n return nums[0]","runtime":"41"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n maxi=nums[0]\n for i in range(len(nums)):\n if maxi>nums[i]:\n maxi=nums[i]\n return maxi\n ","runtime":"42"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left = 0\n right = len(nums) - 1\n\n \n while left < right:\n mid = (left + right) // 2\n \n if nums[mid] > nums[right]:\n left = mid + 1\n elif nums[mid] < nums[right]:\n right = mid\n else:\n right -= 1\n \n \n return nums[left]","runtime":"42"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left, right = 0, len(nums) - 1\n \n while left < right:\n mid = (left + right) // 2\n \n if nums[mid] > nums[right]:\n # Minimum must be in the right half\n left = mid + 1\n elif nums[mid] < nums[right]:\n # Minimum could be in the left half or at mid\n right = mid\n else:\n # nums[mid] == nums[right], cannot determine which side is sorted\n # Reduce the search space\n right -= 1\n \n return nums[left]","runtime":"43"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l = 0\n r = len(nums)-1\n while l<r:\n mid = (l+r)//2\n if nums[mid] < nums[r]:\n r = mid\n elif nums[mid] > nums[r]:\n l = mid + 1\n else:\n r -= 1\n\n return nums[l]\n ","runtime":"44"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(nums)\n ","runtime":"44"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(nums)\n ","runtime":"45"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n # Approach 2024.09.16\n l = 0\n r = len(nums) - 1\n while l < r:\n m = (l + r) // 2\n mv = nums[m]\n if mv == nums[r]:\n r -= 1\n elif mv < nums[r]:\n r = m\n else:\n l = m + 1\n return nums[l]","runtime":"45"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n N = len(nums)\n def foo(a,b):\n if a +1 >= b: \n yield min(nums[a],nums[b])\n return\n m = (a+b) // 2\n while not nums[(m+1) % N] > nums[m] < nums[m-1]:\n print(nums[a],nums[m],nums[b])\n yield nums[m]\n if nums[m] < nums[b]:\n b = m\n elif nums[m] > nums[b]:\n a = m+1\n else:\n if nums[a] != nums[m]:\n b = m\n else: \n f1 = foo(a,m)\n f2 = foo(m,b)\n for l1,l2 in zip(f1,f2):\n if l1 != l2: break\n if l1 < l2: \n yield l1\n yield from f1\n else:\n yield l2 \n yield from f2\n return\n \n m = (a+b) // 2\n \n yield nums[m]\n *_,last = foo(0,N-1)\n return last\n","runtime":"46"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n if n == 2:\n if nums[0] < nums[1]:\n return nums[0]\n else:\n return nums[1]\n while l < r:\n mid = l + (r - l) // 2\n \n if nums[mid] < nums[l]:\n r = mid\n elif nums[mid] > nums[r]:\n l = mid + 1\n else:\n r -= 1\n \n return nums[l]\n \n\n ","runtime":"46"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(nums)\n ","runtime":"47"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n nums.sort()\n return nums[0]\n ","runtime":"48"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left, right = 0, len(nums) - 1\n\n while left < right:\n mid = left + (right - left) // 2\n\n if nums[mid] < nums[right]:\n # The right half is sorted, so the minimum must be in the left half (or mid itself)\n right = mid \n elif nums[mid] > nums[right]:\n # The left half is sorted, so the minimum must be in the right half\n left = mid + 1\n else:\n # nums[mid] == nums[right], we can't be certain where the minimum lies\n # But we know nums[right] is not the minimum, so we can safely decrement right\n right -= 1\n\n return nums[left] ","runtime":"48"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n l,r=0,len(nums)-1\n while l<r:\n mid=(l+r)//2\n if nums[mid]>nums[r]:\n l=mid+1\n elif nums[mid]<nums[r]:\n r=mid\n else:\n r-=1\n return nums[l]","runtime":"49"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(nums)\n ","runtime":"49"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n if n == 2:\n if nums[0] < nums[1]:\n return nums[0]\n else:\n return nums[1]\n while l < r:\n mid = l + (r - l) // 2\n \n if nums[mid] < nums[l]:\n r = mid\n elif nums[mid] > nums[r]:\n l = mid + 1\n else:\n r -= 1\n \n return nums[l]\n \n\n ","runtime":"50"},{"code":"from typing import *\nclass Solution:\n def findMin(self, nums: List[int]) -> int:\n size = len(nums)\n if len(nums)==1:\n return nums[0]\n left,right = 0,size - 1\n while left <= right:\n mid = (left + right) // 2\n # print('left,mid,right: ', left,mid,right)\n if nums[left] < nums[right]:\n return nums[left]\n elif nums[left] == nums[right]:\n left += 1\n elif nums[left] > nums[right]:\n # k in the left-right\n if nums[mid] > nums[left]:\n left = mid + 1\n elif nums[mid] == nums[left]:\n if nums[mid] > nums[right]: \n left = mid + 1\n elif nums[mid] == nums[right]:\n left += 1\n right -= 1\n elif nums[mid] < nums[right]:\n right = mid \n elif nums[mid] < nums[left]:\n right = mid \n # print('left,mid,right: ', left,mid,right)\n return nums[mid]","runtime":"50"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n if n == 2:\n if nums[0] < nums[1]:\n return nums[0]\n else:\n return nums[1]\n while l < r-1:\n mid = l + (r - l) // 2\n print(mid)\n if nums[mid] < nums[l]:\n print('elif')\n r = mid\n elif nums[mid] > nums[r]:\n print('if')\n l = mid\n else:\n r -= 1\n \n print(l, r, mid)\n if nums[l] < nums[r]:\n return nums[l]\n else:\n return nums[r]\n \n\n ","runtime":"51"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n if nums[0] < nums[n-1]:\n return nums[0]\n\n left = 0\n right = n-1\n\n while left < right:\n mid = (left + right) // 2\n if nums[left] < nums[mid]:\n if nums[mid] <= nums[right]:\n return nums[left]\n else:\n left = mid + 1\n elif nums[left] > nums[mid]:\n right = mid\n else:\n if nums[mid] == nums[right]:\n left += 1\n right -= 1\n elif nums[mid] < nums[right]:\n right = mid\n else:\n left = mid + 1\n \n return nums[left]\n\n ","runtime":"51"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n if n == 2:\n if nums[0] < nums[1]:\n return nums[0]\n else:\n return nums[1]\n while l < r:\n mid = l + (r - l) // 2\n \n if nums[mid] < nums[l]:\n r = mid\n elif nums[mid] > nums[r]:\n l = mid + 1\n else:\n r -= 1\n \n return nums[l]\n \n\n ","runtime":"52"},{"code":"from typing import List\n\nclass Solution:\n def findMin(self, nums: List[int]) -> int:\n l, r = 0, len(nums) - 1\n \n while l < r:\n m = (l + r) // 2\n \n if nums[m] > nums[r]:\n l = m + 1\n elif nums[m] < nums[r]:\n r = m\n else: # nums[m] == nums[r], skip the duplicate\n r -= 1\n \n return nums[l]\n","runtime":"52"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n N = len(nums)\n def foo(a,b):\n if a +1 >= b: \n yield min(nums[a],nums[b])\n return\n m = (a+b) // 2\n while not nums[(m+1) % N] > nums[m] < nums[m-1]:\n yield nums[m]\n if nums[m] < nums[b]:\n b = m\n elif nums[m] > nums[b]:\n a = m+1\n else:\n if nums[a] != nums[m]:\n b = m\n else: \n f1 = foo(a,m)\n f2 = foo(m,b)\n for l1,l2 in zip(f1,f2):\n if l1 != l2: break\n if l1 < l2: \n yield l1\n yield from f1\n else:\n yield l2 \n yield from f2\n return\n \n m = (a+b) // 2\n \n yield nums[m]\n *_,last = foo(0,N-1)\n return last\n","runtime":"53"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n if n == 2:\n if nums[0] < nums[1]:\n return nums[0]\n else:\n return nums[1]\n while l < r-1:\n mid = l + (r - l) // 2\n print(mid)\n if nums[mid] < nums[l]:\n print('elif')\n r = mid\n elif nums[mid] > nums[r]:\n print('if')\n l = mid\n else:\n print('else')\n return min(nums)\n \n print(l, r, mid)\n if nums[l] < nums[r]:\n return nums[l]\n else:\n return nums[r]\n \n\n ","runtime":"53"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n N = len(nums)\n def foo(a,b):\n if a +1 >= b: \n yield min(nums[a],nums[b])\n return\n m = (a+b) // 2\n while not nums[(m+1) % N] > nums[m] < nums[m-1]:\n yield nums[m]\n if nums[m] < nums[b]:\n b = m\n elif nums[m] > nums[b]:\n a = m+1\n else:\n if nums[a] != nums[m]:\n b = m\n else: \n f1 = foo(a,m)\n f2 = foo(m,b)\n for l1,l2 in zip(f1,f2):\n if l1 != l2: break\n if l1 < l2: \n yield l1\n yield from f1\n else:\n yield l2 \n yield from f2\n return\n \n m = (a+b) // 2\n \n yield nums[m]\n *_,last = foo(0,N-1)\n return last\n","runtime":"54"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n \n while l < r:\n mid = l + (r - l) // 2\n \n if nums[mid] < nums[l]:\n r = mid\n elif nums[mid] > nums[r]:\n l = mid + 1\n else:\n r -= 1\n \n return nums[l]\n \n\n ","runtime":"54"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n if n == 2:\n if nums[0] < nums[1]:\n return nums[0]\n else:\n return nums[1]\n while l < r - 1:\n mid = l + (r - l) // 2\n \n if nums[mid] < nums[l]:\n r = mid\n elif nums[mid] > nums[r]:\n l = mid\n else:\n r -= 1\n \n if nums[l] < nums[r]:\n return nums[l]\n else:\n return nums[r]\n \n\n ","runtime":"55"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n if n == 2:\n if nums[0] < nums[1]:\n return nums[0]\n else:\n return nums[1]\n while l < r:\n mid = l + (r - l) // 2\n \n if nums[mid] < nums[l]:\n r = mid\n elif nums[mid] > nums[r]:\n l = mid + 1\n else:\n r -= 1\n \n return nums[l]\n \n\n ","runtime":"56"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n N = len(nums)\n def foo(a,b):\n if a +1 >= b: \n yield min(nums[a],nums[b])\n return\n m = (a+b) // 2\n while not nums[(m+1) % N] > nums[m] < nums[m-1]:\n yield nums[m]\n if nums[m] < nums[b]:\n b = m\n elif nums[m] > nums[b]:\n a = m+1\n else:\n if nums[a] != nums[m]:\n b = m\n else: \n f1 = foo(a,m)\n f2 = foo(m,b)\n for l1,l2 in zip(f1,f2):\n if l1 != l2: break\n if l1 < l2: \n yield l1\n yield from f1\n else:\n yield l2 \n yield from f2\n return\n \n m = (a+b) // 2\n \n yield nums[m]\n *_,last = foo(0,N-1)\n return last\n","runtime":"57"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n if nums[0] < nums[n-1]:\n return nums[0]\n\n left = 0\n right = n-1\n\n while left < right:\n mid = (left + right) // 2\n if nums[left] == nums[mid] == nums[right]:\n left += 1\n right -= 1\n elif nums[left] > nums[mid]:\n right = mid\n elif nums[left] < nums[mid] and nums[mid] <= nums[right]:\n return nums[left]\n elif nums[left] < nums[mid] and nums[mid] > nums[right]:\n left = mid + 1\n elif nums[left] == nums[mid] and nums[mid] < nums[right]:\n right = mid\n elif nums[left] == nums[mid] and nums[mid] > nums[right]:\n left = mid + 1\n \n return nums[left]\n\n ","runtime":"57"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n if len(nums) == 1:\n return nums[0]\n\n \n left = 0\n right = len(nums) - 1\n\n if nums[right] > nums[left]:\n return nums[0]\n\n \n while left < right:\n mid = (left + right) // 2\n\n if nums[mid] < nums[right]:\n right = mid \n\n elif nums[mid] > nums[right]:\n left = mid + 1\n\n else:\n right -= 1\n\n return nums[left]","runtime":"58"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n return min(set(nums))\n","runtime":"58"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n if len(nums)==1: return nums[0]\n lower = 0\n upper = len(nums) - 1\n return self.binary_search(lower, upper, nums)\n def binary_search(self, lower, upper, nums):\n if upper >= lower:\n middle = lower + (upper - lower) // 2\n print(f\"low: {lower}, mid: {middle}, up: {upper}\")\n if nums[middle + 1] < nums[middle]:\n return nums[middle + 1]\n elif nums[middle]< nums[middle - 1]:\n return nums[middle]\n # Handle duplicates: shrink the search space\n if nums[lower] == nums[middle] == nums[upper]:\n return self.binary_search( lower + 1, upper - 1,nums)\n # Left side is sorted\n elif nums[middle] <= nums[upper]:\n return self.binary_search(lower, middle - 1, nums)\n # Right side is sorted\n elif nums[middle] > nums[upper]:\n return self.binary_search(middle + 1, upper, nums)\n return nums[lower]","runtime":"59"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left, right = 0, len(nums) - 1\n\n while left < right:\n mid = left + ((right - left) >> 1)\n if nums[left] == nums[mid] == nums[right]:\n left += 1\n right -= 1\n elif nums[mid] > nums[right]:\n left = mid + 1\n else:\n right = mid\n \n return nums[left]","runtime":"59"}],"string":"[\n {\n \"code\": \"class Solution:\\n def findMin(self, a: List[int]) -> int:\\n beg=0\\n last=len(a)-1\\n while beg<last:\\n mid=(last+beg)//2\\n if a[mid]>a[last]:\\n beg=mid+1\\n elif a[mid]<a[last]:\\n last=mid\\n else:\\n last-=1\\n return a[beg]\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(nums)\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n nums.sort()\\n return nums[0] \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(nums)\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left = 0\\n right = len(nums) - 1\\n\\n while left<=right:\\n mid = (left + right)>>1\\n\\n if nums[mid] < nums[right]:\\n right = mid\\n elif nums[mid]>nums[right]:\\n left = mid + 1\\n else:\\n right-=1\\n return nums[left]\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l = 0\\n r = len(nums) - 1\\n while l < r:\\n mid = (l + r) // 2\\n if nums[r] < nums[mid]:\\n l = mid + 1\\n elif nums[r] > nums[mid]:\\n r = mid\\n else:\\n r -= 1\\n return nums[l]\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left = 0 \\n right = len(nums) - 1\\n \\n while left < right: \\n mid = (left + right) // 2\\n \\n if nums[mid] < nums[right]: \\n right = mid\\n elif nums[mid] > nums[right]:\\n left = mid + 1\\n elif nums[mid] == nums[right]:\\n right = right - 1\\n return nums[left]\\n \\n \\n # 3 3 1 3\\n # 1 3 3 \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l = 0\\n r = len(nums)-1\\n while l<=r:\\n mid = (l+r)//2\\n if nums[mid]>nums[r]:\\n l = mid+1\\n elif nums[mid] == nums[r]:\\n r-=1\\n else:\\n r = mid\\n return nums[l]\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def findMin(self, nums: List[int]) -> int:\\n\\n l, r = 0, len(nums)-1\\n mini = nums[0]\\n\\n while l <= r:\\n mid = (l+r)//2\\n if nums[mid] > nums[r]:\\n mini = min(nums[l],mini)\\n l = mid + 1\\n elif nums[mid] < nums[l]:\\n mini = min(mini, nums[mid])\\n r = mid - 1\\n else:\\n mini = min(mini, nums[mid])\\n r -= 1\\n\\n return mini\\n \\n \\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n lo, hi = 0, len(nums)-1\\n while lo<=hi:\\n mid = (lo+hi)//2\\n if nums[mid]==nums[hi]:\\n hi -= 1\\n elif nums[mid]>nums[hi]:\\n lo = mid+1\\n else:\\n hi = mid\\n return nums[lo]\\n \\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(nums)\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left, right = 0, len(nums) -1\\n \\n while left < right:\\n mid = (left + right) // 2\\n \\n if nums[mid] > nums[right]:\\n left = mid + 1\\n elif nums[mid] < nums[right]:\\n right = mid\\n else:\\n right -=1\\n return nums[left]\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(nums)\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n N = len(nums)\\n def foo(a,b):\\n if a +1 >= b: \\n yield min(nums[a],nums[b])\\n return\\n m = (a+b) // 2\\n while not nums[(m+1) % N] > nums[m] < nums[m-1]:\\n yield nums[m]\\n if nums[m] < nums[b]:\\n b = m\\n elif nums[m] > nums[b]:\\n a = m+1\\n else:\\n if nums[a] != nums[m]:\\n b = m\\n else: \\n f1 = foo(a,m)\\n f2 = foo(m,b)\\n for l1,l2 in zip(f1,f2):\\n if l1 != l2: break\\n if l1 < l2: \\n yield l1\\n yield from f1\\n else:\\n yield l2 \\n yield from f2\\n return\\n \\n m = (a+b) // 2\\n \\n yield nums[m]\\n *_,last = foo(0,N-1)\\n return last\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l = 0\\n r = len(nums)-1\\n while l<r:\\n if nums[l+1]<nums[l]:\\n return nums[l+1]\\n if nums[r-1]>nums[r]:\\n return nums[r]\\n l+=1\\n r-=1\\n return nums[0]\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n maxi=nums[0]\\n for i in range(len(nums)):\\n if maxi>nums[i]:\\n maxi=nums[i]\\n return maxi\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left = 0\\n right = len(nums) - 1\\n\\n \\n while left < right:\\n mid = (left + right) // 2\\n \\n if nums[mid] > nums[right]:\\n left = mid + 1\\n elif nums[mid] < nums[right]:\\n right = mid\\n else:\\n right -= 1\\n \\n \\n return nums[left]\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left, right = 0, len(nums) - 1\\n \\n while left < right:\\n mid = (left + right) // 2\\n \\n if nums[mid] > nums[right]:\\n # Minimum must be in the right half\\n left = mid + 1\\n elif nums[mid] < nums[right]:\\n # Minimum could be in the left half or at mid\\n right = mid\\n else:\\n # nums[mid] == nums[right], cannot determine which side is sorted\\n # Reduce the search space\\n right -= 1\\n \\n return nums[left]\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l = 0\\n r = len(nums)-1\\n while l<r:\\n mid = (l+r)//2\\n if nums[mid] < nums[r]:\\n r = mid\\n elif nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r -= 1\\n\\n return nums[l]\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(nums)\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(nums)\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n # Approach 2024.09.16\\n l = 0\\n r = len(nums) - 1\\n while l < r:\\n m = (l + r) // 2\\n mv = nums[m]\\n if mv == nums[r]:\\n r -= 1\\n elif mv < nums[r]:\\n r = m\\n else:\\n l = m + 1\\n return nums[l]\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n N = len(nums)\\n def foo(a,b):\\n if a +1 >= b: \\n yield min(nums[a],nums[b])\\n return\\n m = (a+b) // 2\\n while not nums[(m+1) % N] > nums[m] < nums[m-1]:\\n print(nums[a],nums[m],nums[b])\\n yield nums[m]\\n if nums[m] < nums[b]:\\n b = m\\n elif nums[m] > nums[b]:\\n a = m+1\\n else:\\n if nums[a] != nums[m]:\\n b = m\\n else: \\n f1 = foo(a,m)\\n f2 = foo(m,b)\\n for l1,l2 in zip(f1,f2):\\n if l1 != l2: break\\n if l1 < l2: \\n yield l1\\n yield from f1\\n else:\\n yield l2 \\n yield from f2\\n return\\n \\n m = (a+b) // 2\\n \\n yield nums[m]\\n *_,last = foo(0,N-1)\\n return last\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n if n == 2:\\n if nums[0] < nums[1]:\\n return nums[0]\\n else:\\n return nums[1]\\n while l < r:\\n mid = l + (r - l) // 2\\n \\n if nums[mid] < nums[l]:\\n r = mid\\n elif nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r -= 1\\n \\n return nums[l]\\n \\n\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(nums)\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n nums.sort()\\n return nums[0]\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left, right = 0, len(nums) - 1\\n\\n while left < right:\\n mid = left + (right - left) // 2\\n\\n if nums[mid] < nums[right]:\\n # The right half is sorted, so the minimum must be in the left half (or mid itself)\\n right = mid \\n elif nums[mid] > nums[right]:\\n # The left half is sorted, so the minimum must be in the right half\\n left = mid + 1\\n else:\\n # nums[mid] == nums[right], we can't be certain where the minimum lies\\n # But we know nums[right] is not the minimum, so we can safely decrement right\\n right -= 1\\n\\n return nums[left] \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l,r=0,len(nums)-1\\n while l<r:\\n mid=(l+r)//2\\n if nums[mid]>nums[r]:\\n l=mid+1\\n elif nums[mid]<nums[r]:\\n r=mid\\n else:\\n r-=1\\n return nums[l]\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(nums)\\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n if n == 2:\\n if nums[0] < nums[1]:\\n return nums[0]\\n else:\\n return nums[1]\\n while l < r:\\n mid = l + (r - l) // 2\\n \\n if nums[mid] < nums[l]:\\n r = mid\\n elif nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r -= 1\\n \\n return nums[l]\\n \\n\\n \",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"from typing import *\\nclass Solution:\\n def findMin(self, nums: List[int]) -> int:\\n size = len(nums)\\n if len(nums)==1:\\n return nums[0]\\n left,right = 0,size - 1\\n while left <= right:\\n mid = (left + right) // 2\\n # print('left,mid,right: ', left,mid,right)\\n if nums[left] < nums[right]:\\n return nums[left]\\n elif nums[left] == nums[right]:\\n left += 1\\n elif nums[left] > nums[right]:\\n # k in the left-right\\n if nums[mid] > nums[left]:\\n left = mid + 1\\n elif nums[mid] == nums[left]:\\n if nums[mid] > nums[right]: \\n left = mid + 1\\n elif nums[mid] == nums[right]:\\n left += 1\\n right -= 1\\n elif nums[mid] < nums[right]:\\n right = mid \\n elif nums[mid] < nums[left]:\\n right = mid \\n # print('left,mid,right: ', left,mid,right)\\n return nums[mid]\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n if n == 2:\\n if nums[0] < nums[1]:\\n return nums[0]\\n else:\\n return nums[1]\\n while l < r-1:\\n mid = l + (r - l) // 2\\n print(mid)\\n if nums[mid] < nums[l]:\\n print('elif')\\n r = mid\\n elif nums[mid] > nums[r]:\\n print('if')\\n l = mid\\n else:\\n r -= 1\\n \\n print(l, r, mid)\\n if nums[l] < nums[r]:\\n return nums[l]\\n else:\\n return nums[r]\\n \\n\\n \",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n if nums[0] < nums[n-1]:\\n return nums[0]\\n\\n left = 0\\n right = n-1\\n\\n while left < right:\\n mid = (left + right) // 2\\n if nums[left] < nums[mid]:\\n if nums[mid] <= nums[right]:\\n return nums[left]\\n else:\\n left = mid + 1\\n elif nums[left] > nums[mid]:\\n right = mid\\n else:\\n if nums[mid] == nums[right]:\\n left += 1\\n right -= 1\\n elif nums[mid] < nums[right]:\\n right = mid\\n else:\\n left = mid + 1\\n \\n return nums[left]\\n\\n \",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n if n == 2:\\n if nums[0] < nums[1]:\\n return nums[0]\\n else:\\n return nums[1]\\n while l < r:\\n mid = l + (r - l) // 2\\n \\n if nums[mid] < nums[l]:\\n r = mid\\n elif nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r -= 1\\n \\n return nums[l]\\n \\n\\n \",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def findMin(self, nums: List[int]) -> int:\\n l, r = 0, len(nums) - 1\\n \\n while l < r:\\n m = (l + r) // 2\\n \\n if nums[m] > nums[r]:\\n l = m + 1\\n elif nums[m] < nums[r]:\\n r = m\\n else: # nums[m] == nums[r], skip the duplicate\\n r -= 1\\n \\n return nums[l]\\n\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n N = len(nums)\\n def foo(a,b):\\n if a +1 >= b: \\n yield min(nums[a],nums[b])\\n return\\n m = (a+b) // 2\\n while not nums[(m+1) % N] > nums[m] < nums[m-1]:\\n yield nums[m]\\n if nums[m] < nums[b]:\\n b = m\\n elif nums[m] > nums[b]:\\n a = m+1\\n else:\\n if nums[a] != nums[m]:\\n b = m\\n else: \\n f1 = foo(a,m)\\n f2 = foo(m,b)\\n for l1,l2 in zip(f1,f2):\\n if l1 != l2: break\\n if l1 < l2: \\n yield l1\\n yield from f1\\n else:\\n yield l2 \\n yield from f2\\n return\\n \\n m = (a+b) // 2\\n \\n yield nums[m]\\n *_,last = foo(0,N-1)\\n return last\\n\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n if n == 2:\\n if nums[0] < nums[1]:\\n return nums[0]\\n else:\\n return nums[1]\\n while l < r-1:\\n mid = l + (r - l) // 2\\n print(mid)\\n if nums[mid] < nums[l]:\\n print('elif')\\n r = mid\\n elif nums[mid] > nums[r]:\\n print('if')\\n l = mid\\n else:\\n print('else')\\n return min(nums)\\n \\n print(l, r, mid)\\n if nums[l] < nums[r]:\\n return nums[l]\\n else:\\n return nums[r]\\n \\n\\n \",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n N = len(nums)\\n def foo(a,b):\\n if a +1 >= b: \\n yield min(nums[a],nums[b])\\n return\\n m = (a+b) // 2\\n while not nums[(m+1) % N] > nums[m] < nums[m-1]:\\n yield nums[m]\\n if nums[m] < nums[b]:\\n b = m\\n elif nums[m] > nums[b]:\\n a = m+1\\n else:\\n if nums[a] != nums[m]:\\n b = m\\n else: \\n f1 = foo(a,m)\\n f2 = foo(m,b)\\n for l1,l2 in zip(f1,f2):\\n if l1 != l2: break\\n if l1 < l2: \\n yield l1\\n yield from f1\\n else:\\n yield l2 \\n yield from f2\\n return\\n \\n m = (a+b) // 2\\n \\n yield nums[m]\\n *_,last = foo(0,N-1)\\n return last\\n\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n \\n while l < r:\\n mid = l + (r - l) // 2\\n \\n if nums[mid] < nums[l]:\\n r = mid\\n elif nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r -= 1\\n \\n return nums[l]\\n \\n\\n \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n if n == 2:\\n if nums[0] < nums[1]:\\n return nums[0]\\n else:\\n return nums[1]\\n while l < r - 1:\\n mid = l + (r - l) // 2\\n \\n if nums[mid] < nums[l]:\\n r = mid\\n elif nums[mid] > nums[r]:\\n l = mid\\n else:\\n r -= 1\\n \\n if nums[l] < nums[r]:\\n return nums[l]\\n else:\\n return nums[r]\\n \\n\\n \",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n if n == 2:\\n if nums[0] < nums[1]:\\n return nums[0]\\n else:\\n return nums[1]\\n while l < r:\\n mid = l + (r - l) // 2\\n \\n if nums[mid] < nums[l]:\\n r = mid\\n elif nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r -= 1\\n \\n return nums[l]\\n \\n\\n \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n N = len(nums)\\n def foo(a,b):\\n if a +1 >= b: \\n yield min(nums[a],nums[b])\\n return\\n m = (a+b) // 2\\n while not nums[(m+1) % N] > nums[m] < nums[m-1]:\\n yield nums[m]\\n if nums[m] < nums[b]:\\n b = m\\n elif nums[m] > nums[b]:\\n a = m+1\\n else:\\n if nums[a] != nums[m]:\\n b = m\\n else: \\n f1 = foo(a,m)\\n f2 = foo(m,b)\\n for l1,l2 in zip(f1,f2):\\n if l1 != l2: break\\n if l1 < l2: \\n yield l1\\n yield from f1\\n else:\\n yield l2 \\n yield from f2\\n return\\n \\n m = (a+b) // 2\\n \\n yield nums[m]\\n *_,last = foo(0,N-1)\\n return last\\n\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n if nums[0] < nums[n-1]:\\n return nums[0]\\n\\n left = 0\\n right = n-1\\n\\n while left < right:\\n mid = (left + right) // 2\\n if nums[left] == nums[mid] == nums[right]:\\n left += 1\\n right -= 1\\n elif nums[left] > nums[mid]:\\n right = mid\\n elif nums[left] < nums[mid] and nums[mid] <= nums[right]:\\n return nums[left]\\n elif nums[left] < nums[mid] and nums[mid] > nums[right]:\\n left = mid + 1\\n elif nums[left] == nums[mid] and nums[mid] < nums[right]:\\n right = mid\\n elif nums[left] == nums[mid] and nums[mid] > nums[right]:\\n left = mid + 1\\n \\n return nums[left]\\n\\n \",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n if len(nums) == 1:\\n return nums[0]\\n\\n \\n left = 0\\n right = len(nums) - 1\\n\\n if nums[right] > nums[left]:\\n return nums[0]\\n\\n \\n while left < right:\\n mid = (left + right) // 2\\n\\n if nums[mid] < nums[right]:\\n right = mid \\n\\n elif nums[mid] > nums[right]:\\n left = mid + 1\\n\\n else:\\n right -= 1\\n\\n return nums[left]\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n return min(set(nums))\\n\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n if len(nums)==1: return nums[0]\\n lower = 0\\n upper = len(nums) - 1\\n return self.binary_search(lower, upper, nums)\\n def binary_search(self, lower, upper, nums):\\n if upper >= lower:\\n middle = lower + (upper - lower) // 2\\n print(f\\\"low: {lower}, mid: {middle}, up: {upper}\\\")\\n if nums[middle + 1] < nums[middle]:\\n return nums[middle + 1]\\n elif nums[middle]< nums[middle - 1]:\\n return nums[middle]\\n # Handle duplicates: shrink the search space\\n if nums[lower] == nums[middle] == nums[upper]:\\n return self.binary_search( lower + 1, upper - 1,nums)\\n # Left side is sorted\\n elif nums[middle] <= nums[upper]:\\n return self.binary_search(lower, middle - 1, nums)\\n # Right side is sorted\\n elif nums[middle] > nums[upper]:\\n return self.binary_search(middle + 1, upper, nums)\\n return nums[lower]\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left, right = 0, len(nums) - 1\\n\\n while left < right:\\n mid = left + ((right - left) >> 1)\\n if nums[left] == nums[mid] == nums[right]:\\n left += 1\\n right -= 1\\n elif nums[mid] > nums[right]:\\n left = mid + 1\\n else:\\n right = mid\\n \\n return nums[left]\",\n \"runtime\": \"59\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":47,"string":"47"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n if len(nums) == 1: return nums[0]\n lowest = nums[0]\n # Find the pivot.\n i = 1\n # while i < len(nums) and nums[i-1] < nums[i]:\n # i += 1\n for i in range(1, len(nums)):\n if nums[i] < nums[i-1]:\n break\n return nums[i] if nums[i] < lowest else lowest","memory":"16700"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n left, right = 0, len(nums) - 1\n\n while left < right:\n mid = (left + right) // 2\n if nums[mid] == nums[right]:\n if nums[mid] == nums[left]:\n left += 1\n else:\n right = mid\n elif nums[mid] > nums[right]:\n left = mid + 1\n else:\n right = mid\n \n return nums[left]","memory":"16800"},{"code":"class Solution:\n def findMin(self, a: List[int]) -> int:\n beg=0\n last=len(a)-1\n while beg<last:\n mid=(last+beg)//2\n if a[mid]>a[last]:\n beg=mid+1\n elif a[mid]<a[last]:\n last=mid\n else:\n last-=1\n return a[beg]","memory":"16800"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n if n == 2:\n if nums[0] < nums[1]:\n return nums[0]\n else:\n return nums[1]\n while l < r:\n mid = l + (r - l) // 2\n \n if nums[mid] < nums[l]:\n r = mid\n elif nums[mid] > nums[r]:\n l = mid + 1\n else:\n r -= 1\n \n return nums[l]\n \n\n ","memory":"16900"},{"code":"class Solution:\n def findMin(self, nums: list[int]) -> int:\n l = 0\n r = len(nums) - 1\n\n while l < r:\n m = (l + r) // 2\n if nums[m] == nums[r]:\n r -= 1\n elif nums[m] < nums[r]:\n r = m\n else:\n l = m + 1\n\n return nums[l]","memory":"16900"},{"code":"from typing import *\nclass Solution:\n def findMin(self, nums: List[int]) -> int:\n size = len(nums)\n if len(nums)==1:\n return nums[0]\n left,right = 0,size - 1\n while left <= right:\n mid = (left + right) // 2\n # print('left,mid,right: ', left,mid,right)\n if nums[left] < nums[right]:\n return nums[left]\n elif nums[left] == nums[right]:\n left += 1\n elif nums[left] > nums[right]:\n # k in the left-right\n if nums[mid] > nums[left]:\n left = mid + 1\n elif nums[mid] == nums[left]:\n if nums[mid] > nums[right]: \n left = mid + 1\n elif nums[mid] == nums[right]:\n left += 1\n right -= 1\n elif nums[mid] < nums[right]:\n right = mid \n elif nums[mid] < nums[left]:\n right = mid \n # print('left,mid,right: ', left,mid,right)\n return nums[mid]","memory":"17000"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n if nums[0] < nums[n-1]:\n return nums[0]\n\n left = 0\n right = n-1\n\n while left < right:\n mid = (left + right) // 2\n if nums[left] < nums[mid]:\n if nums[mid] <= nums[right]:\n return nums[left]\n else:\n left = mid + 1\n elif nums[left] > nums[mid]:\n right = mid\n else:\n if nums[mid] == nums[right]:\n left += 1\n right -= 1\n elif nums[mid] < nums[right]:\n right = mid\n else:\n left = mid + 1\n \n return nums[left]\n\n ","memory":"17000"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n if n == 2:\n if nums[0] < nums[1]:\n return nums[0]\n else:\n return nums[1]\n while l < r-1:\n mid = l + (r - l) // 2\n print(mid)\n if nums[mid] < nums[l]:\n print('elif')\n r = mid\n elif nums[mid] > nums[r]:\n print('if')\n l = mid\n else:\n print('else')\n return min(nums)\n \n print(l, r, mid)\n if nums[l] < nums[r]:\n return nums[l]\n else:\n return nums[r]\n \n\n ","memory":"17100"},{"code":"class Solution:\n def findMin(self, nums: List[int]) -> int:\n n = len(nums)\n l, r = 0, n - 1\n if n == 1:\n return nums[0]\n if n == 2:\n if nums[0] < nums[1]:\n return nums[0]\n else:\n return nums[1]\n while l < r-1:\n mid = l + (r - l) // 2\n print(mid)\n if nums[mid] < nums[l]:\n print('elif')\n r = mid\n elif nums[mid] > nums[r]:\n print('if')\n l = mid\n else:\n print('else')\n return min(nums)\n \n print(l, r, mid)\n if nums[l] < nums[r]:\n return nums[l]\n else:\n return nums[r]\n \n\n ","memory":"17100"}],"string":"[\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n if len(nums) == 1: return nums[0]\\n lowest = nums[0]\\n # Find the pivot.\\n i = 1\\n # while i < len(nums) and nums[i-1] < nums[i]:\\n # i += 1\\n for i in range(1, len(nums)):\\n if nums[i] < nums[i-1]:\\n break\\n return nums[i] if nums[i] < lowest else lowest\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n left, right = 0, len(nums) - 1\\n\\n while left < right:\\n mid = (left + right) // 2\\n if nums[mid] == nums[right]:\\n if nums[mid] == nums[left]:\\n left += 1\\n else:\\n right = mid\\n elif nums[mid] > nums[right]:\\n left = mid + 1\\n else:\\n right = mid\\n \\n return nums[left]\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, a: List[int]) -> int:\\n beg=0\\n last=len(a)-1\\n while beg<last:\\n mid=(last+beg)//2\\n if a[mid]>a[last]:\\n beg=mid+1\\n elif a[mid]<a[last]:\\n last=mid\\n else:\\n last-=1\\n return a[beg]\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n if n == 2:\\n if nums[0] < nums[1]:\\n return nums[0]\\n else:\\n return nums[1]\\n while l < r:\\n mid = l + (r - l) // 2\\n \\n if nums[mid] < nums[l]:\\n r = mid\\n elif nums[mid] > nums[r]:\\n l = mid + 1\\n else:\\n r -= 1\\n \\n return nums[l]\\n \\n\\n \",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: list[int]) -> int:\\n l = 0\\n r = len(nums) - 1\\n\\n while l < r:\\n m = (l + r) // 2\\n if nums[m] == nums[r]:\\n r -= 1\\n elif nums[m] < nums[r]:\\n r = m\\n else:\\n l = m + 1\\n\\n return nums[l]\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"from typing import *\\nclass Solution:\\n def findMin(self, nums: List[int]) -> int:\\n size = len(nums)\\n if len(nums)==1:\\n return nums[0]\\n left,right = 0,size - 1\\n while left <= right:\\n mid = (left + right) // 2\\n # print('left,mid,right: ', left,mid,right)\\n if nums[left] < nums[right]:\\n return nums[left]\\n elif nums[left] == nums[right]:\\n left += 1\\n elif nums[left] > nums[right]:\\n # k in the left-right\\n if nums[mid] > nums[left]:\\n left = mid + 1\\n elif nums[mid] == nums[left]:\\n if nums[mid] > nums[right]: \\n left = mid + 1\\n elif nums[mid] == nums[right]:\\n left += 1\\n right -= 1\\n elif nums[mid] < nums[right]:\\n right = mid \\n elif nums[mid] < nums[left]:\\n right = mid \\n # print('left,mid,right: ', left,mid,right)\\n return nums[mid]\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n if nums[0] < nums[n-1]:\\n return nums[0]\\n\\n left = 0\\n right = n-1\\n\\n while left < right:\\n mid = (left + right) // 2\\n if nums[left] < nums[mid]:\\n if nums[mid] <= nums[right]:\\n return nums[left]\\n else:\\n left = mid + 1\\n elif nums[left] > nums[mid]:\\n right = mid\\n else:\\n if nums[mid] == nums[right]:\\n left += 1\\n right -= 1\\n elif nums[mid] < nums[right]:\\n right = mid\\n else:\\n left = mid + 1\\n \\n return nums[left]\\n\\n \",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n if n == 2:\\n if nums[0] < nums[1]:\\n return nums[0]\\n else:\\n return nums[1]\\n while l < r-1:\\n mid = l + (r - l) // 2\\n print(mid)\\n if nums[mid] < nums[l]:\\n print('elif')\\n r = mid\\n elif nums[mid] > nums[r]:\\n print('if')\\n l = mid\\n else:\\n print('else')\\n return min(nums)\\n \\n print(l, r, mid)\\n if nums[l] < nums[r]:\\n return nums[l]\\n else:\\n return nums[r]\\n \\n\\n \",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def findMin(self, nums: List[int]) -> int:\\n n = len(nums)\\n l, r = 0, n - 1\\n if n == 1:\\n return nums[0]\\n if n == 2:\\n if nums[0] < nums[1]:\\n return nums[0]\\n else:\\n return nums[1]\\n while l < r-1:\\n mid = l + (r - l) // 2\\n print(mid)\\n if nums[mid] < nums[l]:\\n print('elif')\\n r = mid\\n elif nums[mid] > nums[r]:\\n print('if')\\n l = mid\\n else:\\n print('else')\\n return min(nums)\\n \\n print(l, r, mid)\\n if nums[l] < nums[r]:\\n return nums[l]\\n else:\\n return nums[r]\\n \\n\\n \",\n \"memory\": \"17100\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":9,"string":"9"}}},{"rowIdx":59,"cells":{"question_id":{"kind":"number","value":155,"string":"155"},"name":{"kind":"string","value":"min-stack"},"content":{"kind":"string","value":"<p>Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.</p>\n\n<p>Implement the <code>MinStack</code> class:</p>\n\n<ul>\n\t<li><code>MinStack()</code> initializes the stack object.</li>\n\t<li><code>void push(int val)</code> pushes the element <code>val</code> onto the stack.</li>\n\t<li><code>void pop()</code> removes the element on the top of the stack.</li>\n\t<li><code>int top()</code> gets the top element of the stack.</li>\n\t<li><code>int getMin()</code> retrieves the minimum element in the stack.</li>\n</ul>\n\n<p>You must implement a solution with <code>O(1)</code> time complexity for each function.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input</strong>\n["MinStack","push","push","push","getMin","pop","top","getMin"]\n[[],[-2],[0],[-3],[],[],[],[]]\n\n<strong>Output</strong>\n[null,null,null,null,-3,null,0,-2]\n\n<strong>Explanation</strong>\nMinStack minStack = new MinStack();\nminStack.push(-2);\nminStack.push(0);\nminStack.push(-3);\nminStack.getMin(); // return -3\nminStack.pop();\nminStack.top(); // return 0\nminStack.getMin(); // return -2\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code></li>\n\t<li>Methods <code>pop</code>, <code>top</code> and <code>getMin</code> operations will always be called on <strong>non-empty</strong> stacks.</li>\n\t<li>At most <code>3 * 10<sup>4</sup></code> calls will be made to <code>push</code>, <code>pop</code>, <code>top</code>, and <code>getMin</code>.</li>\n</ul>\n"},"acRate":{"kind":"number","value":54.98480476428945,"string":"54.984805"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["stack","design"],"string":"[\n \"stack\",\n \"design\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"28\", 0.022], [\"34\", 0.6137], [\"40\", 3.0391000000000004], [\"45\", 15.2104], [\"51\", 32.0317], [\"56\", 24.8173], [\"62\", 10.5238], [\"68\", 0.9022000000000001], [\"73\", 0.1205], [\"79\", 0.054900000000000004], [\"85\", 0.0476], [\"90\", 0.0805], [\"96\", 0.0219], [\"101\", 0.0147], [\"107\", 0.011], [\"113\", 0.0073], [\"118\", 0.0183], [\"124\", 0.0367], [\"130\", 0.0329], [\"135\", 0.0658], [\"141\", 0.0585], [\"146\", 0.0184], [\"152\", 0.0037], [\"158\", 0.0073], [\"163\", 0.0074], [\"169\", 0.011], [\"175\", 0.0074], [\"180\", 0.0037], [\"186\", 0.0148], [\"191\", 0.0074], [\"197\", 0.0147], [\"203\", 0.022], [\"208\", 0.0148], [\"214\", 0.014700000000000001], [\"220\", 0.0147], [\"225\", 0.0037], [\"231\", 0.0073], [\"236\", 0.0111], [\"242\", 0.0257], [\"248\", 0.0294], [\"253\", 0.018500000000000003], [\"259\", 0.0256], [\"265\", 0.0111], [\"270\", 0.0183], [\"276\", 0.011], [\"281\", 0.0037], [\"287\", 0.014700000000000001], [\"293\", 0.0257], [\"298\", 0.033100000000000004], [\"304\", 0.0658], [\"310\", 0.0658], [\"315\", 0.0475], [\"321\", 0.025800000000000003], [\"326\", 0.0111], [\"332\", 0.0074], [\"338\", 0.0037], [\"343\", 0.0037], [\"349\", 0.0037], [\"355\", 0.0037], [\"360\", 0.0037], [\"366\", 0.0037], [\"371\", 0.0037], [\"377\", 0.0037], [\"383\", 0.0037], [\"388\", 0.0073], [\"394\", 0.011], [\"400\", 0.011], [\"405\", 0.0183], [\"411\", 0.0805], [\"416\", 0.13879999999999998], [\"422\", 0.2484], [\"428\", 0.2921], [\"433\", 0.5077999999999999], [\"439\", 0.6758000000000001], [\"445\", 0.61], [\"450\", 0.8071000000000002], [\"456\", 0.7414999999999999], [\"461\", 0.7671], [\"467\", 0.9351], [\"473\", 0.7013]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"19400\", 0.0037], [\"19600\", 0.011], [\"19700\", 0.0073], [\"19800\", 0.0146], [\"19900\", 0.011], [\"20000\", 0.0365], [\"20100\", 0.2046], [\"20200\", 3.0611], [\"20300\", 5.9066], [\"20400\", 5.4573], [\"20500\", 36.2836], [\"20600\", 23.2795], [\"20700\", 1.673], [\"20800\", 6.9696], [\"20900\", 5.8336], [\"21000\", 4.1131]]}"},"rt_list":{"kind":"list like","value":[{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min_stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.min_stack.append(val if not self.min_stack or self.min_stack[-1] > val else self.min_stack[-1])\n\n def pop(self) -> None:\n self.stack.pop()\n self.min_stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.min_stack[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"28"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minStack = []\n\n def push(self, val: int) -> None:\n if len(self.stack) == 0:\n self.stack.append(val)\n self.minStack.append(val)\n else:\n self.stack.append(val)\n self.minStack.append(min(val,self.minStack[-1]))\n\n def pop(self) -> None:\n self.stack.pop()\n self.minStack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return self.minStack[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"28"},{"code":"class MinStack:\n\n def __init__(self):\n self.stk1=[]\n self.stk2=[inf]\n \n \n\n def push(self, val: int) -> None:\n self.stk1.append(val)\n self.stk2.append(min(val,self.stk2[-1]))\n \n\n def pop(self) -> None:\n self.stk1.pop()\n self.stk2.pop()\n\n \n\n def top(self) -> int:\n return self.stk1[-1]\n \n\n def getMin(self) -> int:\n return self.stk2[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"34"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minstack = []\n\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n minVal = min(val, self.minstack[-1]) if self.minstack else val\n self.minstack.append(minVal)\n \n\n def pop(self) -> None:\n self.stack.pop()\n self.minstack.pop()\n\n \n\n def top(self) -> int:\n return self.stack[-1]\n\n\n def getMin(self) -> int:\n # print('stack2[-1]', self.stack2[-1])\n return self.minstack[-1]\n \n\n\n\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"34"},{"code":"class MinStack:\n\n def __init__(self):\n self.minStack=[]\n \n\n def push(self, val: int) -> None:\n min_val = self.getMin()\n if min_val is None or min_val > val:\n min_val = val\n \n self.minStack.append([val, min_val])\n\n def pop(self) -> None:\n a=self.minStack.pop()\n\n def top(self) -> int:\n return self.minStack[-1][0] if self.minStack else None\n \n\n def getMin(self) -> int:\n return self.minStack[-1][1] if self.minStack else None\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"40"},{"code":"class MinStack:\n\n def __init__(self):\n self._value_to_shows = dict()\n self._min_stack = deque()\n self._stack = deque()\n\n def push(self, val: int) -> None:\n if len(self._min_stack) == 0:\n self._min_stack.append(val)\n self._value_to_shows[val] = 1\n self._stack.append(val)\n else:\n if val < self._min_stack[-1]:\n self._min_stack.append(val)\n self._value_to_shows[val] = 1\n self._stack.append(val)\n else:\n if val in self._value_to_shows.keys():\n self._value_to_shows[val] = self._value_to_shows.get(val) + 1\n else:\n self._value_to_shows[val] = 1\n self._stack.append(val)\n\n def pop(self) -> None:\n self._value_to_shows[self._stack[-1]] = self._value_to_shows.get(self._stack[-1]) - 1\n if self._value_to_shows.get(self._stack[-1]) == 0:\n self._value_to_shows.pop(self._stack[-1])\n if self._stack[-1] == self._min_stack[-1]:\n self._min_stack.pop()\n self._stack.pop()\n\n\n def top(self) -> int:\n return self._stack[-1]\n\n def getMin(self) -> int:\n return self._min_stack[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"40"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = list()\n\n def push(self, val: int) -> None:\n m = self.getMin()\n if m is None or m > val:\n m = val\n \n self.stack.append((val, m))\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1][0] if self.stack else None\n \n\n def getMin(self) -> int:\n return self.stack[-1][1] if self.stack else None\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"45"},{"code":"class MinStack:\n\n def __init__(self):\n self.st = []\n self.min_st = [] # store min_val deacrese\n \n def push(self, val: int) -> None:\n self.st.append(val)\n \n if not self.min_st or self.min_st[-1] >= val:\n self.min_st.append(val)\n\n def pop(self) -> None:\n last = self.st.pop()\n \n if last == self.min_st[-1]:\n self.min_st.pop()\n \n\n def top(self) -> int:\n return self.st[-1] \n\n def getMin(self) -> int:\n return self.min_st[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"45"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n if self.stack == []:\n self.stack.append( (val, val) )\n else:\n new_min = min(self.stack[-1][1], val)\n self.stack.append( (val, new_min) ) \n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1][0]\n\n def getMin(self) -> int:\n return self.stack[-1][1]\n \n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"51"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if not self.min or self.min[-1] >= val:\n self.min.append(val)\n\n def pop(self) -> None:\n v = self.stack.pop()\n if v == self.min[-1]:\n self.min.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.min[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"51"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.stack1 = [] # This will store the minimums\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n # Push to stack1 (min stack) based on comparison\n if not self.stack1 or val <= self.stack1[-1]:\n self.stack1.append(val)\n else:\n self.stack1.append(self.stack1[-1])\n\n def pop(self) -> None:\n if self.stack:\n self.stack.pop()\n self.stack1.pop() # Also pop from the min stack\n\n def top(self) -> int:\n if self.stack:\n return self.stack[-1]\n return None # Return None if the stack is empty (optional)\n\n def getMin(self) -> int:\n if self.stack1:\n return self.stack1[-1]\n return None # Return None if the stack is empty (optional)\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()\n","runtime":"56"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min_value = []\n\n def push(self, val: int) -> None:\n if not self.stack:\n self.min_value.append(val)\n elif val <= self.min_value[-1]:\n self.min_value.append(val)\n \n self.stack.append(val)\n\n def pop(self) -> None:\n if self.stack:\n if self.stack[-1] == self.min_value[-1]:\n self.min_value.pop()\n self.stack.pop()\n \n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.min_value[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"56"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = list()\n\n def push(self, val: int) -> None:\n if len(self.stack) > 0:\n self.stack.append((val, min(self.stack[-1][1], val)))\n else:\n self.stack.append((val, val))\n\n def pop(self) -> None:\n val = self.stack.pop()\n\n def top(self) -> int:\n val = self.stack[-1]\n return val[0]\n \n\n def getMin(self) -> int:\n return self.stack[-1][1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"62"},{"code":"class MinStack:\n\n def __init__(self):\n self.minVal = []\n self.stack = []\n\n def push(self, val: int) -> None:\n if self.minVal:\n self.minVal.append(min(self.minVal[-1], val))\n else:\n self.minVal.append(val)\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n self.minVal.pop()\n \n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.minVal[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"62"},{"code":"class MinStack:\n\n def __init__(self):\n self._value_to_shows = dict()\n self._min_stack = deque()\n self._stack = deque()\n\n def push(self, val: int) -> None:\n if len(self._min_stack) == 0:\n self._min_stack.append(val)\n self._value_to_shows[val] = 1\n self._stack.append(val)\n else:\n if val < self._min_stack[-1]:\n self._min_stack.append(val)\n self._value_to_shows[val] = 1\n self._stack.append(val)\n else:\n if val in self._value_to_shows.keys():\n self._value_to_shows[val] = self._value_to_shows.get(val) + 1\n else:\n self._value_to_shows[val] = 1\n self._stack.append(val)\n\n def pop(self) -> None:\n self._value_to_shows[self._stack[-1]] = self._value_to_shows.get(self._stack[-1]) - 1\n if self._value_to_shows.get(self._stack[-1]) == 0:\n self._value_to_shows.pop(self._stack[-1])\n if self._stack[-1] == self._min_stack[-1]:\n self._min_stack.pop()\n self._stack.pop()\n\n\n def top(self) -> int:\n return self._stack[-1]\n\n def getMin(self) -> int:\n return self._min_stack[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"68"},{"code":"class MinStack:\n\n def __init__(self):\n self.minstack = []\n\n\n def push(self, val: int) -> None:\n if not self.minstack:\n self.minstack.append((val, val))\n else:\n _, minSoFar = self.minstack[-1]\n self.minstack.append((val, min(minSoFar, val)))\n\n def pop(self) -> None:\n if self.minstack:\n self.minstack.pop()\n\n def top(self) -> int:\n if self.minstack:\n top_element, _ = self.minstack[-1]\n return top_element\n return -1\n\n def getMin(self) -> int:\n if self.minstack:\n _, minSofar = self.minstack[-1]\n return minSofar\n return -1\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"68"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = [] \n self.min = float('inf')\n\n def push(self, val: int) -> None:\n self.min = min(self.min, val)\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n self.min = float('inf')\n for num in self.stack:\n self.min = min(self.min, num)\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.min\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"73"},{"code":"class MinStack:\n def __init__(self):\n self.stack = []\n self.minRecord = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n if not self.minRecord:\n self.minRecord.append(val)\n\n elif self.minRecord and val < self.minRecord[-1]:\n self.minRecord.append(val)\n else:\n self.minRecord.append(self.minRecord[-1])\n\n def pop(self) -> None:\n del self.stack[-1]\n del self.minRecord[-1]\n\n print(self.stack)\n print(self.minRecord)\n\n def top(self) -> int:\n return self.stack[-1]\n\n print(self.stack)\n print(self.minRecord)\n\n def getMin(self) -> int:\n return self.minRecord[-1]\n\n print(self.stack)\n print(self.minRecord)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"73"},{"code":"import math\n\nclass MinStack:\n\n def __init__(self):\n self.stack_arr = []\n self.last_ind = -1\n \n\n def push(self, val: int) -> None:\n print('val', val,'len', len(self.stack_arr))\n if not self.stack_arr:\n self.stack_arr.append(MinStackNode(val, val))\n else:\n print('min ', )\n self.stack_arr.append(MinStackNode(val, min(val, self.stack_arr[-1].min)))\n print('last in stack', self.stack_arr[-1].value, self.stack_arr[-1].min)\n \n\n def pop(self) -> None:\n return self.stack_arr.pop()\n \n\n def top(self) -> int:\n return self.stack_arr[-1].value\n \n\n def getMin(self) -> int:\n return self.stack_arr[-1].min\n\nclass MinStackNode:\n\n def __init__(self, value, min):\n self.value = value\n self.min = min\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"79"},{"code":"from collections import deque\n\nclass MinStack:\n\n def __init__(self):\n self.min = float(\"inf\")\n self.stack = deque()\n\n def push(self, val: int) -> None:\n self.min = min(self.min, val)\n self.stack.append((val, self.min))\n\n def pop(self) -> None:\n self.stack.pop()\n if self.stack:\n (_, top_min) = self.top_pair()\n self.min = top_min\n else:\n self.min = float(\"inf\")\n\n def top_pair(self) -> (int, int):\n return self.stack[-1]\n\n def top(self) -> int:\n print(\"top:\", self.stack)\n return self.stack[-1][0]\n\n def getMin(self) -> int:\n (new_top, top_min) = self.top_pair()\n return top_min\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"79"},{"code":"class MinStack:\n\n def __init__(self):\n self.st=[]\n \n\n def push(self, val: int) -> None:\n if self.st:\n value = self.st[-1]\n if val < value[1]:\n self.st.append((val, val))\n else:\n self.st.append((val, value[1]))\n else:\n self.st.append((val, val))\n # print(\"self\",self.st)\n # stack lo tuple should be it should store the first element in tuple as a value and second value is till minimum till date \n \n def pop(self) -> None:\n if self.st:\n self.st.pop()\n\n def top(self) -> int:\n print(\"inTop\",self.st)\n if self.st:\n value = self.st[-1][0]\n # print(\"value+++++\",value)\n return value\n\n def getMin(self) -> int:\n\n if self.st:\n value = self.st[-1]\n return value[1]\n\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"85"},{"code":"class MinStack:\n\n def __init__(self):\n self.data = []\n self.rankedData = []\n\n def push(self, val: int) -> None:\n if not self.data:\n self.rankedData.append(val)\n else:\n rankedIdx = 0\n while rankedIdx < len(self.rankedData) and val < self.rankedData[rankedIdx]:\n rankedIdx += 1\n self.rankedData.insert(rankedIdx, val)\n\n self.data.append(val)\n\n def pop(self) -> None:\n print(f'Trying to pop... {self.top()=}, {self.rankedData=}, {self.data=}')\n self.rankedData.remove(self.data[-1])\n self.data.pop()\n\n def top(self) -> int:\n return self.data[-1]\n\n def getMin(self) -> int:\n return self.rankedData[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"85"},{"code":"class MinStack:\n\n def __init__(self):\n # self.min_object = None\n self.stack = []\n self.num_objects = 0\n self.heap = []\n\n def push(self, val: int) -> None:\n self.num_objects += 1\n heapq.heappush(self.heap, val)\n self.stack.append(val)\n\n def pop(self) -> None:\n print('stack before pop:', self.stack)\n pop_val = self.stack.pop()\n print('stack post pop:', self.stack)\n print('heap before pop:', self.heap)\n print('pop val =', pop_val)\n temp = self.stack.copy()\n heapq.heapify(temp)\n self.heap = temp\n # if self.heap[0] == pop_val:\n # temp = self.heap[1:]\n # heapq.heapify(temp)\n # self.heap = temp\n # #heapq.heappop(self.heap)\n print('heap post pop:', self.heap)\n print('stack post update to heap:', self.stack)\n self.num_objects -= 1\n\n\n def top(self) -> int:\n return self.stack[self.num_objects-1]\n \n\n def getMin(self) -> int:\n return self.heap[0] #heapq.heappop(self.heap)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"90"},{"code":"class MinStack:\n\n def __init__(self):\n self.st = []\n\n def push(self, val: int) -> None:\n if self.getMin() is not None:\n min_val = min(self.getMin(), val)\n print(\"getMin: \", self.getMin(), val)\n else:\n min_val = val\n self.st.append([val, min_val])\n \n\n def pop(self) -> None:\n self.st.pop()\n\n def top(self) -> int:\n return self.st[-1][0]\n \n\n def getMin(self) -> int:\n print(f\"len: {len(self.st)}\")\n if len(self.st) > 0:\n print(\"hello\")\n return self.st[-1][1]\n else:\n return None\n\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"90"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = [] \n self.min = None \n\n def push(self, val: int) -> None:\n # each time an element is pushed\n if self.min is None:\n self.min = val \n\n # otherwise check and replace with new min \n if val < self.min:\n self.min = val \n\n self.stack = [val] + self.stack \n\n def pop(self) -> None:\n elt_removed = self.stack[0]\n self.stack = self.stack[1:]\n\n if elt_removed == self.min:\n # get new minimum \n if self.stack == []:\n self.min = None\n else:\n self.min = min(self.stack)\n\n def top(self) -> int:\n return self.stack[0]\n \n\n def getMin(self) -> int:\n return self.min \n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"96"},{"code":"class MinStack:\n # Time: O(1) for all operations\n # Space: O(2*n)\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n current_min = self.getMin() if self.stack else float('inf')\n current_min = val if val < current_min else current_min\n self.stack.append((val, current_min))\n\n def pop(self) -> None:\n self.stack = self.stack[:-1]\n\n def top(self) -> int:\n print(self.stack)\n return self.stack[-1][0]\n\n def getMin(self) -> int:\n return self.stack[-1][1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"96"},{"code":"class MinStack(object):\n class Node:\n def __init__(self, val, minimum):\n self.val = val\n self.min = minimum\n\n def __init__(self):\n self.nodes = list()\n self.min = None\n \n def push(self, val):\n \"\"\"\n :type val: int\n :rtype: None\n \"\"\"\n \n if self.min == None:\n newNode = MinStack.Node(val, val)\n self.min = val\n else:\n self.min = min(self.min, val)\n newNode = MinStack.Node(val, self.min)\n self.nodes = [newNode] + self.nodes\n\n \n\n def pop(self):\n \"\"\"\n :rtype: None\n \"\"\"\n self.nodes = self.nodes[1:]\n\n if self.nodes:\n topNode = self.nodes[0]\n self.min = topNode.min\n else:\n self.min = None\n\n \n\n def top(self):\n \"\"\"\n :rtype: int\n \"\"\"\n return self.nodes[0].val\n \n\n def getMin(self):\n \"\"\"\n :rtype: int\n \"\"\"\n return self.nodes[0].min\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"101"},{"code":"class MinStack:\n def __init__(self):\n self.a=[0 for i in range(100000)]\n self.minval=0\n self.n=0\n\n def push(self, val: int) -> None:\n if self.n==0:\n self.minval=val\n self.a[self.n]=(val)\n elif val<self.minval:\n self.a[self.n]=(2*val-self.minval)\n self.minval=val\n else:\n self.a[self.n]=(val)\n self.n+=1\n\n\n def pop(self) -> None:\n if self.a[self.n-1]<self.minval:\n self.minval=2*self.minval-self.a[self.n-1]\n self.n-=1\n \n \n \n \n\n def top(self) -> int:\n if self.minval>self.a[self.n-1]:\n \n return self.minval\n return self.a[self.n-1]\n \n\n def getMin(self) -> int:\n return self.minval\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"101"},{"code":"class MinStack:\n def __init__(self):\n self.stack = [] \n\n def push(self, val: int) -> None:\n curMin = self.getMin()\n if val < curMin:\n curMin = val\n \n self.stack = [(val, curMin)] + self.stack\n \n return\n\n def pop(self) -> None:\n return self.stack.pop(0)[0]\n\n\n def top(self) -> int:\n return self.stack[0][0]\n \n\n def getMin(self) -> int:\n if self.stack == []:\n return inf\n return self.stack[0][1]\n\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"107"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.top_val = None\n self.cur_min = float('inf')\n\n def push(self, val: int) -> None:\n self.top_val = val\n self.cur_min = min(val, self.cur_min)\n self.stack = [(val, self.cur_min)] + self.stack\n\n def pop(self) -> None:\n val, cur_min = self.stack.pop(0)\n if self.stack:\n self.top_val, new_min = self.stack[0]\n self.cur_min = new_min\n else:\n self.top_val = None\n self.cur_min = float('inf')\n return val\n\n def top(self) -> int:\n return self.top_val\n\n def getMin(self) -> int:\n return self.cur_min\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"107"},{"code":"class MinStack(object):\n class Node:\n def __init__(self, val, minimum):\n self.val = val\n self.min = minimum\n\n def __init__(self):\n self.nodes = list()\n self.min = None\n \n def push(self, val):\n \"\"\"\n :type val: int\n :rtype: None\n \"\"\"\n \n \n if self.min == None:\n newNode = MinStack.Node(val, val)\n self.min = val\n else:\n self.min = min(self.min, val)\n newNode = MinStack.Node(val, self.min)\n self.nodes = [newNode] + self.nodes\n\n \n\n def pop(self):\n \"\"\"\n :rtype: None\n \"\"\"\n self.nodes = self.nodes[1:]\n\n if self.nodes:\n topNode = self.nodes[0]\n self.min = topNode.min\n else:\n self.min = None\n\n \n\n def top(self):\n \"\"\"\n :rtype: int\n \"\"\"\n return self.nodes[0].val\n \n\n def getMin(self):\n \"\"\"\n :rtype: int\n \"\"\"\n return self.nodes[0].min\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"113"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minval = 0\n \n\n def push(self, val: int) -> None:\n if self.stack:\n if self.stack[-1][1] > val:\n self.minval = min(self.minval, val)\n self.stack.append([val,self.minval])\n else:\n self.minval = val\n self.stack.append([val,self.minval])\n\n\n \n\n def pop(self) -> None:\n print(self.stack)\n self.stack.pop()\n if self.stack:\n self.minval=self.stack[-1][1]\n print(self.stack)\n \n\n def top(self) -> int:\n return self.stack[-1][0]\n \n\n def getMin(self) -> int:\n return self.stack[-1][1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"118"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self._min = 0\n \n\n def push(self, val: int) -> None:\n if len(self.stack)==0:\n self._min = val\n if self._min > val:\n self._min = val\n self.stack.append((val,self._min))\n\n\n\n def pop(self) -> None:\n print(self.stack)\n self.stack.pop()\n if len(self.stack)!=0:\n self._min = self.stack[-1][1]\n\n print(self.stack)\n\n def top(self) -> int:\n return self.stack[-1][0]\n\n def getMin(self) -> int:\n return self._min\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"118"},{"code":"class MinStack:\n\n def __init__(self):\n self.stk=[]\n\n def push(self, val: int) -> None:\n if self.stk:\n _,current_min=self.stk[-1]\n self.stk.append([val,min(current_min,val)])\n else:\n self.stk.append([val,val])\n\n def pop(self) -> None:\n print(self.stk)\n self.stk.pop()\n \n\n def top(self) -> int:\n if self.stk:\n print(self.stk)\n return self.stk[-1][0]\n return -1\n\n def getMin(self) -> int:\n if self.stk:\n return self.stk[-1][1]\n return -1\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"124"},{"code":"import numpy as np\nclass MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = {}\n self.min[0] = np.inf\n self.ind = 0\n\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if val < self.min[self.ind]:\n self.min[self.ind+1] = val\n else:\n self.min[self.ind+1] = self.min[self.ind]\n self.ind+=1\n \n\n def pop(self) -> None:\n res = self.stack.pop()\n del self.min[self.ind]\n self.ind-=1\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return self.min[self.ind]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"124"},{"code":"class MinStack:\n\n def __init__(self):\n self.items = []\n self.min = []\n\n def push(self, val: int) -> None:\n self.min.append(val)\n self.min.sort()\n return self.items.append(val)\n\n def pop(self) -> None:\n val = self.items.pop()\n self.min.remove(val)\n return val\n\n def top(self) -> int:\n return self.items[-1]\n\n def getMin(self) -> int:\n return self.min[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"130"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minvals = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.minvals.append(val)\n self.minvals.sort()\n\n def pop(self) -> None:\n popped = self.stack.pop()\n self.minvals.remove(popped)\n return popped\n\n def top(self) -> int:\n top_ele = self.stack[-1]\n return top_ele\n\n def getMin(self) -> int:\n return self.minvals[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"130"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.mins = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.mins.append(val)\n self.mins.sort()\n\n def pop(self) -> None:\n val = self.stack.pop()\n self.mins.remove(val)\n return val\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.mins[0]\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"135"},{"code":"class MinStack:\n\n def __init__(self):\n self.items = []\n self.min = []\n\n def push(self, val: int) -> None:\n self.pushMin(val)\n return self.items.append(val)\n\n def pop(self) -> None:\n self.popMin(self.top())\n return self.items.pop()\n\n def top(self) -> int:\n return self.items[-1]\n\n def getMin(self) -> int:\n return self.min[0]\n\n def pushMin(self, val: int) -> None:\n self.min.append(val)\n self.min.sort()\n\n def popMin(self, val: int) -> None:\n self.min.remove(val)\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"135"},{"code":"class MinStack:\n\n min_val = float ('inf')\n\n def __init__(self):\n self.stack = []\n self.minstack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.minstack.append(val)\n self.minstack.sort()\n \n def pop(self) -> None:\n val = self.stack[-1]\n del self.stack[-1]\n self.minstack.remove(val)\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.minstack[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"141"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.sorted = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.sorted.append(val)\n self.sorted.sort()\n\n def pop(self) -> None:\n val = self.stack.pop()\n self.sorted.remove(val)\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.sorted[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"141"},{"code":"class MinStack:\n\n min_val = float ('inf')\n\n def __init__(self):\n self.stack = []\n self.minstack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.minstack.append(val)\n self.minstack.sort()\n \n def pop(self) -> None:\n val = self.stack[-1]\n del self.stack[-1]\n self.minstack.remove(val)\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.minstack[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"146"},{"code":"class MinStack:\n\n def __init__(self):\n self.list = []\n self.sorted_asc = []\n\n def push(self, val: int) -> None:\n self.list.append(val)\n self.sorted_asc.append(val)\n self.sorted_asc.sort()\n\n def pop(self) -> None:\n self.sorted_asc.remove(self.list[-1])\n self.list.pop()\n\n def top(self) -> int:\n return self.list[-1]\n\n def getMin(self) -> int:\n return self.sorted_asc[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"146"},{"code":"class MinStack(object):\n class Node:\n def __init__(self, val, minimum):\n self.val = val\n self.min = minimum\n\n def __init__(self):\n self.stack = list()\n self.nodes = list()\n self.min = None\n \n def push(self, val):\n \"\"\"\n :type val: int\n :rtype: None\n \"\"\"\n self.stack = [val] + self.stack\n \n if self.min == None:\n newNode = MinStack.Node(val, val)\n self.min = val\n else:\n self.min = min(self.min, val)\n newNode = MinStack.Node(val, self.min)\n self.nodes = [newNode] + self.nodes\n\n \n\n def pop(self):\n \"\"\"\n :rtype: None\n \"\"\"\n\n self.stack = self.stack[1:]\n self.nodes = self.nodes[1:]\n\n if self.nodes:\n topNode = self.nodes[0]\n self.min = topNode.min\n else:\n self.min = None\n\n \n\n def top(self):\n \"\"\"\n :rtype: int\n \"\"\"\n return self.nodes[0].val\n \n\n def getMin(self):\n \"\"\"\n :rtype: int\n \"\"\"\n return self.nodes[0].min\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"158"},{"code":"# It is a normal stack but being able to track the min element -> how to insert in O(1) time complexity?\n# Have one stack that is the actual stack, and another stack that tracks the min element\nclass MinStack:\n\n def __init__(self):\n self.stack = []\n self.min_stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if len(self.min_stack) == 0 or val <= self.getMin(): self.min_stack.append(val)\n else: \n self.min_stack.append(val)\n self.min_stack.sort(reverse = True)\n\n def pop(self) -> None:\n val = self.stack.pop()\n self.min_stack.remove(val)\n return val\n\n def top(self) -> int:\n return self.stack[len(self.stack) - 1]\n\n def getMin(self) -> int:\n return self.min_stack[len(self.min_stack) - 1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"163"},{"code":"# It is a normal stack but being able to track the min element -> how to insert in O(1) time complexity?\n# Have one stack that is the actual stack, and another stack that tracks the min element\nclass MinStack:\n\n def __init__(self):\n self.stack = []\n self.min_stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if len(self.min_stack) == 0 or val <= self.getMin(): self.min_stack.append(val)\n else: \n self.min_stack.append(val)\n self.min_stack.sort(reverse = True)\n\n def pop(self) -> None:\n val = self.stack.pop()\n self.min_stack.remove(val)\n return val\n\n def top(self) -> int:\n return self.stack[len(self.stack) - 1]\n\n def getMin(self) -> int:\n return self.min_stack[len(self.min_stack) - 1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"163"},{"code":"class MinStack:\n\n def __init__(self):\n self.x = []\n self.min = []\n\n def push(self, val: int) -> None:\n self.x.append(val)\n i = len(self.min)-1\n t = False\n while i > -1:\n if val > self.min[i]:\n self.min = self.min[:i+1] + [val] + self.min[i+1:]\n t = True\n break\n i -= 1\n if not t:\n self.min = [val] + self.min\n\n def pop(self) -> None:\n t = self.x[-1]\n self.x = self.x[:-1]\n self.min.remove(t)\n\n def top(self) -> int:\n return self.x[-1]\n\n def getMin(self) -> int:\n return self.min[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"169"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.order = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.order.append(val)\n self.order.sort(reverse=True)\n\n def pop(self) -> None:\n x = self.stack.pop()\n self.order.remove(x)\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.order[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"169"},{"code":"class MinStack:\n\n def __init__(self): \n self.stack = []\n self.minStack = []\n\n\n def push(self, val: int) -> None:\n self.stack.append(val) \n\n # if self.minStack:\n # val = min(self.minStack[-1], val)\n # self.minStack.append(val)\n\n stack_sorted = sorted(self.stack)\n self.minStack.append(stack_sorted[0])\n \n def pop(self) -> None:\n self.stack.pop()\n self.minStack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.minStack[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"175"},{"code":"from typing import List, Optional, Tuple\n\nclass MinStack:\n\n def __init__(self):\n self.stack: List[Tuple[List[int], Optional[int]]] = [([], float('inf'))]\n\n def push(self, val: int) -> None:\n previous_stack, previous_min = self.stack[-1]\n self.stack.append(([*previous_stack, val], min(previous_min, val)))\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1][0][-1]\n\n def getMin(self) -> int:\n return self.stack[-1][1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"175"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.min = sorted(self.stack)\n\n \n\n def pop(self) -> None:\n if (len(self.stack)):\n self.stack.pop(-1) \n self.min = sorted(self.stack)\n \n\n def top(self) -> int:\n if (len(self.stack)):\n return self.stack[-1]\n return None\n \n\n def getMin(self) -> int:\n if (len(self.stack)):\n return self.min[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"180"},{"code":"import numpy as np\nclass MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = {}\n self.min[0] = np.inf\n self.ind = 0\n\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.min[self.ind+1] = min(val, self.min[self.ind])\n self.ind+=1\n \n\n def pop(self) -> None:\n res = self.stack.pop()\n del self.min[self.ind]\n self.ind-=1\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return self.min[self.ind]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"186"},{"code":"# It is a normal stack but being able to track the min element -> how to insert in O(1) time complexity?\n# Have one stack that is the actual stack, and another stack that tracks the min element\nclass MinStack:\n\n def __init__(self):\n self.stack = []\n self.min_stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if len(self.min_stack) == 0 or val <= self.getMin(): self.min_stack.append(val)\n else: \n self.min_stack.append(val)\n self.min_stack.sort(reverse = True)\n\n def pop(self) -> None:\n val = self.stack.pop()\n self.min_stack.remove(val)\n return val\n\n def top(self) -> int:\n return self.stack[len(self.stack) - 1]\n\n def getMin(self) -> int:\n print(len(self.min_stack))\n return self.min_stack[len(self.min_stack) - 1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"186"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.min = sorted(self.stack)\n\n \n\n def pop(self) -> None:\n if (len(self.stack)):\n x =self.stack.pop(-1) \n self.min.remove(x)\n \n\n def top(self) -> int:\n if (len(self.stack)):\n return self.stack[-1]\n return None\n \n\n def getMin(self) -> int:\n if (len(self.stack)):\n return self.min[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"191"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min_elt = None\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if self.stack:\n self.min_elt = sorted(self.stack)[0]\n \n def pop(self) -> None:\n self.stack.pop()\n if self.stack:\n self.min_elt = sorted(self.stack)[0]\n \n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.min_elt\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"191"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.min = sorted(self.stack)\n\n \n\n def pop(self) -> None:\n if (len(self.stack)):\n x =self.stack.pop(-1) \n self.min.remove(x)\n \n\n def top(self) -> int:\n if (len(self.stack)):\n return self.stack[-1]\n return None\n \n\n def getMin(self) -> int:\n if (len(self.stack)):\n return self.min[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"197"},{"code":"class MinStack:\n\n def __init__(self):\n self.a=[]\n self.get_min=[]\n def push(self, val: int) -> None:\n self.a.append(val)\n self.get_min.append(val)\n\n def pop(self) -> None:\n x=self.a.pop()\n self.get_min.remove(x)\n def top(self) -> int:\n return self.a[-1]\n\n def getMin(self) -> int:\n self.get_min.sort()\n return self.get_min[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"197"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = None\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.update_min()\n\n def pop(self) -> None:\n del self.stack[-1]\n self.update_min()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.min[0]\n\n def update_min(self) -> None:\n self.min = sorted(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"203"},{"code":"import numpy as np\n\nclass MinStack:\n\n def __init__(self):\n self.stack = deque()\n\n def push(self, val: int) -> None:\n if len(self.stack) == 0:\n self.stack.append([val, val])\n\n else:\n curr_min = self.getMin()\n if val < curr_min:\n self.stack.append([val, val])\n else:\n self.stack.append([val, curr_min])\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1][0]\n\n def getMin(self) -> int:\n return self.stack[-1][1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"203"},{"code":"import numpy as np\nclass MinStack:\n\n def __init__(self):\n self._stack = [] # Will store tuples\n \n def push(self, val: int) -> None:\n if self._stack:\n self._stack.append((val, min(self._stack[-1][1], val)))\n else:\n self._stack.append((val, val))\n\n def pop(self) -> None:\n el = self._stack.pop()\n\n def top(self) -> int:\n return self._stack[-1][0]\n\n def getMin(self) -> int:\n return self._stack[-1][1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"208"},{"code":"class MinStack:\n minstack=[]\n def __init__(self):\n self.minstack=[]\n self.minval=float('inf')\n self.temp=[]\n\n def push(self, val: int) -> None:\n self.minstack.append(val)\n self.temp.append(val)\n self.temp=sorted(self.minstack)\n if self.minval>val:\n self.minval=val\n\n def pop(self) -> None:\n self.minstack.pop()\n self.temp=sorted(self.minstack)\n\n\n\n def top(self) -> int:\n return self.minstack[-1]\n\n def getMin(self) -> int:\n return self.temp[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"208"},{"code":"class MinStack:\n \n def __init__(self):\n self.stack=[]\n self.min_stack=[]\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.min_stack.append(val)\n \n\n def pop(self) -> None:\n self.min_stack.remove(self.stack[-1])\n self.stack.pop()\n \n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n self.min_stack.sort()\n return self.min_stack[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"214"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.min.append(val)\n \n def pop(self) -> None:\n elem = self.stack.pop()\n self.min.remove(elem)\n \n\n def top(self) -> int:\n return int(self.stack[-1])\n \n\n def getMin(self) -> int:\n self.min.sort()\n return self.min[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"214"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minStack = []\n \n def push(self, val: int) -> None:\n self.stack.append(val)\n self.minStack.append(val)\n if len(self.stack) > 1:\n self.minStack = sorted(self.minStack)\n self.minStack = self.minStack[::-1]\n\n def pop(self) -> None:\n v = self.stack[-1:][0]\n self.minStack.remove(v)\n self.stack.pop()\n \n def top(self) -> int:\n t = self.stack[-1:]\n return t[0]\n\n def getMin(self) -> int:\n m = self.minStack[-1:]\n return m[0] \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"220"},{"code":"import numpy as np\nclass MinStack:\n\n def __init__(self):\n self.stack = []\n self.min_val_stack = []\n\n def push(self, val: int) -> None:\n if self.min_val_stack ==[]:\n self.min_val_stack.append(val)\n else:\n self.min_val_stack.append(min(val, self.min_val_stack[-1]))\n self.stack.append(val)\n \n\n\n def pop(self) -> None:\n self.stack.pop()\n self.min_val_stack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n \n\n def getMin(self) -> int:\n # print(self.min_val_stack)\n # print(f'self.min_val_stack = {self.min_val_stack}')\n return self.min_val_stack[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"220"},{"code":"import numpy as np\nclass MinStack:\n def __init__(self):\n self.stack = []\n self.minstack = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n val = min(val,self.minstack[-1] if self.minstack else val)\n self.minstack.append(val)\n\n \n\n def pop(self) -> None:\n self.stack.pop()\n self.minstack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return self.minstack[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"225"},{"code":"class MinStack:\n\n def __init__(self):\n self.minstack = []\n self.min = float('-inf')\n\n def push(self, val: int) -> None:\n self.minstack.append(val)\n self.min = min(self.minstack,default=\"null\")\n\n def pop(self) -> None:\n if len(self.minstack) == 0:\n return\n self.minstack.pop()\n self.min = min(self.minstack,default=\"null\")\n\n def top(self) -> int:\n return self.minstack[-1]\n \n\n def getMin(self) -> int:\n return self.min\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"231"},{"code":"class MinStack:\n\n def __init__(self):\n self.min_stack = []\n self.minEle =float('inf')\n \n\n def push(self, val: int) -> None:\n self.min_stack.append(val)\n self.minEle = min(self.min_stack)\n print(self.minEle)\n\n def pop(self) -> None:\n self.min_stack.pop()\n if len(self.min_stack) > 0:\n self.minEle = min(self.min_stack)\n else:\n self.minEle = float('inf')\n \n \n\n def top(self) -> int:\n return self.min_stack[-1]\n\n def getMin(self) -> int:\n return self.minEle\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"236"},{"code":"class MinStack:\n\n def __init__(self):\n self.st = []\n self.min = 0\n\n def push(self, val: int) -> None:\n self.st.append(val)\n self.min = [] if len(self.st) == 0 else min(self.st)\n\n def pop(self) -> None:\n self.st.pop()\n self.min = [] if len(self.st) == 0 else min(self.st)\n\n def top(self) -> int:\n return self.st[-1]\n\n def getMin(self) -> int:\n return self.min\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"236"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minstack = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n temp = min(self.stack)\n self.minstack.append(temp)\n\n def pop(self) -> None:\n self.stack.pop()\n self.minstack.pop()\n\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return self.minstack[-1]\n\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"242"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minStack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if self.minStack:\n self.minStack.append(min(val,min(self.minStack)))\n else:\n self.minStack.append(val)\n \n def pop(self) -> None:\n self.stack.pop()\n self.minStack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.minStack[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"242"},{"code":"\n\nclass MinStack:\n\n def __init__(self):\n self.stack=[]\n self.min_val=0\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if len(self.stack)> 0:\n self.min_val=min(self.stack)\n else:\n self.min_val=0\n \n\n def pop(self) -> None:\n if len(self.stack)==0: return\n self.stack.pop()\n if len(self.stack)> 0:\n self.min_val=min(self.stack)\n else:\n self.min_val=0\n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return self.min_val\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"248"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = 0\n\n def push(self, val: int) -> None: \n self.stack.append(val)\n self.min = min(self.stack, default=0)\n\n def pop(self) -> None:\n if len(self.stack)==0:\n return\n \n #pop\n self.stack = self.stack[:-1]\n\n if len(self.stack)==0:\n self.min = 0\n\n self.min = min(self.stack, default=0)\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.min\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"248"},{"code":"class MinStack:\n \n def __init__(self):\n self.Stack = []\n self.Min = []\n\n def push(self, val: int) -> None:\n self.Stack.append(val)\n self.Min = min(self.Stack)\n\n def pop(self) -> None:\n self.Stack.pop()\n if self.Stack:\n self.Min = min(self.Stack)\n else:\n self.Min = None\n\n def top(self) -> int:\n if self.Stack:\n return self.Stack[-1]\n\n def getMin(self) -> int:\n return self.Min\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"253"},{"code":"class MinStack:\n \n def __init__(self):\n self.stack = []\n self.minStack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.minStack.append(min(self.stack))\n\n def pop(self) -> None:\n self.stack.pop()\n self.minStack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.minStack[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"253"},{"code":"class MinStack:\n\n def __init__(self):\n self.minstack = []\n self.min = float('-inf')\n\n def push(self, val: int) -> None:\n self.minstack.append(val)\n self.min = min(self.minstack,default=\"null\")\n\n def pop(self) -> None:\n if len(self.minstack) == 0:\n return\n self.minstack.pop()\n self.min = min(self.minstack,default=\"null\")\n\n def top(self) -> int:\n return self.minstack[-1]\n \n\n def getMin(self) -> int:\n return self.min\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"259"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min_stack = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n temp = min(self.stack)\n self.min_stack.append(temp)\n\n \n\n def pop(self) -> None:\n self.stack.pop()\n self.min_stack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return self.min_stack[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"259"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minstack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n min_val = min(self.stack)\n self.minstack.append(min_val)\n\n def pop(self) -> None:\n self.stack.pop()\n self.minstack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.minstack[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"265"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minStack = []\n self.minimum = 0\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.minStack.append(val)\n if self.stack:\n self.minimum = min(self.minStack)\n\n def pop(self) -> None:\n self.stack.pop()\n self.minStack.pop()\n if self.stack:\n self.minimum = min(self.minStack)\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.minimum\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"265"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min_idx = None\n self.min2_idx = None\n # self.display()\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.min_idx = self.stack.index(min(self.stack))\n # if self.min_idx is None:\n # self.min_idx = 0\n # elif self.min2_idx is None:\n # if self.stack[self.min_idx]>val:\n # self.min_idx = 1\n # self.min2_idx = 0\n # else:\n # self.min2_idx = 1 \n # else:\n # if self.stack[self.min_idx]>val:\n # self.min2_idx = self.min_idx\n # self.min_idx = len(self.stack)-1\n # else:\n # if self.stack[self.min2_idx]>val:\n # self.min2_idx = len(self.stack)-1\n # print('Min indices:', self.min_idx, self.min2_idx)\n # self.display()\n \n\n def pop(self) -> None:\n val = self.stack[-1]\n self.stack = self.stack[:-1]\n if self.stack==[]:\n self.min_idx = None\n else:\n self.min_idx = self.stack.index(min(self.stack))\n # self.display()\n return val\n\n def top(self) -> int:\n val = self.stack[-1]\n # self.display()\n return val\n\n def getMin(self) -> int:\n # self.display()\n # print('Min:', self.stack[self.min_idx], self.stack, self.min_idx)\n return self.stack[self.min_idx]\n \n def display(self):\n print(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"270"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min_stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.min_stack.append(min(self.stack))\n\n def pop(self) -> None:\n # self.stack.remove(self.stack[-1])\n # self.min_stack.remove(self.min_stack[-1])\n self.stack.pop()\n self.min_stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.min_stack[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"270"},{"code":"class MinStack:\n\n def __init__(self):\n self.nums = []\n self.smallest = float(inf)\n\n def push(self, val: int) -> None:\n self.nums.append(val)\n self.smallest = min(self.nums)\n\n def pop(self) -> None:\n self.nums.pop()\n if len(self.nums) == 0:\n self.smallest = None\n else:\n self.smallest = min(self.nums)\n\n def top(self) -> int:\n top_val = self.nums.pop()\n self.nums.append(top_val)\n\n return top_val\n\n \n\n def getMin(self) -> int:\n return self.smallest\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"276"},{"code":"class MinStack:\n\n def __init__(self):\n self.nums = []\n self.smallest = float(inf)\n\n def push(self, val: int) -> None:\n self.nums.append(val)\n self.smallest = min(self.nums)\n\n def pop(self) -> None:\n self.nums.pop()\n if len(self.nums) == 0:\n self.smallest = None\n else:\n self.smallest = min(self.nums)\n\n def top(self) -> int:\n top_val = self.nums.pop()\n self.nums.append(top_val)\n\n return top_val\n\n \n\n def getMin(self) -> int:\n return self.smallest\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"276"},{"code":"class MinStack:\n \n def __init__(self):\n global stack\n stack=[]\n return None\n\n def push(self, val: int) -> None:\n stack.append(val)\n \n\n def pop(self) -> None:\n stack.pop()\n \n\n def top(self) -> int:\n return stack[-1]\n\n def getMin(self) -> int:\n return sorted(stack)[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"281"},{"code":"from collections import deque\nclass MinStack:\n\n def __init__(self):\n self.dq = deque()\n self.min = 0\n \n def push(self, val: int) -> None:\n self.dq.append(val)\n self.min = min(self.dq)\n\n def pop(self) -> None:\n self.dq.pop()\n if self.dq:\n self.min = min(self.dq)\n\n def top(self) -> int:\n return self.dq[-1]\n\n def getMin(self) -> int:\n return self.min\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"287"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minStack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if self.minStack:\n val = min(self.minStack[-1], val)\n self.minStack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n self.minStack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n sorted(self.stack)\n return self.minStack[-1]\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"287"},{"code":"class MinStack:\n\n def __init__(self):\n self.list = []\n \n\n def push(self, val: int) -> None:\n self.list.append(val)\n\n def pop(self) -> None:\n if self.list:\n return self.list.pop()\n else:\n return\n\n def top(self) -> int:\n if self.list:\n return self.list[-1]\n else:\n return\n\n def getMin(self) -> int:\n if self.list:\n sorted_list = sorted(self.list)\n return sorted_list[0]\n else:\n return\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"293"},{"code":"class MinStack:\n\n def __init__(self):\n\n stack = []\n self.stack = stack \n\n def push(self, val: int) -> None:\n \n self.stack.append(val)\n\n def pop(self) -> None:\n \n self.stack.pop()\n\n def top(self) -> int:\n \n return self.stack[-1]\n\n def getMin(self) -> int:\n \n return sorted(self.stack)[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"293"},{"code":"class MinStack:\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val) \n\n def pop(self) -> None:\n self.stack = self.stack[:-1]\n\n def top(self) -> int:\n return self.stack[len(self.stack) - 1 ]\n\n def getMin(self) -> int:\n return sorted(self.stack)[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"298"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n\n def pop(self) -> None:\n self.stack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return sorted(self.stack)[0]\n \n\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"298"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = list()\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n if len(self.stack) != 0:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n x = sorted(self.stack)\n return x[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"304"},{"code":"class MinStack:\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n newstack = sorted(self.stack)\n return newstack[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"304"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop() \n\n def top(self) -> int:\n if self.stack:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return sorted(self.stack)[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"310"},{"code":"class MinStack:\n\n def __init__(self):\n self._stack = []\n self._min = None\n \n\n def push(self, val: int) -> None:\n self._stack.append(val)\n if self._min and val < self._min:\n self._min = val\n\n def pop(self) -> None:\n self._stack.pop()\n self._min = None\n\n def top(self) -> int:\n return self._stack[-1]\n\n def getMin(self) -> int:\n if not self._min:\n self._min = sorted(self._stack)[0]\n return self._min\n \n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"310"},{"code":"class MinStack:\n\n def __init__(self):\n self.value = []\n\n \n\n def push(self, val: int) -> None:\n self.value.append(val)\n return\n \n\n def pop(self) -> None:\n self.value.pop()\n return \n \n\n def top(self) -> int:\n return self.value[-1]\n \n\n def getMin(self) -> int:\n dup = sorted(self.value)\n\n return dup[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"315"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n x = sorted(self.stack)\n return x[0]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"315"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n self.rev=[]\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n \n\n def pop(self) -> None:\n self.stack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n\n \n\n def getMin(self) -> int:\n self.rev=sorted(self.stack)\n return self.rev[0]\n\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"321"},{"code":"class MinStack:\n\n def __init__(self):\n self.arr = []\n\n def push(self, val: int) -> None:\n self.arr.append(val)\n\n def pop(self) -> None:\n if self.arr:\n del self.arr[-1]\n\n def top(self) -> int:\n if self.arr:\n return self.arr[-1]\n else:\n return 0\n \n\n def getMin(self) -> int:\n m = sorted(self.arr)\n \n return m[0]\n \n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"321"},{"code":"class MinStack:\n\n def __init__(self):\n self.data = []\n\n def push(self, val: int) -> None:\n self.data.append(val)\n \n def pop(self) -> None:\n del self.data[len(self.data) -1 ]\n \n def top(self) -> int:\n return self.data[len(self.data) -1 ]\n\n def getMin(self) -> int:\n return sorted(self.data)[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"326"},{"code":"class MinStack:\n\n def __init__(self):\n self.stores = []\n\n def push(self, val: int) -> None:\n self.stores.append(val)\n\n def pop(self) -> None:\n self.stores.pop()\n \n\n def top(self) -> int:\n return self.stores[-1]\n\n def getMin(self) -> int:\n temp = sorted(self.stores)\n return temp[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"326"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n l = len(self.stack)\n if l > 0:\n self.stack.pop(l - 1)\n\n def top(self) -> int:\n l = len(self.stack)\n if l > 0:\n return self.stack[l - 1]\n else:\n return None\n\n def getMin(self) -> int:\n if len(self.stack) == 0:\n return None\n else:\n ss = sorted(self.stack)\n return ss[0]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"332"},{"code":"class MinStack:\n\n def __init__(self):\n self.arr = []\n\n def push(self, val: int) -> None:\n self.arr.append(val)\n\n def pop(self) -> None:\n if self.arr:\n del self.arr[-1]\n\n def top(self) -> int:\n if self.arr:\n return self.arr[-1]\n else:\n return 0\n \n\n def getMin(self) -> int:\n m = sorted(self.arr)\n \n return m[0]\n \n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"332"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minstack = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if self.minstack:\n val = min(self.minstack[-1], val)\n self.minstack.append(val)\n\n \n\n def pop(self) -> None:\n self.stack.pop()\n self.minstack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return min(self.minstack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"338"},{"code":"class MinStack:\n def __init__(self):\n self.s1=[]\n def push(self, val: int) -> None:\n self.s1.append(val)\n def pop(self) -> None:\n return self.s1.pop()\n def top(self) -> int:\n return self.s1[-1]\n def getMin(self) -> int:\n return min(self.s1)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"355"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop(-1)\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"360"},{"code":"class MinStack:\n\n def __init__(self):\n self.arr= []\n \n\n def push(self, val: int) -> None:\n self.arr.append(val)\n\n def pop(self) -> None:\n self.arr.pop()\n\n def top(self) -> int:\n return self.arr[-1]\n\n def getMin(self) -> int:\n minNum=min(self.arr)\n return minNum\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"366"},{"code":"\nclass MinStack():\n \n def __init__(self):\n self.stack = []\n self.min_stack = []\n\n def push(self, val):\n self.stack.append(val)\n\n if len(self.min_stack) > 0:\n current_node_min = val if val < min(self.min_stack) else min(self.min_stack)\n else:\n current_node_min = val\n\n self.min_stack.append(current_node_min)\n \n def pop(self):\n try:\n self.min_stack.pop()\n return self.stack.pop()\n except Exception:\n print('Stack is empty!')\n \n def top(self):\n try:\n return self.stack[-1]\n except IndexError:\n print('Stack is empty!')\n\n def getMin(self):\n try:\n return self.min_stack[-1]\n except IndexError:\n print('Stack is empty!')\n\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"371"},{"code":"class MinStack:\n\n def __init__(self) -> None:\n self.stack = []\n self.min = float('inf')\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n del self.stack[-1]\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"377"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n return self.stack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"383"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n \n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"388"},{"code":"class MinStack:\n\n def __init__(self):\n\n self.stack = []\n \n\n def push(self, val: int) -> None:\n \n self.stack.append(val)\n\n def pop(self) -> None:\n\n self.stack.pop()\n \n\n def top(self) -> int:\n\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"394"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n \n\n \n\n def push(self, val: int) -> None:\n return self.stack.append(val)\n \n \n\n def pop(self) -> None:\n return self.stack.pop()\n \n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"400"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"400"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if len(self.min) == 0:\n self.min.append(val)\n elif val <= min(self.min):\n self.min.append(val)\n else:\n self.min.append(min(self.min))\n \n\n def pop(self) -> None:\n self.stack.pop()\n self.min.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return self.min[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"405"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n \n\n def pop(self) -> None:\n del self.stack[-1]\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"405"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack= []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n def pop(self) -> None:\n self.stack.pop(-1)\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"411"},{"code":"class MinStack:\n\n def __init__(self):\n self.s = list()\n \n\n def push(self, val: int) -> None:\n self.s.append(val)\n\n def pop(self) -> None:\n self.s.pop()\n\n def top(self) -> int:\n return self.s[-1]\n \n\n def getMin(self) -> int:\n return min(self.s)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"411"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n pass\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n if self.stack:\n self.stack = self.stack[:len(self.stack)-1]\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"416"},{"code":"class MinStack:\n\n def __init__(self):\n self.app =[]\n\n def push(self, val: int) -> None:\n self.app.append(val)\n\n def pop(self) -> None:\n self.app.pop()\n\n def top(self) -> int:\n return self.app[-1]\n\n def getMin(self) -> int:\n return min(self.app)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"416"},{"code":"class MinStack:\n\n def __init__(self):\n self.res = []\n\n def push(self, val: int) -> None:\n self.res.append(val)\n\n def pop(self) -> None:\n if self.res:\n self.res.pop()\n\n def top(self) -> int:\n if self.res:\n return self.res[-1]\n\n def getMin(self) -> int:\n if self.res:\n return min(self.res)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"422"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n self.topelem=-1\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n self.topelem+=1\n def pop(self) -> None:\n self.stack.pop()\n self.topelem-=1\n def top(self) -> int:\n return self.stack[self.topelem]\n\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"422"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n \n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"428"},{"code":"class MinStack:\n\n def __init__(self):\n self.arr = []\n\n def push(self, val: int) -> None:\n self.arr.append(val)\n\n def pop(self) -> None:\n if self.arr:\n self.arr.pop()\n\n def top(self) -> int:\n if self.arr:\n return self.arr[-1]\n def getMin(self) -> int:\n if self.arr:\n return min(self.arr)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"428"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"433"},{"code":"class MinStack:\n\n def __init__(self):\n self.arr = []\n\n def push(self, val: int) -> None:\n self.arr.append(val)\n\n def pop(self) -> None:\n self.arr.pop()\n\n def top(self) -> int:\n return self.arr[-1]\n def getMin(self) -> int:\n return min(self.arr)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"433"},{"code":"class MinStack:\n def __init__(self):\n self.stack = []\n \n def push(self, val: int) -> None:\n self.stack.append(val)\n \n def pop(self) -> None:\n self.stack.pop(-1)\n \n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n \n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"439"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n return self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"439"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"445"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"445"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = list()\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n \n\n def pop(self) -> None:\n self.stack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"450"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack) \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"450"},{"code":"from collections import deque\nclass MinStack:\n\n def __init__(self):\n self.container=deque()\n \n\n def push(self, val: int) -> None:\n self.container.append(val)\n\n def pop(self) -> None:\n self.container.pop()\n\n def top(self) -> int:\n return self.container[-1]\n\n def getMin(self) -> int:\n return min(self.container)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"456"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n \n\n def push(self, val: int) -> None:\n stack=self.stack\n stack.append(val)\n \n\n def pop(self) -> None:\n stack=self.stack\n stack.pop(-1)\n \n\n def top(self) -> int:\n stack=self.stack\n return stack[-1]\n \n\n def getMin(self) -> int:\n stack=self.stack\n return min(stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"456"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n \n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n if len(self.stack)>0:\n self.stack.pop()\n\n def top(self) -> int:\n if len(self.stack)>0:\n return self.stack[-1]\n else:\n return null\n\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"461"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n \n\n def pop(self) -> None:\n point=len(self.stack)-1\n self.stack.pop(point)\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return min(self.stack)\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"461"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"467"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = math.inf\n\n def push(self, val: int) -> None:\n self.stack = [val] + self.stack\n if val < self.min:\n self.min = val\n\n def pop(self) -> None:\n self.stack = self.stack[1:]\n\n def top(self) -> int:\n return self.stack[0]\n \n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"467"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"473"},{"code":"class MinStack:\n\n def __init__(self):\n self.s=[]\n \n def push(self, val: int) -> None:\n self.s.append(val)\n \n\n def pop(self) -> None:\n return self.s.pop()\n\n \n\n def top(self) -> int:\n return self.s[-1]\n \n\n def getMin(self) -> int:\n return min(self.s)\n\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","runtime":"473"}],"string":"[\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min_stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.min_stack.append(val if not self.min_stack or self.min_stack[-1] > val else self.min_stack[-1])\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.min_stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.min_stack[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minStack = []\\n\\n def push(self, val: int) -> None:\\n if len(self.stack) == 0:\\n self.stack.append(val)\\n self.minStack.append(val)\\n else:\\n self.stack.append(val)\\n self.minStack.append(min(val,self.minStack[-1]))\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minStack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.minStack[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stk1=[]\\n self.stk2=[inf]\\n \\n \\n\\n def push(self, val: int) -> None:\\n self.stk1.append(val)\\n self.stk2.append(min(val,self.stk2[-1]))\\n \\n\\n def pop(self) -> None:\\n self.stk1.pop()\\n self.stk2.pop()\\n\\n \\n\\n def top(self) -> int:\\n return self.stk1[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.stk2[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minstack = []\\n\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n minVal = min(val, self.minstack[-1]) if self.minstack else val\\n self.minstack.append(minVal)\\n \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minstack.pop()\\n\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n\\n def getMin(self) -> int:\\n # print('stack2[-1]', self.stack2[-1])\\n return self.minstack[-1]\\n \\n\\n\\n\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.minStack=[]\\n \\n\\n def push(self, val: int) -> None:\\n min_val = self.getMin()\\n if min_val is None or min_val > val:\\n min_val = val\\n \\n self.minStack.append([val, min_val])\\n\\n def pop(self) -> None:\\n a=self.minStack.pop()\\n\\n def top(self) -> int:\\n return self.minStack[-1][0] if self.minStack else None\\n \\n\\n def getMin(self) -> int:\\n return self.minStack[-1][1] if self.minStack else None\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self._value_to_shows = dict()\\n self._min_stack = deque()\\n self._stack = deque()\\n\\n def push(self, val: int) -> None:\\n if len(self._min_stack) == 0:\\n self._min_stack.append(val)\\n self._value_to_shows[val] = 1\\n self._stack.append(val)\\n else:\\n if val < self._min_stack[-1]:\\n self._min_stack.append(val)\\n self._value_to_shows[val] = 1\\n self._stack.append(val)\\n else:\\n if val in self._value_to_shows.keys():\\n self._value_to_shows[val] = self._value_to_shows.get(val) + 1\\n else:\\n self._value_to_shows[val] = 1\\n self._stack.append(val)\\n\\n def pop(self) -> None:\\n self._value_to_shows[self._stack[-1]] = self._value_to_shows.get(self._stack[-1]) - 1\\n if self._value_to_shows.get(self._stack[-1]) == 0:\\n self._value_to_shows.pop(self._stack[-1])\\n if self._stack[-1] == self._min_stack[-1]:\\n self._min_stack.pop()\\n self._stack.pop()\\n\\n\\n def top(self) -> int:\\n return self._stack[-1]\\n\\n def getMin(self) -> int:\\n return self._min_stack[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = list()\\n\\n def push(self, val: int) -> None:\\n m = self.getMin()\\n if m is None or m > val:\\n m = val\\n \\n self.stack.append((val, m))\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1][0] if self.stack else None\\n \\n\\n def getMin(self) -> int:\\n return self.stack[-1][1] if self.stack else None\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.st = []\\n self.min_st = [] # store min_val deacrese\\n \\n def push(self, val: int) -> None:\\n self.st.append(val)\\n \\n if not self.min_st or self.min_st[-1] >= val:\\n self.min_st.append(val)\\n\\n def pop(self) -> None:\\n last = self.st.pop()\\n \\n if last == self.min_st[-1]:\\n self.min_st.pop()\\n \\n\\n def top(self) -> int:\\n return self.st[-1] \\n\\n def getMin(self) -> int:\\n return self.min_st[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n if self.stack == []:\\n self.stack.append( (val, val) )\\n else:\\n new_min = min(self.stack[-1][1], val)\\n self.stack.append( (val, new_min) ) \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1][0]\\n\\n def getMin(self) -> int:\\n return self.stack[-1][1]\\n \\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if not self.min or self.min[-1] >= val:\\n self.min.append(val)\\n\\n def pop(self) -> None:\\n v = self.stack.pop()\\n if v == self.min[-1]:\\n self.min.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.min[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.stack1 = [] # This will store the minimums\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n # Push to stack1 (min stack) based on comparison\\n if not self.stack1 or val <= self.stack1[-1]:\\n self.stack1.append(val)\\n else:\\n self.stack1.append(self.stack1[-1])\\n\\n def pop(self) -> None:\\n if self.stack:\\n self.stack.pop()\\n self.stack1.pop() # Also pop from the min stack\\n\\n def top(self) -> int:\\n if self.stack:\\n return self.stack[-1]\\n return None # Return None if the stack is empty (optional)\\n\\n def getMin(self) -> int:\\n if self.stack1:\\n return self.stack1[-1]\\n return None # Return None if the stack is empty (optional)\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\\n\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min_value = []\\n\\n def push(self, val: int) -> None:\\n if not self.stack:\\n self.min_value.append(val)\\n elif val <= self.min_value[-1]:\\n self.min_value.append(val)\\n \\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n if self.stack:\\n if self.stack[-1] == self.min_value[-1]:\\n self.min_value.pop()\\n self.stack.pop()\\n \\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.min_value[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = list()\\n\\n def push(self, val: int) -> None:\\n if len(self.stack) > 0:\\n self.stack.append((val, min(self.stack[-1][1], val)))\\n else:\\n self.stack.append((val, val))\\n\\n def pop(self) -> None:\\n val = self.stack.pop()\\n\\n def top(self) -> int:\\n val = self.stack[-1]\\n return val[0]\\n \\n\\n def getMin(self) -> int:\\n return self.stack[-1][1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.minVal = []\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n if self.minVal:\\n self.minVal.append(min(self.minVal[-1], val))\\n else:\\n self.minVal.append(val)\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minVal.pop()\\n \\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minVal[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self._value_to_shows = dict()\\n self._min_stack = deque()\\n self._stack = deque()\\n\\n def push(self, val: int) -> None:\\n if len(self._min_stack) == 0:\\n self._min_stack.append(val)\\n self._value_to_shows[val] = 1\\n self._stack.append(val)\\n else:\\n if val < self._min_stack[-1]:\\n self._min_stack.append(val)\\n self._value_to_shows[val] = 1\\n self._stack.append(val)\\n else:\\n if val in self._value_to_shows.keys():\\n self._value_to_shows[val] = self._value_to_shows.get(val) + 1\\n else:\\n self._value_to_shows[val] = 1\\n self._stack.append(val)\\n\\n def pop(self) -> None:\\n self._value_to_shows[self._stack[-1]] = self._value_to_shows.get(self._stack[-1]) - 1\\n if self._value_to_shows.get(self._stack[-1]) == 0:\\n self._value_to_shows.pop(self._stack[-1])\\n if self._stack[-1] == self._min_stack[-1]:\\n self._min_stack.pop()\\n self._stack.pop()\\n\\n\\n def top(self) -> int:\\n return self._stack[-1]\\n\\n def getMin(self) -> int:\\n return self._min_stack[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.minstack = []\\n\\n\\n def push(self, val: int) -> None:\\n if not self.minstack:\\n self.minstack.append((val, val))\\n else:\\n _, minSoFar = self.minstack[-1]\\n self.minstack.append((val, min(minSoFar, val)))\\n\\n def pop(self) -> None:\\n if self.minstack:\\n self.minstack.pop()\\n\\n def top(self) -> int:\\n if self.minstack:\\n top_element, _ = self.minstack[-1]\\n return top_element\\n return -1\\n\\n def getMin(self) -> int:\\n if self.minstack:\\n _, minSofar = self.minstack[-1]\\n return minSofar\\n return -1\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = [] \\n self.min = float('inf')\\n\\n def push(self, val: int) -> None:\\n self.min = min(self.min, val)\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.min = float('inf')\\n for num in self.stack:\\n self.min = min(self.min, num)\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.min\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class MinStack:\\n def __init__(self):\\n self.stack = []\\n self.minRecord = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n if not self.minRecord:\\n self.minRecord.append(val)\\n\\n elif self.minRecord and val < self.minRecord[-1]:\\n self.minRecord.append(val)\\n else:\\n self.minRecord.append(self.minRecord[-1])\\n\\n def pop(self) -> None:\\n del self.stack[-1]\\n del self.minRecord[-1]\\n\\n print(self.stack)\\n print(self.minRecord)\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n print(self.stack)\\n print(self.minRecord)\\n\\n def getMin(self) -> int:\\n return self.minRecord[-1]\\n\\n print(self.stack)\\n print(self.minRecord)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"import math\\n\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack_arr = []\\n self.last_ind = -1\\n \\n\\n def push(self, val: int) -> None:\\n print('val', val,'len', len(self.stack_arr))\\n if not self.stack_arr:\\n self.stack_arr.append(MinStackNode(val, val))\\n else:\\n print('min ', )\\n self.stack_arr.append(MinStackNode(val, min(val, self.stack_arr[-1].min)))\\n print('last in stack', self.stack_arr[-1].value, self.stack_arr[-1].min)\\n \\n\\n def pop(self) -> None:\\n return self.stack_arr.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack_arr[-1].value\\n \\n\\n def getMin(self) -> int:\\n return self.stack_arr[-1].min\\n\\nclass MinStackNode:\\n\\n def __init__(self, value, min):\\n self.value = value\\n self.min = min\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass MinStack:\\n\\n def __init__(self):\\n self.min = float(\\\"inf\\\")\\n self.stack = deque()\\n\\n def push(self, val: int) -> None:\\n self.min = min(self.min, val)\\n self.stack.append((val, self.min))\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n if self.stack:\\n (_, top_min) = self.top_pair()\\n self.min = top_min\\n else:\\n self.min = float(\\\"inf\\\")\\n\\n def top_pair(self) -> (int, int):\\n return self.stack[-1]\\n\\n def top(self) -> int:\\n print(\\\"top:\\\", self.stack)\\n return self.stack[-1][0]\\n\\n def getMin(self) -> int:\\n (new_top, top_min) = self.top_pair()\\n return top_min\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.st=[]\\n \\n\\n def push(self, val: int) -> None:\\n if self.st:\\n value = self.st[-1]\\n if val < value[1]:\\n self.st.append((val, val))\\n else:\\n self.st.append((val, value[1]))\\n else:\\n self.st.append((val, val))\\n # print(\\\"self\\\",self.st)\\n # stack lo tuple should be it should store the first element in tuple as a value and second value is till minimum till date \\n \\n def pop(self) -> None:\\n if self.st:\\n self.st.pop()\\n\\n def top(self) -> int:\\n print(\\\"inTop\\\",self.st)\\n if self.st:\\n value = self.st[-1][0]\\n # print(\\\"value+++++\\\",value)\\n return value\\n\\n def getMin(self) -> int:\\n\\n if self.st:\\n value = self.st[-1]\\n return value[1]\\n\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.data = []\\n self.rankedData = []\\n\\n def push(self, val: int) -> None:\\n if not self.data:\\n self.rankedData.append(val)\\n else:\\n rankedIdx = 0\\n while rankedIdx < len(self.rankedData) and val < self.rankedData[rankedIdx]:\\n rankedIdx += 1\\n self.rankedData.insert(rankedIdx, val)\\n\\n self.data.append(val)\\n\\n def pop(self) -> None:\\n print(f'Trying to pop... {self.top()=}, {self.rankedData=}, {self.data=}')\\n self.rankedData.remove(self.data[-1])\\n self.data.pop()\\n\\n def top(self) -> int:\\n return self.data[-1]\\n\\n def getMin(self) -> int:\\n return self.rankedData[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n # self.min_object = None\\n self.stack = []\\n self.num_objects = 0\\n self.heap = []\\n\\n def push(self, val: int) -> None:\\n self.num_objects += 1\\n heapq.heappush(self.heap, val)\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n print('stack before pop:', self.stack)\\n pop_val = self.stack.pop()\\n print('stack post pop:', self.stack)\\n print('heap before pop:', self.heap)\\n print('pop val =', pop_val)\\n temp = self.stack.copy()\\n heapq.heapify(temp)\\n self.heap = temp\\n # if self.heap[0] == pop_val:\\n # temp = self.heap[1:]\\n # heapq.heapify(temp)\\n # self.heap = temp\\n # #heapq.heappop(self.heap)\\n print('heap post pop:', self.heap)\\n print('stack post update to heap:', self.stack)\\n self.num_objects -= 1\\n\\n\\n def top(self) -> int:\\n return self.stack[self.num_objects-1]\\n \\n\\n def getMin(self) -> int:\\n return self.heap[0] #heapq.heappop(self.heap)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.st = []\\n\\n def push(self, val: int) -> None:\\n if self.getMin() is not None:\\n min_val = min(self.getMin(), val)\\n print(\\\"getMin: \\\", self.getMin(), val)\\n else:\\n min_val = val\\n self.st.append([val, min_val])\\n \\n\\n def pop(self) -> None:\\n self.st.pop()\\n\\n def top(self) -> int:\\n return self.st[-1][0]\\n \\n\\n def getMin(self) -> int:\\n print(f\\\"len: {len(self.st)}\\\")\\n if len(self.st) > 0:\\n print(\\\"hello\\\")\\n return self.st[-1][1]\\n else:\\n return None\\n\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = [] \\n self.min = None \\n\\n def push(self, val: int) -> None:\\n # each time an element is pushed\\n if self.min is None:\\n self.min = val \\n\\n # otherwise check and replace with new min \\n if val < self.min:\\n self.min = val \\n\\n self.stack = [val] + self.stack \\n\\n def pop(self) -> None:\\n elt_removed = self.stack[0]\\n self.stack = self.stack[1:]\\n\\n if elt_removed == self.min:\\n # get new minimum \\n if self.stack == []:\\n self.min = None\\n else:\\n self.min = min(self.stack)\\n\\n def top(self) -> int:\\n return self.stack[0]\\n \\n\\n def getMin(self) -> int:\\n return self.min \\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class MinStack:\\n # Time: O(1) for all operations\\n # Space: O(2*n)\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n current_min = self.getMin() if self.stack else float('inf')\\n current_min = val if val < current_min else current_min\\n self.stack.append((val, current_min))\\n\\n def pop(self) -> None:\\n self.stack = self.stack[:-1]\\n\\n def top(self) -> int:\\n print(self.stack)\\n return self.stack[-1][0]\\n\\n def getMin(self) -> int:\\n return self.stack[-1][1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class MinStack(object):\\n class Node:\\n def __init__(self, val, minimum):\\n self.val = val\\n self.min = minimum\\n\\n def __init__(self):\\n self.nodes = list()\\n self.min = None\\n \\n def push(self, val):\\n \\\"\\\"\\\"\\n :type val: int\\n :rtype: None\\n \\\"\\\"\\\"\\n \\n if self.min == None:\\n newNode = MinStack.Node(val, val)\\n self.min = val\\n else:\\n self.min = min(self.min, val)\\n newNode = MinStack.Node(val, self.min)\\n self.nodes = [newNode] + self.nodes\\n\\n \\n\\n def pop(self):\\n \\\"\\\"\\\"\\n :rtype: None\\n \\\"\\\"\\\"\\n self.nodes = self.nodes[1:]\\n\\n if self.nodes:\\n topNode = self.nodes[0]\\n self.min = topNode.min\\n else:\\n self.min = None\\n\\n \\n\\n def top(self):\\n \\\"\\\"\\\"\\n :rtype: int\\n \\\"\\\"\\\"\\n return self.nodes[0].val\\n \\n\\n def getMin(self):\\n \\\"\\\"\\\"\\n :rtype: int\\n \\\"\\\"\\\"\\n return self.nodes[0].min\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"class MinStack:\\n def __init__(self):\\n self.a=[0 for i in range(100000)]\\n self.minval=0\\n self.n=0\\n\\n def push(self, val: int) -> None:\\n if self.n==0:\\n self.minval=val\\n self.a[self.n]=(val)\\n elif val<self.minval:\\n self.a[self.n]=(2*val-self.minval)\\n self.minval=val\\n else:\\n self.a[self.n]=(val)\\n self.n+=1\\n\\n\\n def pop(self) -> None:\\n if self.a[self.n-1]<self.minval:\\n self.minval=2*self.minval-self.a[self.n-1]\\n self.n-=1\\n \\n \\n \\n \\n\\n def top(self) -> int:\\n if self.minval>self.a[self.n-1]:\\n \\n return self.minval\\n return self.a[self.n-1]\\n \\n\\n def getMin(self) -> int:\\n return self.minval\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"class MinStack:\\n def __init__(self):\\n self.stack = [] \\n\\n def push(self, val: int) -> None:\\n curMin = self.getMin()\\n if val < curMin:\\n curMin = val\\n \\n self.stack = [(val, curMin)] + self.stack\\n \\n return\\n\\n def pop(self) -> None:\\n return self.stack.pop(0)[0]\\n\\n\\n def top(self) -> int:\\n return self.stack[0][0]\\n \\n\\n def getMin(self) -> int:\\n if self.stack == []:\\n return inf\\n return self.stack[0][1]\\n\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"107\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.top_val = None\\n self.cur_min = float('inf')\\n\\n def push(self, val: int) -> None:\\n self.top_val = val\\n self.cur_min = min(val, self.cur_min)\\n self.stack = [(val, self.cur_min)] + self.stack\\n\\n def pop(self) -> None:\\n val, cur_min = self.stack.pop(0)\\n if self.stack:\\n self.top_val, new_min = self.stack[0]\\n self.cur_min = new_min\\n else:\\n self.top_val = None\\n self.cur_min = float('inf')\\n return val\\n\\n def top(self) -> int:\\n return self.top_val\\n\\n def getMin(self) -> int:\\n return self.cur_min\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"107\"\n },\n {\n \"code\": \"class MinStack(object):\\n class Node:\\n def __init__(self, val, minimum):\\n self.val = val\\n self.min = minimum\\n\\n def __init__(self):\\n self.nodes = list()\\n self.min = None\\n \\n def push(self, val):\\n \\\"\\\"\\\"\\n :type val: int\\n :rtype: None\\n \\\"\\\"\\\"\\n \\n \\n if self.min == None:\\n newNode = MinStack.Node(val, val)\\n self.min = val\\n else:\\n self.min = min(self.min, val)\\n newNode = MinStack.Node(val, self.min)\\n self.nodes = [newNode] + self.nodes\\n\\n \\n\\n def pop(self):\\n \\\"\\\"\\\"\\n :rtype: None\\n \\\"\\\"\\\"\\n self.nodes = self.nodes[1:]\\n\\n if self.nodes:\\n topNode = self.nodes[0]\\n self.min = topNode.min\\n else:\\n self.min = None\\n\\n \\n\\n def top(self):\\n \\\"\\\"\\\"\\n :rtype: int\\n \\\"\\\"\\\"\\n return self.nodes[0].val\\n \\n\\n def getMin(self):\\n \\\"\\\"\\\"\\n :rtype: int\\n \\\"\\\"\\\"\\n return self.nodes[0].min\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"113\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minval = 0\\n \\n\\n def push(self, val: int) -> None:\\n if self.stack:\\n if self.stack[-1][1] > val:\\n self.minval = min(self.minval, val)\\n self.stack.append([val,self.minval])\\n else:\\n self.minval = val\\n self.stack.append([val,self.minval])\\n\\n\\n \\n\\n def pop(self) -> None:\\n print(self.stack)\\n self.stack.pop()\\n if self.stack:\\n self.minval=self.stack[-1][1]\\n print(self.stack)\\n \\n\\n def top(self) -> int:\\n return self.stack[-1][0]\\n \\n\\n def getMin(self) -> int:\\n return self.stack[-1][1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"118\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self._min = 0\\n \\n\\n def push(self, val: int) -> None:\\n if len(self.stack)==0:\\n self._min = val\\n if self._min > val:\\n self._min = val\\n self.stack.append((val,self._min))\\n\\n\\n\\n def pop(self) -> None:\\n print(self.stack)\\n self.stack.pop()\\n if len(self.stack)!=0:\\n self._min = self.stack[-1][1]\\n\\n print(self.stack)\\n\\n def top(self) -> int:\\n return self.stack[-1][0]\\n\\n def getMin(self) -> int:\\n return self._min\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"118\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stk=[]\\n\\n def push(self, val: int) -> None:\\n if self.stk:\\n _,current_min=self.stk[-1]\\n self.stk.append([val,min(current_min,val)])\\n else:\\n self.stk.append([val,val])\\n\\n def pop(self) -> None:\\n print(self.stk)\\n self.stk.pop()\\n \\n\\n def top(self) -> int:\\n if self.stk:\\n print(self.stk)\\n return self.stk[-1][0]\\n return -1\\n\\n def getMin(self) -> int:\\n if self.stk:\\n return self.stk[-1][1]\\n return -1\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"124\"\n },\n {\n \"code\": \"import numpy as np\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = {}\\n self.min[0] = np.inf\\n self.ind = 0\\n\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if val < self.min[self.ind]:\\n self.min[self.ind+1] = val\\n else:\\n self.min[self.ind+1] = self.min[self.ind]\\n self.ind+=1\\n \\n\\n def pop(self) -> None:\\n res = self.stack.pop()\\n del self.min[self.ind]\\n self.ind-=1\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.min[self.ind]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"124\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.items = []\\n self.min = []\\n\\n def push(self, val: int) -> None:\\n self.min.append(val)\\n self.min.sort()\\n return self.items.append(val)\\n\\n def pop(self) -> None:\\n val = self.items.pop()\\n self.min.remove(val)\\n return val\\n\\n def top(self) -> int:\\n return self.items[-1]\\n\\n def getMin(self) -> int:\\n return self.min[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minvals = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.minvals.append(val)\\n self.minvals.sort()\\n\\n def pop(self) -> None:\\n popped = self.stack.pop()\\n self.minvals.remove(popped)\\n return popped\\n\\n def top(self) -> int:\\n top_ele = self.stack[-1]\\n return top_ele\\n\\n def getMin(self) -> int:\\n return self.minvals[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.mins = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.mins.append(val)\\n self.mins.sort()\\n\\n def pop(self) -> None:\\n val = self.stack.pop()\\n self.mins.remove(val)\\n return val\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.mins[0]\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"135\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.items = []\\n self.min = []\\n\\n def push(self, val: int) -> None:\\n self.pushMin(val)\\n return self.items.append(val)\\n\\n def pop(self) -> None:\\n self.popMin(self.top())\\n return self.items.pop()\\n\\n def top(self) -> int:\\n return self.items[-1]\\n\\n def getMin(self) -> int:\\n return self.min[0]\\n\\n def pushMin(self, val: int) -> None:\\n self.min.append(val)\\n self.min.sort()\\n\\n def popMin(self, val: int) -> None:\\n self.min.remove(val)\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"135\"\n },\n {\n \"code\": \"class MinStack:\\n\\n min_val = float ('inf')\\n\\n def __init__(self):\\n self.stack = []\\n self.minstack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.minstack.append(val)\\n self.minstack.sort()\\n \\n def pop(self) -> None:\\n val = self.stack[-1]\\n del self.stack[-1]\\n self.minstack.remove(val)\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minstack[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"141\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.sorted = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.sorted.append(val)\\n self.sorted.sort()\\n\\n def pop(self) -> None:\\n val = self.stack.pop()\\n self.sorted.remove(val)\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.sorted[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"141\"\n },\n {\n \"code\": \"class MinStack:\\n\\n min_val = float ('inf')\\n\\n def __init__(self):\\n self.stack = []\\n self.minstack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.minstack.append(val)\\n self.minstack.sort()\\n \\n def pop(self) -> None:\\n val = self.stack[-1]\\n del self.stack[-1]\\n self.minstack.remove(val)\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minstack[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.list = []\\n self.sorted_asc = []\\n\\n def push(self, val: int) -> None:\\n self.list.append(val)\\n self.sorted_asc.append(val)\\n self.sorted_asc.sort()\\n\\n def pop(self) -> None:\\n self.sorted_asc.remove(self.list[-1])\\n self.list.pop()\\n\\n def top(self) -> int:\\n return self.list[-1]\\n\\n def getMin(self) -> int:\\n return self.sorted_asc[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class MinStack(object):\\n class Node:\\n def __init__(self, val, minimum):\\n self.val = val\\n self.min = minimum\\n\\n def __init__(self):\\n self.stack = list()\\n self.nodes = list()\\n self.min = None\\n \\n def push(self, val):\\n \\\"\\\"\\\"\\n :type val: int\\n :rtype: None\\n \\\"\\\"\\\"\\n self.stack = [val] + self.stack\\n \\n if self.min == None:\\n newNode = MinStack.Node(val, val)\\n self.min = val\\n else:\\n self.min = min(self.min, val)\\n newNode = MinStack.Node(val, self.min)\\n self.nodes = [newNode] + self.nodes\\n\\n \\n\\n def pop(self):\\n \\\"\\\"\\\"\\n :rtype: None\\n \\\"\\\"\\\"\\n\\n self.stack = self.stack[1:]\\n self.nodes = self.nodes[1:]\\n\\n if self.nodes:\\n topNode = self.nodes[0]\\n self.min = topNode.min\\n else:\\n self.min = None\\n\\n \\n\\n def top(self):\\n \\\"\\\"\\\"\\n :rtype: int\\n \\\"\\\"\\\"\\n return self.nodes[0].val\\n \\n\\n def getMin(self):\\n \\\"\\\"\\\"\\n :rtype: int\\n \\\"\\\"\\\"\\n return self.nodes[0].min\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"158\"\n },\n {\n \"code\": \"# It is a normal stack but being able to track the min element -> how to insert in O(1) time complexity?\\n# Have one stack that is the actual stack, and another stack that tracks the min element\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min_stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if len(self.min_stack) == 0 or val <= self.getMin(): self.min_stack.append(val)\\n else: \\n self.min_stack.append(val)\\n self.min_stack.sort(reverse = True)\\n\\n def pop(self) -> None:\\n val = self.stack.pop()\\n self.min_stack.remove(val)\\n return val\\n\\n def top(self) -> int:\\n return self.stack[len(self.stack) - 1]\\n\\n def getMin(self) -> int:\\n return self.min_stack[len(self.min_stack) - 1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"163\"\n },\n {\n \"code\": \"# It is a normal stack but being able to track the min element -> how to insert in O(1) time complexity?\\n# Have one stack that is the actual stack, and another stack that tracks the min element\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min_stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if len(self.min_stack) == 0 or val <= self.getMin(): self.min_stack.append(val)\\n else: \\n self.min_stack.append(val)\\n self.min_stack.sort(reverse = True)\\n\\n def pop(self) -> None:\\n val = self.stack.pop()\\n self.min_stack.remove(val)\\n return val\\n\\n def top(self) -> int:\\n return self.stack[len(self.stack) - 1]\\n\\n def getMin(self) -> int:\\n return self.min_stack[len(self.min_stack) - 1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"163\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.x = []\\n self.min = []\\n\\n def push(self, val: int) -> None:\\n self.x.append(val)\\n i = len(self.min)-1\\n t = False\\n while i > -1:\\n if val > self.min[i]:\\n self.min = self.min[:i+1] + [val] + self.min[i+1:]\\n t = True\\n break\\n i -= 1\\n if not t:\\n self.min = [val] + self.min\\n\\n def pop(self) -> None:\\n t = self.x[-1]\\n self.x = self.x[:-1]\\n self.min.remove(t)\\n\\n def top(self) -> int:\\n return self.x[-1]\\n\\n def getMin(self) -> int:\\n return self.min[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"169\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.order = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.order.append(val)\\n self.order.sort(reverse=True)\\n\\n def pop(self) -> None:\\n x = self.stack.pop()\\n self.order.remove(x)\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.order[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"169\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self): \\n self.stack = []\\n self.minStack = []\\n\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val) \\n\\n # if self.minStack:\\n # val = min(self.minStack[-1], val)\\n # self.minStack.append(val)\\n\\n stack_sorted = sorted(self.stack)\\n self.minStack.append(stack_sorted[0])\\n \\n def pop(self) -> None:\\n self.stack.pop()\\n self.minStack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minStack[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"175\"\n },\n {\n \"code\": \"from typing import List, Optional, Tuple\\n\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack: List[Tuple[List[int], Optional[int]]] = [([], float('inf'))]\\n\\n def push(self, val: int) -> None:\\n previous_stack, previous_min = self.stack[-1]\\n self.stack.append(([*previous_stack, val], min(previous_min, val)))\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1][0][-1]\\n\\n def getMin(self) -> int:\\n return self.stack[-1][1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"175\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.min = sorted(self.stack)\\n\\n \\n\\n def pop(self) -> None:\\n if (len(self.stack)):\\n self.stack.pop(-1) \\n self.min = sorted(self.stack)\\n \\n\\n def top(self) -> int:\\n if (len(self.stack)):\\n return self.stack[-1]\\n return None\\n \\n\\n def getMin(self) -> int:\\n if (len(self.stack)):\\n return self.min[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"180\"\n },\n {\n \"code\": \"import numpy as np\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = {}\\n self.min[0] = np.inf\\n self.ind = 0\\n\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.min[self.ind+1] = min(val, self.min[self.ind])\\n self.ind+=1\\n \\n\\n def pop(self) -> None:\\n res = self.stack.pop()\\n del self.min[self.ind]\\n self.ind-=1\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.min[self.ind]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"186\"\n },\n {\n \"code\": \"# It is a normal stack but being able to track the min element -> how to insert in O(1) time complexity?\\n# Have one stack that is the actual stack, and another stack that tracks the min element\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min_stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if len(self.min_stack) == 0 or val <= self.getMin(): self.min_stack.append(val)\\n else: \\n self.min_stack.append(val)\\n self.min_stack.sort(reverse = True)\\n\\n def pop(self) -> None:\\n val = self.stack.pop()\\n self.min_stack.remove(val)\\n return val\\n\\n def top(self) -> int:\\n return self.stack[len(self.stack) - 1]\\n\\n def getMin(self) -> int:\\n print(len(self.min_stack))\\n return self.min_stack[len(self.min_stack) - 1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"186\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.min = sorted(self.stack)\\n\\n \\n\\n def pop(self) -> None:\\n if (len(self.stack)):\\n x =self.stack.pop(-1) \\n self.min.remove(x)\\n \\n\\n def top(self) -> int:\\n if (len(self.stack)):\\n return self.stack[-1]\\n return None\\n \\n\\n def getMin(self) -> int:\\n if (len(self.stack)):\\n return self.min[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"191\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min_elt = None\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if self.stack:\\n self.min_elt = sorted(self.stack)[0]\\n \\n def pop(self) -> None:\\n self.stack.pop()\\n if self.stack:\\n self.min_elt = sorted(self.stack)[0]\\n \\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.min_elt\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"191\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.min = sorted(self.stack)\\n\\n \\n\\n def pop(self) -> None:\\n if (len(self.stack)):\\n x =self.stack.pop(-1) \\n self.min.remove(x)\\n \\n\\n def top(self) -> int:\\n if (len(self.stack)):\\n return self.stack[-1]\\n return None\\n \\n\\n def getMin(self) -> int:\\n if (len(self.stack)):\\n return self.min[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"197\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.a=[]\\n self.get_min=[]\\n def push(self, val: int) -> None:\\n self.a.append(val)\\n self.get_min.append(val)\\n\\n def pop(self) -> None:\\n x=self.a.pop()\\n self.get_min.remove(x)\\n def top(self) -> int:\\n return self.a[-1]\\n\\n def getMin(self) -> int:\\n self.get_min.sort()\\n return self.get_min[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"197\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = None\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.update_min()\\n\\n def pop(self) -> None:\\n del self.stack[-1]\\n self.update_min()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.min[0]\\n\\n def update_min(self) -> None:\\n self.min = sorted(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"203\"\n },\n {\n \"code\": \"import numpy as np\\n\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack = deque()\\n\\n def push(self, val: int) -> None:\\n if len(self.stack) == 0:\\n self.stack.append([val, val])\\n\\n else:\\n curr_min = self.getMin()\\n if val < curr_min:\\n self.stack.append([val, val])\\n else:\\n self.stack.append([val, curr_min])\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1][0]\\n\\n def getMin(self) -> int:\\n return self.stack[-1][1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"203\"\n },\n {\n \"code\": \"import numpy as np\\nclass MinStack:\\n\\n def __init__(self):\\n self._stack = [] # Will store tuples\\n \\n def push(self, val: int) -> None:\\n if self._stack:\\n self._stack.append((val, min(self._stack[-1][1], val)))\\n else:\\n self._stack.append((val, val))\\n\\n def pop(self) -> None:\\n el = self._stack.pop()\\n\\n def top(self) -> int:\\n return self._stack[-1][0]\\n\\n def getMin(self) -> int:\\n return self._stack[-1][1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"208\"\n },\n {\n \"code\": \"class MinStack:\\n minstack=[]\\n def __init__(self):\\n self.minstack=[]\\n self.minval=float('inf')\\n self.temp=[]\\n\\n def push(self, val: int) -> None:\\n self.minstack.append(val)\\n self.temp.append(val)\\n self.temp=sorted(self.minstack)\\n if self.minval>val:\\n self.minval=val\\n\\n def pop(self) -> None:\\n self.minstack.pop()\\n self.temp=sorted(self.minstack)\\n\\n\\n\\n def top(self) -> int:\\n return self.minstack[-1]\\n\\n def getMin(self) -> int:\\n return self.temp[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"208\"\n },\n {\n \"code\": \"class MinStack:\\n \\n def __init__(self):\\n self.stack=[]\\n self.min_stack=[]\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.min_stack.append(val)\\n \\n\\n def pop(self) -> None:\\n self.min_stack.remove(self.stack[-1])\\n self.stack.pop()\\n \\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n self.min_stack.sort()\\n return self.min_stack[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"214\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.min.append(val)\\n \\n def pop(self) -> None:\\n elem = self.stack.pop()\\n self.min.remove(elem)\\n \\n\\n def top(self) -> int:\\n return int(self.stack[-1])\\n \\n\\n def getMin(self) -> int:\\n self.min.sort()\\n return self.min[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"214\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minStack = []\\n \\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.minStack.append(val)\\n if len(self.stack) > 1:\\n self.minStack = sorted(self.minStack)\\n self.minStack = self.minStack[::-1]\\n\\n def pop(self) -> None:\\n v = self.stack[-1:][0]\\n self.minStack.remove(v)\\n self.stack.pop()\\n \\n def top(self) -> int:\\n t = self.stack[-1:]\\n return t[0]\\n\\n def getMin(self) -> int:\\n m = self.minStack[-1:]\\n return m[0] \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"220\"\n },\n {\n \"code\": \"import numpy as np\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min_val_stack = []\\n\\n def push(self, val: int) -> None:\\n if self.min_val_stack ==[]:\\n self.min_val_stack.append(val)\\n else:\\n self.min_val_stack.append(min(val, self.min_val_stack[-1]))\\n self.stack.append(val)\\n \\n\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.min_val_stack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n \\n\\n def getMin(self) -> int:\\n # print(self.min_val_stack)\\n # print(f'self.min_val_stack = {self.min_val_stack}')\\n return self.min_val_stack[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"220\"\n },\n {\n \"code\": \"import numpy as np\\nclass MinStack:\\n def __init__(self):\\n self.stack = []\\n self.minstack = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n val = min(val,self.minstack[-1] if self.minstack else val)\\n self.minstack.append(val)\\n\\n \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minstack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.minstack[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"225\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.minstack = []\\n self.min = float('-inf')\\n\\n def push(self, val: int) -> None:\\n self.minstack.append(val)\\n self.min = min(self.minstack,default=\\\"null\\\")\\n\\n def pop(self) -> None:\\n if len(self.minstack) == 0:\\n return\\n self.minstack.pop()\\n self.min = min(self.minstack,default=\\\"null\\\")\\n\\n def top(self) -> int:\\n return self.minstack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.min\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"231\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.min_stack = []\\n self.minEle =float('inf')\\n \\n\\n def push(self, val: int) -> None:\\n self.min_stack.append(val)\\n self.minEle = min(self.min_stack)\\n print(self.minEle)\\n\\n def pop(self) -> None:\\n self.min_stack.pop()\\n if len(self.min_stack) > 0:\\n self.minEle = min(self.min_stack)\\n else:\\n self.minEle = float('inf')\\n \\n \\n\\n def top(self) -> int:\\n return self.min_stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minEle\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"236\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.st = []\\n self.min = 0\\n\\n def push(self, val: int) -> None:\\n self.st.append(val)\\n self.min = [] if len(self.st) == 0 else min(self.st)\\n\\n def pop(self) -> None:\\n self.st.pop()\\n self.min = [] if len(self.st) == 0 else min(self.st)\\n\\n def top(self) -> int:\\n return self.st[-1]\\n\\n def getMin(self) -> int:\\n return self.min\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"236\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minstack = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n temp = min(self.stack)\\n self.minstack.append(temp)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minstack.pop()\\n\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.minstack[-1]\\n\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"242\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minStack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if self.minStack:\\n self.minStack.append(min(val,min(self.minStack)))\\n else:\\n self.minStack.append(val)\\n \\n def pop(self) -> None:\\n self.stack.pop()\\n self.minStack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minStack[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"242\"\n },\n {\n \"code\": \"\\n\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n self.min_val=0\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if len(self.stack)> 0:\\n self.min_val=min(self.stack)\\n else:\\n self.min_val=0\\n \\n\\n def pop(self) -> None:\\n if len(self.stack)==0: return\\n self.stack.pop()\\n if len(self.stack)> 0:\\n self.min_val=min(self.stack)\\n else:\\n self.min_val=0\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.min_val\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"248\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = 0\\n\\n def push(self, val: int) -> None: \\n self.stack.append(val)\\n self.min = min(self.stack, default=0)\\n\\n def pop(self) -> None:\\n if len(self.stack)==0:\\n return\\n \\n #pop\\n self.stack = self.stack[:-1]\\n\\n if len(self.stack)==0:\\n self.min = 0\\n\\n self.min = min(self.stack, default=0)\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.min\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"248\"\n },\n {\n \"code\": \"class MinStack:\\n \\n def __init__(self):\\n self.Stack = []\\n self.Min = []\\n\\n def push(self, val: int) -> None:\\n self.Stack.append(val)\\n self.Min = min(self.Stack)\\n\\n def pop(self) -> None:\\n self.Stack.pop()\\n if self.Stack:\\n self.Min = min(self.Stack)\\n else:\\n self.Min = None\\n\\n def top(self) -> int:\\n if self.Stack:\\n return self.Stack[-1]\\n\\n def getMin(self) -> int:\\n return self.Min\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"253\"\n },\n {\n \"code\": \"class MinStack:\\n \\n def __init__(self):\\n self.stack = []\\n self.minStack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.minStack.append(min(self.stack))\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minStack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minStack[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"253\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.minstack = []\\n self.min = float('-inf')\\n\\n def push(self, val: int) -> None:\\n self.minstack.append(val)\\n self.min = min(self.minstack,default=\\\"null\\\")\\n\\n def pop(self) -> None:\\n if len(self.minstack) == 0:\\n return\\n self.minstack.pop()\\n self.min = min(self.minstack,default=\\\"null\\\")\\n\\n def top(self) -> int:\\n return self.minstack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.min\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"259\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min_stack = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n temp = min(self.stack)\\n self.min_stack.append(temp)\\n\\n \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.min_stack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.min_stack[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"259\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minstack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n min_val = min(self.stack)\\n self.minstack.append(min_val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minstack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minstack[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"265\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minStack = []\\n self.minimum = 0\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.minStack.append(val)\\n if self.stack:\\n self.minimum = min(self.minStack)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minStack.pop()\\n if self.stack:\\n self.minimum = min(self.minStack)\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minimum\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"265\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min_idx = None\\n self.min2_idx = None\\n # self.display()\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.min_idx = self.stack.index(min(self.stack))\\n # if self.min_idx is None:\\n # self.min_idx = 0\\n # elif self.min2_idx is None:\\n # if self.stack[self.min_idx]>val:\\n # self.min_idx = 1\\n # self.min2_idx = 0\\n # else:\\n # self.min2_idx = 1 \\n # else:\\n # if self.stack[self.min_idx]>val:\\n # self.min2_idx = self.min_idx\\n # self.min_idx = len(self.stack)-1\\n # else:\\n # if self.stack[self.min2_idx]>val:\\n # self.min2_idx = len(self.stack)-1\\n # print('Min indices:', self.min_idx, self.min2_idx)\\n # self.display()\\n \\n\\n def pop(self) -> None:\\n val = self.stack[-1]\\n self.stack = self.stack[:-1]\\n if self.stack==[]:\\n self.min_idx = None\\n else:\\n self.min_idx = self.stack.index(min(self.stack))\\n # self.display()\\n return val\\n\\n def top(self) -> int:\\n val = self.stack[-1]\\n # self.display()\\n return val\\n\\n def getMin(self) -> int:\\n # self.display()\\n # print('Min:', self.stack[self.min_idx], self.stack, self.min_idx)\\n return self.stack[self.min_idx]\\n \\n def display(self):\\n print(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"270\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min_stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.min_stack.append(min(self.stack))\\n\\n def pop(self) -> None:\\n # self.stack.remove(self.stack[-1])\\n # self.min_stack.remove(self.min_stack[-1])\\n self.stack.pop()\\n self.min_stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.min_stack[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"270\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.nums = []\\n self.smallest = float(inf)\\n\\n def push(self, val: int) -> None:\\n self.nums.append(val)\\n self.smallest = min(self.nums)\\n\\n def pop(self) -> None:\\n self.nums.pop()\\n if len(self.nums) == 0:\\n self.smallest = None\\n else:\\n self.smallest = min(self.nums)\\n\\n def top(self) -> int:\\n top_val = self.nums.pop()\\n self.nums.append(top_val)\\n\\n return top_val\\n\\n \\n\\n def getMin(self) -> int:\\n return self.smallest\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"276\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.nums = []\\n self.smallest = float(inf)\\n\\n def push(self, val: int) -> None:\\n self.nums.append(val)\\n self.smallest = min(self.nums)\\n\\n def pop(self) -> None:\\n self.nums.pop()\\n if len(self.nums) == 0:\\n self.smallest = None\\n else:\\n self.smallest = min(self.nums)\\n\\n def top(self) -> int:\\n top_val = self.nums.pop()\\n self.nums.append(top_val)\\n\\n return top_val\\n\\n \\n\\n def getMin(self) -> int:\\n return self.smallest\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"276\"\n },\n {\n \"code\": \"class MinStack:\\n \\n def __init__(self):\\n global stack\\n stack=[]\\n return None\\n\\n def push(self, val: int) -> None:\\n stack.append(val)\\n \\n\\n def pop(self) -> None:\\n stack.pop()\\n \\n\\n def top(self) -> int:\\n return stack[-1]\\n\\n def getMin(self) -> int:\\n return sorted(stack)[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"281\"\n },\n {\n \"code\": \"from collections import deque\\nclass MinStack:\\n\\n def __init__(self):\\n self.dq = deque()\\n self.min = 0\\n \\n def push(self, val: int) -> None:\\n self.dq.append(val)\\n self.min = min(self.dq)\\n\\n def pop(self) -> None:\\n self.dq.pop()\\n if self.dq:\\n self.min = min(self.dq)\\n\\n def top(self) -> int:\\n return self.dq[-1]\\n\\n def getMin(self) -> int:\\n return self.min\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"287\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minStack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if self.minStack:\\n val = min(self.minStack[-1], val)\\n self.minStack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minStack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n sorted(self.stack)\\n return self.minStack[-1]\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"287\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.list = []\\n \\n\\n def push(self, val: int) -> None:\\n self.list.append(val)\\n\\n def pop(self) -> None:\\n if self.list:\\n return self.list.pop()\\n else:\\n return\\n\\n def top(self) -> int:\\n if self.list:\\n return self.list[-1]\\n else:\\n return\\n\\n def getMin(self) -> int:\\n if self.list:\\n sorted_list = sorted(self.list)\\n return sorted_list[0]\\n else:\\n return\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"293\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n\\n stack = []\\n self.stack = stack \\n\\n def push(self, val: int) -> None:\\n \\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n \\n self.stack.pop()\\n\\n def top(self) -> int:\\n \\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n \\n return sorted(self.stack)[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"293\"\n },\n {\n \"code\": \"class MinStack:\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val) \\n\\n def pop(self) -> None:\\n self.stack = self.stack[:-1]\\n\\n def top(self) -> int:\\n return self.stack[len(self.stack) - 1 ]\\n\\n def getMin(self) -> int:\\n return sorted(self.stack)[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"298\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return sorted(self.stack)[0]\\n \\n\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"298\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = list()\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n if len(self.stack) != 0:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n x = sorted(self.stack)\\n return x[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"304\"\n },\n {\n \"code\": \"class MinStack:\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n newstack = sorted(self.stack)\\n return newstack[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"304\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop() \\n\\n def top(self) -> int:\\n if self.stack:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return sorted(self.stack)[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"310\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self._stack = []\\n self._min = None\\n \\n\\n def push(self, val: int) -> None:\\n self._stack.append(val)\\n if self._min and val < self._min:\\n self._min = val\\n\\n def pop(self) -> None:\\n self._stack.pop()\\n self._min = None\\n\\n def top(self) -> int:\\n return self._stack[-1]\\n\\n def getMin(self) -> int:\\n if not self._min:\\n self._min = sorted(self._stack)[0]\\n return self._min\\n \\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"310\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.value = []\\n\\n \\n\\n def push(self, val: int) -> None:\\n self.value.append(val)\\n return\\n \\n\\n def pop(self) -> None:\\n self.value.pop()\\n return \\n \\n\\n def top(self) -> int:\\n return self.value[-1]\\n \\n\\n def getMin(self) -> int:\\n dup = sorted(self.value)\\n\\n return dup[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"315\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n x = sorted(self.stack)\\n return x[0]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"315\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n self.rev=[]\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n \\n\\n def getMin(self) -> int:\\n self.rev=sorted(self.stack)\\n return self.rev[0]\\n\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"321\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.arr = []\\n\\n def push(self, val: int) -> None:\\n self.arr.append(val)\\n\\n def pop(self) -> None:\\n if self.arr:\\n del self.arr[-1]\\n\\n def top(self) -> int:\\n if self.arr:\\n return self.arr[-1]\\n else:\\n return 0\\n \\n\\n def getMin(self) -> int:\\n m = sorted(self.arr)\\n \\n return m[0]\\n \\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"321\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.data = []\\n\\n def push(self, val: int) -> None:\\n self.data.append(val)\\n \\n def pop(self) -> None:\\n del self.data[len(self.data) -1 ]\\n \\n def top(self) -> int:\\n return self.data[len(self.data) -1 ]\\n\\n def getMin(self) -> int:\\n return sorted(self.data)[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"326\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stores = []\\n\\n def push(self, val: int) -> None:\\n self.stores.append(val)\\n\\n def pop(self) -> None:\\n self.stores.pop()\\n \\n\\n def top(self) -> int:\\n return self.stores[-1]\\n\\n def getMin(self) -> int:\\n temp = sorted(self.stores)\\n return temp[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"326\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n l = len(self.stack)\\n if l > 0:\\n self.stack.pop(l - 1)\\n\\n def top(self) -> int:\\n l = len(self.stack)\\n if l > 0:\\n return self.stack[l - 1]\\n else:\\n return None\\n\\n def getMin(self) -> int:\\n if len(self.stack) == 0:\\n return None\\n else:\\n ss = sorted(self.stack)\\n return ss[0]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"332\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.arr = []\\n\\n def push(self, val: int) -> None:\\n self.arr.append(val)\\n\\n def pop(self) -> None:\\n if self.arr:\\n del self.arr[-1]\\n\\n def top(self) -> int:\\n if self.arr:\\n return self.arr[-1]\\n else:\\n return 0\\n \\n\\n def getMin(self) -> int:\\n m = sorted(self.arr)\\n \\n return m[0]\\n \\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"332\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minstack = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if self.minstack:\\n val = min(self.minstack[-1], val)\\n self.minstack.append(val)\\n\\n \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minstack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return min(self.minstack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"338\"\n },\n {\n \"code\": \"class MinStack:\\n def __init__(self):\\n self.s1=[]\\n def push(self, val: int) -> None:\\n self.s1.append(val)\\n def pop(self) -> None:\\n return self.s1.pop()\\n def top(self) -> int:\\n return self.s1[-1]\\n def getMin(self) -> int:\\n return min(self.s1)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"355\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop(-1)\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"360\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.arr= []\\n \\n\\n def push(self, val: int) -> None:\\n self.arr.append(val)\\n\\n def pop(self) -> None:\\n self.arr.pop()\\n\\n def top(self) -> int:\\n return self.arr[-1]\\n\\n def getMin(self) -> int:\\n minNum=min(self.arr)\\n return minNum\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"366\"\n },\n {\n \"code\": \"\\nclass MinStack():\\n \\n def __init__(self):\\n self.stack = []\\n self.min_stack = []\\n\\n def push(self, val):\\n self.stack.append(val)\\n\\n if len(self.min_stack) > 0:\\n current_node_min = val if val < min(self.min_stack) else min(self.min_stack)\\n else:\\n current_node_min = val\\n\\n self.min_stack.append(current_node_min)\\n \\n def pop(self):\\n try:\\n self.min_stack.pop()\\n return self.stack.pop()\\n except Exception:\\n print('Stack is empty!')\\n \\n def top(self):\\n try:\\n return self.stack[-1]\\n except IndexError:\\n print('Stack is empty!')\\n\\n def getMin(self):\\n try:\\n return self.min_stack[-1]\\n except IndexError:\\n print('Stack is empty!')\\n\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"371\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self) -> None:\\n self.stack = []\\n self.min = float('inf')\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n del self.stack[-1]\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"377\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n return self.stack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"383\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n \\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"388\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n\\n self.stack = []\\n \\n\\n def push(self, val: int) -> None:\\n \\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n\\n self.stack.pop()\\n \\n\\n def top(self) -> int:\\n\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"394\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n \\n\\n \\n\\n def push(self, val: int) -> None:\\n return self.stack.append(val)\\n \\n \\n\\n def pop(self) -> None:\\n return self.stack.pop()\\n \\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"400\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"400\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if len(self.min) == 0:\\n self.min.append(val)\\n elif val <= min(self.min):\\n self.min.append(val)\\n else:\\n self.min.append(min(self.min))\\n \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.min.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.min[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"405\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n \\n\\n def pop(self) -> None:\\n del self.stack[-1]\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"405\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack= []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n def pop(self) -> None:\\n self.stack.pop(-1)\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"411\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.s = list()\\n \\n\\n def push(self, val: int) -> None:\\n self.s.append(val)\\n\\n def pop(self) -> None:\\n self.s.pop()\\n\\n def top(self) -> int:\\n return self.s[-1]\\n \\n\\n def getMin(self) -> int:\\n return min(self.s)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"411\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n pass\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n if self.stack:\\n self.stack = self.stack[:len(self.stack)-1]\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"416\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.app =[]\\n\\n def push(self, val: int) -> None:\\n self.app.append(val)\\n\\n def pop(self) -> None:\\n self.app.pop()\\n\\n def top(self) -> int:\\n return self.app[-1]\\n\\n def getMin(self) -> int:\\n return min(self.app)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"416\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.res = []\\n\\n def push(self, val: int) -> None:\\n self.res.append(val)\\n\\n def pop(self) -> None:\\n if self.res:\\n self.res.pop()\\n\\n def top(self) -> int:\\n if self.res:\\n return self.res[-1]\\n\\n def getMin(self) -> int:\\n if self.res:\\n return min(self.res)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"422\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n self.topelem=-1\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n self.topelem+=1\\n def pop(self) -> None:\\n self.stack.pop()\\n self.topelem-=1\\n def top(self) -> int:\\n return self.stack[self.topelem]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"422\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n \\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"428\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.arr = []\\n\\n def push(self, val: int) -> None:\\n self.arr.append(val)\\n\\n def pop(self) -> None:\\n if self.arr:\\n self.arr.pop()\\n\\n def top(self) -> int:\\n if self.arr:\\n return self.arr[-1]\\n def getMin(self) -> int:\\n if self.arr:\\n return min(self.arr)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"428\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"433\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.arr = []\\n\\n def push(self, val: int) -> None:\\n self.arr.append(val)\\n\\n def pop(self) -> None:\\n self.arr.pop()\\n\\n def top(self) -> int:\\n return self.arr[-1]\\n def getMin(self) -> int:\\n return min(self.arr)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"433\"\n },\n {\n \"code\": \"class MinStack:\\n def __init__(self):\\n self.stack = []\\n \\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n \\n def pop(self) -> None:\\n self.stack.pop(-1)\\n \\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"439\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n return self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"439\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"445\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"445\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = list()\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"450\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack) \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"450\"\n },\n {\n \"code\": \"from collections import deque\\nclass MinStack:\\n\\n def __init__(self):\\n self.container=deque()\\n \\n\\n def push(self, val: int) -> None:\\n self.container.append(val)\\n\\n def pop(self) -> None:\\n self.container.pop()\\n\\n def top(self) -> int:\\n return self.container[-1]\\n\\n def getMin(self) -> int:\\n return min(self.container)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"456\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n \\n\\n def push(self, val: int) -> None:\\n stack=self.stack\\n stack.append(val)\\n \\n\\n def pop(self) -> None:\\n stack=self.stack\\n stack.pop(-1)\\n \\n\\n def top(self) -> int:\\n stack=self.stack\\n return stack[-1]\\n \\n\\n def getMin(self) -> int:\\n stack=self.stack\\n return min(stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"456\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n \\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n if len(self.stack)>0:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n if len(self.stack)>0:\\n return self.stack[-1]\\n else:\\n return null\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"461\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n \\n\\n def pop(self) -> None:\\n point=len(self.stack)-1\\n self.stack.pop(point)\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"461\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"467\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = math.inf\\n\\n def push(self, val: int) -> None:\\n self.stack = [val] + self.stack\\n if val < self.min:\\n self.min = val\\n\\n def pop(self) -> None:\\n self.stack = self.stack[1:]\\n\\n def top(self) -> int:\\n return self.stack[0]\\n \\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"467\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"473\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.s=[]\\n \\n def push(self, val: int) -> None:\\n self.s.append(val)\\n \\n\\n def pop(self) -> None:\\n return self.s.pop()\\n\\n \\n\\n def top(self) -> int:\\n return self.s[-1]\\n \\n\\n def getMin(self) -> int:\\n return min(self.s)\\n\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"runtime\": \"473\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":139,"string":"139"},"mm_list":{"kind":"list like","value":[{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n self.min_stack=[]\n \n def push(self, val: int) -> None:\n self.stack.append(val)\n if not self.min_stack or val<=self.min_stack[-1]:\n self.min_stack.append(val)\n \n def pop(self) -> None:\n if self.min_stack[-1]==self.stack[-1]:\n self.min_stack.pop()\n self.stack.pop() \n\n def top(self) -> int:\n return self.stack[-1]\n \n def getMin(self) -> int:\n return self.min_stack[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"19400"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n \n def getMin(self) -> int:\n low = float('inf')\n for i in self.stack:\n low = min(low, i)\n return low\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"19600"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n minimum = self.stack[0]\n \n for i in self.stack:\n minimum = min(minimum,i)\n \n return minimum\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"19700"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n self.minval=float(inf)\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n \n\n def pop(self) -> None:\n self.stack=self.stack[:-1]\n \n\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n minnum=float(inf)\n for num in self.stack:\n minnum=min(minnum,num)\n return minnum\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"19800"},{"code":"class MinStack:\n\n def __init__(self):\n self.st = []\n\n def push(self, val: int) -> None:\n self.st.append(val)\n\n def pop(self) -> None:\n self.st.pop()\n\n def top(self) -> int:\n return self.st[-1]\n\n def getMin(self) -> int:\n return min(self.st)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"19900"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minstack = []\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if len(self.minstack) == 0 or val <= self.minstack[-1]:\n self.minstack.append(val)\n \n def pop(self) -> None:\n val = self.stack.pop()\n if val == self.minstack[-1]:\n self.minstack.pop()\n\n def top(self) -> int:\n return self.stack[-1]\n \n def getMin(self) -> int:\n return self.minstack[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20000"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = deque()\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n\n def pop(self) -> None:\n self.stack.pop()\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20100"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.minStack = []\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if len(self.minStack) != 0:\n val = min(val, self.minStack[-1])\n else:\n val = val\n \n self.minStack.append(val)\n\n \n\n def pop(self) -> None:\n self.stack.pop()\n self.minStack.pop()\n\n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return self.minStack[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20200"},{"code":"class MinOneStack:\n def __init__(self):\n self._pairs = [] \n\n def push(self, val: int) -> None:\n prev_min_val = self._pairs[-1][1] if self._pairs else float('inf')\n min_val = min(prev_min_val, val)\n self._pairs.append([val, min_val])\n\n def pop(self) -> None:\n self._pairs.pop()\n\n def top(self) -> int:\n return self._pairs[-1][0] \n\n def getMin(self) -> int:\n return self._pairs[-1][1]\n\n\nclass MinTwoStack:\n def __init__(self):\n self._values = []\n self._mins = []\n\n def push(self, val: int) -> None:\n self._values.append(val)\n\n if not self._mins or val <= self._mins[-1]:\n self._mins.append(val) \n\n def pop(self) -> None:\n val = self._values.pop()\n\n if val == self._mins[-1]:\n self._mins.pop()\n\n def top(self) -> int:\n return self._values[-1]\n\n def getMin(self) -> int:\n return self._mins[-1] \n\n\n# class MinStack(MinOneStack):\nclass MinStack(MinTwoStack):\n pass","memory":"20200"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n pass\n def push(self, val: int) -> None:\n self.stack.append(val)\n return\n def pop(self) -> None:\n self.stack = self.stack[:len(self.stack) - 1]\n return\n def top(self) -> int:\n return self.stack[-1]\n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20300"},{"code":"class MinStack:\n\n def __init__(self):\n self.minVal = float('inf')\n self.stack = []\n\n def push(self, val: int) -> None:\n self.minVal = min(self.minVal, val)\n self.stack.append(val)\n\n def pop(self) -> None:\n top = self.stack.pop()\n if self.minVal == top:\n self.minVal = float('inf')\n for n in self.stack:\n self.minVal = min(self.minVal, n)\n \n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.minVal\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20300"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = math.inf\n\n def push(self, val: int) -> None:\n self.stack = [val] + self.stack\n if val < self.min:\n self.min = val\n\n def pop(self) -> None:\n self.stack = self.stack[1:]\n\n def top(self) -> int:\n return self.stack[0]\n \n def getMin(self) -> int:\n return min(self.stack)\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20400"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack=[]\n self.minstack=[]\n\n def push(self, val: int) -> None:\n\n self.stack.append(val)\n if not self.minstack:\n self.minstack.append(val)\n else:\n self.minstack.append(min(val, self.minstack[-1]))\n\n def pop(self) -> None:\n\n self.stack.pop()\n self.minstack.pop()\n \n\n def top(self) -> int:\n\n return self.stack[-1]\n\n def getMin(self) -> int:\n\n return self.minstack[-1]\n \n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20400"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.pointers = {}\n self.min_pos = None\n\n def push(self, val: int) -> None:\n self.stack.append(val)\n if self.min_pos is None:\n self.min_pos = len(self.stack)-1\n self.pointers[self.min_pos] = None\n elif val < self.stack[self.min_pos]:\n self.pointers[len(self.stack)-1] = self.min_pos\n self.min_pos = len(self.stack)-1\n print(self.pointers)\n\n def pop(self) -> None:\n if len(self.stack)-1 == self.min_pos:\n self.min_pos = self.pointers.pop(self.min_pos)\n self.stack.pop(-1)\n\n def top(self) -> int:\n return self.stack[-1]\n \n def getMin(self) -> int:\n return self.stack[self.min_pos] \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20500"},{"code":"class MinStack:\n def __init__(self):\n self.stack = []\n self.minStack = []\n def push(self, val: int) -> None:\n self.stack.append(val)\n if(not self.minStack):\n self.minStack.append(val)\n elif(self.minStack[-1]>val):\n self.minStack.append(val)\n else:\n self.minStack.append(self.minStack[-1])\n\n def pop(self) -> None:\n self.stack.pop(-1)\n self.minStack.pop(-1)\n def top(self) -> int:\n return self.stack[-1]\n\n def getMin(self) -> int:\n return self.minStack[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20500"},{"code":"class MinStack:\n\n def __init__(self):\n self.stk = list()\n self.min_val = list()\n self.cur_min = 2 << 32\n\n def push(self, val: int) -> None:\n self.stk.append(val)\n if val < self.cur_min:\n self.cur_min = val\n self.min_val.append(self.cur_min)\n\n def pop(self) -> None:\n self.stk.pop()\n self.min_val.pop()\n if len(self.stk) > 0:\n self.cur_min = self.min_val[-1]\n else:\n self.cur_min = 2 << 32\n\n def top(self) -> int:\n return self.stk[-1]\n\n def getMin(self) -> int:\n return self.min_val[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20600"},{"code":"class MinStack:\n\n def __init__(self):\n self.reg_stack = []\n self.min_stack = []\n\n def push(self, val: int) -> None:\n self.reg_stack.append(val)\n\n if self.min_stack:\n new_min = min(self.min_stack[-1], val)\n else:\n new_min = val\n self.min_stack.append(new_min)\n\n def pop(self) -> None:\n self.min_stack.pop()\n self.reg_stack.pop()\n\n def top(self) -> int:\n return self.reg_stack[-1]\n\n def getMin(self) -> int:\n return self.min_stack[-1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20600"},{"code":"from collections import deque\n\nclass MinStack:\n\n def __init__(self):\n self.stack = deque()\n\n def push(self, val: int) -> None:\n if len(self.stack) == 0:\n self.stack.append((val, val))\n else:\n self.stack.append((val, min(val, self.stack[-1][1])))\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1][0]\n\n def getMin(self) -> int:\n return self.stack[-1][1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20700"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n self.min = float(\"inf\")\n\n def push(self, val: int) -> None:\n self.stack.append((val, self.min))\n self.setMin(min(self.min, val))\n\n def pop(self) -> None:\n val = self.stack.pop()\n self.setMin(val[1])\n\n def top(self) -> int:\n return self.stack[-1][0]\n\n def setMin(self, val: str) -> None:\n self.min = val\n\n def getMin(self) -> int:\n return self.min\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20700"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n if self.stack == []:\n self.stack.append( (val, val) )\n else:\n new_min = min(self.stack[-1][1], val)\n self.stack.append( (val, new_min) ) \n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1][0]\n\n def getMin(self) -> int:\n return self.stack[-1][1]\n \n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20800"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = []\n\n def push(self, val: int) -> None:\n if not self.stack:\n self.stack.append((val,val))\n else:\n minval = self.stack[-1][1]\n self.stack.append((val,min(val,minval))) \n #print(\"push\",self.stack)\n\n def pop(self) -> None:\n e = self.stack.pop()\n #print(\"pop\",e, self.stack)\n\n def top(self) -> int:\n #print(\"top\", self.stack[-1][0])\n return self.stack[-1][0]\n\n def getMin(self) -> int:\n #print(\"getmin\",self.stack[-1][1])\n return self.stack[-1][1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20800"},{"code":"\"\"\"\nWhen pushing an ele, min ele is either ele being pushed or the curr min element\n\nStack or (ele, minEle)\n\"\"\"\nclass MinStack:\n def __init__(self):\n self.stack = [] \n\n def push(self, val: int) -> None:\n if not self.stack:\n self.stack.append((val, val))\n return\n smallest = min(val, self.stack[-1][1])\n self.stack.append((val, smallest))\n\n def pop(self) -> None:\n self.stack.pop()\n\n def top(self) -> int:\n return self.stack[-1][0]\n\n def getMin(self) -> int:\n return self.stack[-1][1]\n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20900"},{"code":"class MinStack:\n\n def __init__(self):\n self.stack = list()\n\n def push(self, val: int) -> None:\n if len(self.stack) > 0:\n self.stack.append((val, min(self.stack[-1][1], val)))\n else:\n self.stack.append((val, val))\n\n def pop(self) -> None:\n val = self.stack.pop()\n\n def top(self) -> int:\n val = self.stack[-1]\n return val[0]\n \n\n def getMin(self) -> int:\n return self.stack[-1][1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"20900"},{"code":"from sortedcontainers import SortedSet; from heapq import *\nclass MinStack:\n\n def __init__(self):\n self.stack=[]\n self.minlist=[]\n\n \n\n def push(self, val: int) -> None:\n self.stack.append(val)\n \n if self.minlist: #is not empty\n self.minlist.append( min(val, self.minlist[-1]) ) \n else: #if self.minlist is empty\n self.minlist.append(val)\n \n\n def pop(self) -> None:\n self.stack.pop()\n self.minlist.pop()\n \n \n\n def top(self) -> int:\n return self.stack[-1]\n \n\n def getMin(self) -> int:\n return self.minlist[-1]\n \n\n\n# Your MinStack object will be instantiated and called as such:\n# obj = MinStack()\n# obj.push(val)\n# obj.pop()\n# param_3 = obj.top()\n# param_4 = obj.getMin()","memory":"21000"}],"string":"[\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n self.min_stack=[]\\n \\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if not self.min_stack or val<=self.min_stack[-1]:\\n self.min_stack.append(val)\\n \\n def pop(self) -> None:\\n if self.min_stack[-1]==self.stack[-1]:\\n self.min_stack.pop()\\n self.stack.pop() \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n def getMin(self) -> int:\\n return self.min_stack[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n def getMin(self) -> int:\\n low = float('inf')\\n for i in self.stack:\\n low = min(low, i)\\n return low\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"19600\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n minimum = self.stack[0]\\n \\n for i in self.stack:\\n minimum = min(minimum,i)\\n \\n return minimum\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"19700\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n self.minval=float(inf)\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n \\n\\n def pop(self) -> None:\\n self.stack=self.stack[:-1]\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n minnum=float(inf)\\n for num in self.stack:\\n minnum=min(minnum,num)\\n return minnum\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"19800\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.st = []\\n\\n def push(self, val: int) -> None:\\n self.st.append(val)\\n\\n def pop(self) -> None:\\n self.st.pop()\\n\\n def top(self) -> int:\\n return self.st[-1]\\n\\n def getMin(self) -> int:\\n return min(self.st)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"19900\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minstack = []\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if len(self.minstack) == 0 or val <= self.minstack[-1]:\\n self.minstack.append(val)\\n \\n def pop(self) -> None:\\n val = self.stack.pop()\\n if val == self.minstack[-1]:\\n self.minstack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n def getMin(self) -> int:\\n return self.minstack[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20000\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = deque()\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20100\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.minStack = []\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if len(self.minStack) != 0:\\n val = min(val, self.minStack[-1])\\n else:\\n val = val\\n \\n self.minStack.append(val)\\n\\n \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minStack.pop()\\n\\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.minStack[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20200\"\n },\n {\n \"code\": \"class MinOneStack:\\n def __init__(self):\\n self._pairs = [] \\n\\n def push(self, val: int) -> None:\\n prev_min_val = self._pairs[-1][1] if self._pairs else float('inf')\\n min_val = min(prev_min_val, val)\\n self._pairs.append([val, min_val])\\n\\n def pop(self) -> None:\\n self._pairs.pop()\\n\\n def top(self) -> int:\\n return self._pairs[-1][0] \\n\\n def getMin(self) -> int:\\n return self._pairs[-1][1]\\n\\n\\nclass MinTwoStack:\\n def __init__(self):\\n self._values = []\\n self._mins = []\\n\\n def push(self, val: int) -> None:\\n self._values.append(val)\\n\\n if not self._mins or val <= self._mins[-1]:\\n self._mins.append(val) \\n\\n def pop(self) -> None:\\n val = self._values.pop()\\n\\n if val == self._mins[-1]:\\n self._mins.pop()\\n\\n def top(self) -> int:\\n return self._values[-1]\\n\\n def getMin(self) -> int:\\n return self._mins[-1] \\n\\n\\n# class MinStack(MinOneStack):\\nclass MinStack(MinTwoStack):\\n pass\",\n \"memory\": \"20200\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n pass\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n return\\n def pop(self) -> None:\\n self.stack = self.stack[:len(self.stack) - 1]\\n return\\n def top(self) -> int:\\n return self.stack[-1]\\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20300\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.minVal = float('inf')\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n self.minVal = min(self.minVal, val)\\n self.stack.append(val)\\n\\n def pop(self) -> None:\\n top = self.stack.pop()\\n if self.minVal == top:\\n self.minVal = float('inf')\\n for n in self.stack:\\n self.minVal = min(self.minVal, n)\\n \\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minVal\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20300\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = math.inf\\n\\n def push(self, val: int) -> None:\\n self.stack = [val] + self.stack\\n if val < self.min:\\n self.min = val\\n\\n def pop(self) -> None:\\n self.stack = self.stack[1:]\\n\\n def top(self) -> int:\\n return self.stack[0]\\n \\n def getMin(self) -> int:\\n return min(self.stack)\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20400\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n self.minstack=[]\\n\\n def push(self, val: int) -> None:\\n\\n self.stack.append(val)\\n if not self.minstack:\\n self.minstack.append(val)\\n else:\\n self.minstack.append(min(val, self.minstack[-1]))\\n\\n def pop(self) -> None:\\n\\n self.stack.pop()\\n self.minstack.pop()\\n \\n\\n def top(self) -> int:\\n\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n\\n return self.minstack[-1]\\n \\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20400\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.pointers = {}\\n self.min_pos = None\\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if self.min_pos is None:\\n self.min_pos = len(self.stack)-1\\n self.pointers[self.min_pos] = None\\n elif val < self.stack[self.min_pos]:\\n self.pointers[len(self.stack)-1] = self.min_pos\\n self.min_pos = len(self.stack)-1\\n print(self.pointers)\\n\\n def pop(self) -> None:\\n if len(self.stack)-1 == self.min_pos:\\n self.min_pos = self.pointers.pop(self.min_pos)\\n self.stack.pop(-1)\\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n def getMin(self) -> int:\\n return self.stack[self.min_pos] \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"class MinStack:\\n def __init__(self):\\n self.stack = []\\n self.minStack = []\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n if(not self.minStack):\\n self.minStack.append(val)\\n elif(self.minStack[-1]>val):\\n self.minStack.append(val)\\n else:\\n self.minStack.append(self.minStack[-1])\\n\\n def pop(self) -> None:\\n self.stack.pop(-1)\\n self.minStack.pop(-1)\\n def top(self) -> int:\\n return self.stack[-1]\\n\\n def getMin(self) -> int:\\n return self.minStack[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stk = list()\\n self.min_val = list()\\n self.cur_min = 2 << 32\\n\\n def push(self, val: int) -> None:\\n self.stk.append(val)\\n if val < self.cur_min:\\n self.cur_min = val\\n self.min_val.append(self.cur_min)\\n\\n def pop(self) -> None:\\n self.stk.pop()\\n self.min_val.pop()\\n if len(self.stk) > 0:\\n self.cur_min = self.min_val[-1]\\n else:\\n self.cur_min = 2 << 32\\n\\n def top(self) -> int:\\n return self.stk[-1]\\n\\n def getMin(self) -> int:\\n return self.min_val[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20600\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.reg_stack = []\\n self.min_stack = []\\n\\n def push(self, val: int) -> None:\\n self.reg_stack.append(val)\\n\\n if self.min_stack:\\n new_min = min(self.min_stack[-1], val)\\n else:\\n new_min = val\\n self.min_stack.append(new_min)\\n\\n def pop(self) -> None:\\n self.min_stack.pop()\\n self.reg_stack.pop()\\n\\n def top(self) -> int:\\n return self.reg_stack[-1]\\n\\n def getMin(self) -> int:\\n return self.min_stack[-1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20600\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack = deque()\\n\\n def push(self, val: int) -> None:\\n if len(self.stack) == 0:\\n self.stack.append((val, val))\\n else:\\n self.stack.append((val, min(val, self.stack[-1][1])))\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1][0]\\n\\n def getMin(self) -> int:\\n return self.stack[-1][1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20700\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n self.min = float(\\\"inf\\\")\\n\\n def push(self, val: int) -> None:\\n self.stack.append((val, self.min))\\n self.setMin(min(self.min, val))\\n\\n def pop(self) -> None:\\n val = self.stack.pop()\\n self.setMin(val[1])\\n\\n def top(self) -> int:\\n return self.stack[-1][0]\\n\\n def setMin(self, val: str) -> None:\\n self.min = val\\n\\n def getMin(self) -> int:\\n return self.min\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20700\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n if self.stack == []:\\n self.stack.append( (val, val) )\\n else:\\n new_min = min(self.stack[-1][1], val)\\n self.stack.append( (val, new_min) ) \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1][0]\\n\\n def getMin(self) -> int:\\n return self.stack[-1][1]\\n \\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20800\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = []\\n\\n def push(self, val: int) -> None:\\n if not self.stack:\\n self.stack.append((val,val))\\n else:\\n minval = self.stack[-1][1]\\n self.stack.append((val,min(val,minval))) \\n #print(\\\"push\\\",self.stack)\\n\\n def pop(self) -> None:\\n e = self.stack.pop()\\n #print(\\\"pop\\\",e, self.stack)\\n\\n def top(self) -> int:\\n #print(\\\"top\\\", self.stack[-1][0])\\n return self.stack[-1][0]\\n\\n def getMin(self) -> int:\\n #print(\\\"getmin\\\",self.stack[-1][1])\\n return self.stack[-1][1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20800\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nWhen pushing an ele, min ele is either ele being pushed or the curr min element\\n\\nStack or (ele, minEle)\\n\\\"\\\"\\\"\\nclass MinStack:\\n def __init__(self):\\n self.stack = [] \\n\\n def push(self, val: int) -> None:\\n if not self.stack:\\n self.stack.append((val, val))\\n return\\n smallest = min(val, self.stack[-1][1])\\n self.stack.append((val, smallest))\\n\\n def pop(self) -> None:\\n self.stack.pop()\\n\\n def top(self) -> int:\\n return self.stack[-1][0]\\n\\n def getMin(self) -> int:\\n return self.stack[-1][1]\\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20900\"\n },\n {\n \"code\": \"class MinStack:\\n\\n def __init__(self):\\n self.stack = list()\\n\\n def push(self, val: int) -> None:\\n if len(self.stack) > 0:\\n self.stack.append((val, min(self.stack[-1][1], val)))\\n else:\\n self.stack.append((val, val))\\n\\n def pop(self) -> None:\\n val = self.stack.pop()\\n\\n def top(self) -> int:\\n val = self.stack[-1]\\n return val[0]\\n \\n\\n def getMin(self) -> int:\\n return self.stack[-1][1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"20900\"\n },\n {\n \"code\": \"from sortedcontainers import SortedSet; from heapq import *\\nclass MinStack:\\n\\n def __init__(self):\\n self.stack=[]\\n self.minlist=[]\\n\\n \\n\\n def push(self, val: int) -> None:\\n self.stack.append(val)\\n \\n if self.minlist: #is not empty\\n self.minlist.append( min(val, self.minlist[-1]) ) \\n else: #if self.minlist is empty\\n self.minlist.append(val)\\n \\n\\n def pop(self) -> None:\\n self.stack.pop()\\n self.minlist.pop()\\n \\n \\n\\n def top(self) -> int:\\n return self.stack[-1]\\n \\n\\n def getMin(self) -> int:\\n return self.minlist[-1]\\n \\n\\n\\n# Your MinStack object will be instantiated and called as such:\\n# obj = MinStack()\\n# obj.push(val)\\n# obj.pop()\\n# param_3 = obj.top()\\n# param_4 = obj.getMin()\",\n \"memory\": \"21000\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":24,"string":"24"}}},{"rowIdx":60,"cells":{"question_id":{"kind":"number","value":160,"string":"160"},"name":{"kind":"string","value":"intersection-of-two-linked-lists"},"content":{"kind":"string","value":"<p>Given the heads of two singly linked-lists <code>headA</code> and <code>headB</code>, return <em>the node at which the two lists intersect</em>. If the two linked lists have no intersection at all, return <code>null</code>.</p>\n\n<p>For example, the following two linked lists begin to intersect at node <code>c1</code>:</p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/03/05/160_statement.png\" style=\"width: 500px; height: 162px;\" />\n<p>The test cases are generated such that there are no cycles anywhere in the entire linked structure.</p>\n\n<p><strong>Note</strong> that the linked lists must <strong>retain their original structure</strong> after the function returns.</p>\n\n<p><strong>Custom Judge:</strong></p>\n\n<p>The inputs to the <strong>judge</strong> are given as follows (your program is <strong>not</strong> given these inputs):</p>\n\n<ul>\n\t<li><code>intersectVal</code> - The value of the node where the intersection occurs. This is <code>0</code> if there is no intersected node.</li>\n\t<li><code>listA</code> - The first linked list.</li>\n\t<li><code>listB</code> - The second linked list.</li>\n\t<li><code>skipA</code> - The number of nodes to skip ahead in <code>listA</code> (starting from the head) to get to the intersected node.</li>\n\t<li><code>skipB</code> - The number of nodes to skip ahead in <code>listB</code> (starting from the head) to get to the intersected node.</li>\n</ul>\n\n<p>The judge will then create the linked structure based on these inputs and pass the two heads, <code>headA</code> and <code>headB</code> to your program. If you correctly return the intersected node, then your solution will be <strong>accepted</strong>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/03/05/160_example_1_1.png\" style=\"width: 500px; height: 162px;\" />\n<pre>\n<strong>Input:</strong> intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3\n<strong>Output:</strong> Intersected at '8'\n<strong>Explanation:</strong> The intersected node's value is 8 (note that this must not be 0 if the two lists intersect).\nFrom the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.\n- Note that the intersected node's value is not 1 because the nodes with value 1 in A and B (2<sup>nd</sup> node in A and 3<sup>rd</sup> node in B) are different node references. In other words, they point to two different locations in memory, while the nodes with value 8 in A and B (3<sup>rd</sup> node in A and 4<sup>th</sup> node in B) point to the same location in memory.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/03/05/160_example_2.png\" style=\"width: 500px; height: 194px;\" />\n<pre>\n<strong>Input:</strong> intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1\n<strong>Output:</strong> Intersected at '2'\n<strong>Explanation:</strong> The intersected node's value is 2 (note that this must not be 0 if the two lists intersect).\nFrom the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/03/05/160_example_3.png\" style=\"width: 300px; height: 189px;\" />\n<pre>\n<strong>Input:</strong> intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2\n<strong>Output:</strong> No intersection\n<strong>Explanation:</strong> From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.\nExplanation: The two lists do not intersect, so return null.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of nodes of <code>listA</code> is in the <code>m</code>.</li>\n\t<li>The number of nodes of <code>listB</code> is in the <code>n</code>.</li>\n\t<li><code>1 <= m, n <= 3 * 10<sup>4</sup></code></li>\n\t<li><code>1 <= Node.val <= 10<sup>5</sup></code></li>\n\t<li><code>0 <= skipA < m</code></li>\n\t<li><code>0 <= skipB < n</code></li>\n\t<li><code>intersectVal</code> is <code>0</code> if <code>listA</code> and <code>listB</code> do not intersect.</li>\n\t<li><code>intersectVal == listA[skipA] == listB[skipB]</code> if <code>listA</code> and <code>listB</code> intersect.</li>\n</ul>\n\n<p> </p>\n<strong>Follow up:</strong> Could you write a solution that runs in <code>O(m + n)</code> time and use only <code>O(1)</code> memory?"},"acRate":{"kind":"number","value":58.84117234795181,"string":"58.841172"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["hash-table","linked-list","two-pointers"],"string":"[\n \"hash-table\",\n \"linked-list\",\n \"two-pointers\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"38\", 0.0083], [\"56\", 0.0331], [\"57\", 0.0331], [\"58\", 0.0248], [\"59\", 0.0248], [\"60\", 0.0662], [\"61\", 0.0496], [\"62\", 0.1324], [\"63\", 0.1986], [\"64\", 0.2648], [\"65\", 0.3889], [\"66\", 0.5378], [\"67\", 0.6702], [\"68\", 0.9019], [\"69\", 1.299], [\"70\", 1.299], [\"71\", 1.8037], [\"72\", 2.2174], [\"73\", 2.6642], [\"74\", 3.0779], [\"75\", 3.5578], [\"76\", 4.4432], [\"77\", 4.5011], [\"78\", 4.7079], [\"79\", 4.6914], [\"80\", 5.6677], [\"81\", 5.9325], [\"82\", 5.5767], [\"83\", 5.7256], [\"84\", 5.5353], [\"85\", 5.1134], [\"86\", 4.7079], [\"87\", 4.5093], [\"88\", 3.4172], [\"89\", 3.2103], [\"90\", 2.3002], [\"91\", 2.0023], [\"92\", 1.4314], [\"93\", 1.1832], [\"94\", 0.7943]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"17900\", 0.0083], [\"25500\", 0.0083], [\"26000\", 0.0083], [\"26400\", 0.0083], [\"26500\", 0.0083], [\"26600\", 0.0331], [\"26700\", 0.0496], [\"26800\", 0.0414], [\"26900\", 0.6123], [\"27000\", 8.3237], [\"27100\", 38.8714], [\"27200\", 25.0952], [\"27300\", 3.169], [\"27400\", 2.4822], [\"27500\", 2.7635], [\"27600\", 7.0826], [\"27700\", 2.3746], [\"27800\", 1.0591], [\"27900\", 2.6146], [\"28000\", 0.3227]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n# class Solution:\n# def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n# tempA = headA\n# tempB = headB\n# while tempA != tempB:\n# tempA = tempA.next if tempA else headB\n# tempB = tempB.next if tempB else headA\n# return tempA\n\ndef solve():\n f=open('user.out','w')\n iterator=map(loads,stdin)\n while True:\n try:\n i=next(iterator)\n lA=next(iterator)\n lB=next(iterator)\n sA=next(iterator)\n sB=next(iterator)\n except StopIteration:\n break\n stmt = f\"Intersected at '{i}'\" if i != 0 else \"No intersection\"\n print(stmt, file=f)\n# solution=Solution()\nsolve()\nexit()","runtime":"38"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n h1 = headA\n h2 = headB\n while h1 != h2:\n h1 = h1.next if h1 else headB\n h2 = h2.next if h2 else headA\n return h1\n \n\n\n \n \n\n ","runtime":"56"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n found = set()\n curr = headA \n while curr is not None:\n found.add(curr)\n curr = curr.next\n curr = headB \n while curr is not None:\n if curr in found:\n return curr\n curr = curr.next\n return None","runtime":"57"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n s = set()\n while headA:\n s.add(headA)\n headA = headA.next \n \n while headB:\n if headB in s:\n return headB\n headB = headB.next\n return None","runtime":"58"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = 56\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n p1 = headA\n p2 = headB\n while p1 != p2:\n p1 = p1.next if p1 else headB\n p2 = p2.next if p2 else headA\n \n return p1\n ","runtime":"59"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n hashmap = {}\n t1 = headA\n t2 = headB\n\n # do not store the values but the whole nodes to compare the memory addresses\n\n while t1!= None:\n hashmap[t1] = 1\n t1 = t1.next\n \n while t2!= None:\n if t2 in hashmap:\n return t2\n \n t2 = t2.next\n \n return t2\n\n\n","runtime":"60"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n a = headA\n b = headB\n while a != b:\n if a:\n a = a.next\n else:\n a = headB\n if b:\n b = b.next\n else:\n b = headA\n return a","runtime":"61"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n curr1 = headA\n curr2 = headB\n\n while curr1 and curr2:\n curr1=curr1.next\n curr2=curr2.next\n\n c1,c2=0,0\n while curr1:\n curr1=curr1.next\n c1+=1\n while curr2:\n curr2=curr2.next\n c2+=1\n \n curr1,curr2=headA,headB\n while c1:\n curr1=curr1.next\n c1-=1\n while c2:\n curr2=curr2.next\n c2-=1\n\n while curr1 and curr2:\n if curr1==curr2:\n return curr1\n curr1=curr1.next\n curr2=curr2.next\n \n return None\n \n","runtime":"62"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n nodes_in_b = set()\n\n while headB:\n nodes_in_b.add(headB)\n headB = headB.next\n\n while headA:\n if headA in nodes_in_b:\n return headA\n \n headA = headA.next\n\n return None","runtime":"63"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n cur_a = headA\n cur_b = headB\n\n l1 = 0\n l2 = 0\n while cur_a.next is not None:\n cur_a = cur_a.next\n l1 += 1\n \n while cur_b.next is not None:\n cur_b = cur_b.next\n l2 += 1\n\n cur_a = headA\n cur_b = headB\n if l1 < l2:\n for _ in range(l2 - l1):\n cur_b = cur_b.next\n elif l1 > l2:\n for _ in range(l1 - l2):\n cur_a = cur_a.next\n \n while cur_a != cur_b and cur_a is not None and cur_b is not None:\n cur_a = cur_a.next\n cur_b = cur_b.next\n \n return cur_a\n","runtime":"63"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n cur_a = headA\n cur_b = headB\n\n l1 = 0\n l2 = 0\n while cur_a.next is not None:\n cur_a = cur_a.next\n l1 += 1\n \n while cur_b.next is not None:\n cur_b = cur_b.next\n l2 += 1\n\n cur_a = headA\n cur_b = headB\n if l1 < l2:\n for _ in range(l2 - l1):\n cur_b = cur_b.next\n elif l1 > l2:\n for _ in range(l1 - l2):\n cur_a = cur_a.next\n \n while cur_a != cur_b and cur_a is not None and cur_b is not None:\n cur_a = cur_a.next\n cur_b = cur_b.next\n \n return cur_a\n","runtime":"64"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if not headA or not headB:\n return none\n pa,pb = headA,headB\n while pa!=pb:\n pa = pa.next if pa else headB\n pb = pb.next if pb else headA\n\n return pa\n \n \n ","runtime":"65"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if not headA or not headB:\n return None\n \n currentA = headA\n currentB = headB\n\n while currentA != currentB:\n currentA = currentA.next if currentA else headB\n currentB = currentB.next if currentB else headA\n\n return currentA","runtime":"66"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n tempA = headA\n tempB = headB\n len1 = 0\n while headA:\n headA = headA.next\n len1 += 1\n \n len2 = 0\n while headB:\n headB = headB.next\n len2 += 1\n \n headA = tempA\n headB = tempB\n\n if len1 < len2:\n for j in range(len2-len1):\n headB = headB.next\n else:\n for j in range(len1-len2):\n headA = headA.next\n \n while headA and headB:\n if headA == headB:\n return headA\n \n headA = headA.next\n headB = headB.next\n \n return None\n","runtime":"67"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n temp1 = headA\n temp2 = headB\n\n hashMap = {}\n\n while(temp1):\n hashMap[temp1] = 1\n temp1 = temp1.next\n \n while(temp2):\n if(temp2 in hashMap):\n return temp2\n temp2 = temp2.next\n return None","runtime":"68"},{"code":"class Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:\n a, b = headA, headB\n while a != b:\n a = a.next if a else headB\n b = b.next if b else headA\n return a ","runtime":"69"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n seen = set()\n a, b = headA, headB\n while a:\n seen.add(a)\n a = a.next\n \n while b:\n if b in seen:\n return b\n else:\n seen.add(b)\n b = b.next\n \n return None\n ","runtime":"69"},{"code":"class Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n stackA = ['A']\n stackB = ['B']\n\n while headA or headB:\n if headA:\n stackA.append(headA)\n headA = headA.next\n\n if headB:\n stackB.append(headB)\n headB = headB.next\n\n prev = None\n while stackA and stackB:\n nodeA = stackA.pop(-1)\n nodeB = stackB.pop(-1)\n\n if nodeA != nodeB:\n return prev\n\n prev = nodeA ","runtime":"70"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n curr_1 = headA\n curr_2 = headB\n if not headA or not headB:\n return None\n while curr_1!=curr_2:\n if curr_1:\n curr_1 = curr_1.next\n else:\n curr_1 = headB\n if curr_2:\n curr_2 = curr_2.next\n else:\n curr_2 = headA\n return curr_1\n ","runtime":"71"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n a, b = headA, headB\n ca, cb = 0, 0\n while(a and b):\n if a == b:\n break\n a = a.next\n b = b.next\n \n if not a and ca == 0:\n ca += 1\n a = headB\n \n if not b and cb == 0:\n cb += 1\n b = headA\n \n \n return a\n ","runtime":"71"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n intersection = False\n a_nodes = set()\n \n while headA: \n a_nodes.add(headA)\n headA = headA.next\n \n while headB: \n if headB in a_nodes: \n return headB\n headB = headB.next\n return None","runtime":"72"},{"code":"from typing import Optional\n\n# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, x: int):\n self.val = x\n self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if not headA or not headB:\n return None\n \n pointerA, pointerB = headA, headB\n \n # Traverse both lists\n while pointerA != pointerB:\n # Move to the next node, or to the head of the other list\n pointerA = pointerA.next if pointerA else headB\n pointerB = pointerB.next if pointerB else headA\n \n # Return the intersection node, or None if no intersection\n return pointerA\n","runtime":"72"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n pointer_a = headA\n pointer_b = headB\n \n \n while pointer_a != pointer_b:\n pointer_a = pointer_a.next if pointer_a else headB\n pointer_b = pointer_b.next if pointer_b else headA\n \n \n return pointer_a\n ","runtime":"73"},{"code":"class Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n stackA = ['A']\n stackB = ['B']\n\n while headA or headB:\n if headA:\n stackA.append(headA)\n headA = headA.next\n\n if headB:\n stackB.append(headB)\n headB = headB.next\n\n prev = None\n while stackA and stackB:\n nodeA = stackA.pop(-1)\n nodeB = stackB.pop(-1)\n\n if nodeA != nodeB:\n return prev\n\n prev = nodeA","runtime":"73"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n a,b = headA, headB\n\n while(a!=b):\n a = a.next if a else headB\n b = b.next if b else headA\n return a","runtime":"74"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n a, b = headA, headB\n ca, cb = 0, 0\n while(a != b):\n a = a.next if a else headB\n b = b.next if b else headA\n \n return a\n ","runtime":"74"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, h1: ListNode, h2: ListNode) -> Optional[ListNode]:\n c1, c2 = 0,0\n temp1 = h1\n while temp1 != None:\n c1+=1\n temp1 = temp1.next\n temp2 = h2\n while temp2 != None:\n c2 += 1 \n temp2 = temp2.next\n\n t1, t2 = h1, h2\n if c1 > c2:\n for i in range(c1-c2):\n t1 = t1.next\n else:\n for i in range(c2 - c1):\n t2 = t2.next\n while t1 !=None and t2!= None:\n if t1 == t2:\n return t1\n t1 = t1.next\n t2 = t2.next\n","runtime":"75"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n\n # Solução O(N+M) com O(N) de espaço\n visited = set()\n it_a = headA\n while( it_a is not None ):\n visited.add(it_a)\n it_a = it_a.next\n it_b = headB\n while( it_b is not None ):\n if it_b in visited:\n return it_b\n it_b = it_b.next\n return None\n \n # Solução trivial: O(N^2) [TLE]\n # it_a = headA\n # while( it_a is not None ):\n # it_b = headB\n # while( it_b is not None ):\n # if (it_a == it_b):\n # return it_a\n # it_b = it_b.next\n # it_a = it_a.next\n # return None\n\n","runtime":"75"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, h1: ListNode, h2: ListNode) -> Optional[ListNode]:\n c1, c2 = 0,0\n temp1 = h1\n while temp1 != None:\n c1+=1\n temp1 = temp1.next\n temp2 = h2\n while temp2 != None:\n c2 += 1 \n temp2 = temp2.next\n\n t1, t2 = h1, h2\n if c1 > c2:\n for i in range(c1-c2):\n t1 = t1.next\n else:\n for i in range(c2 - c1):\n t2 = t2.next\n while t1 !=None and t2!= None:\n if t1 == t2:\n return t1\n t1 = t1.next\n t2 = t2.next\n","runtime":"76"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n a,b=headA,headB\n while a!=b:\n a=a.next if a else headB\n b=b.next if b else headA\n return a \n\n ","runtime":"76"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n p_a, p_b = headA, headB\n while p_a != p_b:\n if p_a is None:\n p_a = headB\n else:\n p_a = p_a.next\n if p_b is None:\n p_b = headA\n else:\n p_b = p_b.next\n return p_a","runtime":"77"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n nA, nodeA = 0, headA\n while nodeA:\n nA += 1\n nodeA = nodeA.next \n nB, nodeB = 0, headB\n while nodeB:\n nB += 1\n nodeB = nodeB.next\n nodeL = headA if nA > nB else headB\n nodeS = headB if nA > nB else headA # IMPORTANT NOTE: make sure the condition is same.\n nd = abs(nA - nB)\n for _ in range(nd):\n nodeL = nodeL.next\n while nodeL != nodeS:\n nodeL = nodeL.next\n nodeS = nodeS.next\n return nodeL\n\n def getIntersectionNode2(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if not headA: return None\n node_dict = {}\n nodeA = headA\n while nodeA:\n node_dict[id(nodeA)] = nodeA\n nodeA = nodeA.next\n nodeB = headB\n while nodeB:\n if id(nodeB) in node_dict:\n return nodeB\n nodeB = nodeB.next\n return None\n ","runtime":"77"},{"code":"class Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:\n a, b = headA, headB\n while a != b:\n a = a.next if a else headB\n b = b.next if b else headA\n return a ","runtime":"78"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n l_a, l_b = 1, 1\n ha = headA\n hb = headB\n listA = []\n listB = []\n skipA = 0\n skipB = 0\n\n while ha.next:\n l_a += 1\n ha = ha.next\n\n while hb.next:\n l_b += 1\n hb = hb.next\n\n ha = headA\n hb = headB\n\n if l_a < l_b:\n skipB += (l_b - l_a)\n for _ in range(l_b - l_a):\n hb = hb.next\n elif l_a > l_b:\n skipA += (l_a - l_b)\n for _ in range(l_a - l_b):\n ha = ha.next\n\n intersectVal = None\n for _ in range(min(l_a, l_b)):\n if ha == hb and intersectVal is None:\n intersectVal = ha\n elif ha != hb:\n intersectVal = None\n\n ha = ha.next\n hb = hb.next\n skipA += 1\n skipB += 1\n\n return intersectVal\n\n \n\n\n \n ","runtime":"78"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if headA is None or headB is None:\n return None\n hashtable = dict()\n currA = headA\n currB = headB\n while currA:\n hashtable[currA] = 1\n currA = currA.next\n while currB:\n if currB in hashtable:\n return currB\n currB = currB.next\n return None","runtime":"79"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n setA, setB = set(), set()\n while headA or headB:\n if headA:\n setA.add(headA)\n headA = headA.next\n if headB in setA:\n return headB\n if headB:\n setB.add(headB)\n headB = headB.next\n if headA in setB:\n return headA\n return None\n ","runtime":"79"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n curA, curB = headA, headB\n while curA or curB:\n if curA is curB:\n return curA\n\n if not curA:\n curA = headB\n else:\n curA = curA.next\n \n if not curB:\n curB = headA\n else:\n curB = curB.next\n\n return None\n","runtime":"80"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if not headA or not headB:\n return None\n\n pA = headA\n pB = headB\n\n while pA != pB:\n pA = pA.next if pA else headB\n pB = pB.next if pB else headA\n\n return pA","runtime":"80"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n h1 = headA\n h2 = headB\n while h1 != h2:\n h1 = h1.next if h1 else headB\n h2 = h2.next if h2 else headA\n return h1\n \n setA, setB = set(), set()\n while headA or headB:\n if headA:\n setA.add(headA)\n headA = headA.next\n if headB:\n setB.add(headB)\n headB = headB.next\n if headB in setA:\n return headB\n if headA in setB:\n return headA\n return None\n ","runtime":"81"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n lenA, lenB = 0, 0\n curr = headA\n while(curr):\n lenA += 1\n curr = curr.next\n curr = headB\n while(curr):\n lenB += 1\n curr = curr.next\n diff = lenA - lenB\n if diff >= 0:\n while diff > 0:\n headA = headA.next\n diff -= 1\n while (headA):\n if headA == headB:\n return headA\n else:\n headA = headA.next\n headB = headB.next\n return\n else:\n while diff < 0:\n headB = headB.next\n diff += 1\n while (headA):\n if headA == headB:\n return headA\n else:\n headA = headA.next\n headB = headB.next\n return ","runtime":"81"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if not headA or not headB:\n return\n pointerA=headA\n pointerB=headB\n while pointerB!= pointerA:\n pointerA=pointerA.next if pointerA else headB\n pointerB=pointerB.next if pointerB else headA\n return pointerA\n ","runtime":"82"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n res = None\n found = False\n\n lenA = self.lenLinked(headA)\n lenB = self.lenLinked(headB)\n if lenA > lenB:\n for i in range(lenA-lenB):\n headA = headA.next\n else:\n for i in range(lenB-lenA):\n headB = headB.next\n\n while headA and headB and not found:\n if headA == headB:\n found = True\n res = headA\n headA = headA.next\n headB = headB.next\n\n return res\n\n def lenLinked(self, head):\n l = 0\n while head:\n l += 1\n head = head.next\n return l\n","runtime":"82"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if not headA or not headB:\n return\n pointerA=headA\n pointerB=headB\n while pointerB!= pointerA:\n pointerA=pointerA.next if pointerA else headB\n pointerB=pointerB.next if pointerB else headA\n return pointerA\n ","runtime":"83"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n iterA = headA\n iterB = headB\n while iterA != iterB:\n iterA = iterA.next if iterA else headB\n iterB = iterB.next if iterB else headA\n return iterA","runtime":"83"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n pointer_a = headA\n pointer_b = headB\n\n while pointer_a != pointer_b:\n pointer_a = headB if not pointer_a else pointer_a.next\n pointer_b = headA if not pointer_b else pointer_b.next\n\n\n return pointer_a","runtime":"84"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n def forward(n, l):\n while n:\n l = l.next\n n -= 1\n return l\n \n \n def get_len(l):\n n = 1\n while l:\n l = l.next\n n += 1\n return n\n \n a_len = get_len(headA)\n b_len = get_len(headB)\n \n if a_len > b_len:\n headA = forward(a_len - b_len, headA)\n else:\n headB = forward(b_len - a_len, headB)\n \n while headA and headB:\n if headA == headB:\n return headA\n headA = headA.next\n headB = headB.next\n ","runtime":"84"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n pA=headA\n pB=headB\n while pA!=pB:\n pA=pA.next if pA else headB\n pB=pB.next if pB else headA\n return pA\n ","runtime":"85"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n len1 = len2 = 0\n temp1, temp2 = headA, headB\n while temp1 and temp2:\n len1 += 1\n len2 += 1\n temp1 = temp1.next\n temp2 = temp2.next\n while temp1:\n len1 += 1\n temp1 = temp1.next\n while temp2:\n len2 += 1\n temp2 = temp2.next\n \n diff = len1 - len2 if len1 > len2 else len2 - len1\n if len1 >= len2:\n temp1 = headA\n temp2 = headB\n else:\n temp1 = headB\n temp2 = headA\n while diff > 0:\n temp1 = temp1.next\n diff -= 1\n \n while temp1 and temp2:\n if temp1 == temp2:\n return temp1\n temp1 = temp1.next\n temp2 = temp2.next\n return None","runtime":"85"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n l1, l2 = headA, headB\n while l1 != l2:\n l1 = l1.next if l1 else headB\n l2 = l2.next if l2 else headA\n return l1","runtime":"86"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if not headA: return None\n node_dict = {}\n nodeA = headA\n node_dict[id(nodeA)] = nodeA\n while nodeA.next:\n nodeA = nodeA.next\n node_dict[id(nodeA)] = nodeA\n nodeB = headB\n while nodeB:\n if id(nodeB) in node_dict:\n return nodeB\n nodeB = nodeB.next\n return None\n ","runtime":"86"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n hashMap = {}\n tempA = headA\n\n while tempA is not None:\n hashMap[tempA] = tempA.val\n tempA = tempA.next\n tempB = headB\n while tempB is not None:\n if tempB in hashMap:\n return tempB\n tempB = tempB.next\n \n return None","runtime":"87"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n\n def findLength(head):\n length = 0\n trav = head\n while trav is not None:\n trav = trav.next\n length+=1\n\n return length\n\n lengthA = findLength(headA)\n lengthB = findLength(headB)\n diff = abs(lengthA - lengthB)\n\n travA = headA\n travB = headB\n\n if lengthA > lengthB:\n for i in range(diff):\n travA = travA.next\n else:\n for i in range(diff):\n travB = travB.next\n\n while travA is not None and travB is not None:\n if travA == travB:\n return travA\n\n travA = travA.next\n travB = travB.next\n\n return None\n\n ","runtime":"87"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def size(self,head):\n count = 0\n if head is None:\n return count\n curr = head\n while curr:\n count += 1\n curr = curr.next\n return count\n \n def find_intersect(self,headA,headB):\n while headA and headB:\n if headA == headB:\n return headA\n headA = headA.next\n headB = headB.next\n return None\n\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n sizeA = self.size(headA)\n sizeB = self.size(headB)\n if sizeA > sizeB:\n dif = sizeA - sizeB\n for i in range(dif):\n headA = headA.next\n currA = headA\n currB = headB\n return self.find_intersect(currA,currB)\n else:\n dif = sizeB - sizeA\n for i in range(dif):\n headB = headB.next\n currA = headA\n currB = headB\n return self.find_intersect(currA,currB)\n ","runtime":"88"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n st = set()\n while headA:\n st.add(headA)\n headA = headA.next\n while headB:\n if headB in st:\n return headB\n headB = headB.next\n return None\n\n\n\n\n\n ","runtime":"88"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def get_length(self, head):\n temp = head\n length = 0\n while(temp):\n length += 1\n temp = temp.next\n return length\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n length_a = self.get_length(headA)\n length_b = self.get_length(headB)\n print(length_a, length_b)\n to_skip = length_b - length_a\n print(to_skip)\n new_headB = headB\n for i in range(to_skip):\n new_headB = new_headB.next\n to_skip = length_a - length_b\n new_headA = headA\n for i in range(to_skip):\n new_headA = new_headA.next\n \n while (new_headB):\n if new_headB == new_headA:\n return new_headB\n new_headB = new_headB.next\n new_headA = new_headA.next\n return None\n ","runtime":"89"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(\n self, headA: ListNode, headB: ListNode\n ) -> Optional[ListNode]:\n l1, l2 = headA, headB\n while l1 != l2:\n l1 = l1.next if l1 else headB\n l2 = l2.next if l2 else headA\n return l1","runtime":"89"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n intersection = False\n a_nodes = set()\n \n while headA: \n a_nodes.add(headA)\n headA = headA.next\n \n while headB: \n if headB in a_nodes: \n return headB\n headB = headB.next\n return None","runtime":"90"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n intersection = False\n a_nodes = set()\n \n while headA: \n a_nodes.add(headA)\n headA = headA.next\n \n while headB: \n if headB in a_nodes: \n return headB\n headB = headB.next\n return None","runtime":"90"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n l1,l2=headA,headB\n while l1!=l2:\n l1=l1.next if l1 else headB\n l2=l2.next if l2 else headA\n return l1","runtime":"91"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, x):\n self.val = x\n self.next = None\n\nclass Solution:\n def getIntersectionNode(self, h1: ListNode, h2: ListNode) -> Optional[ListNode]:\n c1, c2 = 0,0\n temp1 = h1\n while temp1 != None:\n c1+=1\n temp1 = temp1.next\n temp2 = h2\n while temp2 != None:\n c2 += 1 \n temp2 = temp2.next\n\n t1, t2 = h1, h2\n if c1 > c2:\n for i in range(c1-c2):\n t1 = t1.next\n else:\n for i in range(c2 - c1):\n t2 = t2.next\n while t1 !=None and t2!= None:\n if t1 == t2:\n return t1\n t1 = t1.next\n t2 = t2.next\n","runtime":"93"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n first_set=set()\n curr=headA\n \n while curr:\n first_set.add(curr)\n curr=curr.next\n \n curr = headB\n while curr:\n if curr in first_set:\n return curr\n curr=curr.next\n\n return None","runtime":"93"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n hA = headA\n hB = headB\n \n while hA!=hB:\n hA = headB if not hA else hA.next\n hB = headA if not hB else hB.next\n \n return hA","runtime":"94"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n# class Solution:\\n# def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n# tempA = headA\\n# tempB = headB\\n# while tempA != tempB:\\n# tempA = tempA.next if tempA else headB\\n# tempB = tempB.next if tempB else headA\\n# return tempA\\n\\ndef solve():\\n f=open('user.out','w')\\n iterator=map(loads,stdin)\\n while True:\\n try:\\n i=next(iterator)\\n lA=next(iterator)\\n lB=next(iterator)\\n sA=next(iterator)\\n sB=next(iterator)\\n except StopIteration:\\n break\\n stmt = f\\\"Intersected at '{i}'\\\" if i != 0 else \\\"No intersection\\\"\\n print(stmt, file=f)\\n# solution=Solution()\\nsolve()\\nexit()\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n h1 = headA\\n h2 = headB\\n while h1 != h2:\\n h1 = h1.next if h1 else headB\\n h2 = h2.next if h2 else headA\\n return h1\\n \\n\\n\\n \\n \\n\\n \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n found = set()\\n curr = headA \\n while curr is not None:\\n found.add(curr)\\n curr = curr.next\\n curr = headB \\n while curr is not None:\\n if curr in found:\\n return curr\\n curr = curr.next\\n return None\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n s = set()\\n while headA:\\n s.add(headA)\\n headA = headA.next \\n \\n while headB:\\n if headB in s:\\n return headB\\n headB = headB.next\\n return None\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = 56\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n p1 = headA\\n p2 = headB\\n while p1 != p2:\\n p1 = p1.next if p1 else headB\\n p2 = p2.next if p2 else headA\\n \\n return p1\\n \",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n hashmap = {}\\n t1 = headA\\n t2 = headB\\n\\n # do not store the values but the whole nodes to compare the memory addresses\\n\\n while t1!= None:\\n hashmap[t1] = 1\\n t1 = t1.next\\n \\n while t2!= None:\\n if t2 in hashmap:\\n return t2\\n \\n t2 = t2.next\\n \\n return t2\\n\\n\\n\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n a = headA\\n b = headB\\n while a != b:\\n if a:\\n a = a.next\\n else:\\n a = headB\\n if b:\\n b = b.next\\n else:\\n b = headA\\n return a\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n curr1 = headA\\n curr2 = headB\\n\\n while curr1 and curr2:\\n curr1=curr1.next\\n curr2=curr2.next\\n\\n c1,c2=0,0\\n while curr1:\\n curr1=curr1.next\\n c1+=1\\n while curr2:\\n curr2=curr2.next\\n c2+=1\\n \\n curr1,curr2=headA,headB\\n while c1:\\n curr1=curr1.next\\n c1-=1\\n while c2:\\n curr2=curr2.next\\n c2-=1\\n\\n while curr1 and curr2:\\n if curr1==curr2:\\n return curr1\\n curr1=curr1.next\\n curr2=curr2.next\\n \\n return None\\n \\n\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n nodes_in_b = set()\\n\\n while headB:\\n nodes_in_b.add(headB)\\n headB = headB.next\\n\\n while headA:\\n if headA in nodes_in_b:\\n return headA\\n \\n headA = headA.next\\n\\n return None\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n cur_a = headA\\n cur_b = headB\\n\\n l1 = 0\\n l2 = 0\\n while cur_a.next is not None:\\n cur_a = cur_a.next\\n l1 += 1\\n \\n while cur_b.next is not None:\\n cur_b = cur_b.next\\n l2 += 1\\n\\n cur_a = headA\\n cur_b = headB\\n if l1 < l2:\\n for _ in range(l2 - l1):\\n cur_b = cur_b.next\\n elif l1 > l2:\\n for _ in range(l1 - l2):\\n cur_a = cur_a.next\\n \\n while cur_a != cur_b and cur_a is not None and cur_b is not None:\\n cur_a = cur_a.next\\n cur_b = cur_b.next\\n \\n return cur_a\\n\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n cur_a = headA\\n cur_b = headB\\n\\n l1 = 0\\n l2 = 0\\n while cur_a.next is not None:\\n cur_a = cur_a.next\\n l1 += 1\\n \\n while cur_b.next is not None:\\n cur_b = cur_b.next\\n l2 += 1\\n\\n cur_a = headA\\n cur_b = headB\\n if l1 < l2:\\n for _ in range(l2 - l1):\\n cur_b = cur_b.next\\n elif l1 > l2:\\n for _ in range(l1 - l2):\\n cur_a = cur_a.next\\n \\n while cur_a != cur_b and cur_a is not None and cur_b is not None:\\n cur_a = cur_a.next\\n cur_b = cur_b.next\\n \\n return cur_a\\n\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if not headA or not headB:\\n return none\\n pa,pb = headA,headB\\n while pa!=pb:\\n pa = pa.next if pa else headB\\n pb = pb.next if pb else headA\\n\\n return pa\\n \\n \\n \",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if not headA or not headB:\\n return None\\n \\n currentA = headA\\n currentB = headB\\n\\n while currentA != currentB:\\n currentA = currentA.next if currentA else headB\\n currentB = currentB.next if currentB else headA\\n\\n return currentA\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n tempA = headA\\n tempB = headB\\n len1 = 0\\n while headA:\\n headA = headA.next\\n len1 += 1\\n \\n len2 = 0\\n while headB:\\n headB = headB.next\\n len2 += 1\\n \\n headA = tempA\\n headB = tempB\\n\\n if len1 < len2:\\n for j in range(len2-len1):\\n headB = headB.next\\n else:\\n for j in range(len1-len2):\\n headA = headA.next\\n \\n while headA and headB:\\n if headA == headB:\\n return headA\\n \\n headA = headA.next\\n headB = headB.next\\n \\n return None\\n\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n temp1 = headA\\n temp2 = headB\\n\\n hashMap = {}\\n\\n while(temp1):\\n hashMap[temp1] = 1\\n temp1 = temp1.next\\n \\n while(temp2):\\n if(temp2 in hashMap):\\n return temp2\\n temp2 = temp2.next\\n return None\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:\\n a, b = headA, headB\\n while a != b:\\n a = a.next if a else headB\\n b = b.next if b else headA\\n return a \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n seen = set()\\n a, b = headA, headB\\n while a:\\n seen.add(a)\\n a = a.next\\n \\n while b:\\n if b in seen:\\n return b\\n else:\\n seen.add(b)\\n b = b.next\\n \\n return None\\n \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n stackA = ['A']\\n stackB = ['B']\\n\\n while headA or headB:\\n if headA:\\n stackA.append(headA)\\n headA = headA.next\\n\\n if headB:\\n stackB.append(headB)\\n headB = headB.next\\n\\n prev = None\\n while stackA and stackB:\\n nodeA = stackA.pop(-1)\\n nodeB = stackB.pop(-1)\\n\\n if nodeA != nodeB:\\n return prev\\n\\n prev = nodeA \",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n curr_1 = headA\\n curr_2 = headB\\n if not headA or not headB:\\n return None\\n while curr_1!=curr_2:\\n if curr_1:\\n curr_1 = curr_1.next\\n else:\\n curr_1 = headB\\n if curr_2:\\n curr_2 = curr_2.next\\n else:\\n curr_2 = headA\\n return curr_1\\n \",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n a, b = headA, headB\\n ca, cb = 0, 0\\n while(a and b):\\n if a == b:\\n break\\n a = a.next\\n b = b.next\\n \\n if not a and ca == 0:\\n ca += 1\\n a = headB\\n \\n if not b and cb == 0:\\n cb += 1\\n b = headA\\n \\n \\n return a\\n \",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n intersection = False\\n a_nodes = set()\\n \\n while headA: \\n a_nodes.add(headA)\\n headA = headA.next\\n \\n while headB: \\n if headB in a_nodes: \\n return headB\\n headB = headB.next\\n return None\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"from typing import Optional\\n\\n# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, x: int):\\n self.val = x\\n self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if not headA or not headB:\\n return None\\n \\n pointerA, pointerB = headA, headB\\n \\n # Traverse both lists\\n while pointerA != pointerB:\\n # Move to the next node, or to the head of the other list\\n pointerA = pointerA.next if pointerA else headB\\n pointerB = pointerB.next if pointerB else headA\\n \\n # Return the intersection node, or None if no intersection\\n return pointerA\\n\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n pointer_a = headA\\n pointer_b = headB\\n \\n \\n while pointer_a != pointer_b:\\n pointer_a = pointer_a.next if pointer_a else headB\\n pointer_b = pointer_b.next if pointer_b else headA\\n \\n \\n return pointer_a\\n \",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n stackA = ['A']\\n stackB = ['B']\\n\\n while headA or headB:\\n if headA:\\n stackA.append(headA)\\n headA = headA.next\\n\\n if headB:\\n stackB.append(headB)\\n headB = headB.next\\n\\n prev = None\\n while stackA and stackB:\\n nodeA = stackA.pop(-1)\\n nodeB = stackB.pop(-1)\\n\\n if nodeA != nodeB:\\n return prev\\n\\n prev = nodeA\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n a,b = headA, headB\\n\\n while(a!=b):\\n a = a.next if a else headB\\n b = b.next if b else headA\\n return a\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n a, b = headA, headB\\n ca, cb = 0, 0\\n while(a != b):\\n a = a.next if a else headB\\n b = b.next if b else headA\\n \\n return a\\n \",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, h1: ListNode, h2: ListNode) -> Optional[ListNode]:\\n c1, c2 = 0,0\\n temp1 = h1\\n while temp1 != None:\\n c1+=1\\n temp1 = temp1.next\\n temp2 = h2\\n while temp2 != None:\\n c2 += 1 \\n temp2 = temp2.next\\n\\n t1, t2 = h1, h2\\n if c1 > c2:\\n for i in range(c1-c2):\\n t1 = t1.next\\n else:\\n for i in range(c2 - c1):\\n t2 = t2.next\\n while t1 !=None and t2!= None:\\n if t1 == t2:\\n return t1\\n t1 = t1.next\\n t2 = t2.next\\n\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n\\n # Solução O(N+M) com O(N) de espaço\\n visited = set()\\n it_a = headA\\n while( it_a is not None ):\\n visited.add(it_a)\\n it_a = it_a.next\\n it_b = headB\\n while( it_b is not None ):\\n if it_b in visited:\\n return it_b\\n it_b = it_b.next\\n return None\\n \\n # Solução trivial: O(N^2) [TLE]\\n # it_a = headA\\n # while( it_a is not None ):\\n # it_b = headB\\n # while( it_b is not None ):\\n # if (it_a == it_b):\\n # return it_a\\n # it_b = it_b.next\\n # it_a = it_a.next\\n # return None\\n\\n\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, h1: ListNode, h2: ListNode) -> Optional[ListNode]:\\n c1, c2 = 0,0\\n temp1 = h1\\n while temp1 != None:\\n c1+=1\\n temp1 = temp1.next\\n temp2 = h2\\n while temp2 != None:\\n c2 += 1 \\n temp2 = temp2.next\\n\\n t1, t2 = h1, h2\\n if c1 > c2:\\n for i in range(c1-c2):\\n t1 = t1.next\\n else:\\n for i in range(c2 - c1):\\n t2 = t2.next\\n while t1 !=None and t2!= None:\\n if t1 == t2:\\n return t1\\n t1 = t1.next\\n t2 = t2.next\\n\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n a,b=headA,headB\\n while a!=b:\\n a=a.next if a else headB\\n b=b.next if b else headA\\n return a \\n\\n \",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n p_a, p_b = headA, headB\\n while p_a != p_b:\\n if p_a is None:\\n p_a = headB\\n else:\\n p_a = p_a.next\\n if p_b is None:\\n p_b = headA\\n else:\\n p_b = p_b.next\\n return p_a\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n nA, nodeA = 0, headA\\n while nodeA:\\n nA += 1\\n nodeA = nodeA.next \\n nB, nodeB = 0, headB\\n while nodeB:\\n nB += 1\\n nodeB = nodeB.next\\n nodeL = headA if nA > nB else headB\\n nodeS = headB if nA > nB else headA # IMPORTANT NOTE: make sure the condition is same.\\n nd = abs(nA - nB)\\n for _ in range(nd):\\n nodeL = nodeL.next\\n while nodeL != nodeS:\\n nodeL = nodeL.next\\n nodeS = nodeS.next\\n return nodeL\\n\\n def getIntersectionNode2(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if not headA: return None\\n node_dict = {}\\n nodeA = headA\\n while nodeA:\\n node_dict[id(nodeA)] = nodeA\\n nodeA = nodeA.next\\n nodeB = headB\\n while nodeB:\\n if id(nodeB) in node_dict:\\n return nodeB\\n nodeB = nodeB.next\\n return None\\n \",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:\\n a, b = headA, headB\\n while a != b:\\n a = a.next if a else headB\\n b = b.next if b else headA\\n return a \",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n l_a, l_b = 1, 1\\n ha = headA\\n hb = headB\\n listA = []\\n listB = []\\n skipA = 0\\n skipB = 0\\n\\n while ha.next:\\n l_a += 1\\n ha = ha.next\\n\\n while hb.next:\\n l_b += 1\\n hb = hb.next\\n\\n ha = headA\\n hb = headB\\n\\n if l_a < l_b:\\n skipB += (l_b - l_a)\\n for _ in range(l_b - l_a):\\n hb = hb.next\\n elif l_a > l_b:\\n skipA += (l_a - l_b)\\n for _ in range(l_a - l_b):\\n ha = ha.next\\n\\n intersectVal = None\\n for _ in range(min(l_a, l_b)):\\n if ha == hb and intersectVal is None:\\n intersectVal = ha\\n elif ha != hb:\\n intersectVal = None\\n\\n ha = ha.next\\n hb = hb.next\\n skipA += 1\\n skipB += 1\\n\\n return intersectVal\\n\\n \\n\\n\\n \\n \",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if headA is None or headB is None:\\n return None\\n hashtable = dict()\\n currA = headA\\n currB = headB\\n while currA:\\n hashtable[currA] = 1\\n currA = currA.next\\n while currB:\\n if currB in hashtable:\\n return currB\\n currB = currB.next\\n return None\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n setA, setB = set(), set()\\n while headA or headB:\\n if headA:\\n setA.add(headA)\\n headA = headA.next\\n if headB in setA:\\n return headB\\n if headB:\\n setB.add(headB)\\n headB = headB.next\\n if headA in setB:\\n return headA\\n return None\\n \",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n curA, curB = headA, headB\\n while curA or curB:\\n if curA is curB:\\n return curA\\n\\n if not curA:\\n curA = headB\\n else:\\n curA = curA.next\\n \\n if not curB:\\n curB = headA\\n else:\\n curB = curB.next\\n\\n return None\\n\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if not headA or not headB:\\n return None\\n\\n pA = headA\\n pB = headB\\n\\n while pA != pB:\\n pA = pA.next if pA else headB\\n pB = pB.next if pB else headA\\n\\n return pA\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n h1 = headA\\n h2 = headB\\n while h1 != h2:\\n h1 = h1.next if h1 else headB\\n h2 = h2.next if h2 else headA\\n return h1\\n \\n setA, setB = set(), set()\\n while headA or headB:\\n if headA:\\n setA.add(headA)\\n headA = headA.next\\n if headB:\\n setB.add(headB)\\n headB = headB.next\\n if headB in setA:\\n return headB\\n if headA in setB:\\n return headA\\n return None\\n \",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n lenA, lenB = 0, 0\\n curr = headA\\n while(curr):\\n lenA += 1\\n curr = curr.next\\n curr = headB\\n while(curr):\\n lenB += 1\\n curr = curr.next\\n diff = lenA - lenB\\n if diff >= 0:\\n while diff > 0:\\n headA = headA.next\\n diff -= 1\\n while (headA):\\n if headA == headB:\\n return headA\\n else:\\n headA = headA.next\\n headB = headB.next\\n return\\n else:\\n while diff < 0:\\n headB = headB.next\\n diff += 1\\n while (headA):\\n if headA == headB:\\n return headA\\n else:\\n headA = headA.next\\n headB = headB.next\\n return \",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if not headA or not headB:\\n return\\n pointerA=headA\\n pointerB=headB\\n while pointerB!= pointerA:\\n pointerA=pointerA.next if pointerA else headB\\n pointerB=pointerB.next if pointerB else headA\\n return pointerA\\n \",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n res = None\\n found = False\\n\\n lenA = self.lenLinked(headA)\\n lenB = self.lenLinked(headB)\\n if lenA > lenB:\\n for i in range(lenA-lenB):\\n headA = headA.next\\n else:\\n for i in range(lenB-lenA):\\n headB = headB.next\\n\\n while headA and headB and not found:\\n if headA == headB:\\n found = True\\n res = headA\\n headA = headA.next\\n headB = headB.next\\n\\n return res\\n\\n def lenLinked(self, head):\\n l = 0\\n while head:\\n l += 1\\n head = head.next\\n return l\\n\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if not headA or not headB:\\n return\\n pointerA=headA\\n pointerB=headB\\n while pointerB!= pointerA:\\n pointerA=pointerA.next if pointerA else headB\\n pointerB=pointerB.next if pointerB else headA\\n return pointerA\\n \",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n iterA = headA\\n iterB = headB\\n while iterA != iterB:\\n iterA = iterA.next if iterA else headB\\n iterB = iterB.next if iterB else headA\\n return iterA\",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n pointer_a = headA\\n pointer_b = headB\\n\\n while pointer_a != pointer_b:\\n pointer_a = headB if not pointer_a else pointer_a.next\\n pointer_b = headA if not pointer_b else pointer_b.next\\n\\n\\n return pointer_a\",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n def forward(n, l):\\n while n:\\n l = l.next\\n n -= 1\\n return l\\n \\n \\n def get_len(l):\\n n = 1\\n while l:\\n l = l.next\\n n += 1\\n return n\\n \\n a_len = get_len(headA)\\n b_len = get_len(headB)\\n \\n if a_len > b_len:\\n headA = forward(a_len - b_len, headA)\\n else:\\n headB = forward(b_len - a_len, headB)\\n \\n while headA and headB:\\n if headA == headB:\\n return headA\\n headA = headA.next\\n headB = headB.next\\n \",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n pA=headA\\n pB=headB\\n while pA!=pB:\\n pA=pA.next if pA else headB\\n pB=pB.next if pB else headA\\n return pA\\n \",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n len1 = len2 = 0\\n temp1, temp2 = headA, headB\\n while temp1 and temp2:\\n len1 += 1\\n len2 += 1\\n temp1 = temp1.next\\n temp2 = temp2.next\\n while temp1:\\n len1 += 1\\n temp1 = temp1.next\\n while temp2:\\n len2 += 1\\n temp2 = temp2.next\\n \\n diff = len1 - len2 if len1 > len2 else len2 - len1\\n if len1 >= len2:\\n temp1 = headA\\n temp2 = headB\\n else:\\n temp1 = headB\\n temp2 = headA\\n while diff > 0:\\n temp1 = temp1.next\\n diff -= 1\\n \\n while temp1 and temp2:\\n if temp1 == temp2:\\n return temp1\\n temp1 = temp1.next\\n temp2 = temp2.next\\n return None\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n l1, l2 = headA, headB\\n while l1 != l2:\\n l1 = l1.next if l1 else headB\\n l2 = l2.next if l2 else headA\\n return l1\",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if not headA: return None\\n node_dict = {}\\n nodeA = headA\\n node_dict[id(nodeA)] = nodeA\\n while nodeA.next:\\n nodeA = nodeA.next\\n node_dict[id(nodeA)] = nodeA\\n nodeB = headB\\n while nodeB:\\n if id(nodeB) in node_dict:\\n return nodeB\\n nodeB = nodeB.next\\n return None\\n \",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n hashMap = {}\\n tempA = headA\\n\\n while tempA is not None:\\n hashMap[tempA] = tempA.val\\n tempA = tempA.next\\n tempB = headB\\n while tempB is not None:\\n if tempB in hashMap:\\n return tempB\\n tempB = tempB.next\\n \\n return None\",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n\\n def findLength(head):\\n length = 0\\n trav = head\\n while trav is not None:\\n trav = trav.next\\n length+=1\\n\\n return length\\n\\n lengthA = findLength(headA)\\n lengthB = findLength(headB)\\n diff = abs(lengthA - lengthB)\\n\\n travA = headA\\n travB = headB\\n\\n if lengthA > lengthB:\\n for i in range(diff):\\n travA = travA.next\\n else:\\n for i in range(diff):\\n travB = travB.next\\n\\n while travA is not None and travB is not None:\\n if travA == travB:\\n return travA\\n\\n travA = travA.next\\n travB = travB.next\\n\\n return None\\n\\n \",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def size(self,head):\\n count = 0\\n if head is None:\\n return count\\n curr = head\\n while curr:\\n count += 1\\n curr = curr.next\\n return count\\n \\n def find_intersect(self,headA,headB):\\n while headA and headB:\\n if headA == headB:\\n return headA\\n headA = headA.next\\n headB = headB.next\\n return None\\n\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n sizeA = self.size(headA)\\n sizeB = self.size(headB)\\n if sizeA > sizeB:\\n dif = sizeA - sizeB\\n for i in range(dif):\\n headA = headA.next\\n currA = headA\\n currB = headB\\n return self.find_intersect(currA,currB)\\n else:\\n dif = sizeB - sizeA\\n for i in range(dif):\\n headB = headB.next\\n currA = headA\\n currB = headB\\n return self.find_intersect(currA,currB)\\n \",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n st = set()\\n while headA:\\n st.add(headA)\\n headA = headA.next\\n while headB:\\n if headB in st:\\n return headB\\n headB = headB.next\\n return None\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def get_length(self, head):\\n temp = head\\n length = 0\\n while(temp):\\n length += 1\\n temp = temp.next\\n return length\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n length_a = self.get_length(headA)\\n length_b = self.get_length(headB)\\n print(length_a, length_b)\\n to_skip = length_b - length_a\\n print(to_skip)\\n new_headB = headB\\n for i in range(to_skip):\\n new_headB = new_headB.next\\n to_skip = length_a - length_b\\n new_headA = headA\\n for i in range(to_skip):\\n new_headA = new_headA.next\\n \\n while (new_headB):\\n if new_headB == new_headA:\\n return new_headB\\n new_headB = new_headB.next\\n new_headA = new_headA.next\\n return None\\n \",\n \"runtime\": \"89\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(\\n self, headA: ListNode, headB: ListNode\\n ) -> Optional[ListNode]:\\n l1, l2 = headA, headB\\n while l1 != l2:\\n l1 = l1.next if l1 else headB\\n l2 = l2.next if l2 else headA\\n return l1\",\n \"runtime\": \"89\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n intersection = False\\n a_nodes = set()\\n \\n while headA: \\n a_nodes.add(headA)\\n headA = headA.next\\n \\n while headB: \\n if headB in a_nodes: \\n return headB\\n headB = headB.next\\n return None\",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n intersection = False\\n a_nodes = set()\\n \\n while headA: \\n a_nodes.add(headA)\\n headA = headA.next\\n \\n while headB: \\n if headB in a_nodes: \\n return headB\\n headB = headB.next\\n return None\",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n l1,l2=headA,headB\\n while l1!=l2:\\n l1=l1.next if l1 else headB\\n l2=l2.next if l2 else headA\\n return l1\",\n \"runtime\": \"91\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, x):\\n self.val = x\\n self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, h1: ListNode, h2: ListNode) -> Optional[ListNode]:\\n c1, c2 = 0,0\\n temp1 = h1\\n while temp1 != None:\\n c1+=1\\n temp1 = temp1.next\\n temp2 = h2\\n while temp2 != None:\\n c2 += 1 \\n temp2 = temp2.next\\n\\n t1, t2 = h1, h2\\n if c1 > c2:\\n for i in range(c1-c2):\\n t1 = t1.next\\n else:\\n for i in range(c2 - c1):\\n t2 = t2.next\\n while t1 !=None and t2!= None:\\n if t1 == t2:\\n return t1\\n t1 = t1.next\\n t2 = t2.next\\n\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n first_set=set()\\n curr=headA\\n \\n while curr:\\n first_set.add(curr)\\n curr=curr.next\\n \\n curr = headB\\n while curr:\\n if curr in first_set:\\n return curr\\n curr=curr.next\\n\\n return None\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n hA = headA\\n hB = headB\\n \\n while hA!=hB:\\n hA = headB if not hA else hA.next\\n hB = headA if not hB else hB.next\\n \\n return hA\",\n \"runtime\": \"94\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":62,"string":"62"},"mm_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\n# class Solution:\n# def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n# tempA = headA\n# tempB = headB\n# while tempA != tempB:\n# tempA = tempA.next if tempA else headB\n# tempB = tempB.next if tempB else headA\n# return tempA\n\ndef solve():\n f=open('user.out','w')\n iterator=map(loads,stdin)\n while True:\n try:\n i=next(iterator)\n lA=next(iterator)\n lB=next(iterator)\n sA=next(iterator)\n sB=next(iterator)\n except StopIteration:\n break\n stmt = f\"Intersected at '{i}'\" if i != 0 else \"No intersection\"\n print(stmt, file=f)\n# solution=Solution()\nsolve()\nexit()","memory":"17900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n a = []\n while headA:\n a.append(headA)\n headA = headA.next\n b = []\n while headB:\n b.append(headB)\n headB = headB.next\n ans = last = None\n for i in a[::-1]:\n if i in b:\n ans = i\n \n return ans if ans else None","memory":"25500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n ls=[]\n temp=headA\n while temp:\n ls.append(temp)\n temp=temp.next\n while headB:\n if headB in ls:\n return headB\n headB=headB.next\n else:\n return None","memory":"26000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n p1 = headA\n p2 = headB\n\n while p1 != p2:\n p1 = p1.next if p1 is not None else headB\n p2 = p2.next if p2 is not None else headA\n return p1","memory":"26400"},{"code":"class Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if not headA or not headB:\n return None\n\n pointerA = headA\n pointerB = headB\n\n while pointerA is not pointerB:\n pointerA = pointerA.next if pointerA else headB\n pointerB = pointerB.next if pointerB else headA\n\n return pointerA\n","memory":"26500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n a, b = headA, headB\n ca, cb = 0, 0\n while(a != b):\n a = a.next if a else headB\n b = b.next if b else headA\n \n return a\n ","memory":"26600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n stackA = ['A']\n stackB = ['B']\n\n while headA or headB:\n if headA:\n stackA.append(headA)\n headA = headA.next\n\n if headB:\n stackB.append(headB)\n headB = headB.next\n\n prev = None\n while stackA and stackB:\n nodeA = stackA.pop(-1)\n nodeB = stackB.pop(-1)\n\n if nodeA != nodeB:\n return prev\n\n prev = nodeA ","memory":"26700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n pointer1, pointer2, loopCount = headA, headB, 0\n\n while pointer1 != pointer2:\n pointer1 = pointer1.next\n pointer2 = pointer2.next\n\n if pointer1 == None:\n pointer1 = headB\n loopCount += 1\n \n if pointer2 == None:\n pointer2 = headA\n loopCount += 1\n \n if loopCount > 2:\n return None\n \n return pointer1","memory":"26800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n l1 = headA\n l2 = headB\n c1 = self.count(l1)\n c2 = self.count(l2)\n diff = abs(c1-c2)\n\n if c1 > c2:\n while diff > 0:\n l1 = l1.next\n diff -= 1\n else:\n while diff > 0:\n l2 = l2.next\n diff -= 1\n \n while(l1!=l2):\n if(l1==l2):\n return l1\n l1=l1.next\n l2=l2.next\n\n return l1\n \n def count(self, head: ListNode):\n cnt = 0\n temp = head\n while(temp != None):\n cnt=cnt+1\n temp=temp.next\n return cnt\n","memory":"26900"},{"code":"class Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n stackA = ['A']\n stackB = ['B']\n\n while headA or headB:\n if headA:\n stackA.append(headA)\n headA = headA.next\n\n if headB:\n stackB.append(headB)\n headB = headB.next\n\n prev = None\n while stackA and stackB:\n nodeA = stackA.pop(-1)\n nodeB = stackB.pop(-1)\n\n if nodeA != nodeB:\n return prev\n\n prev = nodeA","memory":"26900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n pA=headA\n pB=headB\n while pA!=pB:\n pA=pA.next if pA else headB\n pB=pB.next if pB else headA\n return pA\n ","memory":"27000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, h1: ListNode, h2: ListNode) -> Optional[ListNode]:\n c1, c2 = 0,0\n temp1 = h1\n while temp1 != None:\n c1+=1\n temp1 = temp1.next\n temp2 = h2\n while temp2 != None:\n c2 += 1 \n temp2 = temp2.next\n\n t1, t2 = h1, h2\n if c1 > c2:\n for i in range(c1-c2):\n t1 = t1.next\n else:\n for i in range(c2 - c1):\n t2 = t2.next\n while t1 !=None and t2!= None:\n if t1 == t2:\n return t1\n t1 = t1.next\n t2 = t2.next\n","memory":"27000"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n iterA = headA\n iterB = headB\n while iterA != iterB:\n iterA = iterA.next if iterA else headB\n iterB = iterB.next if iterB else headA\n return iterA","memory":"27100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n l1 = headA\n l2 = headB\n while l1!= l2:\n # Move to the next node in each list, or to the head of the other list\n l1= l1.next if l1 else headB\n l2 = l2.next if l2 else headA\n #l3 = l1.val\n return l1\n ","memory":"27100"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n l_a, l_b = 1, 1\n ha = headA\n hb = headB\n listA = []\n listB = []\n skipA = 0\n skipB = 0\n\n while ha.next:\n l_a += 1\n ha = ha.next\n\n while hb.next:\n l_b += 1\n hb = hb.next\n\n ha = headA\n hb = headB\n\n if l_a < l_b:\n skipB += (l_b - l_a)\n for _ in range(l_b - l_a):\n hb = hb.next\n elif l_a > l_b:\n skipA += (l_a - l_b)\n for _ in range(l_a - l_b):\n ha = ha.next\n\n intersectVal = None\n for _ in range(min(l_a, l_b)):\n if ha == hb and intersectVal is None:\n intersectVal = ha\n elif ha != hb:\n intersectVal = None\n\n ha = ha.next\n hb = hb.next\n skipA += 1\n skipB += 1\n\n return intersectVal\n\n \n\n\n \n ","memory":"27200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def size(self,head):\n count = 0\n if head is None:\n return count\n curr = head\n while curr:\n count += 1\n curr = curr.next\n return count\n \n def find_intersect(self,headA,headB):\n while headA and headB:\n if headA == headB:\n return headA\n headA = headA.next\n headB = headB.next\n return None\n\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n sizeA = self.size(headA)\n sizeB = self.size(headB)\n if sizeA > sizeB:\n dif = sizeA - sizeB\n for i in range(dif):\n headA = headA.next\n currA = headA\n currB = headB\n return self.find_intersect(currA,currB)\n else:\n dif = sizeB - sizeA\n for i in range(dif):\n headB = headB.next\n currA = headA\n currB = headB\n return self.find_intersect(currA,currB)\n ","memory":"27200"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n hashMap = {}\n tempA = headA\n\n while tempA is not None:\n hashMap[tempA] = tempA.val\n tempA = tempA.next\n tempB = headB\n while tempB is not None:\n if tempB in hashMap:\n return tempB\n tempB = tempB.next\n \n return None","memory":"27300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n nodeA = headA\n nodeB = headB\n\n while nodeA!= nodeB:\n nodeA = headB if nodeA is None else nodeA.next\n nodeB = headA if nodeB is None else nodeB.next\n\n return nodeA","memory":"27300"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n if headA is None or headB is None:\n return None\n hashtable = dict()\n currA = headA\n currB = headB\n while currA:\n hashtable[currA] = 1\n currA = currA.next\n while currB:\n if currB in hashtable:\n return currB\n currB = currB.next\n return None","memory":"27400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n addressToNodeA = {}\n iterA = headA\n while iterA:\n addressToNodeA[iterA] = iterA\n iterA = iterA.next\n\n iterB = headB\n while iterB and iterB not in addressToNodeA:\n iterB = iterB.next\n return iterB","memory":"27400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n intersection = False\n a_nodes = set()\n \n while headA: \n a_nodes.add(headA)\n headA = headA.next\n \n while headB: \n if headB in a_nodes: \n return headB\n headB = headB.next\n return None","memory":"27500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n nodes_in_b = set()\n\n while headB:\n nodes_in_b.add(headB)\n headB = headB.next\n\n while headA:\n if headA in nodes_in_b:\n return headA\n \n headA = headA.next\n\n return None","memory":"27500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n intersection = False\n a_nodes = set()\n \n while headA: \n a_nodes.add(headA)\n headA = headA.next\n \n while headB: \n if headB in a_nodes: \n return headB\n headB = headB.next\n return None","memory":"27600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n \n intersection = False\n a_nodes = set()\n \n while headA: \n a_nodes.add(headA)\n headA = headA.next\n \n while headB: \n if headB in a_nodes: \n return headB\n headB = headB.next\n return None","memory":"27600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n hashset = set()\n\n l1 = headA\n l2 = headB\n\n #comecamos a percorrer a lista A:\n\n while l1:\n hashset.add(l1)\n l1= l1.next\n\n while l2:\n\n if l2 in hashset:\n return l2\n else:\n pass\n\n l2 = l2.next \n \n return None\n ","memory":"27700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n hashset = set()\n\n l1 = headA\n l2 = headB\n\n #comecamos a percorrer a lista A:\n\n while l1:\n hashset.add(l1)\n l1= l1.next\n\n while l2:\n\n if l2 in hashset:\n return l2\n else:\n pass\n\n l2 = l2.next \n \n return None\n ","memory":"27700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n nodes_set = set()\n cur = headA\n while cur:\n nodes_set.add(cur)\n cur = cur.next\n cur = headB\n while cur:\n if cur in nodes_set:\n return cur\n cur = cur.next\n return None","memory":"27800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n\n currA=headA\n SetA=set()\n\n while currA:\n SetA.add(currA)\n currA=currA.next\n \n currB=headB\n\n while currB:\n if currB in SetA:\n return currB\n currB=currB.next\n \n return None\n\n\n ","memory":"27900"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n mapping = {}\n while headA is not None or headB is not None:\n if headA is not None:\n idHeadA = id(headA)\n if idHeadA in mapping:\n return headA\n else:\n mapping[idHeadA] = True\n headA = headA.next\n\n if headB is not None:\n idHeadB = id(headB)\n if idHeadB in mapping:\n return headB\n else:\n mapping[idHeadB] = True\n headB = headB.next\n return None","memory":"28000"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\n# class Solution:\\n# def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n# tempA = headA\\n# tempB = headB\\n# while tempA != tempB:\\n# tempA = tempA.next if tempA else headB\\n# tempB = tempB.next if tempB else headA\\n# return tempA\\n\\ndef solve():\\n f=open('user.out','w')\\n iterator=map(loads,stdin)\\n while True:\\n try:\\n i=next(iterator)\\n lA=next(iterator)\\n lB=next(iterator)\\n sA=next(iterator)\\n sB=next(iterator)\\n except StopIteration:\\n break\\n stmt = f\\\"Intersected at '{i}'\\\" if i != 0 else \\\"No intersection\\\"\\n print(stmt, file=f)\\n# solution=Solution()\\nsolve()\\nexit()\",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n a = []\\n while headA:\\n a.append(headA)\\n headA = headA.next\\n b = []\\n while headB:\\n b.append(headB)\\n headB = headB.next\\n ans = last = None\\n for i in a[::-1]:\\n if i in b:\\n ans = i\\n \\n return ans if ans else None\",\n \"memory\": \"25500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n ls=[]\\n temp=headA\\n while temp:\\n ls.append(temp)\\n temp=temp.next\\n while headB:\\n if headB in ls:\\n return headB\\n headB=headB.next\\n else:\\n return None\",\n \"memory\": \"26000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n p1 = headA\\n p2 = headB\\n\\n while p1 != p2:\\n p1 = p1.next if p1 is not None else headB\\n p2 = p2.next if p2 is not None else headA\\n return p1\",\n \"memory\": \"26400\"\n },\n {\n \"code\": \"class Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if not headA or not headB:\\n return None\\n\\n pointerA = headA\\n pointerB = headB\\n\\n while pointerA is not pointerB:\\n pointerA = pointerA.next if pointerA else headB\\n pointerB = pointerB.next if pointerB else headA\\n\\n return pointerA\\n\",\n \"memory\": \"26500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n a, b = headA, headB\\n ca, cb = 0, 0\\n while(a != b):\\n a = a.next if a else headB\\n b = b.next if b else headA\\n \\n return a\\n \",\n \"memory\": \"26600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n stackA = ['A']\\n stackB = ['B']\\n\\n while headA or headB:\\n if headA:\\n stackA.append(headA)\\n headA = headA.next\\n\\n if headB:\\n stackB.append(headB)\\n headB = headB.next\\n\\n prev = None\\n while stackA and stackB:\\n nodeA = stackA.pop(-1)\\n nodeB = stackB.pop(-1)\\n\\n if nodeA != nodeB:\\n return prev\\n\\n prev = nodeA \",\n \"memory\": \"26700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n pointer1, pointer2, loopCount = headA, headB, 0\\n\\n while pointer1 != pointer2:\\n pointer1 = pointer1.next\\n pointer2 = pointer2.next\\n\\n if pointer1 == None:\\n pointer1 = headB\\n loopCount += 1\\n \\n if pointer2 == None:\\n pointer2 = headA\\n loopCount += 1\\n \\n if loopCount > 2:\\n return None\\n \\n return pointer1\",\n \"memory\": \"26800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n l1 = headA\\n l2 = headB\\n c1 = self.count(l1)\\n c2 = self.count(l2)\\n diff = abs(c1-c2)\\n\\n if c1 > c2:\\n while diff > 0:\\n l1 = l1.next\\n diff -= 1\\n else:\\n while diff > 0:\\n l2 = l2.next\\n diff -= 1\\n \\n while(l1!=l2):\\n if(l1==l2):\\n return l1\\n l1=l1.next\\n l2=l2.next\\n\\n return l1\\n \\n def count(self, head: ListNode):\\n cnt = 0\\n temp = head\\n while(temp != None):\\n cnt=cnt+1\\n temp=temp.next\\n return cnt\\n\",\n \"memory\": \"26900\"\n },\n {\n \"code\": \"class Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n stackA = ['A']\\n stackB = ['B']\\n\\n while headA or headB:\\n if headA:\\n stackA.append(headA)\\n headA = headA.next\\n\\n if headB:\\n stackB.append(headB)\\n headB = headB.next\\n\\n prev = None\\n while stackA and stackB:\\n nodeA = stackA.pop(-1)\\n nodeB = stackB.pop(-1)\\n\\n if nodeA != nodeB:\\n return prev\\n\\n prev = nodeA\",\n \"memory\": \"26900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n pA=headA\\n pB=headB\\n while pA!=pB:\\n pA=pA.next if pA else headB\\n pB=pB.next if pB else headA\\n return pA\\n \",\n \"memory\": \"27000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, h1: ListNode, h2: ListNode) -> Optional[ListNode]:\\n c1, c2 = 0,0\\n temp1 = h1\\n while temp1 != None:\\n c1+=1\\n temp1 = temp1.next\\n temp2 = h2\\n while temp2 != None:\\n c2 += 1 \\n temp2 = temp2.next\\n\\n t1, t2 = h1, h2\\n if c1 > c2:\\n for i in range(c1-c2):\\n t1 = t1.next\\n else:\\n for i in range(c2 - c1):\\n t2 = t2.next\\n while t1 !=None and t2!= None:\\n if t1 == t2:\\n return t1\\n t1 = t1.next\\n t2 = t2.next\\n\",\n \"memory\": \"27000\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n iterA = headA\\n iterB = headB\\n while iterA != iterB:\\n iterA = iterA.next if iterA else headB\\n iterB = iterB.next if iterB else headA\\n return iterA\",\n \"memory\": \"27100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n l1 = headA\\n l2 = headB\\n while l1!= l2:\\n # Move to the next node in each list, or to the head of the other list\\n l1= l1.next if l1 else headB\\n l2 = l2.next if l2 else headA\\n #l3 = l1.val\\n return l1\\n \",\n \"memory\": \"27100\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n l_a, l_b = 1, 1\\n ha = headA\\n hb = headB\\n listA = []\\n listB = []\\n skipA = 0\\n skipB = 0\\n\\n while ha.next:\\n l_a += 1\\n ha = ha.next\\n\\n while hb.next:\\n l_b += 1\\n hb = hb.next\\n\\n ha = headA\\n hb = headB\\n\\n if l_a < l_b:\\n skipB += (l_b - l_a)\\n for _ in range(l_b - l_a):\\n hb = hb.next\\n elif l_a > l_b:\\n skipA += (l_a - l_b)\\n for _ in range(l_a - l_b):\\n ha = ha.next\\n\\n intersectVal = None\\n for _ in range(min(l_a, l_b)):\\n if ha == hb and intersectVal is None:\\n intersectVal = ha\\n elif ha != hb:\\n intersectVal = None\\n\\n ha = ha.next\\n hb = hb.next\\n skipA += 1\\n skipB += 1\\n\\n return intersectVal\\n\\n \\n\\n\\n \\n \",\n \"memory\": \"27200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def size(self,head):\\n count = 0\\n if head is None:\\n return count\\n curr = head\\n while curr:\\n count += 1\\n curr = curr.next\\n return count\\n \\n def find_intersect(self,headA,headB):\\n while headA and headB:\\n if headA == headB:\\n return headA\\n headA = headA.next\\n headB = headB.next\\n return None\\n\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n sizeA = self.size(headA)\\n sizeB = self.size(headB)\\n if sizeA > sizeB:\\n dif = sizeA - sizeB\\n for i in range(dif):\\n headA = headA.next\\n currA = headA\\n currB = headB\\n return self.find_intersect(currA,currB)\\n else:\\n dif = sizeB - sizeA\\n for i in range(dif):\\n headB = headB.next\\n currA = headA\\n currB = headB\\n return self.find_intersect(currA,currB)\\n \",\n \"memory\": \"27200\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n hashMap = {}\\n tempA = headA\\n\\n while tempA is not None:\\n hashMap[tempA] = tempA.val\\n tempA = tempA.next\\n tempB = headB\\n while tempB is not None:\\n if tempB in hashMap:\\n return tempB\\n tempB = tempB.next\\n \\n return None\",\n \"memory\": \"27300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n nodeA = headA\\n nodeB = headB\\n\\n while nodeA!= nodeB:\\n nodeA = headB if nodeA is None else nodeA.next\\n nodeB = headA if nodeB is None else nodeB.next\\n\\n return nodeA\",\n \"memory\": \"27300\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n if headA is None or headB is None:\\n return None\\n hashtable = dict()\\n currA = headA\\n currB = headB\\n while currA:\\n hashtable[currA] = 1\\n currA = currA.next\\n while currB:\\n if currB in hashtable:\\n return currB\\n currB = currB.next\\n return None\",\n \"memory\": \"27400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n addressToNodeA = {}\\n iterA = headA\\n while iterA:\\n addressToNodeA[iterA] = iterA\\n iterA = iterA.next\\n\\n iterB = headB\\n while iterB and iterB not in addressToNodeA:\\n iterB = iterB.next\\n return iterB\",\n \"memory\": \"27400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n intersection = False\\n a_nodes = set()\\n \\n while headA: \\n a_nodes.add(headA)\\n headA = headA.next\\n \\n while headB: \\n if headB in a_nodes: \\n return headB\\n headB = headB.next\\n return None\",\n \"memory\": \"27500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n nodes_in_b = set()\\n\\n while headB:\\n nodes_in_b.add(headB)\\n headB = headB.next\\n\\n while headA:\\n if headA in nodes_in_b:\\n return headA\\n \\n headA = headA.next\\n\\n return None\",\n \"memory\": \"27500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n intersection = False\\n a_nodes = set()\\n \\n while headA: \\n a_nodes.add(headA)\\n headA = headA.next\\n \\n while headB: \\n if headB in a_nodes: \\n return headB\\n headB = headB.next\\n return None\",\n \"memory\": \"27600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n \\n intersection = False\\n a_nodes = set()\\n \\n while headA: \\n a_nodes.add(headA)\\n headA = headA.next\\n \\n while headB: \\n if headB in a_nodes: \\n return headB\\n headB = headB.next\\n return None\",\n \"memory\": \"27600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n hashset = set()\\n\\n l1 = headA\\n l2 = headB\\n\\n #comecamos a percorrer a lista A:\\n\\n while l1:\\n hashset.add(l1)\\n l1= l1.next\\n\\n while l2:\\n\\n if l2 in hashset:\\n return l2\\n else:\\n pass\\n\\n l2 = l2.next \\n \\n return None\\n \",\n \"memory\": \"27700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n hashset = set()\\n\\n l1 = headA\\n l2 = headB\\n\\n #comecamos a percorrer a lista A:\\n\\n while l1:\\n hashset.add(l1)\\n l1= l1.next\\n\\n while l2:\\n\\n if l2 in hashset:\\n return l2\\n else:\\n pass\\n\\n l2 = l2.next \\n \\n return None\\n \",\n \"memory\": \"27700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n nodes_set = set()\\n cur = headA\\n while cur:\\n nodes_set.add(cur)\\n cur = cur.next\\n cur = headB\\n while cur:\\n if cur in nodes_set:\\n return cur\\n cur = cur.next\\n return None\",\n \"memory\": \"27800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n\\n currA=headA\\n SetA=set()\\n\\n while currA:\\n SetA.add(currA)\\n currA=currA.next\\n \\n currB=headB\\n\\n while currB:\\n if currB in SetA:\\n return currB\\n currB=currB.next\\n \\n return None\\n\\n\\n \",\n \"memory\": \"27900\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\\n mapping = {}\\n while headA is not None or headB is not None:\\n if headA is not None:\\n idHeadA = id(headA)\\n if idHeadA in mapping:\\n return headA\\n else:\\n mapping[idHeadA] = True\\n headA = headA.next\\n\\n if headB is not None:\\n idHeadB = id(headB)\\n if idHeadB in mapping:\\n return headB\\n else:\\n mapping[idHeadB] = True\\n headB = headB.next\\n return None\",\n \"memory\": \"28000\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":29,"string":"29"}}},{"rowIdx":61,"cells":{"question_id":{"kind":"number","value":237,"string":"237"},"name":{"kind":"string","value":"delete-node-in-a-linked-list"},"content":{"kind":"string","value":"<p>There is a singly-linked list <code>head</code> and we want to delete a node <code>node</code> in it.</p>\n\n<p>You are given the node to be deleted <code>node</code>. You will <strong>not be given access</strong> to the first node of <code>head</code>.</p>\n\n<p>All the values of the linked list are <strong>unique</strong>, and it is guaranteed that the given node <code>node</code> is not the last node in the linked list.</p>\n\n<p>Delete the given node. Note that by deleting the node, we do not mean removing it from memory. We mean:</p>\n\n<ul>\n\t<li>The value of the given node should not exist in the linked list.</li>\n\t<li>The number of nodes in the linked list should decrease by one.</li>\n\t<li>All the values before <code>node</code> should be in the same order.</li>\n\t<li>All the values after <code>node</code> should be in the same order.</li>\n</ul>\n\n<p><strong>Custom testing:</strong></p>\n\n<ul>\n\t<li>For the input, you should provide the entire linked list <code>head</code> and the node to be given <code>node</code>. <code>node</code> should not be the last node of the list and should be an actual node in the list.</li>\n\t<li>We will build the linked list and pass the node to your function.</li>\n\t<li>The output will be the entire list after calling your function.</li>\n</ul>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2020/09/01/node1.jpg\" style=\"width: 400px; height: 286px;\" />\n<pre>\n<strong>Input:</strong> head = [4,5,1,9], node = 5\n<strong>Output:</strong> [4,1,9]\n<strong>Explanation: </strong>You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2020/09/01/node2.jpg\" style=\"width: 400px; height: 315px;\" />\n<pre>\n<strong>Input:</strong> head = [4,5,1,9], node = 1\n<strong>Output:</strong> [4,5,9]\n<strong>Explanation: </strong>You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of the nodes in the given list is in the range <code>[2, 1000]</code>.</li>\n\t<li><code>-1000 <= Node.val <= 1000</code></li>\n\t<li>The value of each node in the list is <strong>unique</strong>.</li>\n\t<li>The <code>node</code> to be deleted is <strong>in the list</strong> and is <strong>not a tail</strong> node.</li>\n</ul>\n"},"acRate":{"kind":"number","value":80.7677376691039,"string":"80.767738"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["linked-list"],"string":"[\n \"linked-list\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16\", 0.0136], [\"18\", 0.0136], [\"19\", 0.0136], [\"20\", 0.0408], [\"21\", 0.1089], [\"22\", 0.1769], [\"23\", 0.1905], [\"24\", 0.2858], [\"25\", 0.1225], [\"26\", 0.7756], [\"27\", 0.6668], [\"28\", 1.2655], [\"29\", 1.4288], [\"30\", 2.531], [\"31\", 1.905], [\"32\", 3.7828], [\"33\", 4.3679], [\"34\", 5.0075], [\"35\", 3.7964], [\"36\", 6.6676], [\"37\", 7.8378], [\"38\", 7.9194], [\"39\", 5.892], [\"40\", 6.9533], [\"41\", 8.7767], [\"42\", 6.9941], [\"43\", 5.5518], [\"44\", 4.2047], [\"45\", 4.2727], [\"46\", 2.9528]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16400\", 0.0136], [\"16500\", 0.0953], [\"16600\", 3.1297], [\"16700\", 31.011], [\"16800\", 52.0343]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node:ListNode) -> None:\n node.val = node.next.val\n node.next = node.next.next\n\n\n \n ","runtime":"16"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n \n node.val = node.next.val\n node.next = node.next.next\n","runtime":"18"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n first = node\n second = node.next\n\n temp = first.val\n first.val = second.val\n second.val = temp\n\n first.next = first.next.next\n ","runtime":"19"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val=node.next.val\n node.next=node.next.next\n \n ","runtime":"20"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n node.val=node.next.val\n node.next=node.next.next\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n ","runtime":"21"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n ","runtime":"22"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n \n if node.next == None:\n node = None\n return\n node.val = node.next.val\n node.next = node.next.next","runtime":"23"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","runtime":"24"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n\n node.next = node.next.next\n\n\n # -> node -> next -> something\n\n # you can remove next but overwrite the current node val with next val","runtime":"25"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n node.val = node.next.val\n node.next = node.next.next\n \n ","runtime":"26"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","runtime":"27"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n # Make current node point to next of next node.\n node.next = node.next.next\n ","runtime":"27"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","runtime":"28"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","runtime":"28"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n while node.next.next is not None:\n node.val = node.next.val\n node = node.next\n node.val = node.next.val\n node.next = None","runtime":"29"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n \n ","runtime":"29"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n ","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","runtime":"30"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n node.val=node.next.val\n node.next=node.next.next\n ","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\" \n curr=node\n while curr.next:\n curr.val=curr.next.val\n if curr.next.next==None:\n curr.next=None\n else:\n curr=curr.next\n\n \n\n","runtime":"31"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\" \n while node.next.next:\n node.val = node.next.val \n node = node.next \n node.val = node.next.val\n node.next = None \n ","runtime":"32"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n\n ","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n ptr=node\n ptr1=ptr.next\n while ptr1 is not None:\n if ptr1.next is None:\n ptr.val=ptr1.val\n ptr.next=None\n ptr1=ptr1.next\n else:\n ptr.val=ptr1.val\n ptr=ptr.next\n ptr1=ptr1.next\n","runtime":"33"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n temp = node.next\n prev = None\n while temp:\n node.val, temp.val = temp.val, node.val\n temp = temp.next\n prev = node\n node = node.next\n prev.next = None\n ","runtime":"34"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n while node.next.next!=None:\n node.val=node.next.val\n node=node.next\n node.val=node.next.val\n node.next=None","runtime":"35"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","runtime":"36"},{"code":"class ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n\nclass Solution:\n def deleteNode(self, node: ListNode) -> None:\n # Copy the value of the next node to the current node\n node.val = node.next.val\n # Bypass the next node by linking the current node to the next of the next node\n node.next = node.next.next\n","runtime":"36"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n\n node.val = node.next.val \n node.next = node.next.next \n\n ","runtime":"37"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val=node.next.val\n node.next=node.next.next\n\n \n ","runtime":"37"},{"code":"# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, x):\n self.val = x\n self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val=node.next.val\n temp = node.next\n node.next=node.next.next\n temp.next = None\n \n\n ","runtime":"38"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n \n node.val = node.next.val\n node.next = node.next.next","runtime":"38"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n \n node.val = node.next.val\n node.next = node.next.next","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n \n node.val = node.next.val\n node.next = node.next.next","runtime":"39"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n\n ","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","runtime":"40"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n # Overwrite data of next node on current node.\n node.val = node.next.val\n # Make current node point to next of next node.\n node.next = node.next.next","runtime":"41"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n \n ","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n next = node.next\n node.val = next.val\n node.next = next.next\n ","runtime":"42"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next=node.next.next\n ","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n while node.next.next:\n node.val = node.next.val\n node = node.next\n node.val = node.next.val\n node.next = None\n \n \n ","runtime":"43"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n ","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","runtime":"44"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n ","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n\n","runtime":"45"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","runtime":"46"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n ","runtime":"46"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node:ListNode) -> None:\\n node.val = node.next.val\\n node.next = node.next.next\\n\\n\\n \\n \",\n \"runtime\": \"16\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n \\n node.val = node.next.val\\n node.next = node.next.next\\n\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n first = node\\n second = node.next\\n\\n temp = first.val\\n first.val = second.val\\n second.val = temp\\n\\n first.next = first.next.next\\n \",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val=node.next.val\\n node.next=node.next.next\\n \\n \",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n node.val=node.next.val\\n node.next=node.next.next\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n \",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n \\n if node.next == None:\\n node = None\\n return\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n\\n node.next = node.next.next\\n\\n\\n # -> node -> next -> something\\n\\n # you can remove next but overwrite the current node val with next val\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n node.val = node.next.val\\n node.next = node.next.next\\n \\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n # Make current node point to next of next node.\\n node.next = node.next.next\\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n while node.next.next is not None:\\n node.val = node.next.val\\n node = node.next\\n node.val = node.next.val\\n node.next = None\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n \\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n node.val=node.next.val\\n node.next=node.next.next\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\" \\n curr=node\\n while curr.next:\\n curr.val=curr.next.val\\n if curr.next.next==None:\\n curr.next=None\\n else:\\n curr=curr.next\\n\\n \\n\\n\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\" \\n while node.next.next:\\n node.val = node.next.val \\n node = node.next \\n node.val = node.next.val\\n node.next = None \\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n\\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n ptr=node\\n ptr1=ptr.next\\n while ptr1 is not None:\\n if ptr1.next is None:\\n ptr.val=ptr1.val\\n ptr.next=None\\n ptr1=ptr1.next\\n else:\\n ptr.val=ptr1.val\\n ptr=ptr.next\\n ptr1=ptr1.next\\n\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n temp = node.next\\n prev = None\\n while temp:\\n node.val, temp.val = temp.val, node.val\\n temp = temp.next\\n prev = node\\n node = node.next\\n prev.next = None\\n \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n while node.next.next!=None:\\n node.val=node.next.val\\n node=node.next\\n node.val=node.next.val\\n node.next=None\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class ListNode:\\n def __init__(self, val=0, next=None):\\n self.val = val\\n self.next = next\\n\\nclass Solution:\\n def deleteNode(self, node: ListNode) -> None:\\n # Copy the value of the next node to the current node\\n node.val = node.next.val\\n # Bypass the next node by linking the current node to the next of the next node\\n node.next = node.next.next\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n\\n node.val = node.next.val \\n node.next = node.next.next \\n\\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val=node.next.val\\n node.next=node.next.next\\n\\n \\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\nclass ListNode:\\n def __init__(self, x):\\n self.val = x\\n self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val=node.next.val\\n temp = node.next\\n node.next=node.next.next\\n temp.next = None\\n \\n\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n \\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n \\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n \\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n\\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n # Overwrite data of next node on current node.\\n node.val = node.next.val\\n # Make current node point to next of next node.\\n node.next = node.next.next\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n \\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n next = node.next\\n node.val = next.val\\n node.next = next.next\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next=node.next.next\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n while node.next.next:\\n node.val = node.next.val\\n node = node.next\\n node.val = node.next.val\\n node.next = None\\n \\n \\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n\\n\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n \",\n \"runtime\": \"46\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":48,"string":"48"},"mm_list":{"kind":"list like","value":[{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n ","memory":"16400"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next","memory":"16500"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n prev = node\n while node.next:\n prev = node\n node.val = node.next.val\n node = node.next\n prev.next = None\n\n ","memory":"16600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n prev = None\n while node and node.next:\n node.val = node.next.val\n prev = node\n node = node.next\n \n prev.next = None\n\n return ","memory":"16600"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n node.val = node.next.val\n node.next = node.next.next\n ","memory":"16700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n ","memory":"16700"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n node.val = node.next.val\n node.next = node.next.next\n ","memory":"16800"},{"code":"# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, x):\n# self.val = x\n# self.next = None\n\nclass Solution:\n def deleteNode(self, node):\n \"\"\"\n :type node: ListNode\n :rtype: void Do not return anything, modify node in-place instead.\n \"\"\"\n # Overwrite data of next node on current node.\n node.val = node.next.val\n # Make current node point to next of next node.\n node.next = node.next.next","memory":"16800"}],"string":"[\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n prev = node\\n while node.next:\\n prev = node\\n node.val = node.next.val\\n node = node.next\\n prev.next = None\\n\\n \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n prev = None\\n while node and node.next:\\n node.val = node.next.val\\n prev = node\\n node = node.next\\n \\n prev.next = None\\n\\n return \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n node.val = node.next.val\\n node.next = node.next.next\\n \",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n \",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n node.val = node.next.val\\n node.next = node.next.next\\n \",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"# Definition for singly-linked list.\\n# class ListNode:\\n# def __init__(self, x):\\n# self.val = x\\n# self.next = None\\n\\nclass Solution:\\n def deleteNode(self, node):\\n \\\"\\\"\\\"\\n :type node: ListNode\\n :rtype: void Do not return anything, modify node in-place instead.\\n \\\"\\\"\\\"\\n # Overwrite data of next node on current node.\\n node.val = node.next.val\\n # Make current node point to next of next node.\\n node.next = node.next.next\",\n \"memory\": \"16800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":8,"string":"8"}}},{"rowIdx":62,"cells":{"question_id":{"kind":"number","value":238,"string":"238"},"name":{"kind":"string","value":"product-of-array-except-self"},"content":{"kind":"string","value":"<p>Given an integer array <code>nums</code>, return <em>an array</em> <code>answer</code> <em>such that</em> <code>answer[i]</code> <em>is equal to the product of all the elements of</em> <code>nums</code> <em>except</em> <code>nums[i]</code>.</p>\n\n<p>The product of any prefix or suffix of <code>nums</code> is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</p>\n\n<p>You must write an algorithm that runs in <code>O(n)</code> time and without using the division operation.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<pre><strong>Input:</strong> nums = [1,2,3,4]\n<strong>Output:</strong> [24,12,8,6]\n</pre><p><strong class=\"example\">Example 2:</strong></p>\n<pre><strong>Input:</strong> nums = [-1,1,0,-3,3]\n<strong>Output:</strong> [0,0,9,0,0]\n</pre>\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>2 <= nums.length <= 10<sup>5</sup></code></li>\n\t<li><code>-30 <= nums[i] <= 30</code></li>\n\t<li>The product of any prefix or suffix of <code>nums</code> is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</li>\n</ul>\n\n<p> </p>\n<p><strong>Follow up:</strong> Can you solve the problem in <code>O(1)</code> extra space complexity? (The output array <strong>does not</strong> count as extra space for space complexity analysis.)</p>\n"},"acRate":{"kind":"number","value":66.71051789661894,"string":"66.710518"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","prefix-sum"],"string":"[\n \"array\",\n \"prefix-sum\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"63\", 0.0050999999999999995], [\"66\", 0.0069], [\"69\", 0.0069], [\"73\", 0.0139], [\"76\", 0.0087], [\"79\", 0.031400000000000004], [\"82\", 0.019200000000000002], [\"85\", 0.0226], [\"88\", 0.0157], [\"92\", 0.0034], [\"95\", 0.0052], [\"98\", 0.0034], [\"101\", 0.0035], [\"104\", 0.0017], [\"108\", 0.0035], [\"111\", 0.0017], [\"114\", 0.0017], [\"117\", 0.0017], [\"120\", 0.0017], [\"123\", 0.0017], [\"127\", 0.0017], [\"130\", 0.0035], [\"133\", 0.007], [\"136\", 0.0052], [\"139\", 0.007], [\"142\", 0.0087], [\"146\", 0.0087], [\"149\", 0.0192], [\"152\", 0.0157], [\"155\", 0.0332], [\"158\", 0.0472], [\"162\", 0.0577], [\"165\", 0.0857], [\"168\", 0.0979], [\"171\", 0.1416], [\"174\", 0.1643], [\"177\", 0.2168], [\"181\", 0.3199], [\"184\", 0.3112], [\"187\", 0.4423], [\"190\", 0.5559], [\"193\", 0.659], [\"196\", 0.8006], [\"200\", 0.902], [\"203\", 1.117], [\"206\", 1.2132], [\"209\", 1.5016], [\"212\", 1.6222], [\"215\", 1.8932], [\"219\", 2.0225], [\"222\", 2.2515], [\"225\", 2.4193], [\"228\", 2.7515], [\"231\", 2.8528], [\"235\", 2.9682], [\"238\", 3.1658], [\"241\", 3.2322], [\"244\", 3.2846], [\"247\", 3.2951], [\"250\", 3.2252], [\"254\", 3.3091], [\"257\", 3.1937], [\"260\", 3.1815], [\"263\", 3.1255], [\"266\", 2.8808], [\"269\", 2.6955], [\"273\", 2.685], [\"276\", 7.170599999999999], [\"279\", 7.368], [\"282\", 4.029299999999999], [\"285\", 3.0346], [\"289\", 2.2637], [\"292\", 1.7428], [\"295\", 1.3023], [\"298\", 1.1923], [\"301\", 0.5803], [\"304\", 0.4738], [\"308\", 0.3198], [\"311\", 0.3041], [\"314\", 0.222]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"19800\", 0.0052], [\"20100\", 0.0017], [\"22600\", 0.0017], [\"22700\", 0.0017], [\"23300\", 0.0017], [\"23700\", 0.0017], [\"23800\", 0.0017], [\"23900\", 0.0035], [\"24100\", 0.0052], [\"24200\", 0.0017], [\"24300\", 0.007], [\"24400\", 0.007], [\"24500\", 0.0087], [\"24600\", 0.0594], [\"24700\", 0.0577], [\"24800\", 0.0647], [\"24900\", 0.2902], [\"25000\", 1.1852], [\"25100\", 1.2097], [\"25200\", 0.3094], [\"25300\", 0.2133], [\"25400\", 0.1398], [\"25500\", 0.8129], [\"25600\", 9.8783], [\"25700\", 38.1184], [\"25800\", 9.492], [\"25900\", 0.8618], [\"26000\", 0.5034], [\"26100\", 1.547], [\"26200\", 13.9076], [\"26300\", 11.8711], [\"26400\", 1.1485], [\"26500\", 0.465], [\"26600\", 1.0471], [\"26700\", 0.5856], [\"26800\", 0.8251]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)\n\n\n \n\n \n\n\n\n\n \n\n\n \n\n \n\n \n \n\n\n \n\n \n\n\n\n \n\n \n\n\n\n\n\n\n\n \n ","runtime":"63"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res, front, back, fprod, bprod = [], [], [], 1, 1\n for i in range(len(nums)):\n front.append(fprod)\n fprod *= nums[i]\n\n for j in range(len(nums) - 1, -1, -1):\n back.append(bprod)\n bprod *= nums[j]\n\n back.reverse()\n\n for k in range(len(nums)):\n res.append(front[k] * back[k])\n\n return res\n \nwith open(\"user.out\", \"w\") as f:\n s = Solution()\n for nums in map(loads, stdin):\n f.write(f\"[{','.join([str(i) for i in s.productExceptSelf(nums)])}]\\n\")\nexit(0)","runtime":"63"},{"code":"def product_of(nums):\n result = 1\n for i in nums:\n result *= i\n return result\n\ndef canCompleteCircuit(nums: List[int]) -> List[int]:\n \n try:\n i_1 = nums.index(0)\n try:\n size = len(nums)\n tmp = [0] * size\n i_2 = nums.index(0, i+1)\n return tmp\n except:\n size = len(nums)\n tmp = [0] * size\n tmp[i_1] = product_of(nums[:i_1]+nums[i_1+1:])\n return tmp\n except:\n product = product_of(nums)\n return [int(product/i) for i in nums]\n\nwith open(\"user.out\", \"w\") as Solution:\n for nums in map(loads, stdin):\n Solution.write(f\"{canCompleteCircuit(nums)}\\n\".replace(\" \",\"\"))\n\nexit()","runtime":"66"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n count_zeros = 0\n prod = 1\n for n in nums:\n if n:\n prod *= n\n else:\n count_zeros += 1\n\n return [\n prod if n == 0 and count_zeros == 1 else 0 if count_zeros else prod // n\n for n in nums\n ]\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n\n exit(0)","runtime":"66"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n count_zeros = 0\n prod = 1\n for n in nums:\n if n:\n prod *= n\n if n == 0:\n count_zeros += 1\n\n ans = []\n for n in nums:\n if count_zeros:\n if n == 0 and count_zeros == 1:\n ans.append(prod)\n else:\n ans.append(0)\n else:\n ans.append(prod // n)\n return ans\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)\n","runtime":"69"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n count_zeros = 0\n prod = 1\n for n in nums:\n if n:\n prod *= n\n else:\n count_zeros += 1\n\n return [\n prod if n == 0 and count_zeros == 1 else 0 if count_zeros else prod // n\n for n in nums\n ]\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n\n exit(0)","runtime":"69"},{"code":"def productExceptSelf(nums: List[int]) -> List[int]:\n prodZeros = 1\n prodWithoutZeros = 1\n numZeros = 0\n for num in nums:\n if num == 0:\n numZeros += 1\n \n if numZeros > 1:\n return [0] * len(nums)\n\n prodZeros *= num \n prodWithoutZeros *= num if num != 0 else 1\n \n\n return [(prodZeros // num) if num != 0 else prodWithoutZeros for num in nums ]\n \n\nwith open('user.out', 'w') as f:\n for c in map(loads, stdin):\n print(str(productExceptSelf(c)).replace(\" \", \"\"), file=f)\nexit(0)\n ","runtime":"73"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n n = len(nums)\n a = [1] * n\n for i in range(1, n):\n a[i] = a[i - 1] * nums[i - 1]\n suf = 1\n for i in range(n - 1, -1, -1):\n a[i] = a[i] * suf\n suf *= nums[i]\n return a\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)","runtime":"73"},{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)\n\n\n \n\n \n\n\n\n\n \n\n\n \n\n \n\n \n \n\n\n \n\n \n\n\n\n \n\n \n\n\n\n\n\n\n\n \n ","runtime":"76"},{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)\n\n\n \n\n \n\n\n\n\n \n\n\n \n\n \n\n \n \n\n\n \n\n \n\n\n\n \n\n \n\n\n\n\n\n\n\n \n ","runtime":"76"},{"code":"def productExceptSelf(nums):\n # prefix and postfix are initialized to 1. These variables will store the product of numbers encountered so far when traversing nums in two \n # directions (left-to-right and right-to-left).\n prefix, postfix = 1, 1\n answer = [1] * len(nums)\n # First for loop (Left-to-right traversal). This loop ensures that answer[i] will have the product of all elements to the left of nums[i] \n # after it completes.\n for i in range(len(nums)):\n # The current value of prefix (product of all elements before nums[i]) is multiplied with answer[i] and stored back into answer[i].\n answer[i] *= prefix\n # prefix is then updated by multiplying it with nums[i]. This prepares prefix to store the product of elements up to the next index.\n prefix *= nums[i]\n # Second for loop (Right-to-left traversal (len(nums) - 2 to 0)). After this loop finishes, answer[j] will hold the product of all elements both to the left and \n # right of nums[j], which is the desired result.\n for j in range(len(nums)-2, -1, -1):\n # postfix is updated by multiplying it with nums[j+1] (i.e., the element to the right of nums[j]).\n postfix *= nums[j+1]\n # The current value of postfix (product of all elements after nums[j]) is multiplied with answer[j] and stored back into answer[j].\n answer[j] *= postfix\n return answer\n# Checks if the script is being run as the main program. If this script is imported as a module in another script, the code block under this \n# condition will not be executed. This is useful for code that should only run when the script is executed directly.\nif __name__ == \"__main__\":\n from sys import stdin\n from json import loads\n # Opens a file named 'user.out' as f in write mode ('w'). The 'with' statement ensures that the file is properly closed after the block of \n # code is executed.\n with open('user.out', 'w') as f:\n # Iterates over each line of standard input ('stdin'). \n # map(loads, stdin) applies the 'loads' function to each line of input. loads() parses a JSON string and converts it into a Python object.\n # Each parsed input is assigned to the variable 'nums'\n for nums in map(loads, stdin):\n # For each 'nums', the 'canCompleteCircuit' function is called to compute the product of the array except itself.\n # The result is then written to the file 'user.out', followed by a newline character ('\\n').\n # replace(\" \",\"\") method replaces all spaces (\" \") in the string with nothing (\"\").\n f.write(f\"{productExceptSelf(nums)}\\n\".replace(\" \",\"\"))\n # Terminates the program with an exit status of `0`, indicating successful execution.\n exit(0) ","runtime":"79"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n prefixSum = [1]\n suffixSum = [1]\n ans = []\n for i in range(len(nums)-1):\n prefixSum.append(nums[i]*prefixSum[i])\n suffixSum.append(nums[-(i+1)]*suffixSum[i])\n for i in range(0, len(nums)):\n ans.append(prefixSum[i]*suffixSum[-(i+1)])\n return ans\n \n with open('user.out', 'w') as f:\n for c in map(loads, stdin):\n print(str(productExceptSelf(c)).replace(\" \", \"\"), file=f)\n exit(0)","runtime":"79"},{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)\n\n\n \n\n \n\n\n\n\n \n\n\n \n\n \n\n \n \n\n\n \n\n \n\n\n\n \n\n \n\n\n\n\n\n\n\n \n ","runtime":"82"},{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)","runtime":"82"},{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)\n\n\n \n\n \n\n\n\n\n \n\n\n \n\n \n\n \n \n\n\n \n\n \n\n\n\n \n\n \n\n\n\n\n\n\n\n \n ","runtime":"85"},{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)\n\n\n \n\n \n\n\n\n\n \n\n\n \n\n \n\n \n \n\n\n \n\n \n\n\n\n \n\n \n\n\n\n\n\n\n\n \n ","runtime":"85"},{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)","runtime":"88"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n before = [1]\n prod = 1\n for n in nums[:-1]:\n prod *= n\n before.append(prod)\n after = [1]\n prod = 1\n for n in nums[::-1][:-1]:\n prod *= n\n after.append(prod)\n prod = [a*b for a,b in zip(before, after[::-1])]\n return prod\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)","runtime":"88"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n totalall = 1\n index_zero = []\n zero_more_than_one = False\n result = []\n for i, num in enumerate(nums):\n if num == 0:\n index_zero.append(i)\n else:\n totalall *= num\n \n leniz=len(index_zero)\n\n if leniz>1:\n return [0 for x in range(len(nums))]\n \n for i, num in enumerate(nums):\n if i in index_zero:\n result.append(totalall)\n elif leniz==1:\n result.append(0)\n else:\n result.append(int(totalall/num))\n return result \n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)","runtime":"92"},{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)","runtime":"92"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n prefixSum = [1]\n suffixSum = [1]\n ans = []\n for i in range(len(nums)-1):\n prefixSum.append(nums[i]*prefixSum[i])\n suffixSum.append(nums[-(i+1)]*suffixSum[i])\n for i in range(0, len(nums)):\n ans.append(prefixSum[i]*suffixSum[-(i+1)])\n return ans\n \n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)","runtime":"95"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n res1=1\n right=[1]\n res=[]\n res1,res2=1,1\n for i in range(len(nums)-1,0,-1):\n res1*=nums[i]\n right.append(res1)\n res.append(right[len(right)-1])\n for i in range(len(nums)-1):\n res2*=nums[i]\n res.append(right[len(right)-i-2]*res2)\n return res\n\n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)","runtime":"95"},{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)\n\n\n ","runtime":"98"},{"code":"class Solution:\n def productExceptSelf( nums: List[int]) -> List[int]:\n n = len(nums)\n\n \n left = [0]*n\n right = [0]*n\n left_mul,right_mul = 1,1\n\n\n for i in range(n):\n j = -i-1\n\n left[i] = left_mul\n right[j] = right_mul \n\n left_mul *= nums[i]\n right_mul *= nums[j]\n\n return [k*l for k,l in zip(left,right)] \n\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)\n\n\n \n\n \n\n\n\n\n \n\n\n \n\n \n\n \n \n\n\n \n\n \n\n\n\n \n\n \n\n\n\n\n\n\n\n \n ","runtime":"98"},{"code":"f = open(\"user.out\", \"w\")\nfor i in stdin:\n nums = list(map(int, i.rstrip()[1:-1].split(r\",\")))\n l = nums[0]\n r = nums[-1]\n ans = [1] * len(nums)\n for i in range(1, len(nums)):\n ans[i] = l\n l *= nums[i]\n for i in range(len(nums) - 2, -1, -1):\n ans[i] *= r\n r *= nums[i]\n print(str(ans).replace(\" \", \"\"), file=f)\nexit(0)\n\n \n\n\n\n\n \n\n\n ","runtime":"101"},{"code":"f = open(\"user.out\", \"w\")\nfor i in stdin:\n nums = list(map(int, i.rstrip()[1:-1].split(r\",\")))\n l = nums[0]\n r = nums[-1]\n ans = [1] * len(nums)\n for i in range(1, len(nums)):\n ans[i] = l\n l *= nums[i]\n for i in range(len(nums) - 2, -1, -1):\n ans[i] *= r\n r *= nums[i]\n print(str(ans).replace(\" \", \"\"), file=f)\nexit(0)","runtime":"104"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res, front, back, fprod, bprod = [], [], [], 1, 1\n for i in range(len(nums)):\n front.append(fprod)\n fprod *= nums[i]\n\n for j in range(len(nums) - 1, -1, -1):\n back.append(bprod)\n bprod *= nums[j]\n\n back.reverse()\n\n for k in range(len(nums)):\n res.append(front[k] * back[k])\n\n return res\n \nwith open(\"user.out\", \"w\") as f:\n s = Solution()\n for temperatures in map(loads, stdin):\n f.write(f\"[{','.join([str(i) for i in s.productExceptSelf(temperatures)])}]\\n\")\nexit(0)","runtime":"108"},{"code":"f = open(\"user.out\", \"w\")\nfor i in stdin:\n nums = list(map(int, i.rstrip()[1:-1].split(r\",\")))\n l = nums[0]\n r = nums[-1]\n ans = [1] * len(nums)\n for i in range(1, len(nums)):\n ans[i] = l\n l *= nums[i]\n for i in range(len(nums) - 2, -1, -1):\n ans[i] *= r\n r *= nums[i]\n print(str(ans).replace(\" \", \"\"), file=f)\nexit(0)","runtime":"111"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n before = [1]\n prod = 1\n for n in nums[:-1]:\n prod *= n\n before.append(prod)\n print(n)\n after = [1]\n prod = 1\n for n in nums[::-1][:-1]:\n prod *= n\n after.append(prod)\n prod = [a*b for a,b in zip(before, after[::-1])]\n return prod\n\n f = open('user.out', 'w')\n for i in stdin:\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \n exit(0)","runtime":"114"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n out = [1] * len(nums)\n\n pre =1 \n for i in range(len(nums)):\n out[i] = pre\n pre*=nums[i]\n post = 1\n for i in range(len(nums)-1,-1,-1):\n out[i] *=post\n post*=nums[i]\n return out ","runtime":"123"},{"code":"import math\n\nclass Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n counter = nums.count(0)\n if counter >= 2 :\n return [0] * len(nums)\n else :\n product = 1\n for x in nums:\n if x != 0:\n product *= x\n if counter == 1 :\n result = [0] * len(nums)\n result[nums.index(0)] = product\n if counter == 0 :\n result = [product//x for x in nums]\n return result\n ","runtime":"127"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * (len(nums))\n\n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n postfix = 1\n for i in range(len(nums)-1, -1, -1):\n res[i] *= postfix\n postfix *= nums[i]\n return res\n","runtime":"130"},{"code":"class Solution:\n def productExceptSelf(self, A: List[int]) -> List[int]:\n N = len(A)\n p = 1\n zcnt = 0\n\n for a in A:\n if a == 0:\n zcnt += 1\n else:\n p *= a\n \n ans = [0] * N\n\n if zcnt >= 2:\n return ans\n else:\n for i in range(N):\n if zcnt == 0:\n ans[i] = p // A[i]\n else:\n ans[i] = p if A[i] == 0 else 0\n \n return ans\n\n","runtime":"133"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n \n res = [1] * len(nums) \n\n # prefix computations \n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n\n # postfix \n postfix = 1\n for i in range(len(nums) - 1, -1, -1):\n res[i] *= postfix \n postfix *= nums[i]\n \n return res","runtime":"136"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n=len(nums)\n ans=[]\n res,res1=1,1\n if(0 in nums):\n idx=nums.index(0)\n for i in range(n):\n if(i==idx):\n continue\n res1*=nums[i]\n ans1=[0]*n\n ans1[idx]=res1\n return ans1\n else:\n for i in nums:\n res*=i\n for i in nums:\n ans.append(res//i)\n return ans","runtime":"139"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n nums_0s = nums.count(0)\n res = [0] * len(nums)\n\n if nums_0s == 0:\n prod_ = prod(nums)\n\n for i in range(len(nums)):\n res[i] = prod_ // nums[i]\n elif nums_0s == 1:\n ind_0 = nums.index(0)\n prod_ = 1\n\n for i in range(len(nums)):\n if nums[i] != 0:\n prod_ *= nums[i]\n \n res[ind_0] = prod_\n \n return res\n\n \n return res\n\n\n\n\n# [1,2,0,3]\n\n# [0,0,6,0]\n\n# 6\n\n# [1,2,0,0,3]\n# []","runtime":"142"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n res = [1] * n\n\n l_mult = 1\n for i in range(n):\n res[i] = l_mult\n l_mult *= nums[i]\n \n r_mult = 1\n for i in range(n - 1, -1 , -1):\n res[i] *= r_mult\n r_mult *= nums[i]\n\n return res\n","runtime":"146"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n cnt_zero = nums.count(0)\n if cnt_zero > 1:\n return [0] * len(nums)\n elif cnt_zero == 1:\n product = 1\n for num in nums:\n if num != 0:\n product *= num\n return [product if num == 0 else 0 for num in nums]\n else:\n product = 1\n for num in nums:\n product *= num\n return [product // num for num in nums]","runtime":"149"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n total_product = 1\n zero_count = 0\n \n for num in nums:\n if num != 0:\n total_product *= num\n else:\n zero_count += 1\n \n result = []\n \n if zero_count > 1:\n return [0] * len(nums)\n \n for num in nums:\n if num != 0:\n if zero_count == 1:\n result.append(0)\n else:\n result.append(total_product // num)\n else:\n result.append(total_product)\n \n return result","runtime":"152"},{"code":"import math\n\nclass Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = []\n l = len(nums)\n if 0 not in nums:\n tp = math.prod(nums)\n for num in nums:\n res.append(tp//num)\n\n return res\n\n for i, n in enumerate(nums):\n if i == 0:\n res.append(math.prod(nums[i+1:]))\n elif i == l-1:\n res.append(math.prod(nums[:l-1]))\n else:\n res.append(math.prod(nums[i+1:]) * math.prod(nums[:i]))\n return res","runtime":"152"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res=[]\n p=math.prod(nums)\n for i in range(len(nums)):\n if nums[i]!=0:\n res.append(p//nums[i])\n else:\n a=nums.copy()\n a.pop(i)\n res.append(math.prod(a))\n return res","runtime":"155"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res=[]\n p=math.prod(nums)\n for i in range(len(nums)):\n if nums[i]!=0:\n res.append(p//nums[i])\n else :\n a=nums.copy()\n a.pop(i)\n res.append(math.prod(a))\n return res","runtime":"155"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prod = 1\n num_0 = 0\n for n in nums:\n if n == 0:\n num_0 += 1\n continue\n prod *= n\n if num_0 > 1:\n return [0] * len(nums)\n elif num_0 == 1:\n return [prod if n == 0 else 0 for n in nums]\n return [prod // n for n in nums]","runtime":"158"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n answer = [1] * n\n\n left = 1\n for i in range(n):\n answer[i] = left\n left *= nums[i]\n\n right = 1\n for i in range(n - 1, -1, -1):\n answer[i] *= right\n right *= nums[i]\n\n return answer\n","runtime":"162"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n product= 1\n zero_count=0\n for num in nums:\n if num != 0:\n product *= num\n else:\n zero_count += 1\n\n output = []\n for num in nums:\n if zero_count > 1:\n # If more than one zero, all products are zero\n output.append(0)\n elif zero_count == 1:\n # If exactly one zero, only the zero element gets the product of non-zero elements\n if num == 0:\n output.append(product)\n else:\n output.append(0)\n else:\n # No zeroes, calculate the product normally (product divided by the current element)\n output.append(product // num)\n \n return(output)\n ","runtime":"165"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n # store = {}\n # ls = []\n # def product(new_ls):\n # pro = 1\n # for i in new_ls:\n # pro *= i\n # return pro \n\n # for i in nums:\n # if i not in store:\n # cp_ls = nums.copy()\n # cp_ls.remove(i)\n # re = product(cp_ls)\n # store[i] = re\n # else:\n # re = store[i]\n # ls.append(re)\n # return ls\n\n n = len(nums)\n if n == 0:\n print([]) # Edge case: empty list\n exit()\n\n # Initialize product variables\n total_product = 1\n zero_count = 0\n\n # Compute total product and count zeros\n for num in nums:\n if num == 0:\n zero_count += 1\n else:\n total_product *= num\n\n # Generate result list based on zero count\n ls = []\n for num in nums:\n if zero_count > 1:\n # More than one zero: all products are zero\n ls.append(0)\n elif zero_count == 1:\n # Exactly one zero: only the position with zero will have non-zero product\n if num == 0:\n ls.append(total_product)\n else:\n ls.append(0)\n else:\n # No zeros: standard case\n ls.append(total_product // num)\n return ls","runtime":"168"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n=len(nums)\n answer=[1]*n\n prefix=1\n for i in range(n):\n answer[i]=prefix\n prefix*=nums[i]\n suffix=1\n for i in range(n-1,-1,-1):\n answer[i]*=suffix\n suffix*=nums[i]\n return answer\n\n \n ","runtime":"171"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n preProd = 1\n postProd = 1\n resultArr = [0]*(len(nums))\n\n # fill array with preProds\n for i in range(0, len(nums)):\n resultArr[i] = preProd\n preProd *= nums[i]\n\n # now multiple preProds by postProds\n for i in range((len(nums) - 1), -1, -1):\n resultArr[i] *= postProd\n postProd *= nums[i] \n\n return resultArr ","runtime":"171"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * len(nums)\n\n prefix = 1\n\n for i in range(len(nums)):\n res[i] = prefix\n prefix = prefix * nums[i]\n \n postfix = 1\n\n for i in range(len(nums)-1, -1, -1):\n res[i] *= postfix\n postfix *= nums[i]\n \n return res\n","runtime":"174"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix = 1\n answer = [1] * len(nums)\n for i in range(len(nums)): \n answer[i] = prefix\n prefix *= nums[i]\n suffix = 1\n for i in range(len(nums) - 1, -1, -1):\n answer[i] *= suffix\n suffix *= nums[i]\n return answer","runtime":"177"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n\n n = len(nums)\n answer = [1] * n\n \n # Step 1: Calculate prefix product\n prefix = 1\n for i in range(n):\n answer[i] = prefix\n prefix *= nums[i]\n \n # Step 2: Calculate suffix product and multiply it with the prefix product stored in answer\n suffix = 1\n for i in range(n - 1, -1, -1):\n answer[i] *= suffix\n suffix *= nums[i]\n \n return answer","runtime":"177"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n grandprod = 1\n zerocount = 0\n answer = []\n for n in nums:\n if n == 0:\n zerocount += 1\n else:\n grandprod *= n\n \n if zerocount > 1:\n return [0 for _ in nums]\n \n if zerocount == 1:\n for n in nums:\n if n == 0:\n answer.append(grandprod)\n else:\n answer.append(0)\n \n else:\n for n in nums:\n answer.append(grandprod//n)\n \n return answer","runtime":"181"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n res = [1] * n\n\n l_mult = 1\n for i in range(n):\n res[i] = l_mult\n l_mult *= nums[i]\n\n r_mult = 1\n for i in range(n - 1, -1, -1):\n res[i] *= r_mult\n r_mult *= nums[i]\n\n return res\n\n\n \n\n ","runtime":"184"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n tot_prod = 1\n zeroes = 0\n for i in nums:\n if i == 0:\n zeroes += 1\n else:\n tot_prod *= i\n if zeroes > 1:\n out = [0 for i in nums]\n elif zeroes == 1:\n out = [0 for i in nums]\n out[nums.index(0)] = tot_prod\n elif zeroes == 0:\n out = [tot_prod//i for i in nums]\n return out\n ","runtime":"184"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n output = [1]*len(nums)\n pre = 1\n for i in range(0, len(nums)):\n output[i] = pre\n pre *= nums[i]\n post = 1\n for i in range(-1, -len(nums)-1, -1):\n output[i] = output[i] * post\n post *= nums[i] \n return output","runtime":"187"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n # answer = [] \n # for i in range(len(nums)):\n # current = nums[i]\n # sum = 1\n # for j in range(len(nums)): \n # #returns an error here because this reaches the end of the list first\n # #nums[j] is an error because we are accessing each vlaue of nums\n # # so there is no index of 12 for example\n # if (nums[j] != current):\n # sum *= nums[j]\n # answer.append(sum)\n # return answer\n \n # we want to calculte all the products to teh left and right of each number in nums\n # thus excluding the index value\n\n n = len(nums)\n\n answer = [1] * n\n\n # prefix\n left = 1\n for i in range(n):\n answer[i] = left\n left *= nums[i] \n\n\n # suffix\n right = 1\n for i in range(n - 1, -1, -1):\n answer[i] *= right\n right *= nums[i]\n\n\n return answer","runtime":"187"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n product = 1 \n zeroes = 0\n for num in nums:\n if num != 0:\n product *= num\n else:\n zeroes += 1\n \n if zeroes > 1:\n return [0]*len(nums)\n \n if zeroes != 0:\n return [0 if num != 0 else int(product) for num in nums] \n else:\n return [int(product/num) for num in nums]","runtime":"190"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prod=1\n zeroCount=0\n hasZero=False\n for i in nums:\n if(i!=0):\n prod*=i\n else:\n zeroCount+=1\n res=[]\n for i in nums:\n if(i==0):\n res.append(0) if zeroCount>1 else res.append(prod)\n elif(zeroCount>0):\n res.append(0)\n else:\n res.append(prod//i)\n return res\n ","runtime":"190"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n output = []\n\n product = 1\n for n in nums:\n product *= n\n \n for i, n in enumerate(nums):\n if n == 0 and product == 0:\n one = 1\n temp = [x for x in nums if x != 0]\n if temp == [] or nums.count(0) >= 2:\n one = 0\n for x in temp:\n one *= x\n output.append(one)\n else:\n output.append(int(product / n))\n return output","runtime":"193"},{"code":"class Solution:\n def productExceptSelf(self, nums):\n res = [0] * len(nums)\n mul = 1\n for num in nums:\n if num != 0:\n mul *= num\n if 0 in nums:\n if nums.count(0)<=1:\n res[nums.index(0)] = mul\n\n else:\n for i in range(len(nums)):\n res[i] = mul // nums[i]\n return res\n","runtime":"193"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * len(nums)\n \n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n\n postfix = 1\n for i in range(len(nums)-1, -1, -1):\n res[i] = postfix*res[i]\n postfix *= nums[i]\n \n return res\n ","runtime":"196"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n=len(nums)\n product=1\n count=0\n product2=1\n for i in range(n):\n product*=nums[i]\n for l in range(n):\n if nums[l]==0:\n count+=1\n if count==1:\n for i in range(n):\n if nums[i]==0:\n continue\n else:\n product2*=nums[i]\n for j in range(n):\n if nums[j]==0:\n nums[j]=product2\n continue\n else:\n nums[j]=product\n elif count>1:\n for i in range(n):\n nums[i]=0\n else:\n for i in range(n):\n nums[i]=product//nums[i]\n return nums\n\n\n ","runtime":"196"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n result = [1] * len(nums)\n\n prefix = 1\n for i in range(len(nums)):\n result[i] = prefix\n prefix = prefix * nums[i]\n \n postfix = 1\n for i in range(len(nums)-1, -1, -1):\n result[i] = result[i] * postfix\n postfix = postfix * nums[i]\n\n return result","runtime":"200"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n # prefix array and suffix array, accumulation product\n # get the product of the subarray before it, and the subarray after it by retrieving from the prefix and suffix arrays\n # then save the product of those two values\n\n # this method below is really space efficient, but is a little trickier to understand\n # essentially, the core is result[i] = prefix[i - 1] * suffix[i + 1]\n # you first produce the prefix values and store them in result, but they're offset by 1. storing the prefix accumulation in acc\n # i.e. result[i] = prefix[i - 1] normally\n # then you iterate the other way, but offset one, storing the suffix accumulation in acc\n # i.e. acc = suffix[i + 1] normally\n # on the way back, you have access to prefix[i - 1] via results[i]\n # and you have the suffix[i + 1] via acc\n # so result[i] *= acc is the same as result[i] = result[i] * acc = prefix[i - 1] * suffix[i + 1]\n\n # not my favorite since it's trickier to read without a huge benefit (optimizing space complexity is lower priority)\n\n result = [1] * len(nums)\n acc = 1\n for i in range(len(nums)):\n result[i] = acc\n acc *= nums[i]\n\n acc = 1\n for i in range(len(nums) - 1, -1, -1):\n result[i] *= acc\n acc *= nums[i]\n \n return result\n\n# nums = [1,2,3,4]\n\n# prefix run\n# result = [1, 1, 2, 6]\n\n# suffix run, acc = 1, 4, 12, 24\n# result = [24, 12, 8, 6]","runtime":"200"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * (len(nums))\n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n postfix = 1\n for i in range(len(nums)-1,-1,-1):\n res[i] *= postfix\n postfix*= nums[i]\n\n return res\n\n ","runtime":"203"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1 for _ in range(len(nums))]\n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n print(res)\n postfix = 1\n for i in range(len(nums)-1,-1,-1):\n res[i] *= postfix\n postfix *= nums[i]\n print(res)\n return res","runtime":"203"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n output = [0] * len(nums)\n full_prod = 1\n zero_count = 0\n zero_pos = 0\n for i, num in enumerate(nums):\n if num == 0:\n zero_pos = i\n zero_count +=1\n if zero_count > 1:\n break\n else:\n full_prod *= num\n \n if zero_count == 1:\n output[zero_pos] = full_prod\n\n elif zero_count == 0: \n for i, num in enumerate(nums):\n output[i] = full_prod // num\n \n return output\n\n","runtime":"206"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n ans = [1]*n\n left_product = 1\n for i in range(n):\n ans[i] = left_product\n left_product *= nums[i]\n right_product = 1\n for i in range(n-1,-1,-1):\n ans[i] *= right_product\n right_product *= nums[i]\n return ans\n\n ","runtime":"206"},{"code":"class Solution:\n def productExceptSelf(self, nums):\n n = len(nums)\n answer = [1] * n\n left = 1\n \n for i in range(n):\n answer[i] = left\n left *= nums[i]\n \n right = 1\n \n for i in range(n-1, -1, -1):\n answer[i] *= right\n right *= nums[i]\n \n return answer\n","runtime":"209"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * len(nums)\n\n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n \n suffix = 1\n for i in range(len(nums)-1, -1, -1):\n res[i] *= suffix\n suffix *= nums[i]\n\n return res","runtime":"209"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1]*(len(nums))\n prefix = 1\n postfix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n for i in range(len(nums)-1,-1,-1):\n res[i] *= postfix\n postfix *= nums[i]\n return res \n ","runtime":"212"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n l_mult = 1\n r_mult = 1\n n = len(nums)\n l_arr = [0] * n\n r_arr = [0] * n\n\n for i in range(n):\n j = -i -1\n l_arr[i] = l_mult\n r_arr[j] = r_mult\n l_mult = l_mult * nums[i]\n r_mult = r_mult * nums[j]\n \n return [l*r for l,r in zip(l_arr,r_arr)]\n\n ","runtime":"212"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n result=[1]*len(nums)\n\n prefix=1\n for i in range(len(nums)):\n result[i]=prefix\n prefix*=nums[i]\n \n postfix=1\n for j in range(len(nums)-1,-1,-1):\n result[j]*=postfix\n postfix*=nums[j]\n return result","runtime":"215"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n product = [1 for i in range(n)]\n prefix = 1\n for i in range(n):\n product[i] *= prefix\n prefix *= nums[i]\n postfix = 1\n for i in range(n-1,-1,-1):\n product[i] *= postfix\n postfix *= nums[i]\n return product","runtime":"215"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * len(nums)\n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n postfix = 1\n for i in range(len(nums)-1,-1,-1):\n res[i] *= postfix\n postfix *= nums[i]\n return res\n \n ","runtime":"219"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n output = [0] * len(nums)\n full_prod = 1\n zero_count = 0\n zero_pos = 0\n for i, num in enumerate(nums):\n if num == 0:\n zero_pos = i\n zero_count +=1\n else:\n full_prod *= num\n \n\n \n\n if zero_count == 1:\n output[zero_pos] = full_prod\n\n elif zero_count == 0: \n for i, num in enumerate(nums):\n output[i] = full_prod // num\n \n return output\n\n","runtime":"219"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * len(nums)\n\n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n\n postfix = 1\n for i in range(len(nums) -1, -1, -1):\n res[i] *= postfix\n postfix *= nums[i]\n return res","runtime":"222"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n l_mult = 1\n r_mult = 1\n n = len(nums)\n r_arr = [0] * n\n l_arr = [0] *n\n\n for i in range(n):\n j = -i -1\n l_arr[i] = l_mult\n r_arr[j] = r_mult\n l_mult = l_mult*nums[i]\n r_mult = r_mult*nums[j]\n \n\n return [l*r for l, r in zip(l_arr, r_arr)]\n ","runtime":"222"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * len(nums)\n \n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n\n postfix = 1\n for i in range(len(nums)-1, 0-1, -1):\n res[i] = postfix*res[i]\n postfix *= nums[i]\n print(postfix)\n return res\n ","runtime":"225"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n \"\"\" n=len(nums)\n product=1\n count=0\n product2=1\n for i in range(n):\n product*=nums[i]\n for l in range(n):\n if nums[l]==0:\n count+=1\n if count==1:\n for i in range(n):\n if nums[i]==0:\n continue\n else:\n product2*=nums[i]\n for j in range(n):\n if nums[j]==0:\n nums[j]=product2\n continue\n else:\n nums[j]=product\n elif count>1:\n for i in range(n):\n nums[i]=0\n else:\n for i in range(n):\n nums[i]=product//nums[i]\n return nums\"\"\"\n \"\"\" n=len(nums)\n answer=[0]*n\n i=0\n k=0\n product=1\n while(i<n):\n if i==k:\n i+=1\n continue\n else:\n product*=nums[i]\n if i==n-1:\n answer[k]=product\n product=1\n k+=1\n i=0\n i+=1\n answer[k]=product\n return answer\"\"\"\n n=len(nums)\n answer=[0]*n\n left_product=1\n right_product=1\n for i in range(n):\n answer[i]=left_product\n left_product*=nums[i]\n for j in range(n-1,-1,-1):\n answer[j]*=right_product\n right_product*=nums[j]\n return answer\n\n \n\n\n\n ","runtime":"225"},{"code":"\nclass Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n result = [1] * n\n \n left_product = 1\n for i in range(n):\n result[i] = left_product\n left_product *= nums[i]\n \n right_product = 1\n for i in range(n-1,-1,-1):\n result[i] *= right_product\n right_product *= nums[i] \n\n return result","runtime":"228"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n \n res = [1] * (len(nums))\n\n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n\n postfix = 1\n\n for i in range(len(nums) -1, -1, -1):\n res[i] *= postfix\n postfix *= nums[i]\n\n return res","runtime":"228"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]: \n res = [1] * len(nums) \n\n pre = 1 \n for i in range(len(nums)): \n res[i] = pre \n pre *= nums[i] \n post = 1\n for i in range(len(nums) - 1, -1, -1): \n res[i] *= post \n post *= nums[i] \n return res \n ","runtime":"231"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n p = 1\n r = []\n c = nums.count(0)\n\n if c>1:\n r = [0]*len(nums)\n return r\n\n \n if c == 1:#zero count =1 \n for i in nums:\n if i != 0:\n p = p*i\n for i in nums:\n if i == 0:\n r.append(p)\n else:\n r.append(0)\n return r\n\n\n for i in nums:\n p = p*i\n for i in nums:\n r.append(p//i)\n return r\n \n \n \n \n\n ","runtime":"231"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n output = [0] * len(nums)\n full_prod = 1\n zero_count = 0\n zero_pos = 0\n for i, num in enumerate(nums):\n if num == 0:\n zero_pos = i\n zero_count +=1\n if zero_count > 1:\n break\n else:\n full_prod *= num\n \n if zero_count == 1:\n output[zero_pos] = full_prod\n\n elif zero_count == 0: \n for i, num in enumerate(nums):\n output[i] = full_prod // num\n \n return output\n\n","runtime":"235"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * len(nums)\n\n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n\n postfix = 1\n for i in range(len(nums) -1, -1, -1):\n res[i] *= postfix\n postfix *= nums[i]\n return res","runtime":"235"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n result = [None] * len(nums)\n\n prefix_value = 1\n\n for x in range(len(result)):\n result[x] = prefix_value\n prefix_value *= nums[x]\n\n postfix_value = 1\n\n for x in range(len(result) - 1, -1, -1):\n result[x] *= postfix_value\n postfix_value *= nums[x]\n \n return result","runtime":"238"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n output = []\n\n product = 1\n for n in nums:\n product *= n\n \n for i, n in enumerate(nums):\n if n == 0 and product == 0:\n one = 1\n temp = [x for x in nums if x != 0]\n if temp == [] or nums.count(0) >= 2:\n one = 0\n for x in temp:\n one *= x\n output.append(one)\n else:\n output.append(int(product / n))\n return output","runtime":"238"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n answer = [1] * len(nums)\n\n left = 1\n for i in range(len(nums)):\n answer[i] = left\n left *= nums[i]\n\n right =1\n for i in range(len(nums) -1, -1, -1):\n answer[i] *= right\n right *= nums[i]\n \n return answer\n \n\n\n\n","runtime":"241"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n res = [1] * n\n \n prefix = 1\n for i in range(n):\n res[i] = prefix\n prefix *= nums[i]\n \n suffix = 1\n for i in range(n-1, -1, -1):\n res[i] *= suffix\n suffix *= nums[i]\n \n return res\n","runtime":"244"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n output = []\n\n product = 1\n for n in nums:\n product *= n\n \n for i, n in enumerate(nums):\n if n == 0 and product == 0:\n one = 1\n temp = [x for x in nums if x != 0]\n if temp == [] or nums.count(0) >= 2:\n one = 0\n for x in temp:\n one *= x\n output.append(one)\n else:\n output.append(int(product / n))\n return output","runtime":"244"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n totmu = 1\n toz= 1\n c = 0\n for i in nums:\n if i==0:\n c+=1\n if c>1:\n return [0]*len(nums)\n answer = []\n for i in nums:\n totmu*=i\n if i!=0:\n toz*=i\n for i in nums:\n if i == 0:\n answer.append(toz)\n else:\n answer.append(int(totmu/i))\n return answer\n","runtime":"247"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n length, left, right = len(nums), 1, 1\n answer = [1] * length\n for i in range(length):\n answer[i] *= left\n left *= nums[i]\n answer[length - i - 1] *= right\n right *= nums[length - i - 1]\n return answer","runtime":"247"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n output = [0] * len(nums)\n full_prod = 1\n zero_count = 0\n zero_pos = 0\n for i, num in enumerate(nums):\n if num == 0:\n zero_pos = i\n zero_count +=1\n if zero_count > 1:\n break\n else:\n full_prod *= num\n \n if zero_count == 1:\n output[zero_pos] = full_prod\n\n elif zero_count == 0: \n for i, num in enumerate(nums):\n output[i] = full_prod // num\n \n return output\n\n","runtime":"250"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n=len(nums)\n prefix_product=1\n postfix_product=1\n result = [0]*n\n for i in range(n):\n result[i]=prefix_product\n prefix_product*=nums[i]\n for i in range(n-1,-1,-1):\n result[i] *= postfix_product\n postfix_product *= nums[i]\n return result \n","runtime":"250"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * len(nums)\n\n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n\n postfix = 1\n for i in range(len(nums) -1, -1, -1):\n res[i] *= postfix\n postfix *= nums[i]\n return res","runtime":"254"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n mul_p = [nums[0]]\n mul_s = [nums[-1]]\n for i in range(1,len(nums)):\n mul_p.append(mul_p[-1]*nums[i])\n \n nums = nums[::-1]\n for i in range(1,len(nums)):\n mul_s.append(mul_s[-1]*nums[i])\n mul_s = mul_s[::-1]\n nums = []\n for i in range(1,len(mul_s)-1):\n nums.append(mul_p[i-1]*mul_s[i+1])\n nums.append(mul_p[-2])\n nums.insert(0,mul_s[1])\n \n return nums","runtime":"254"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n curr = 1\n res = [1] * n\n\n for i in range(n):\n res[i] *= curr\n curr *= nums[i]\n\n curr = 1\n\n for i in range(n-1, -1, -1):\n res[i] *= curr\n curr *= nums[i]\n return res","runtime":"257"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * (len(nums))\n prefix = 1\n for i in range(len(nums)):\n res[i] *= prefix\n prefix *= nums[i]\n postfix = 1\n for i in range(len(nums)-1,-1,-1):\n res[i] *= postfix\n postfix*= nums[i]\n\n return res\n\n ","runtime":"257"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n left = [1] *n\n right = [1]*n\n res = [1]*n\n for i in range(1, n):\n left[i] = left[i-1] * nums[i-1]\n \n for i in range(n-2,-1,-1):\n right[i] = right[i+1] * nums[i+1]\n \n # print(left, right)\n \n for i in range(n):\n res[i] = left[i]*right[i]\n \n \n return res","runtime":"260"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]: \n lprod = []\n rprod = []\n\n for i in range(len(nums)): \n if i == 0:\n lprod.append(1)\n rprod.append(1)\n else:\n lprod.append(lprod[-1] * nums[i-1])\n rprod.append(rprod[-1] * nums[-i])\n ans = []\n for i in range(len(lprod)):\n ans.append(lprod[i] * rprod[-i-1])\n\n return ans","runtime":"260"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n answer = []\n total = 1\n for k in range(len(nums)):\n total = total * nums[k]\n for i in range(len(nums)):\n if nums[i] != 0:\n answer.append(int(total/nums[i]))\n else:\n product = 1\n for j in range(len(nums)):\n if i != j:\n product = product * nums[j]\n answer.append(int(product))\n return answer\n \n ","runtime":"263"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prod = 1\n zero_count = 0\n\n for num in nums:\n if num == 0:\n zero_count += 1\n continue\n prod *= num \n \n if zero_count > 1:\n return [0] * len(nums)\n\n res = []\n for num in nums:\n new_num = None\n if zero_count == 1:\n new_num = 0 if num != 0 else prod\n else:\n new_num = prod//num\n res.append(new_num)\n\n return res","runtime":"263"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n left_prod = [1]\n\n for i in range(1, len(nums)):\n left_prod.append(nums[i-1] * left_prod[-1])\n \n right_prod = 1\n for i in range(len(nums) - 1, -1, -1):\n left_prod[i] = left_prod[i] * right_prod\n right_prod *= nums[i]\n \n return left_prod\n\n\n","runtime":"266"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n ans = [1] * len(nums)\n \n left, right = 1, 1\n for i in range(len(nums)):\n ans[i] *= left\n ans[~i] *= right\n \n left *= nums[i]\n right *= nums[~i]\n \n return ans","runtime":"266"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n ans = [0] * n\n ans[0] = 1\n for i in range(1, n):\n ans[i] = ans[i-1] * nums[i-1]\n R = 1\n for i in reversed(range(n)):\n ans[i] = ans[i] * R\n R *= nums[i]\n return ans","runtime":"269"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n rez=[1]*len(nums)\n\n #Prefix\n for i in range(1,len(nums)):\n rez[i]=rez[i-1]*nums[i-1]\n\n #Suffix\n suffix=1\n for i in range(len(nums)-2,-1,-1):\n suffix*=nums[i+1]\n rez[i]*=suffix\n \n return rez","runtime":"269"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n totmu = 1\n totmuwithoutzero = 1\n if nums.count(0)>1:\n return [0]*len(nums)\n answer = []\n for i in nums:\n totmu*=i\n if i!=0:\n totmuwithoutzero*=i\n for i in nums:\n if i == 0:\n answer.append(totmuwithoutzero)\n else:\n answer.append(int(totmu/i))\n return answer\n","runtime":"273"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]: \n lefts = []\n rights = [0] * len(nums)\n for i in range(len(nums)):\n if i == 0:\n prod = 1\n rprod = 1\n else:\n prod *= nums[i-1]\n rprod *= nums[-i]\n lefts.append(prod)\n rights[len(nums)-1-i] = rprod\n\n ans = []\n for i in range(len(nums)):\n ans.append(lefts[i] * rights[i])\n\n return ans","runtime":"273"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix = [1] * len(nums)\n suffix = [1] * len(nums)\n\n for i in range(1,len(nums)):\n prefix[i] = nums[i - 1] * prefix[i - 1]\n\n for i in range(len(nums)-2, -1, -1):\n suffix[i] = nums[i + 1] * suffix[i + 1]\n\n return [prefix[i] * suffix[i] for i in range(len(nums))] ","runtime":"276"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n l_mult = 1\n r_mult = 1\n n = len(nums)\n l_arr = [0] * n\n r_arr = [0] * n\n\n for i in range(n):\n j = -i -1\n l_arr[i] = l_mult\n r_arr[j] = r_mult\n l_mult *= nums[i]\n r_mult *= nums[j]\n\n return [r*l for r, l in zip(r_arr, l_arr)]\n ","runtime":"276"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n left_prod = []\n left_product = 1\n\n right_product = 1\n right_prod = []\n\n answer = []\n for i in range(n):\n if i == 0:\n left_prod.append(1)\n else:\n left_product *= nums[i-1]\n left_prod.append(left_product)\n\n for j in range(n-1,-1,-1):\n if j == n-1:\n right_prod.append(1)\n else:\n right_product *= nums[j+1]\n right_prod.append(right_product)\n\n for k in range(n):\n answer.append(left_prod[k] * right_prod[n-k-1])\n return answer\n ","runtime":"279"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n left_prod = []\n left_product = 1\n\n right_product = 1\n right_prod = []\n\n answer = []\n for i in range(n):\n if i == 0:\n left_prod.append(1)\n else:\n left_product *= nums[i-1]\n left_prod.append(left_product)\n\n for j in range(n-1,-1,-1):\n if j == n-1:\n right_prod.append(1)\n else:\n right_product *= nums[j+1]\n right_prod.append(right_product)\n\n for k in range(n):\n answer.append(left_prod[k] * right_prod[n-k-1])\n return answer\n ","runtime":"279"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n ans = [1] * len(nums)\n \n left, right = 1, 1\n for i in range(len(nums)):\n ans[i] *= left\n ans[~i] *= right\n \n left *= nums[i]\n right *= nums[~i]\n \n return ans\n \n return res","runtime":"282"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n l_multi = 1\n r_multi = 1\n l_arr = [0] * n\n r_arr = [0] * n\n \n for i in range(n):\n j = -i -1\n l_arr[i] = l_multi\n r_arr[j] = r_multi\n l_multi *= nums[i]\n r_multi *= nums[j]\n \n return [l*r for l,r in zip(l_arr,r_arr)]","runtime":"282"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n pre_time = [0] * len(nums)\n suf_time = [0] * len(nums)\n pre_time[0] = 1\n suf_time[len(nums) - 1] = 1\n ans = []\n for i in range(1, len(nums)):\n pre_time[i] = nums[i - 1] * pre_time[i - 1]\n suf_time[len(nums) - i - 1] = nums[len(nums) - i] * suf_time[len(nums) - i]\n for i in range(len(nums)):\n ans.append(pre_time[i] * suf_time[i])\n return ans\n\n","runtime":"285"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix_mul = []\n suffix_mul = []\n prod_ex_self = []\n prev = 1\n after = 1\n reversed_nums = nums[::-1]\n\n for i in range(len(nums)):\n prev = prev * nums[i]\n prefix_mul.append(prev)\n\n after = after * reversed_nums[i]\n suffix_mul.append(after)\n\n suffix_mul = suffix_mul[::-1]\n for i in range(len(nums)):\n if i == 0:\n prefix = 1\n else: \n prefix = prefix_mul[i-1]\n\n if i == len(nums) - 1:\n suffix = 1\n else: \n suffix = suffix_mul[i+1] \n \n prod_ex_self.append(prefix * suffix)\n\n return prod_ex_self\n \n ","runtime":"285"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n answer = [1] * len(nums)\n prefix_product = nums[0]\n for i in range(len(nums)):\n if i - 1 >= 0:\n answer[i] *= prefix_product\n prefix_product = nums[i] * prefix_product\n suffix_product = nums[-1]\n for i in range(len(nums) - 2, -1, -1):\n if i + 1 != len(nums):\n answer[i] *= suffix_product\n suffix_product = nums[i] * suffix_product\n return answer","runtime":"289"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n pref_prod, suff_prod = 1, 1\n prefixes = {}\n suffixes = {}\n for i in range(len(nums)):\n pref_prod, suff_prod = pref_prod*nums[i], suff_prod*nums[len(nums) - i - 1]\n prefixes[i] = pref_prod\n suffixes[len(nums) - i - 1] = suff_prod\n result = [suffixes[1]]\n for i in range(1, len(nums) - 1):\n result.append(prefixes[i-1] * suffixes[i+1])\n result.append(prefixes[len(nums)-2])\n return result","runtime":"289"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n if n == 0:\n return []\n \n prefix_products = [1] * n\n suffix_products = [1] * n\n result = [1] * n\n \n for i in range(1, n):\n prefix_products[i] = prefix_products[i - 1] * nums[i - 1]\n \n for i in range(n - 2, -1, -1):\n suffix_products[i] = suffix_products[i + 1] * nums[i + 1]\n \n for i in range(n):\n result[i] = prefix_products[i] * suffix_products[i]\n \n return result ","runtime":"292"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix_mul = []\n suffix_mul = []\n prod_ex_self = []\n prev = 1\n after = 1\n reversed_nums = nums[::-1]\n\n for i in range(len(nums)):\n prev = prev * nums[i]\n prefix_mul.append(prev)\n\n after = after * reversed_nums[i]\n suffix_mul.append(after)\n\n suffix_mul = suffix_mul[::-1]\n for i in range(len(nums)):\n if i == 0:\n prefix = 1\n else: \n prefix = prefix_mul[i-1]\n\n if i == len(nums) - 1:\n suffix = 1\n else: \n suffix = suffix_mul[i+1] \n \n prod_ex_self.append(prefix * suffix)\n\n return prod_ex_self\n \n ","runtime":"292"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n left_prod = []\n left_product = 1\n\n right_product = 1\n right_prod = []\n\n answer = []\n for i in range(n):\n if i == 0:\n left_prod.append(1)\n else:\n left_product *= nums[i-1]\n left_prod.append(left_product)\n\n for j in range(n-1,-1,-1):\n if j == n-1:\n right_prod.append(1)\n else:\n right_product *= nums[j+1]\n right_prod.append(right_product)\n\n for k in range(n):\n answer.append(left_prod[k] * right_prod[n-k-1])\n return answer\n ","runtime":"295"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n l=[nums[0]]\n for i in range(1,len(nums)):\n l.append(nums[i]*l[i-1])\n print(l)\n\n out=[]\n res=nums[-1]\n for i in range(len(l)-1,-1,-1):\n if(i==len(l)-1):\n out.append(l[-2])\n elif(i==0):\n out.append(res)\n else:\n out.append(l[i-1]*res)\n res*=nums[i]\n return out[::-1]","runtime":"295"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n\n dp = [1 if nums[i]>=0 else -1 for i in range(n)]\n dp2 = [1 if nums[i]>=0 else -1 for i in range(n)]\n\n prod = nums[0]\n for i in range(1, n):\n dp[i]*=prod\n prod*=nums[i]\n \n prod = nums[-1]\n for i in range(n-2, -1, -1):\n dp2[i]*=prod\n prod*=nums[i]\n\n \n ans = [1 for i in range(n)]\n for i in range(n):\n ans[i]=dp[i]*dp2[i]\n return ans\n\n\n\n ","runtime":"298"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n left = [1]\n right = [1]\n answer = []\n\n for i in range(1,len(nums)):\n left.append( left[i-1] * nums[i - 1])\n \n for i in range(1,len(nums)):\n right.append( right[i -1] * nums[len(nums) - i])\n \n for i in range(0,len(nums)):\n answer.append( left[i] * right[len(nums) - i - 1])\n\n \n return answer \n","runtime":"298"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix_product = [nums[0]] * len(nums)\n for i in range(1, len(nums)):\n prefix_product[i] = nums[i] * prefix_product[i-1]\n suffix_product = [nums[-1]] * len(nums)\n for i in range(len(nums) - 2, -1, -1):\n suffix_product[i] = nums[i] * suffix_product[i+1]\n\n answer = [1] * len(nums)\n for i in range(len(nums)):\n if i + 1 != len(nums):\n answer[i] *= suffix_product[i + 1]\n if i - 1 >= 0:\n answer[i] *= prefix_product[i - 1]\n return answer","runtime":"301"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n left_mult = []\n right_mult = []\n for i in range(len(nums)):\n right_i = len(nums)-1-i\n if i == 0:\n left_mult.append(nums[i])\n right_mult.append(nums[right_i])\n else:\n left_mult.append(left_mult[i-1]*nums[i])\n right_mult.append(right_mult[i-1]*nums[right_i])\n for i in range(len(nums)):\n right_i = len(nums)-1-i\n if i == 0:\n nums[i] = right_mult[right_i-1]\n elif i == len(nums)-1:\n nums[i] = left_mult[i-1]\n else:\n nums[i] = left_mult[i-1] * right_mult[right_i-1]\n return nums\n\n\n ","runtime":"301"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n r = [1] * len(nums)\n for i in range(1, len(nums)):\n r[-i-1] = r[-i] * nums[-i]\n for i in range(1, len(nums)):\n nums[i] *= nums[i-1]\n r[i] *= nums[i-1]\n print(r)\n print(nums)\n return r","runtime":"304"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n dict_left = {}\n dict_right = {}\n for i in range(len(nums)):\n if i == 0:\n dict_left[i] = 1\n else:\n dict_left[i] = dict_left[i - 1] * nums[i-1]\n for i in range(len(nums) - 1, -1, -1):\n if i == len(nums) - 1:\n dict_right[i] = 1\n else:\n dict_right[i] = dict_right[i + 1] * nums[i+1]\n\n res = []\n for i in range(len(nums)):\n res.append(dict_left[i] * dict_right[i])\n\n return res","runtime":"304"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n prefix = [1]*n\n prev = 1\n for i in range(n):\n prev = prev * nums[i]\n prefix[i] = prev\n suffix = [1]*n\n prev = 1\n for i in range(n-1, -1, -1):\n prev = prev * nums[i]\n suffix[i] = prev\n print(suffix)\n print(prefix)\n print(nums)\n output = [1] * n\n prev = 1\n for i in range(n):\n if i == n - 1:\n nxt = 1\n else:\n nxt = suffix[i+1]\n \n output [i] = prev * nxt\n prev = prefix[i]\n return output","runtime":"308"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n\n l_pointer = 0\n r_pointer = len(nums)-1\n\n l_prod_list = []\n r_prod_list = []\n l_prod_list.append(nums[l_pointer])\n r_prod_list.append(nums[r_pointer])\n\n for i in range(1, len(nums)):\n \n l_pointer = i\n r_pointer = len(nums) - i - 1\n\n l_prod = nums[l_pointer] * l_prod_list[i-1]\n r_prod = nums[r_pointer] * r_prod_list[i-1]\n\n l_prod_list.append(l_prod)\n r_prod_list.append(r_prod)\n\n l_pointer += 1\n r_pointer -= 1\n\n r_prod_list.reverse()\n print(\"l_prod_list: \", l_prod_list, \" r_prod_list: \", r_prod_list)\n\n result = []\n for i in range(0, len(nums)):\n\n if i == 0:\n product = r_prod_list[1]\n result.append(product)\n elif i == len(nums)-1:\n product = l_prod_list[i-1]\n result.append(product)\n else:\n product = l_prod_list[i-1] * r_prod_list[i+1]\n result.append(product)\n\n return result\n ","runtime":"308"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res=[]\n p=1\n size=len(nums)\n res=size*[1]\n \n \n for i in range(size-2,-1,-1):\n print(i)\n p=nums[i+1]*res[i+1]\n res[i]=p\n \n\n p=1\n for i in range(1,size):\n p=p*nums[i-1]\n res[i]=res[i]*p\n\n return res\n\n \n\n ","runtime":"311"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n ans = []\n prod = 1\n zeroCount = 0\n for i in range(0, len(nums)):\n if(nums[i]!=0):\n prod = prod * nums[i] \n else:\n zeroCount+=1 \n print(prod)\n for j in range(0,len(nums)):\n print(j)\n if(zeroCount>1):\n ans.append(0)\n elif(zeroCount==1):\n if(nums[j]!=0):\n ans.append(0)\n else:\n ans.append(prod)\n else:\n ans.append((int)(prod/nums[j]))\n \n return ans\n ","runtime":"311"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n lenNums = len(nums)\n L = [1] * lenNums\n R = [1] * lenNums\n res = [0] * lenNums\n for i in range(1,lenNums):\n Lprev = nums[i-1]\n Rprev = nums[-i]\n L[i] = L[i-1]*Lprev\n R[-i-1] = R[-i] * Rprev\n \n print(L)\n print(R)\n\n for i in range(0, lenNums):\n res[i] = L[i] * R[i]\n \n return res","runtime":"314"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n prefix_product = [nums[0]] + [0 for x in range(n-1)]\n suffix_product = [0 for x in range(n-1)] + [nums[-1]]\n for i in range(1, n):\n prefix_product[i] = prefix_product[i-1]*nums[i]\n suffix_product[n-i-1] = suffix_product[n-i]*nums[n-i-1] \n\n ans = [suffix_product[1]] + [0]*(n-2) + [prefix_product[-2]]\n\n for i in range(1,n-1):\n ans[i] = prefix_product[i-1]*suffix_product[i+1]\n \n return ans","runtime":"314"}],"string":"[\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \\n\\n \\n\\n \\n \\n\\n\\n \\n\\n \\n\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res, front, back, fprod, bprod = [], [], [], 1, 1\\n for i in range(len(nums)):\\n front.append(fprod)\\n fprod *= nums[i]\\n\\n for j in range(len(nums) - 1, -1, -1):\\n back.append(bprod)\\n bprod *= nums[j]\\n\\n back.reverse()\\n\\n for k in range(len(nums)):\\n res.append(front[k] * back[k])\\n\\n return res\\n \\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n s = Solution()\\n for nums in map(loads, stdin):\\n f.write(f\\\"[{','.join([str(i) for i in s.productExceptSelf(nums)])}]\\\\n\\\")\\nexit(0)\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"def product_of(nums):\\n result = 1\\n for i in nums:\\n result *= i\\n return result\\n\\ndef canCompleteCircuit(nums: List[int]) -> List[int]:\\n \\n try:\\n i_1 = nums.index(0)\\n try:\\n size = len(nums)\\n tmp = [0] * size\\n i_2 = nums.index(0, i+1)\\n return tmp\\n except:\\n size = len(nums)\\n tmp = [0] * size\\n tmp[i_1] = product_of(nums[:i_1]+nums[i_1+1:])\\n return tmp\\n except:\\n product = product_of(nums)\\n return [int(product/i) for i in nums]\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as Solution:\\n for nums in map(loads, stdin):\\n Solution.write(f\\\"{canCompleteCircuit(nums)}\\\\n\\\".replace(\\\" \\\",\\\"\\\"))\\n\\nexit()\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n count_zeros = 0\\n prod = 1\\n for n in nums:\\n if n:\\n prod *= n\\n else:\\n count_zeros += 1\\n\\n return [\\n prod if n == 0 and count_zeros == 1 else 0 if count_zeros else prod // n\\n for n in nums\\n ]\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n\\n exit(0)\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n count_zeros = 0\\n prod = 1\\n for n in nums:\\n if n:\\n prod *= n\\n if n == 0:\\n count_zeros += 1\\n\\n ans = []\\n for n in nums:\\n if count_zeros:\\n if n == 0 and count_zeros == 1:\\n ans.append(prod)\\n else:\\n ans.append(0)\\n else:\\n ans.append(prod // n)\\n return ans\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\\n\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n count_zeros = 0\\n prod = 1\\n for n in nums:\\n if n:\\n prod *= n\\n else:\\n count_zeros += 1\\n\\n return [\\n prod if n == 0 and count_zeros == 1 else 0 if count_zeros else prod // n\\n for n in nums\\n ]\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n\\n exit(0)\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"def productExceptSelf(nums: List[int]) -> List[int]:\\n prodZeros = 1\\n prodWithoutZeros = 1\\n numZeros = 0\\n for num in nums:\\n if num == 0:\\n numZeros += 1\\n \\n if numZeros > 1:\\n return [0] * len(nums)\\n\\n prodZeros *= num \\n prodWithoutZeros *= num if num != 0 else 1\\n \\n\\n return [(prodZeros // num) if num != 0 else prodWithoutZeros for num in nums ]\\n \\n\\nwith open('user.out', 'w') as f:\\n for c in map(loads, stdin):\\n print(str(productExceptSelf(c)).replace(\\\" \\\", \\\"\\\"), file=f)\\nexit(0)\\n \",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n n = len(nums)\\n a = [1] * n\\n for i in range(1, n):\\n a[i] = a[i - 1] * nums[i - 1]\\n suf = 1\\n for i in range(n - 1, -1, -1):\\n a[i] = a[i] * suf\\n suf *= nums[i]\\n return a\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \\n\\n \\n\\n \\n \\n\\n\\n \\n\\n \\n\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \\n\\n \\n\\n \\n \\n\\n\\n \\n\\n \\n\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"def productExceptSelf(nums):\\n # prefix and postfix are initialized to 1. These variables will store the product of numbers encountered so far when traversing nums in two \\n # directions (left-to-right and right-to-left).\\n prefix, postfix = 1, 1\\n answer = [1] * len(nums)\\n # First for loop (Left-to-right traversal). This loop ensures that answer[i] will have the product of all elements to the left of nums[i] \\n # after it completes.\\n for i in range(len(nums)):\\n # The current value of prefix (product of all elements before nums[i]) is multiplied with answer[i] and stored back into answer[i].\\n answer[i] *= prefix\\n # prefix is then updated by multiplying it with nums[i]. This prepares prefix to store the product of elements up to the next index.\\n prefix *= nums[i]\\n # Second for loop (Right-to-left traversal (len(nums) - 2 to 0)). After this loop finishes, answer[j] will hold the product of all elements both to the left and \\n # right of nums[j], which is the desired result.\\n for j in range(len(nums)-2, -1, -1):\\n # postfix is updated by multiplying it with nums[j+1] (i.e., the element to the right of nums[j]).\\n postfix *= nums[j+1]\\n # The current value of postfix (product of all elements after nums[j]) is multiplied with answer[j] and stored back into answer[j].\\n answer[j] *= postfix\\n return answer\\n# Checks if the script is being run as the main program. If this script is imported as a module in another script, the code block under this \\n# condition will not be executed. This is useful for code that should only run when the script is executed directly.\\nif __name__ == \\\"__main__\\\":\\n from sys import stdin\\n from json import loads\\n # Opens a file named 'user.out' as f in write mode ('w'). The 'with' statement ensures that the file is properly closed after the block of \\n # code is executed.\\n with open('user.out', 'w') as f:\\n # Iterates over each line of standard input ('stdin'). \\n # map(loads, stdin) applies the 'loads' function to each line of input. loads() parses a JSON string and converts it into a Python object.\\n # Each parsed input is assigned to the variable 'nums'\\n for nums in map(loads, stdin):\\n # For each 'nums', the 'canCompleteCircuit' function is called to compute the product of the array except itself.\\n # The result is then written to the file 'user.out', followed by a newline character ('\\\\n').\\n # replace(\\\" \\\",\\\"\\\") method replaces all spaces (\\\" \\\") in the string with nothing (\\\"\\\").\\n f.write(f\\\"{productExceptSelf(nums)}\\\\n\\\".replace(\\\" \\\",\\\"\\\"))\\n # Terminates the program with an exit status of `0`, indicating successful execution.\\n exit(0) \",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n prefixSum = [1]\\n suffixSum = [1]\\n ans = []\\n for i in range(len(nums)-1):\\n prefixSum.append(nums[i]*prefixSum[i])\\n suffixSum.append(nums[-(i+1)]*suffixSum[i])\\n for i in range(0, len(nums)):\\n ans.append(prefixSum[i]*suffixSum[-(i+1)])\\n return ans\\n \\n with open('user.out', 'w') as f:\\n for c in map(loads, stdin):\\n print(str(productExceptSelf(c)).replace(\\\" \\\", \\\"\\\"), file=f)\\n exit(0)\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \\n\\n \\n\\n \\n \\n\\n\\n \\n\\n \\n\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \\n\\n \\n\\n \\n \\n\\n\\n \\n\\n \\n\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \\n\\n \\n\\n \\n \\n\\n\\n \\n\\n \\n\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n before = [1]\\n prod = 1\\n for n in nums[:-1]:\\n prod *= n\\n before.append(prod)\\n after = [1]\\n prod = 1\\n for n in nums[::-1][:-1]:\\n prod *= n\\n after.append(prod)\\n prod = [a*b for a,b in zip(before, after[::-1])]\\n return prod\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n totalall = 1\\n index_zero = []\\n zero_more_than_one = False\\n result = []\\n for i, num in enumerate(nums):\\n if num == 0:\\n index_zero.append(i)\\n else:\\n totalall *= num\\n \\n leniz=len(index_zero)\\n\\n if leniz>1:\\n return [0 for x in range(len(nums))]\\n \\n for i, num in enumerate(nums):\\n if i in index_zero:\\n result.append(totalall)\\n elif leniz==1:\\n result.append(0)\\n else:\\n result.append(int(totalall/num))\\n return result \\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n prefixSum = [1]\\n suffixSum = [1]\\n ans = []\\n for i in range(len(nums)-1):\\n prefixSum.append(nums[i]*prefixSum[i])\\n suffixSum.append(nums[-(i+1)]*suffixSum[i])\\n for i in range(0, len(nums)):\\n ans.append(prefixSum[i]*suffixSum[-(i+1)])\\n return ans\\n \\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\",\n \"runtime\": \"95\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n res1=1\\n right=[1]\\n res=[]\\n res1,res2=1,1\\n for i in range(len(nums)-1,0,-1):\\n res1*=nums[i]\\n right.append(res1)\\n res.append(right[len(right)-1])\\n for i in range(len(nums)-1):\\n res2*=nums[i]\\n res.append(right[len(right)-i-2]*res2)\\n return res\\n\\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\",\n \"runtime\": \"95\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\\n\\n\\n \",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf( nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n \\n left = [0]*n\\n right = [0]*n\\n left_mul,right_mul = 1,1\\n\\n\\n for i in range(n):\\n j = -i-1\\n\\n left[i] = left_mul\\n right[j] = right_mul \\n\\n left_mul *= nums[i]\\n right_mul *= nums[j]\\n\\n return [k*l for k,l in zip(left,right)] \\n\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \\n\\n \\n\\n \\n \\n\\n\\n \\n\\n \\n\\n\\n\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", \\\"w\\\")\\nfor i in stdin:\\n nums = list(map(int, i.rstrip()[1:-1].split(r\\\",\\\")))\\n l = nums[0]\\n r = nums[-1]\\n ans = [1] * len(nums)\\n for i in range(1, len(nums)):\\n ans[i] = l\\n l *= nums[i]\\n for i in range(len(nums) - 2, -1, -1):\\n ans[i] *= r\\n r *= nums[i]\\n print(str(ans).replace(\\\" \\\", \\\"\\\"), file=f)\\nexit(0)\\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", \\\"w\\\")\\nfor i in stdin:\\n nums = list(map(int, i.rstrip()[1:-1].split(r\\\",\\\")))\\n l = nums[0]\\n r = nums[-1]\\n ans = [1] * len(nums)\\n for i in range(1, len(nums)):\\n ans[i] = l\\n l *= nums[i]\\n for i in range(len(nums) - 2, -1, -1):\\n ans[i] *= r\\n r *= nums[i]\\n print(str(ans).replace(\\\" \\\", \\\"\\\"), file=f)\\nexit(0)\",\n \"runtime\": \"104\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res, front, back, fprod, bprod = [], [], [], 1, 1\\n for i in range(len(nums)):\\n front.append(fprod)\\n fprod *= nums[i]\\n\\n for j in range(len(nums) - 1, -1, -1):\\n back.append(bprod)\\n bprod *= nums[j]\\n\\n back.reverse()\\n\\n for k in range(len(nums)):\\n res.append(front[k] * back[k])\\n\\n return res\\n \\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n s = Solution()\\n for temperatures in map(loads, stdin):\\n f.write(f\\\"[{','.join([str(i) for i in s.productExceptSelf(temperatures)])}]\\\\n\\\")\\nexit(0)\",\n \"runtime\": \"108\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", \\\"w\\\")\\nfor i in stdin:\\n nums = list(map(int, i.rstrip()[1:-1].split(r\\\",\\\")))\\n l = nums[0]\\n r = nums[-1]\\n ans = [1] * len(nums)\\n for i in range(1, len(nums)):\\n ans[i] = l\\n l *= nums[i]\\n for i in range(len(nums) - 2, -1, -1):\\n ans[i] *= r\\n r *= nums[i]\\n print(str(ans).replace(\\\" \\\", \\\"\\\"), file=f)\\nexit(0)\",\n \"runtime\": \"111\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n before = [1]\\n prod = 1\\n for n in nums[:-1]:\\n prod *= n\\n before.append(prod)\\n print(n)\\n after = [1]\\n prod = 1\\n for n in nums[::-1][:-1]:\\n prod *= n\\n after.append(prod)\\n prod = [a*b for a,b in zip(before, after[::-1])]\\n return prod\\n\\n f = open('user.out', 'w')\\n for i in stdin:\\n nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\n exit(0)\",\n \"runtime\": \"114\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n out = [1] * len(nums)\\n\\n pre =1 \\n for i in range(len(nums)):\\n out[i] = pre\\n pre*=nums[i]\\n post = 1\\n for i in range(len(nums)-1,-1,-1):\\n out[i] *=post\\n post*=nums[i]\\n return out \",\n \"runtime\": \"123\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n counter = nums.count(0)\\n if counter >= 2 :\\n return [0] * len(nums)\\n else :\\n product = 1\\n for x in nums:\\n if x != 0:\\n product *= x\\n if counter == 1 :\\n result = [0] * len(nums)\\n result[nums.index(0)] = product\\n if counter == 0 :\\n result = [product//x for x in nums]\\n return result\\n \",\n \"runtime\": \"127\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * (len(nums))\\n\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n postfix = 1\\n for i in range(len(nums)-1, -1, -1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n return res\\n\",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, A: List[int]) -> List[int]:\\n N = len(A)\\n p = 1\\n zcnt = 0\\n\\n for a in A:\\n if a == 0:\\n zcnt += 1\\n else:\\n p *= a\\n \\n ans = [0] * N\\n\\n if zcnt >= 2:\\n return ans\\n else:\\n for i in range(N):\\n if zcnt == 0:\\n ans[i] = p // A[i]\\n else:\\n ans[i] = p if A[i] == 0 else 0\\n \\n return ans\\n\\n\",\n \"runtime\": \"133\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n \\n res = [1] * len(nums) \\n\\n # prefix computations \\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n\\n # postfix \\n postfix = 1\\n for i in range(len(nums) - 1, -1, -1):\\n res[i] *= postfix \\n postfix *= nums[i]\\n \\n return res\",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n=len(nums)\\n ans=[]\\n res,res1=1,1\\n if(0 in nums):\\n idx=nums.index(0)\\n for i in range(n):\\n if(i==idx):\\n continue\\n res1*=nums[i]\\n ans1=[0]*n\\n ans1[idx]=res1\\n return ans1\\n else:\\n for i in nums:\\n res*=i\\n for i in nums:\\n ans.append(res//i)\\n return ans\",\n \"runtime\": \"139\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n nums_0s = nums.count(0)\\n res = [0] * len(nums)\\n\\n if nums_0s == 0:\\n prod_ = prod(nums)\\n\\n for i in range(len(nums)):\\n res[i] = prod_ // nums[i]\\n elif nums_0s == 1:\\n ind_0 = nums.index(0)\\n prod_ = 1\\n\\n for i in range(len(nums)):\\n if nums[i] != 0:\\n prod_ *= nums[i]\\n \\n res[ind_0] = prod_\\n \\n return res\\n\\n \\n return res\\n\\n\\n\\n\\n# [1,2,0,3]\\n\\n# [0,0,6,0]\\n\\n# 6\\n\\n# [1,2,0,0,3]\\n# []\",\n \"runtime\": \"142\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n res = [1] * n\\n\\n l_mult = 1\\n for i in range(n):\\n res[i] = l_mult\\n l_mult *= nums[i]\\n \\n r_mult = 1\\n for i in range(n - 1, -1 , -1):\\n res[i] *= r_mult\\n r_mult *= nums[i]\\n\\n return res\\n\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n cnt_zero = nums.count(0)\\n if cnt_zero > 1:\\n return [0] * len(nums)\\n elif cnt_zero == 1:\\n product = 1\\n for num in nums:\\n if num != 0:\\n product *= num\\n return [product if num == 0 else 0 for num in nums]\\n else:\\n product = 1\\n for num in nums:\\n product *= num\\n return [product // num for num in nums]\",\n \"runtime\": \"149\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n total_product = 1\\n zero_count = 0\\n \\n for num in nums:\\n if num != 0:\\n total_product *= num\\n else:\\n zero_count += 1\\n \\n result = []\\n \\n if zero_count > 1:\\n return [0] * len(nums)\\n \\n for num in nums:\\n if num != 0:\\n if zero_count == 1:\\n result.append(0)\\n else:\\n result.append(total_product // num)\\n else:\\n result.append(total_product)\\n \\n return result\",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = []\\n l = len(nums)\\n if 0 not in nums:\\n tp = math.prod(nums)\\n for num in nums:\\n res.append(tp//num)\\n\\n return res\\n\\n for i, n in enumerate(nums):\\n if i == 0:\\n res.append(math.prod(nums[i+1:]))\\n elif i == l-1:\\n res.append(math.prod(nums[:l-1]))\\n else:\\n res.append(math.prod(nums[i+1:]) * math.prod(nums[:i]))\\n return res\",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res=[]\\n p=math.prod(nums)\\n for i in range(len(nums)):\\n if nums[i]!=0:\\n res.append(p//nums[i])\\n else:\\n a=nums.copy()\\n a.pop(i)\\n res.append(math.prod(a))\\n return res\",\n \"runtime\": \"155\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res=[]\\n p=math.prod(nums)\\n for i in range(len(nums)):\\n if nums[i]!=0:\\n res.append(p//nums[i])\\n else :\\n a=nums.copy()\\n a.pop(i)\\n res.append(math.prod(a))\\n return res\",\n \"runtime\": \"155\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prod = 1\\n num_0 = 0\\n for n in nums:\\n if n == 0:\\n num_0 += 1\\n continue\\n prod *= n\\n if num_0 > 1:\\n return [0] * len(nums)\\n elif num_0 == 1:\\n return [prod if n == 0 else 0 for n in nums]\\n return [prod // n for n in nums]\",\n \"runtime\": \"158\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n answer = [1] * n\\n\\n left = 1\\n for i in range(n):\\n answer[i] = left\\n left *= nums[i]\\n\\n right = 1\\n for i in range(n - 1, -1, -1):\\n answer[i] *= right\\n right *= nums[i]\\n\\n return answer\\n\",\n \"runtime\": \"162\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n product= 1\\n zero_count=0\\n for num in nums:\\n if num != 0:\\n product *= num\\n else:\\n zero_count += 1\\n\\n output = []\\n for num in nums:\\n if zero_count > 1:\\n # If more than one zero, all products are zero\\n output.append(0)\\n elif zero_count == 1:\\n # If exactly one zero, only the zero element gets the product of non-zero elements\\n if num == 0:\\n output.append(product)\\n else:\\n output.append(0)\\n else:\\n # No zeroes, calculate the product normally (product divided by the current element)\\n output.append(product // num)\\n \\n return(output)\\n \",\n \"runtime\": \"165\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n # store = {}\\n # ls = []\\n # def product(new_ls):\\n # pro = 1\\n # for i in new_ls:\\n # pro *= i\\n # return pro \\n\\n # for i in nums:\\n # if i not in store:\\n # cp_ls = nums.copy()\\n # cp_ls.remove(i)\\n # re = product(cp_ls)\\n # store[i] = re\\n # else:\\n # re = store[i]\\n # ls.append(re)\\n # return ls\\n\\n n = len(nums)\\n if n == 0:\\n print([]) # Edge case: empty list\\n exit()\\n\\n # Initialize product variables\\n total_product = 1\\n zero_count = 0\\n\\n # Compute total product and count zeros\\n for num in nums:\\n if num == 0:\\n zero_count += 1\\n else:\\n total_product *= num\\n\\n # Generate result list based on zero count\\n ls = []\\n for num in nums:\\n if zero_count > 1:\\n # More than one zero: all products are zero\\n ls.append(0)\\n elif zero_count == 1:\\n # Exactly one zero: only the position with zero will have non-zero product\\n if num == 0:\\n ls.append(total_product)\\n else:\\n ls.append(0)\\n else:\\n # No zeros: standard case\\n ls.append(total_product // num)\\n return ls\",\n \"runtime\": \"168\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n=len(nums)\\n answer=[1]*n\\n prefix=1\\n for i in range(n):\\n answer[i]=prefix\\n prefix*=nums[i]\\n suffix=1\\n for i in range(n-1,-1,-1):\\n answer[i]*=suffix\\n suffix*=nums[i]\\n return answer\\n\\n \\n \",\n \"runtime\": \"171\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n preProd = 1\\n postProd = 1\\n resultArr = [0]*(len(nums))\\n\\n # fill array with preProds\\n for i in range(0, len(nums)):\\n resultArr[i] = preProd\\n preProd *= nums[i]\\n\\n # now multiple preProds by postProds\\n for i in range((len(nums) - 1), -1, -1):\\n resultArr[i] *= postProd\\n postProd *= nums[i] \\n\\n return resultArr \",\n \"runtime\": \"171\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * len(nums)\\n\\n prefix = 1\\n\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix = prefix * nums[i]\\n \\n postfix = 1\\n\\n for i in range(len(nums)-1, -1, -1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n \\n return res\\n\",\n \"runtime\": \"174\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix = 1\\n answer = [1] * len(nums)\\n for i in range(len(nums)): \\n answer[i] = prefix\\n prefix *= nums[i]\\n suffix = 1\\n for i in range(len(nums) - 1, -1, -1):\\n answer[i] *= suffix\\n suffix *= nums[i]\\n return answer\",\n \"runtime\": \"177\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n\\n n = len(nums)\\n answer = [1] * n\\n \\n # Step 1: Calculate prefix product\\n prefix = 1\\n for i in range(n):\\n answer[i] = prefix\\n prefix *= nums[i]\\n \\n # Step 2: Calculate suffix product and multiply it with the prefix product stored in answer\\n suffix = 1\\n for i in range(n - 1, -1, -1):\\n answer[i] *= suffix\\n suffix *= nums[i]\\n \\n return answer\",\n \"runtime\": \"177\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n grandprod = 1\\n zerocount = 0\\n answer = []\\n for n in nums:\\n if n == 0:\\n zerocount += 1\\n else:\\n grandprod *= n\\n \\n if zerocount > 1:\\n return [0 for _ in nums]\\n \\n if zerocount == 1:\\n for n in nums:\\n if n == 0:\\n answer.append(grandprod)\\n else:\\n answer.append(0)\\n \\n else:\\n for n in nums:\\n answer.append(grandprod//n)\\n \\n return answer\",\n \"runtime\": \"181\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n res = [1] * n\\n\\n l_mult = 1\\n for i in range(n):\\n res[i] = l_mult\\n l_mult *= nums[i]\\n\\n r_mult = 1\\n for i in range(n - 1, -1, -1):\\n res[i] *= r_mult\\n r_mult *= nums[i]\\n\\n return res\\n\\n\\n \\n\\n \",\n \"runtime\": \"184\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n tot_prod = 1\\n zeroes = 0\\n for i in nums:\\n if i == 0:\\n zeroes += 1\\n else:\\n tot_prod *= i\\n if zeroes > 1:\\n out = [0 for i in nums]\\n elif zeroes == 1:\\n out = [0 for i in nums]\\n out[nums.index(0)] = tot_prod\\n elif zeroes == 0:\\n out = [tot_prod//i for i in nums]\\n return out\\n \",\n \"runtime\": \"184\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n output = [1]*len(nums)\\n pre = 1\\n for i in range(0, len(nums)):\\n output[i] = pre\\n pre *= nums[i]\\n post = 1\\n for i in range(-1, -len(nums)-1, -1):\\n output[i] = output[i] * post\\n post *= nums[i] \\n return output\",\n \"runtime\": \"187\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n # answer = [] \\n # for i in range(len(nums)):\\n # current = nums[i]\\n # sum = 1\\n # for j in range(len(nums)): \\n # #returns an error here because this reaches the end of the list first\\n # #nums[j] is an error because we are accessing each vlaue of nums\\n # # so there is no index of 12 for example\\n # if (nums[j] != current):\\n # sum *= nums[j]\\n # answer.append(sum)\\n # return answer\\n \\n # we want to calculte all the products to teh left and right of each number in nums\\n # thus excluding the index value\\n\\n n = len(nums)\\n\\n answer = [1] * n\\n\\n # prefix\\n left = 1\\n for i in range(n):\\n answer[i] = left\\n left *= nums[i] \\n\\n\\n # suffix\\n right = 1\\n for i in range(n - 1, -1, -1):\\n answer[i] *= right\\n right *= nums[i]\\n\\n\\n return answer\",\n \"runtime\": \"187\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n product = 1 \\n zeroes = 0\\n for num in nums:\\n if num != 0:\\n product *= num\\n else:\\n zeroes += 1\\n \\n if zeroes > 1:\\n return [0]*len(nums)\\n \\n if zeroes != 0:\\n return [0 if num != 0 else int(product) for num in nums] \\n else:\\n return [int(product/num) for num in nums]\",\n \"runtime\": \"190\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prod=1\\n zeroCount=0\\n hasZero=False\\n for i in nums:\\n if(i!=0):\\n prod*=i\\n else:\\n zeroCount+=1\\n res=[]\\n for i in nums:\\n if(i==0):\\n res.append(0) if zeroCount>1 else res.append(prod)\\n elif(zeroCount>0):\\n res.append(0)\\n else:\\n res.append(prod//i)\\n return res\\n \",\n \"runtime\": \"190\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n output = []\\n\\n product = 1\\n for n in nums:\\n product *= n\\n \\n for i, n in enumerate(nums):\\n if n == 0 and product == 0:\\n one = 1\\n temp = [x for x in nums if x != 0]\\n if temp == [] or nums.count(0) >= 2:\\n one = 0\\n for x in temp:\\n one *= x\\n output.append(one)\\n else:\\n output.append(int(product / n))\\n return output\",\n \"runtime\": \"193\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums):\\n res = [0] * len(nums)\\n mul = 1\\n for num in nums:\\n if num != 0:\\n mul *= num\\n if 0 in nums:\\n if nums.count(0)<=1:\\n res[nums.index(0)] = mul\\n\\n else:\\n for i in range(len(nums)):\\n res[i] = mul // nums[i]\\n return res\\n\",\n \"runtime\": \"193\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * len(nums)\\n \\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n\\n postfix = 1\\n for i in range(len(nums)-1, -1, -1):\\n res[i] = postfix*res[i]\\n postfix *= nums[i]\\n \\n return res\\n \",\n \"runtime\": \"196\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n=len(nums)\\n product=1\\n count=0\\n product2=1\\n for i in range(n):\\n product*=nums[i]\\n for l in range(n):\\n if nums[l]==0:\\n count+=1\\n if count==1:\\n for i in range(n):\\n if nums[i]==0:\\n continue\\n else:\\n product2*=nums[i]\\n for j in range(n):\\n if nums[j]==0:\\n nums[j]=product2\\n continue\\n else:\\n nums[j]=product\\n elif count>1:\\n for i in range(n):\\n nums[i]=0\\n else:\\n for i in range(n):\\n nums[i]=product//nums[i]\\n return nums\\n\\n\\n \",\n \"runtime\": \"196\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n result = [1] * len(nums)\\n\\n prefix = 1\\n for i in range(len(nums)):\\n result[i] = prefix\\n prefix = prefix * nums[i]\\n \\n postfix = 1\\n for i in range(len(nums)-1, -1, -1):\\n result[i] = result[i] * postfix\\n postfix = postfix * nums[i]\\n\\n return result\",\n \"runtime\": \"200\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n # prefix array and suffix array, accumulation product\\n # get the product of the subarray before it, and the subarray after it by retrieving from the prefix and suffix arrays\\n # then save the product of those two values\\n\\n # this method below is really space efficient, but is a little trickier to understand\\n # essentially, the core is result[i] = prefix[i - 1] * suffix[i + 1]\\n # you first produce the prefix values and store them in result, but they're offset by 1. storing the prefix accumulation in acc\\n # i.e. result[i] = prefix[i - 1] normally\\n # then you iterate the other way, but offset one, storing the suffix accumulation in acc\\n # i.e. acc = suffix[i + 1] normally\\n # on the way back, you have access to prefix[i - 1] via results[i]\\n # and you have the suffix[i + 1] via acc\\n # so result[i] *= acc is the same as result[i] = result[i] * acc = prefix[i - 1] * suffix[i + 1]\\n\\n # not my favorite since it's trickier to read without a huge benefit (optimizing space complexity is lower priority)\\n\\n result = [1] * len(nums)\\n acc = 1\\n for i in range(len(nums)):\\n result[i] = acc\\n acc *= nums[i]\\n\\n acc = 1\\n for i in range(len(nums) - 1, -1, -1):\\n result[i] *= acc\\n acc *= nums[i]\\n \\n return result\\n\\n# nums = [1,2,3,4]\\n\\n# prefix run\\n# result = [1, 1, 2, 6]\\n\\n# suffix run, acc = 1, 4, 12, 24\\n# result = [24, 12, 8, 6]\",\n \"runtime\": \"200\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * (len(nums))\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n postfix = 1\\n for i in range(len(nums)-1,-1,-1):\\n res[i] *= postfix\\n postfix*= nums[i]\\n\\n return res\\n\\n \",\n \"runtime\": \"203\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1 for _ in range(len(nums))]\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n print(res)\\n postfix = 1\\n for i in range(len(nums)-1,-1,-1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n print(res)\\n return res\",\n \"runtime\": \"203\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n output = [0] * len(nums)\\n full_prod = 1\\n zero_count = 0\\n zero_pos = 0\\n for i, num in enumerate(nums):\\n if num == 0:\\n zero_pos = i\\n zero_count +=1\\n if zero_count > 1:\\n break\\n else:\\n full_prod *= num\\n \\n if zero_count == 1:\\n output[zero_pos] = full_prod\\n\\n elif zero_count == 0: \\n for i, num in enumerate(nums):\\n output[i] = full_prod // num\\n \\n return output\\n\\n\",\n \"runtime\": \"206\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n ans = [1]*n\\n left_product = 1\\n for i in range(n):\\n ans[i] = left_product\\n left_product *= nums[i]\\n right_product = 1\\n for i in range(n-1,-1,-1):\\n ans[i] *= right_product\\n right_product *= nums[i]\\n return ans\\n\\n \",\n \"runtime\": \"206\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums):\\n n = len(nums)\\n answer = [1] * n\\n left = 1\\n \\n for i in range(n):\\n answer[i] = left\\n left *= nums[i]\\n \\n right = 1\\n \\n for i in range(n-1, -1, -1):\\n answer[i] *= right\\n right *= nums[i]\\n \\n return answer\\n\",\n \"runtime\": \"209\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * len(nums)\\n\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n \\n suffix = 1\\n for i in range(len(nums)-1, -1, -1):\\n res[i] *= suffix\\n suffix *= nums[i]\\n\\n return res\",\n \"runtime\": \"209\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1]*(len(nums))\\n prefix = 1\\n postfix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n for i in range(len(nums)-1,-1,-1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n return res \\n \",\n \"runtime\": \"212\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n l_mult = 1\\n r_mult = 1\\n n = len(nums)\\n l_arr = [0] * n\\n r_arr = [0] * n\\n\\n for i in range(n):\\n j = -i -1\\n l_arr[i] = l_mult\\n r_arr[j] = r_mult\\n l_mult = l_mult * nums[i]\\n r_mult = r_mult * nums[j]\\n \\n return [l*r for l,r in zip(l_arr,r_arr)]\\n\\n \",\n \"runtime\": \"212\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n result=[1]*len(nums)\\n\\n prefix=1\\n for i in range(len(nums)):\\n result[i]=prefix\\n prefix*=nums[i]\\n \\n postfix=1\\n for j in range(len(nums)-1,-1,-1):\\n result[j]*=postfix\\n postfix*=nums[j]\\n return result\",\n \"runtime\": \"215\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n product = [1 for i in range(n)]\\n prefix = 1\\n for i in range(n):\\n product[i] *= prefix\\n prefix *= nums[i]\\n postfix = 1\\n for i in range(n-1,-1,-1):\\n product[i] *= postfix\\n postfix *= nums[i]\\n return product\",\n \"runtime\": \"215\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * len(nums)\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n postfix = 1\\n for i in range(len(nums)-1,-1,-1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n return res\\n \\n \",\n \"runtime\": \"219\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n output = [0] * len(nums)\\n full_prod = 1\\n zero_count = 0\\n zero_pos = 0\\n for i, num in enumerate(nums):\\n if num == 0:\\n zero_pos = i\\n zero_count +=1\\n else:\\n full_prod *= num\\n \\n\\n \\n\\n if zero_count == 1:\\n output[zero_pos] = full_prod\\n\\n elif zero_count == 0: \\n for i, num in enumerate(nums):\\n output[i] = full_prod // num\\n \\n return output\\n\\n\",\n \"runtime\": \"219\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * len(nums)\\n\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n\\n postfix = 1\\n for i in range(len(nums) -1, -1, -1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n return res\",\n \"runtime\": \"222\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n l_mult = 1\\n r_mult = 1\\n n = len(nums)\\n r_arr = [0] * n\\n l_arr = [0] *n\\n\\n for i in range(n):\\n j = -i -1\\n l_arr[i] = l_mult\\n r_arr[j] = r_mult\\n l_mult = l_mult*nums[i]\\n r_mult = r_mult*nums[j]\\n \\n\\n return [l*r for l, r in zip(l_arr, r_arr)]\\n \",\n \"runtime\": \"222\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * len(nums)\\n \\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n\\n postfix = 1\\n for i in range(len(nums)-1, 0-1, -1):\\n res[i] = postfix*res[i]\\n postfix *= nums[i]\\n print(postfix)\\n return res\\n \",\n \"runtime\": \"225\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n \\\"\\\"\\\" n=len(nums)\\n product=1\\n count=0\\n product2=1\\n for i in range(n):\\n product*=nums[i]\\n for l in range(n):\\n if nums[l]==0:\\n count+=1\\n if count==1:\\n for i in range(n):\\n if nums[i]==0:\\n continue\\n else:\\n product2*=nums[i]\\n for j in range(n):\\n if nums[j]==0:\\n nums[j]=product2\\n continue\\n else:\\n nums[j]=product\\n elif count>1:\\n for i in range(n):\\n nums[i]=0\\n else:\\n for i in range(n):\\n nums[i]=product//nums[i]\\n return nums\\\"\\\"\\\"\\n \\\"\\\"\\\" n=len(nums)\\n answer=[0]*n\\n i=0\\n k=0\\n product=1\\n while(i<n):\\n if i==k:\\n i+=1\\n continue\\n else:\\n product*=nums[i]\\n if i==n-1:\\n answer[k]=product\\n product=1\\n k+=1\\n i=0\\n i+=1\\n answer[k]=product\\n return answer\\\"\\\"\\\"\\n n=len(nums)\\n answer=[0]*n\\n left_product=1\\n right_product=1\\n for i in range(n):\\n answer[i]=left_product\\n left_product*=nums[i]\\n for j in range(n-1,-1,-1):\\n answer[j]*=right_product\\n right_product*=nums[j]\\n return answer\\n\\n \\n\\n\\n\\n \",\n \"runtime\": \"225\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n result = [1] * n\\n \\n left_product = 1\\n for i in range(n):\\n result[i] = left_product\\n left_product *= nums[i]\\n \\n right_product = 1\\n for i in range(n-1,-1,-1):\\n result[i] *= right_product\\n right_product *= nums[i] \\n\\n return result\",\n \"runtime\": \"228\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n \\n res = [1] * (len(nums))\\n\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n\\n postfix = 1\\n\\n for i in range(len(nums) -1, -1, -1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n\\n return res\",\n \"runtime\": \"228\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]: \\n res = [1] * len(nums) \\n\\n pre = 1 \\n for i in range(len(nums)): \\n res[i] = pre \\n pre *= nums[i] \\n post = 1\\n for i in range(len(nums) - 1, -1, -1): \\n res[i] *= post \\n post *= nums[i] \\n return res \\n \",\n \"runtime\": \"231\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n p = 1\\n r = []\\n c = nums.count(0)\\n\\n if c>1:\\n r = [0]*len(nums)\\n return r\\n\\n \\n if c == 1:#zero count =1 \\n for i in nums:\\n if i != 0:\\n p = p*i\\n for i in nums:\\n if i == 0:\\n r.append(p)\\n else:\\n r.append(0)\\n return r\\n\\n\\n for i in nums:\\n p = p*i\\n for i in nums:\\n r.append(p//i)\\n return r\\n \\n \\n \\n \\n\\n \",\n \"runtime\": \"231\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n output = [0] * len(nums)\\n full_prod = 1\\n zero_count = 0\\n zero_pos = 0\\n for i, num in enumerate(nums):\\n if num == 0:\\n zero_pos = i\\n zero_count +=1\\n if zero_count > 1:\\n break\\n else:\\n full_prod *= num\\n \\n if zero_count == 1:\\n output[zero_pos] = full_prod\\n\\n elif zero_count == 0: \\n for i, num in enumerate(nums):\\n output[i] = full_prod // num\\n \\n return output\\n\\n\",\n \"runtime\": \"235\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * len(nums)\\n\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n\\n postfix = 1\\n for i in range(len(nums) -1, -1, -1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n return res\",\n \"runtime\": \"235\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n result = [None] * len(nums)\\n\\n prefix_value = 1\\n\\n for x in range(len(result)):\\n result[x] = prefix_value\\n prefix_value *= nums[x]\\n\\n postfix_value = 1\\n\\n for x in range(len(result) - 1, -1, -1):\\n result[x] *= postfix_value\\n postfix_value *= nums[x]\\n \\n return result\",\n \"runtime\": \"238\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n output = []\\n\\n product = 1\\n for n in nums:\\n product *= n\\n \\n for i, n in enumerate(nums):\\n if n == 0 and product == 0:\\n one = 1\\n temp = [x for x in nums if x != 0]\\n if temp == [] or nums.count(0) >= 2:\\n one = 0\\n for x in temp:\\n one *= x\\n output.append(one)\\n else:\\n output.append(int(product / n))\\n return output\",\n \"runtime\": \"238\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n answer = [1] * len(nums)\\n\\n left = 1\\n for i in range(len(nums)):\\n answer[i] = left\\n left *= nums[i]\\n\\n right =1\\n for i in range(len(nums) -1, -1, -1):\\n answer[i] *= right\\n right *= nums[i]\\n \\n return answer\\n \\n\\n\\n\\n\",\n \"runtime\": \"241\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n res = [1] * n\\n \\n prefix = 1\\n for i in range(n):\\n res[i] = prefix\\n prefix *= nums[i]\\n \\n suffix = 1\\n for i in range(n-1, -1, -1):\\n res[i] *= suffix\\n suffix *= nums[i]\\n \\n return res\\n\",\n \"runtime\": \"244\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n output = []\\n\\n product = 1\\n for n in nums:\\n product *= n\\n \\n for i, n in enumerate(nums):\\n if n == 0 and product == 0:\\n one = 1\\n temp = [x for x in nums if x != 0]\\n if temp == [] or nums.count(0) >= 2:\\n one = 0\\n for x in temp:\\n one *= x\\n output.append(one)\\n else:\\n output.append(int(product / n))\\n return output\",\n \"runtime\": \"244\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n totmu = 1\\n toz= 1\\n c = 0\\n for i in nums:\\n if i==0:\\n c+=1\\n if c>1:\\n return [0]*len(nums)\\n answer = []\\n for i in nums:\\n totmu*=i\\n if i!=0:\\n toz*=i\\n for i in nums:\\n if i == 0:\\n answer.append(toz)\\n else:\\n answer.append(int(totmu/i))\\n return answer\\n\",\n \"runtime\": \"247\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n length, left, right = len(nums), 1, 1\\n answer = [1] * length\\n for i in range(length):\\n answer[i] *= left\\n left *= nums[i]\\n answer[length - i - 1] *= right\\n right *= nums[length - i - 1]\\n return answer\",\n \"runtime\": \"247\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n output = [0] * len(nums)\\n full_prod = 1\\n zero_count = 0\\n zero_pos = 0\\n for i, num in enumerate(nums):\\n if num == 0:\\n zero_pos = i\\n zero_count +=1\\n if zero_count > 1:\\n break\\n else:\\n full_prod *= num\\n \\n if zero_count == 1:\\n output[zero_pos] = full_prod\\n\\n elif zero_count == 0: \\n for i, num in enumerate(nums):\\n output[i] = full_prod // num\\n \\n return output\\n\\n\",\n \"runtime\": \"250\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n=len(nums)\\n prefix_product=1\\n postfix_product=1\\n result = [0]*n\\n for i in range(n):\\n result[i]=prefix_product\\n prefix_product*=nums[i]\\n for i in range(n-1,-1,-1):\\n result[i] *= postfix_product\\n postfix_product *= nums[i]\\n return result \\n\",\n \"runtime\": \"250\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * len(nums)\\n\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n\\n postfix = 1\\n for i in range(len(nums) -1, -1, -1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n return res\",\n \"runtime\": \"254\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n mul_p = [nums[0]]\\n mul_s = [nums[-1]]\\n for i in range(1,len(nums)):\\n mul_p.append(mul_p[-1]*nums[i])\\n \\n nums = nums[::-1]\\n for i in range(1,len(nums)):\\n mul_s.append(mul_s[-1]*nums[i])\\n mul_s = mul_s[::-1]\\n nums = []\\n for i in range(1,len(mul_s)-1):\\n nums.append(mul_p[i-1]*mul_s[i+1])\\n nums.append(mul_p[-2])\\n nums.insert(0,mul_s[1])\\n \\n return nums\",\n \"runtime\": \"254\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n curr = 1\\n res = [1] * n\\n\\n for i in range(n):\\n res[i] *= curr\\n curr *= nums[i]\\n\\n curr = 1\\n\\n for i in range(n-1, -1, -1):\\n res[i] *= curr\\n curr *= nums[i]\\n return res\",\n \"runtime\": \"257\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * (len(nums))\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] *= prefix\\n prefix *= nums[i]\\n postfix = 1\\n for i in range(len(nums)-1,-1,-1):\\n res[i] *= postfix\\n postfix*= nums[i]\\n\\n return res\\n\\n \",\n \"runtime\": \"257\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n left = [1] *n\\n right = [1]*n\\n res = [1]*n\\n for i in range(1, n):\\n left[i] = left[i-1] * nums[i-1]\\n \\n for i in range(n-2,-1,-1):\\n right[i] = right[i+1] * nums[i+1]\\n \\n # print(left, right)\\n \\n for i in range(n):\\n res[i] = left[i]*right[i]\\n \\n \\n return res\",\n \"runtime\": \"260\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]: \\n lprod = []\\n rprod = []\\n\\n for i in range(len(nums)): \\n if i == 0:\\n lprod.append(1)\\n rprod.append(1)\\n else:\\n lprod.append(lprod[-1] * nums[i-1])\\n rprod.append(rprod[-1] * nums[-i])\\n ans = []\\n for i in range(len(lprod)):\\n ans.append(lprod[i] * rprod[-i-1])\\n\\n return ans\",\n \"runtime\": \"260\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n answer = []\\n total = 1\\n for k in range(len(nums)):\\n total = total * nums[k]\\n for i in range(len(nums)):\\n if nums[i] != 0:\\n answer.append(int(total/nums[i]))\\n else:\\n product = 1\\n for j in range(len(nums)):\\n if i != j:\\n product = product * nums[j]\\n answer.append(int(product))\\n return answer\\n \\n \",\n \"runtime\": \"263\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prod = 1\\n zero_count = 0\\n\\n for num in nums:\\n if num == 0:\\n zero_count += 1\\n continue\\n prod *= num \\n \\n if zero_count > 1:\\n return [0] * len(nums)\\n\\n res = []\\n for num in nums:\\n new_num = None\\n if zero_count == 1:\\n new_num = 0 if num != 0 else prod\\n else:\\n new_num = prod//num\\n res.append(new_num)\\n\\n return res\",\n \"runtime\": \"263\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n left_prod = [1]\\n\\n for i in range(1, len(nums)):\\n left_prod.append(nums[i-1] * left_prod[-1])\\n \\n right_prod = 1\\n for i in range(len(nums) - 1, -1, -1):\\n left_prod[i] = left_prod[i] * right_prod\\n right_prod *= nums[i]\\n \\n return left_prod\\n\\n\\n\",\n \"runtime\": \"266\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n ans = [1] * len(nums)\\n \\n left, right = 1, 1\\n for i in range(len(nums)):\\n ans[i] *= left\\n ans[~i] *= right\\n \\n left *= nums[i]\\n right *= nums[~i]\\n \\n return ans\",\n \"runtime\": \"266\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n ans = [0] * n\\n ans[0] = 1\\n for i in range(1, n):\\n ans[i] = ans[i-1] * nums[i-1]\\n R = 1\\n for i in reversed(range(n)):\\n ans[i] = ans[i] * R\\n R *= nums[i]\\n return ans\",\n \"runtime\": \"269\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n rez=[1]*len(nums)\\n\\n #Prefix\\n for i in range(1,len(nums)):\\n rez[i]=rez[i-1]*nums[i-1]\\n\\n #Suffix\\n suffix=1\\n for i in range(len(nums)-2,-1,-1):\\n suffix*=nums[i+1]\\n rez[i]*=suffix\\n \\n return rez\",\n \"runtime\": \"269\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n totmu = 1\\n totmuwithoutzero = 1\\n if nums.count(0)>1:\\n return [0]*len(nums)\\n answer = []\\n for i in nums:\\n totmu*=i\\n if i!=0:\\n totmuwithoutzero*=i\\n for i in nums:\\n if i == 0:\\n answer.append(totmuwithoutzero)\\n else:\\n answer.append(int(totmu/i))\\n return answer\\n\",\n \"runtime\": \"273\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]: \\n lefts = []\\n rights = [0] * len(nums)\\n for i in range(len(nums)):\\n if i == 0:\\n prod = 1\\n rprod = 1\\n else:\\n prod *= nums[i-1]\\n rprod *= nums[-i]\\n lefts.append(prod)\\n rights[len(nums)-1-i] = rprod\\n\\n ans = []\\n for i in range(len(nums)):\\n ans.append(lefts[i] * rights[i])\\n\\n return ans\",\n \"runtime\": \"273\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix = [1] * len(nums)\\n suffix = [1] * len(nums)\\n\\n for i in range(1,len(nums)):\\n prefix[i] = nums[i - 1] * prefix[i - 1]\\n\\n for i in range(len(nums)-2, -1, -1):\\n suffix[i] = nums[i + 1] * suffix[i + 1]\\n\\n return [prefix[i] * suffix[i] for i in range(len(nums))] \",\n \"runtime\": \"276\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n l_mult = 1\\n r_mult = 1\\n n = len(nums)\\n l_arr = [0] * n\\n r_arr = [0] * n\\n\\n for i in range(n):\\n j = -i -1\\n l_arr[i] = l_mult\\n r_arr[j] = r_mult\\n l_mult *= nums[i]\\n r_mult *= nums[j]\\n\\n return [r*l for r, l in zip(r_arr, l_arr)]\\n \",\n \"runtime\": \"276\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n left_prod = []\\n left_product = 1\\n\\n right_product = 1\\n right_prod = []\\n\\n answer = []\\n for i in range(n):\\n if i == 0:\\n left_prod.append(1)\\n else:\\n left_product *= nums[i-1]\\n left_prod.append(left_product)\\n\\n for j in range(n-1,-1,-1):\\n if j == n-1:\\n right_prod.append(1)\\n else:\\n right_product *= nums[j+1]\\n right_prod.append(right_product)\\n\\n for k in range(n):\\n answer.append(left_prod[k] * right_prod[n-k-1])\\n return answer\\n \",\n \"runtime\": \"279\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n left_prod = []\\n left_product = 1\\n\\n right_product = 1\\n right_prod = []\\n\\n answer = []\\n for i in range(n):\\n if i == 0:\\n left_prod.append(1)\\n else:\\n left_product *= nums[i-1]\\n left_prod.append(left_product)\\n\\n for j in range(n-1,-1,-1):\\n if j == n-1:\\n right_prod.append(1)\\n else:\\n right_product *= nums[j+1]\\n right_prod.append(right_product)\\n\\n for k in range(n):\\n answer.append(left_prod[k] * right_prod[n-k-1])\\n return answer\\n \",\n \"runtime\": \"279\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n ans = [1] * len(nums)\\n \\n left, right = 1, 1\\n for i in range(len(nums)):\\n ans[i] *= left\\n ans[~i] *= right\\n \\n left *= nums[i]\\n right *= nums[~i]\\n \\n return ans\\n \\n return res\",\n \"runtime\": \"282\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n l_multi = 1\\n r_multi = 1\\n l_arr = [0] * n\\n r_arr = [0] * n\\n \\n for i in range(n):\\n j = -i -1\\n l_arr[i] = l_multi\\n r_arr[j] = r_multi\\n l_multi *= nums[i]\\n r_multi *= nums[j]\\n \\n return [l*r for l,r in zip(l_arr,r_arr)]\",\n \"runtime\": \"282\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n pre_time = [0] * len(nums)\\n suf_time = [0] * len(nums)\\n pre_time[0] = 1\\n suf_time[len(nums) - 1] = 1\\n ans = []\\n for i in range(1, len(nums)):\\n pre_time[i] = nums[i - 1] * pre_time[i - 1]\\n suf_time[len(nums) - i - 1] = nums[len(nums) - i] * suf_time[len(nums) - i]\\n for i in range(len(nums)):\\n ans.append(pre_time[i] * suf_time[i])\\n return ans\\n\\n\",\n \"runtime\": \"285\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix_mul = []\\n suffix_mul = []\\n prod_ex_self = []\\n prev = 1\\n after = 1\\n reversed_nums = nums[::-1]\\n\\n for i in range(len(nums)):\\n prev = prev * nums[i]\\n prefix_mul.append(prev)\\n\\n after = after * reversed_nums[i]\\n suffix_mul.append(after)\\n\\n suffix_mul = suffix_mul[::-1]\\n for i in range(len(nums)):\\n if i == 0:\\n prefix = 1\\n else: \\n prefix = prefix_mul[i-1]\\n\\n if i == len(nums) - 1:\\n suffix = 1\\n else: \\n suffix = suffix_mul[i+1] \\n \\n prod_ex_self.append(prefix * suffix)\\n\\n return prod_ex_self\\n \\n \",\n \"runtime\": \"285\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n answer = [1] * len(nums)\\n prefix_product = nums[0]\\n for i in range(len(nums)):\\n if i - 1 >= 0:\\n answer[i] *= prefix_product\\n prefix_product = nums[i] * prefix_product\\n suffix_product = nums[-1]\\n for i in range(len(nums) - 2, -1, -1):\\n if i + 1 != len(nums):\\n answer[i] *= suffix_product\\n suffix_product = nums[i] * suffix_product\\n return answer\",\n \"runtime\": \"289\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n pref_prod, suff_prod = 1, 1\\n prefixes = {}\\n suffixes = {}\\n for i in range(len(nums)):\\n pref_prod, suff_prod = pref_prod*nums[i], suff_prod*nums[len(nums) - i - 1]\\n prefixes[i] = pref_prod\\n suffixes[len(nums) - i - 1] = suff_prod\\n result = [suffixes[1]]\\n for i in range(1, len(nums) - 1):\\n result.append(prefixes[i-1] * suffixes[i+1])\\n result.append(prefixes[len(nums)-2])\\n return result\",\n \"runtime\": \"289\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n if n == 0:\\n return []\\n \\n prefix_products = [1] * n\\n suffix_products = [1] * n\\n result = [1] * n\\n \\n for i in range(1, n):\\n prefix_products[i] = prefix_products[i - 1] * nums[i - 1]\\n \\n for i in range(n - 2, -1, -1):\\n suffix_products[i] = suffix_products[i + 1] * nums[i + 1]\\n \\n for i in range(n):\\n result[i] = prefix_products[i] * suffix_products[i]\\n \\n return result \",\n \"runtime\": \"292\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix_mul = []\\n suffix_mul = []\\n prod_ex_self = []\\n prev = 1\\n after = 1\\n reversed_nums = nums[::-1]\\n\\n for i in range(len(nums)):\\n prev = prev * nums[i]\\n prefix_mul.append(prev)\\n\\n after = after * reversed_nums[i]\\n suffix_mul.append(after)\\n\\n suffix_mul = suffix_mul[::-1]\\n for i in range(len(nums)):\\n if i == 0:\\n prefix = 1\\n else: \\n prefix = prefix_mul[i-1]\\n\\n if i == len(nums) - 1:\\n suffix = 1\\n else: \\n suffix = suffix_mul[i+1] \\n \\n prod_ex_self.append(prefix * suffix)\\n\\n return prod_ex_self\\n \\n \",\n \"runtime\": \"292\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n left_prod = []\\n left_product = 1\\n\\n right_product = 1\\n right_prod = []\\n\\n answer = []\\n for i in range(n):\\n if i == 0:\\n left_prod.append(1)\\n else:\\n left_product *= nums[i-1]\\n left_prod.append(left_product)\\n\\n for j in range(n-1,-1,-1):\\n if j == n-1:\\n right_prod.append(1)\\n else:\\n right_product *= nums[j+1]\\n right_prod.append(right_product)\\n\\n for k in range(n):\\n answer.append(left_prod[k] * right_prod[n-k-1])\\n return answer\\n \",\n \"runtime\": \"295\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n l=[nums[0]]\\n for i in range(1,len(nums)):\\n l.append(nums[i]*l[i-1])\\n print(l)\\n\\n out=[]\\n res=nums[-1]\\n for i in range(len(l)-1,-1,-1):\\n if(i==len(l)-1):\\n out.append(l[-2])\\n elif(i==0):\\n out.append(res)\\n else:\\n out.append(l[i-1]*res)\\n res*=nums[i]\\n return out[::-1]\",\n \"runtime\": \"295\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n\\n dp = [1 if nums[i]>=0 else -1 for i in range(n)]\\n dp2 = [1 if nums[i]>=0 else -1 for i in range(n)]\\n\\n prod = nums[0]\\n for i in range(1, n):\\n dp[i]*=prod\\n prod*=nums[i]\\n \\n prod = nums[-1]\\n for i in range(n-2, -1, -1):\\n dp2[i]*=prod\\n prod*=nums[i]\\n\\n \\n ans = [1 for i in range(n)]\\n for i in range(n):\\n ans[i]=dp[i]*dp2[i]\\n return ans\\n\\n\\n\\n \",\n \"runtime\": \"298\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n left = [1]\\n right = [1]\\n answer = []\\n\\n for i in range(1,len(nums)):\\n left.append( left[i-1] * nums[i - 1])\\n \\n for i in range(1,len(nums)):\\n right.append( right[i -1] * nums[len(nums) - i])\\n \\n for i in range(0,len(nums)):\\n answer.append( left[i] * right[len(nums) - i - 1])\\n\\n \\n return answer \\n\",\n \"runtime\": \"298\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix_product = [nums[0]] * len(nums)\\n for i in range(1, len(nums)):\\n prefix_product[i] = nums[i] * prefix_product[i-1]\\n suffix_product = [nums[-1]] * len(nums)\\n for i in range(len(nums) - 2, -1, -1):\\n suffix_product[i] = nums[i] * suffix_product[i+1]\\n\\n answer = [1] * len(nums)\\n for i in range(len(nums)):\\n if i + 1 != len(nums):\\n answer[i] *= suffix_product[i + 1]\\n if i - 1 >= 0:\\n answer[i] *= prefix_product[i - 1]\\n return answer\",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n left_mult = []\\n right_mult = []\\n for i in range(len(nums)):\\n right_i = len(nums)-1-i\\n if i == 0:\\n left_mult.append(nums[i])\\n right_mult.append(nums[right_i])\\n else:\\n left_mult.append(left_mult[i-1]*nums[i])\\n right_mult.append(right_mult[i-1]*nums[right_i])\\n for i in range(len(nums)):\\n right_i = len(nums)-1-i\\n if i == 0:\\n nums[i] = right_mult[right_i-1]\\n elif i == len(nums)-1:\\n nums[i] = left_mult[i-1]\\n else:\\n nums[i] = left_mult[i-1] * right_mult[right_i-1]\\n return nums\\n\\n\\n \",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n r = [1] * len(nums)\\n for i in range(1, len(nums)):\\n r[-i-1] = r[-i] * nums[-i]\\n for i in range(1, len(nums)):\\n nums[i] *= nums[i-1]\\n r[i] *= nums[i-1]\\n print(r)\\n print(nums)\\n return r\",\n \"runtime\": \"304\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n dict_left = {}\\n dict_right = {}\\n for i in range(len(nums)):\\n if i == 0:\\n dict_left[i] = 1\\n else:\\n dict_left[i] = dict_left[i - 1] * nums[i-1]\\n for i in range(len(nums) - 1, -1, -1):\\n if i == len(nums) - 1:\\n dict_right[i] = 1\\n else:\\n dict_right[i] = dict_right[i + 1] * nums[i+1]\\n\\n res = []\\n for i in range(len(nums)):\\n res.append(dict_left[i] * dict_right[i])\\n\\n return res\",\n \"runtime\": \"304\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n prefix = [1]*n\\n prev = 1\\n for i in range(n):\\n prev = prev * nums[i]\\n prefix[i] = prev\\n suffix = [1]*n\\n prev = 1\\n for i in range(n-1, -1, -1):\\n prev = prev * nums[i]\\n suffix[i] = prev\\n print(suffix)\\n print(prefix)\\n print(nums)\\n output = [1] * n\\n prev = 1\\n for i in range(n):\\n if i == n - 1:\\n nxt = 1\\n else:\\n nxt = suffix[i+1]\\n \\n output [i] = prev * nxt\\n prev = prefix[i]\\n return output\",\n \"runtime\": \"308\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n\\n l_pointer = 0\\n r_pointer = len(nums)-1\\n\\n l_prod_list = []\\n r_prod_list = []\\n l_prod_list.append(nums[l_pointer])\\n r_prod_list.append(nums[r_pointer])\\n\\n for i in range(1, len(nums)):\\n \\n l_pointer = i\\n r_pointer = len(nums) - i - 1\\n\\n l_prod = nums[l_pointer] * l_prod_list[i-1]\\n r_prod = nums[r_pointer] * r_prod_list[i-1]\\n\\n l_prod_list.append(l_prod)\\n r_prod_list.append(r_prod)\\n\\n l_pointer += 1\\n r_pointer -= 1\\n\\n r_prod_list.reverse()\\n print(\\\"l_prod_list: \\\", l_prod_list, \\\" r_prod_list: \\\", r_prod_list)\\n\\n result = []\\n for i in range(0, len(nums)):\\n\\n if i == 0:\\n product = r_prod_list[1]\\n result.append(product)\\n elif i == len(nums)-1:\\n product = l_prod_list[i-1]\\n result.append(product)\\n else:\\n product = l_prod_list[i-1] * r_prod_list[i+1]\\n result.append(product)\\n\\n return result\\n \",\n \"runtime\": \"308\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res=[]\\n p=1\\n size=len(nums)\\n res=size*[1]\\n \\n \\n for i in range(size-2,-1,-1):\\n print(i)\\n p=nums[i+1]*res[i+1]\\n res[i]=p\\n \\n\\n p=1\\n for i in range(1,size):\\n p=p*nums[i-1]\\n res[i]=res[i]*p\\n\\n return res\\n\\n \\n\\n \",\n \"runtime\": \"311\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n ans = []\\n prod = 1\\n zeroCount = 0\\n for i in range(0, len(nums)):\\n if(nums[i]!=0):\\n prod = prod * nums[i] \\n else:\\n zeroCount+=1 \\n print(prod)\\n for j in range(0,len(nums)):\\n print(j)\\n if(zeroCount>1):\\n ans.append(0)\\n elif(zeroCount==1):\\n if(nums[j]!=0):\\n ans.append(0)\\n else:\\n ans.append(prod)\\n else:\\n ans.append((int)(prod/nums[j]))\\n \\n return ans\\n \",\n \"runtime\": \"311\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n lenNums = len(nums)\\n L = [1] * lenNums\\n R = [1] * lenNums\\n res = [0] * lenNums\\n for i in range(1,lenNums):\\n Lprev = nums[i-1]\\n Rprev = nums[-i]\\n L[i] = L[i-1]*Lprev\\n R[-i-1] = R[-i] * Rprev\\n \\n print(L)\\n print(R)\\n\\n for i in range(0, lenNums):\\n res[i] = L[i] * R[i]\\n \\n return res\",\n \"runtime\": \"314\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n prefix_product = [nums[0]] + [0 for x in range(n-1)]\\n suffix_product = [0 for x in range(n-1)] + [nums[-1]]\\n for i in range(1, n):\\n prefix_product[i] = prefix_product[i-1]*nums[i]\\n suffix_product[n-i-1] = suffix_product[n-i]*nums[n-i-1] \\n\\n ans = [suffix_product[1]] + [0]*(n-2) + [prefix_product[-2]]\\n\\n for i in range(1,n-1):\\n ans[i] = prefix_product[i-1]*suffix_product[i+1]\\n \\n return ans\",\n \"runtime\": \"314\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":135,"string":"135"},"mm_list":{"kind":"list like","value":[{"code":"def productExceptSelf(nums: List[int]) -> List[int]:\n totalWithZero = 1\n totalWithOutZero = 1\n cnt = 0\n for i in nums:\n if i == 0:\n cnt += 1 \n if cnt > 1:\n return [0] * len(nums)\n totalWithZero *= i\n if i != 0:\n totalWithOutZero *= i\n return [totalWithZero//i if i != 0 else totalWithOutZero for i in nums]\n\nwith open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(str(productExceptSelf(case)).replace(\" \",\"\")+\"\\n\")\n # print(str(productExceptSelf(case)).replace(\" \", \"\"), file=f) \n# for i in stdin:\n# nums = list(map(int,i.rstrip()[1:-1].split(r',')))\n# print(str(productExceptSelf(nums)).replace(\" \", \"\"), file=f)\n \nexit(0)\n ","memory":"19800"},{"code":"def productExceptSelf(nums):\n # prefix and postfix are initialized to 1. These variables will store the product of numbers encountered so far when traversing nums in two \n # directions (left-to-right and right-to-left).\n prefix, postfix = 1, 1\n answer = [1] * len(nums)\n # First for loop (Left-to-right traversal). This loop ensures that answer[i] will have the product of all elements to the left of nums[i] \n # after it completes.\n for i in range(len(nums)):\n # The current value of prefix (product of all elements before nums[i]) is multiplied with answer[i] and stored back into answer[i].\n answer[i] *= prefix\n # prefix is then updated by multiplying it with nums[i]. This prepares prefix to store the product of elements up to the next index.\n prefix *= nums[i]\n # Second for loop (Right-to-left traversal (len(nums) - 2 to 0)). After this loop finishes, answer[j] will hold the product of all elements both to the left and \n # right of nums[j], which is the desired result.\n for j in range(len(nums)-2, -1, -1):\n # postfix is updated by multiplying it with nums[j+1] (i.e., the element to the right of nums[j]).\n postfix *= nums[j+1]\n # The current value of postfix (product of all elements after nums[j]) is multiplied with answer[j] and stored back into answer[j].\n answer[j] *= postfix\n return answer\n# Checks if the script is being run as the main program. If this script is imported as a module in another script, the code block under this \n# condition will not be executed. This is useful for code that should only run when the script is executed directly.\nif __name__ == \"__main__\":\n from sys import stdin\n from json import loads\n # Opens a file named 'user.out' as f in write mode ('w'). The 'with' statement ensures that the file is properly closed after the block of \n # code is executed.\n with open('user.out', 'w') as f:\n # Iterates over each line of standard input ('stdin'). \n # map(loads, stdin) applies the 'loads' function to each line of input. loads() parses a JSON string and converts it into a Python object.\n # Each parsed input is assigned to the variable 'nums'\n for nums in map(loads, stdin):\n # For each 'nums', the 'canCompleteCircuit' function is called to compute the product of the array except itself.\n # The result is then written to the file 'user.out', followed by a newline character ('\\n').\n # replace(\" \",\"\") method replaces all spaces (\" \") in the string with nothing (\"\").\n f.write(f\"{productExceptSelf(nums)}\\n\".replace(\" \",\"\"))\n # Terminates the program with an exit status of `0`, indicating successful execution.\n exit(0) ","memory":"20100"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n prefixSum = [1]\n suffixSum = [1]\n ans = []\n for i in range(len(nums)-1):\n prefixSum.append(nums[i]*prefixSum[i])\n suffixSum.append(nums[-(i+1)]*suffixSum[i])\n for i in range(0, len(nums)):\n ans.append(prefixSum[i]*suffixSum[-(i+1)])\n return ans\n \n with open('user.out', 'w') as f:\n for c in map(loads, stdin):\n print(str(productExceptSelf(c)).replace(\" \", \"\"), file=f)\n exit(0)","memory":"22600"},{"code":"class Solution:\n def productExceptSelf(nums: List[int]) -> List[int]:\n prefixSum = [1]\n suffixSum = [1]\n ans = []\n for i in range(len(nums)-1):\n prefixSum.append(nums[i]*prefixSum[i])\n suffixSum.append(nums[-(i+1)]*suffixSum[i])\n for i in range(0, len(nums)):\n ans.append(prefixSum[i]*suffixSum[-(i+1)])\n return ans\n \n with open('user.out', 'w') as f:\n for c in map(loads, stdin):\n print(str(productExceptSelf(c)).replace(\" \", \"\"), file=f)\n exit(0)","memory":"22700"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n ans = [0]*len(nums)\n l=1\n ans[0]=1\n for i in range(1,len(nums)):\n l*=nums[i-1]\n ans[i]=l\n r=1\n print(ans)\n for i in range(len(nums)-2,-1,-1):\n r*=nums[i+1]\n ans[i]=ans[i]*r\n return ans","memory":"23300"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n length = len(nums)\n products = [1] * length\n for i in range(1, length):\n products[i] = products[i-1] * nums[i-1]\n\n right = nums[-1]\n for i in range(length-2, -1, -1):\n products[i] *= right\n right *= nums[i]\n \n return products\n","memory":"23700"},{"code":"class Solution:\n def productExceptSelf(self, nums: list[int]) -> list[int]:\n zero_count = 0\n zero_index = 0\n product = 1\n for i in range(len(nums)):\n if nums[i] == 0:\n zero_count += 1\n zero_index = i\n else:\n product *= nums[i]\n if zero_count > 1:\n return [0] * len(nums)\n elif zero_count == 1:\n ans = [0] * len(nums)\n ans[zero_index] = product\n return ans\n for i in range(len(nums)):\n nums[i] = product // nums[i]\n return nums","memory":"23800"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n if not nums: return []\n L = len(nums)\n\n if L < 2: return [1]\n\n res = [1] * L\n for i in range(1, L):\n res[i] *= res[i-1] * nums[i-1]\n\n rl = 1\n for i in reversed(range(0, L - 1)):\n rl *= nums[i+1]\n res[i] *= rl\n\n return res","memory":"23900"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * (len(nums))\n\n prefix = 1\n for i in range(len(nums)):\n res[i] = prefix\n prefix *= nums[i]\n postfix = 1\n for i in range(len(nums) - 1, -1, -1):\n res[i] *= postfix\n postfix *= nums[i]\n return res \n\n\n\n ","memory":"24100"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]: \n product=1\n if 0 in nums:\n if nums.count(0)>=2:\n return [0]*len(nums)\n else:\n \n for i in nums:\n if i==0:\n continue\n product*=i\n for i in range(len(nums)):\n if nums[i]==0:\n nums[i]=product\n else:\n nums[i]=0\n return nums\n for i in nums:\n product*=i\n \n for i in range(len(nums)):\n if nums[i]==0:\n nums[i]=product\n else:\n nums[i]=(product//nums[i])\n return nums\n\n\n ","memory":"24200"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n pref=1\n l=nums[:]\n r=nums[:]\n for i in range(len(nums)):\n nums[i]=pref \n pref*=l[i]\n suff=1 \n for i in range(len(nums)-1,-1,-1):\n nums[i]*=suff\n suff*=r[i]\n return nums","memory":"24300"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n total_product = 1\n zero_count = 0\n \n for num in nums:\n if num != 0:\n total_product *= num\n else:\n zero_count += 1\n \n result = []\n \n if zero_count > 1:\n return [0] * len(nums)\n \n for num in nums:\n if num != 0:\n if zero_count == 1:\n result.append(0)\n else:\n result.append(total_product // num)\n else:\n result.append(total_product)\n \n return result\n ","memory":"24400"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n # we can create two areas\n # one that represents everything on the left\n # another array that represents everything on the right\n # we are going to have a current value\n # we are going to multiply the current value by the element we are one\n # then we append it to the output\n\n # we do the same for right side except we go backwards\n # we start at the second to last element\n # have the multiplier start at 1 and each time multiply by current\n \n # set value then update for next, \n #[1,1,2,6]\n #[24,12,4,1]\n\n prefix = [0] * len(nums)\n postfix = [0] * len(nums)\n\n curr = 1\n\n for i in range(len(nums)):\n prefix[i] = curr\n curr *= nums[i]\n \n curr = 1\n\n for i in range(len(nums)-1,-1,-1):\n prefix[i] *= curr\n curr *= nums[i]\n \n\n return prefix\n\n\n","memory":"24500"},{"code":"class Solution:\n def prefixProducts(self, nums: List[int]) -> list[int]:\n prefixProducts = [nums[0]]\n\n for i in range(1,len(nums)):\n prefixProducts.append(prefixProducts[i-1] * nums[i])\n\n return prefixProducts\n\n def suffixProducts(self, nums: List[int]) -> list[int]:\n i = len(nums)-2\n suffixProducts = nums\n\n while i >= 0:\n suffixProducts[i] = suffixProducts[i]*suffixProducts[i+1]\n i -= 1\n \n return suffixProducts\n\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n if len(nums) < 2:\n return nums\n\n prefixProduct = self.prefixProducts(nums)\n suffixProduct = self.suffixProducts(nums)\n\n products = []\n\n products.append(suffixProduct[1])\n\n for i in range(1,len(nums)-1):\n products.append(prefixProduct[i-1]*suffixProduct[i+1])\n\n products.append(prefixProduct[len(nums)-2])\n\n return products\n\n\n\n ","memory":"24600"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n forward, backward = [], []\n temp = 1\n for i in nums:\n temp *= i\n forward.append(temp)\n temp = 1\n for i in reversed(nums):\n temp *= i\n backward.append(temp)\n ans = []\n for i in range(len(forward)):\n if i == 0: ans.append(backward[-2])\n elif i == len(forward) - 1: ans.append(forward[-2])\n else:\n ans.append(forward[i-1] * backward[len(backward)-i-2])\n return ans\n ","memory":"24800"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n=len(nums)\n ps=[0]*n\n ps[0]=nums[0]\n for i in range(1,len(nums)):\n ps[i] = ps[i-1]*nums[i]\n sf=[0]*n\n sf[n-1]=nums[n-1]\n for j in range(n-2,-1,-1):\n sf[j] = sf[j+1]*nums[j]\n nums[0]=sf[1]\n nums[n-1] = ps[-2]\n for k in range(1,len(nums)-1):\n nums[k] = ps[k-1]*sf[k+1]\n return nums","memory":"24900"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix, suffix = [0]*len(nums), [0]*len(nums)\n prefix[0], suffix[-1] = 1, 1\n for i in range(1, len(nums)):\n prefix[i] = prefix[i-1]*nums[i-1]\n for i in range(len(nums)-2,-1,-1):\n suffix[i] = suffix[i+1]*nums[i+1]\n for i in range(len(nums)):\n nums[i] = prefix[i]*suffix[i]\n return nums\n ","memory":"24900"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix_mul = [1]*len(nums)\n suffix_mul = [1]*len(nums)\n n = len(nums)\n prefix_mul[0] = nums[0]\n suffix_mul[n-1] = nums[n-1]\n for i in range(1,n-1):\n prefix_mul[i] = prefix_mul[i-1]*nums[i]\n suffix_mul[n-1-i] = suffix_mul[n-i]*nums[n-1-i]\n nums[0]= suffix_mul[1]\n nums[n-1] = prefix_mul[n-2]\n for i in range(n-1):\n if(i>0 and i<n-1):\n nums[i] = prefix_mul[i-1]*suffix_mul[i+1]\n \n return nums","memory":"25000"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n suffixProducts = nums.copy()\n prefixProducts = nums.copy()\n length = len(nums)\n\n # Calculate prefix products\n for i in range(length - 2):\n prefixProducts[i + 1] = prefixProducts[i] * prefixProducts[i + 1]\n\n # Calculate suffix products\n for i in range(length - 2):\n suffixProducts[length - 2 - i] = suffixProducts[length - 1 - i] * suffixProducts[length - 2 - i]\n\n # Calculate\n for i in range(length - 2):\n nums[i + 1] = prefixProducts[i] * suffixProducts[i + 2]#\n nums[0] = suffixProducts[1]\n nums[length - 1] = prefixProducts[length - 2]\n\n return nums","memory":"25000"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n product = 1\n num_zeros = 0\n for i in nums:\n if i != 0:\n product *= i\n else:\n num_zeros += 1\n \n if num_zeros == 1:\n for i, n in enumerate(nums):\n if n == 0:\n nums[i] = product\n else:\n nums[i] = 0 \n return nums\n\n if num_zeros > 1:\n for i, n in enumerate(nums):\n nums[i] = 0 \n return nums\n \n for i, n in enumerate(nums):\n nums[i] = int(product/n)\n\n return nums ","memory":"25100"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n p=1\n x=1\n c=0\n\n for i in range(len(nums)):\n if nums[i]!=0:\n\n x=x*nums[i]\n else:\n c+=1\n p*=nums[i]\n for i in range(len(nums)): \n if nums[i]!=0:\n nums[i]=p//nums[i]\n else:\n if c==1:\n nums[i]=x\n else:\n nums[i]=0\n \n return nums\n ","memory":"25100"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n=len(nums)\n product=1\n count=0\n product2=1\n for i in range(n):\n product*=nums[i]\n for l in range(n):\n if nums[l]==0:\n count+=1\n if count==1:\n for i in range(n):\n if nums[i]==0:\n continue\n else:\n product2*=nums[i]\n for j in range(n):\n if nums[j]==0:\n nums[j]=product2\n continue\n else:\n nums[j]=product\n elif count>1:\n for i in range(n):\n nums[i]=0\n else:\n for i in range(n):\n nums[i]=product//nums[i]\n return nums\n\n\n ","memory":"25200"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prod = 1\n zero = 0\n idx = -1\n for i in range(len(nums)):\n if nums[i] == 0:\n zero += 1 \n idx = i\n else:\n prod *= nums[i]\n\n if zero > 1:\n return [0]*len(nums)\n \n if zero == 1:\n arr = [0]*len(nums)\n arr[idx]=prod\n return arr\n if zero == 0:\n for i in range(len(nums)):\n nums[i] = prod//nums[i]\n return nums\n \n","memory":"25200"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n answer = [1] * n\n \n # Calculate the prefix products\n prefix = 1\n for i in range(n):\n answer[i] = prefix\n prefix *= nums[i]\n \n # Calculate the suffix products and multiply with the prefix product\n suffix = 1\n for i in range(n - 1, -1, -1):\n answer[i] *= suffix\n suffix *= nums[i]\n \n return answer\n\n ","memory":"25300"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n l = len(nums)\n pre = [1]*l\n suf = [1]*l\n\n for i in range(l):\n if i==0:\n pre[i] = 1\n else:\n pre[i] = pre[i-1] * nums[i-1]\n \n print(pre)\n \n for i in range(l-1, -1, -1):\n if i==(l-1):\n suf[i] = 1\n else:\n suf[i] = suf[i+1] * nums[i+1]\n \n print(suf)\n\n for i in range(l):\n nums[i] = pre[i] * suf[i]\n\n return nums\n ","memory":"25300"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n out = nums[:]\n prefix = nums[0]\n for i in range(1,len(nums)):\n temp = prefix\n prefix*=nums[i]\n nums[i]=temp\n print(nums)\n suffix = out[len(nums)-1]\n for i in range(len(nums)-2,0,-1):\n temp = suffix\n suffix*=out[i]\n nums[i]=nums[i]*temp\n nums[0] = suffix\n return nums\n\n ","memory":"25400"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res =[1]* len(nums)\n\n for i in range(1, len(nums)):\n res[i] = nums[i-1] * res[i-1] \n\n \n hold = 1\n\n\n for i in range(len(nums)-2, -2, -1):\n res[i+1] *= hold \n hold *= nums[i+1]\n\n\n return res","memory":"25400"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n result = [None] * len(nums)\n\n prefix_value = 1\n\n for x in range(len(result)):\n result[x] = prefix_value\n prefix_value *= nums[x]\n\n postfix_value = 1\n\n for x in range(len(result) - 1, -1, -1):\n result[x] *= postfix_value\n postfix_value *= nums[x]\n \n return result","memory":"25500"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n product = [1 for i in range(n)]\n prefix = 1\n for i in range(n):\n product[i] *= prefix\n prefix *= nums[i]\n postfix = 1\n for i in range(n-1,-1,-1):\n product[i] *= postfix\n postfix *= nums[i]\n return product","memory":"25500"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n result = [0]*n \n \n result[0] = 1\n for i in range(1, n):\n result[i] = result[i-1]*nums[i-1]\n \n right_product = 1\n for i in range(n-1, -1, -1):\n result[i] = result[i] * right_product\n right_product *= nums[i]\n return result","memory":"25600"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix = 1\n res = []\n for n in nums:\n res.append(prefix)\n prefix *= n\n\n postfix = 1\n for i in range(len(nums) - 1,-1,-1):\n res[i] *= postfix\n postfix *= nums[i]\n return res","memory":"25600"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n product = 1\n result = []\n count_zero = 0\n for i in nums:\n if i != 0:\n product *= i\n else:\n count_zero += 1\n \n for i in nums:\n if count_zero > 1:\n result.append(0)\n elif count_zero == 1:\n if i == 0:\n result.append(product)\n else:\n result.append(0)\n else:\n result.append(int(product/i))\n return result","memory":"25700"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n answer = [0] * len(nums)\n\n prefix = 1\n for i in range(len(nums)):\n answer[i] = prefix\n prefix *= nums[i]\n\n postfix = 1\n for i in range(len(nums)-1, -1, -1):\n answer[i] *= postfix\n postfix *= nums[i]\n \n return answer","memory":"25700"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n if not nums:\n return nums\n n = len(nums)\n res = [1] * n\n for i in range(1, n):\n res[i] = res[i - 1] * nums[i - 1]\n\n temp = 1\n for i in reversed(range(n-1)):\n temp *= nums[i+1]\n res[i] = temp * res[i]\n\n return res\n","memory":"25800"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res = [1] * len(nums)\n prefix = 1\n for i in range(len(nums)):\n res[i] *= prefix\n prefix *= nums[i]\n postfix = 1\n for i in range(len(nums) - 1, -1, -1):\n res[i] *= postfix\n postfix *= nums[i]\n \n return res","memory":"25800"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n mul_p = [nums[0]]\n mul_s = [nums[-1]]\n for i in range(1,len(nums)):\n mul_p.append(mul_p[-1]*nums[i])\n \n nums = nums[::-1]\n for i in range(1,len(nums)):\n mul_s.append(mul_s[-1]*nums[i])\n mul_s = mul_s[::-1]\n nums = []\n for i in range(1,len(mul_s)-1):\n nums.append(mul_p[i-1]*mul_s[i+1])\n nums.append(mul_p[-2])\n nums.insert(0,mul_s[1])\n \n return nums","memory":"25900"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n ans = [1] * n\n\n for i in range(1, n):\n ans[i] = ans[i - 1] * nums[i - 1]\n\n mult = 1\n for i in range(n - 2, -1, -1):\n mult = mult * nums[i + 1]\n ans[i] *= mult\n\n return ans","memory":"25900"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n=len(nums)\n p=[1]*n\n s=[1]*n\n for i in range(1,n):\n p[i]=p[i-1]*nums[i-1]\n for i in range(n-2,-1,-1):\n s[i]=s[i+1]*nums[i+1]\n ans=[p[i]*s[i] for i in range(n)]\n return ans\n\n \n\n ","memory":"26000"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n res=[]\n p=1\n size=len(nums)\n res=size*[1]\n \n \n for i in range(size-2,-1,-1):\n print(i)\n p=nums[i+1]*res[i+1]\n res[i]=p\n \n\n p=1\n for i in range(1,size):\n p=p*nums[i-1]\n res[i]=res[i]*p\n\n return res\n\n \n\n ","memory":"26000"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n \n prefix = [1] * n\n suffix = [1] * n\n \n for i in range(1, n):\n prefix[i] = prefix[i - 1] * nums[i - 1]\n \n for i in range(n - 2, -1, -1):\n suffix[i] = suffix[i + 1] * nums[i + 1]\n \n answer = [prefix[i] * suffix[i] for i in range(n)]\n \n return answer","memory":"26100"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix = [1] * len(nums)\n postfix = [1] * len(nums)\n res = []\n\n for i in range(1, len(nums)):\n prefix[i] = nums[i - 1] * prefix[i - 1] \n \n for i in range(len(nums) - 2, -1, -1):\n postfix[i] = nums[i + 1] * postfix[i + 1]\n\n\n for i in range(len(nums)):\n res.append(prefix[i] * postfix[i])\n \n return res\n","memory":"26100"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n prefix_mult, suffix_mult = [1] * n, [1] * n\n for i in range(1, n):\n prefix_mult[i] = prefix_mult[i - 1] * nums[i - 1]\n for i in range(n - 2, -1, -1):\n suffix_mult[i] = suffix_mult[i + 1] * nums[i + 1]\n print(prefix_mult, suffix_mult)\n answer = []\n for i in range(n):\n answer.append(prefix_mult[i] * suffix_mult[i])\n\n return answer","memory":"26200"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n n = len(nums)\n prefix_mult, suffix_mult = [1] * n, [1] * n\n for i in range(1, n):\n prefix_mult[i] = prefix_mult[i - 1] * nums[i - 1]\n for i in range(n - 2, -1, -1):\n suffix_mult[i] = suffix_mult[i + 1] * nums[i + 1]\n print(prefix_mult, suffix_mult)\n answer = []\n for i in range(n):\n answer.append(prefix_mult[i] * suffix_mult[i])\n\n return answer","memory":"26200"},{"code":"class Solution:\n def prefix_list(self, start_i, past_end_i, start_val, func):\n answers = [None] * (abs(past_end_i - start_i) + 1)\n \n is_left_to_right = int(start_i < past_end_i)\n base_i = (-1) * int(not is_left_to_right)\n \n answers[base_i] = start_val\n stepsize = 1 if is_left_to_right else -1\n for i in range(start_i, past_end_i, stepsize):\n cum_i = i + int(is_left_to_right)\n answers[cum_i] = func(answers[cum_i - stepsize], i)\n \n answers.pop(base_i)\n return answers\n\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n \n left_prefix_mults = self.prefix_list(\n 0, len(nums), 1, lambda prev, i: prev * nums[i]\n )\n right_prefix_mults = self.prefix_list(\n len(nums) - 1, -1, 1, lambda prev, i: prev * nums[i]\n )\n\n print(left_prefix_mults, right_prefix_mults)\n\n answers = []\n for i, num in enumerate(nums):\n left_ans = left_prefix_mults[i-1] if i > 0 else 1\n right_ans = right_prefix_mults[i+1] if i < len(nums) - 1 else 1\n answers.append(left_ans * right_ans)\n \n return answers","memory":"26300"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n # print(nums)\n p_sum = [1,nums[0]]\n s_sum = [0]*len(nums)\n s_sum[-1] = 1\n s_sum[-2] = nums[-1]\n for i in range(2,len(nums)):\n p_sum.append(p_sum[i-1]*nums[i-1])\n # print(p_sum)\n # print(s_sum)\n for i in range(len(s_sum)-3,-1,-1):\n s_sum[i] = s_sum[i+1]*nums[i+1]\n # print(s_sum)\n res = [p_sum[i] * s_sum[i] for i in range(len(p_sum))]\n return res\n \n ","memory":"26300"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n l = len(nums)\n prefix = [0 for i in range(l)]\n postfix = [0 for i in range(l)]\n res = [0 for i in range(l)]\n prefix[0] = nums[0]\n for i in range(1,l):\n prefix[i] = nums[i] * prefix[i-1]\n \n postfix[-1] = nums[-1]\n for i in range(l-2,-1,-1):\n postfix[i] = nums[i] * postfix[i+1]\n # print(prefix, postfix)\n for i in range(l):\n if i == 0 :\n res[i] = postfix[1]\n elif i == l-1 :\n res[i] = prefix[l-2]\n else :\n res[i] = prefix[i-1] * postfix[i+1]\n\n return res\n\n\n ","memory":"26400"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n lp ,rp = [],[]\n lr,rr = 1,1\n for i in nums:\n lr = lr*i\n lp.append(lr)\n for i in range(len(nums)-1,-1,-1):\n rr = rr*nums[i]\n rp.append(rr)\n rp = rp[::-1]\n ans = []\n ans.append(rp[1])\n for i in range(1,len(nums)-1):\n ans.append(rp[i+1]*lp[i-1])\n ans.append(lp[-2])\n return ans","memory":"26400"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n left_products = [1]\n for i, element in enumerate(nums):\n if len(left_products) == 0:\n product = 1\n else:\n product = left_products[-1] * element\n left_products.append(product)\n left_products = left_products[:-1]\n \n right_products = [1]\n for element in nums[::-1]:\n if len(right_products) == 1:\n product = nums[-1]\n else:\n product = right_products[-1] * element\n right_products.append(product)\n right_products = right_products[:-1]\n\n answer = []\n for i, element in enumerate(nums):\n left_side_len = i\n right_side_len = len(nums) - i - 1\n\n left_product = left_products[left_side_len]\n right_product = right_products[right_side_len]\n answer.append(left_product * right_product)\n \n return answer\n","memory":"26500"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix = [1]\n suffix = [1]\n ans = []\n\n for index in range(len(nums)):\n end_index = len(nums) - 1 - index \n if index != len(nums) - 1:\n prefix.append(prefix[-1] * nums[index])\n if end_index != 0:\n suffix.append(suffix[-1] * nums[end_index])\n\n for index in range(0, len(nums) ):\n ans.append(prefix[index] * suffix[len(nums) - 1 - index])\n\n return ans","memory":"26500"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix_mul = []\n suffix_mul = []\n prod_ex_self = []\n prev = 1\n after = 1\n reversed_nums = nums[::-1]\n\n for i in range(len(nums)):\n prev = prev * nums[i]\n prefix_mul.append(prev)\n\n after = after * reversed_nums[i]\n suffix_mul.append(after)\n\n suffix_mul = suffix_mul[::-1]\n for i in range(len(nums)):\n if i == 0:\n prefix = 1\n else: \n prefix = prefix_mul[i-1]\n\n if i == len(nums) - 1:\n suffix = 1\n else: \n suffix = suffix_mul[i+1] \n \n prod_ex_self.append(prefix * suffix)\n\n return prod_ex_self\n \n ","memory":"26600"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix_mul = []\n suffix_mul = []\n prod_ex_self = []\n prev = 1\n after = 1\n reversed_nums = nums[::-1]\n\n for i in range(len(nums)):\n prev = prev * nums[i]\n prefix_mul.append(prev)\n\n after = after * reversed_nums[i]\n suffix_mul.append(after)\n\n suffix_mul = suffix_mul[::-1]\n for i in range(len(nums)):\n if i == 0:\n prefix = 1\n else: \n prefix = prefix_mul[i-1]\n\n if i == len(nums) - 1:\n suffix = 1\n else: \n suffix = suffix_mul[i+1] \n \n prod_ex_self.append(prefix * suffix)\n\n return prod_ex_self\n \n ","memory":"26600"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]: \n lprod = []\n rprod = []\n\n for i in range(len(nums)): \n if i == 0:\n lprod.append(1)\n rprod.append(1)\n else:\n lprod.append(lprod[-1] * nums[i-1])\n rprod.append(rprod[-1] * nums[-i])\n ans = []\n for i in range(len(lprod)):\n ans.append(lprod[i] * rprod[-i-1])\n\n return ans","memory":"26700"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n prefix_mul = []\n suffix_mul = []\n prod_ex_self = []\n prev = 1\n after = 1\n reversed_nums = nums[::-1]\n\n for i in range(len(nums)):\n prev = prev * nums[i]\n prefix_mul.append(prev)\n\n after = after * reversed_nums[i]\n suffix_mul.append(after)\n\n suffix_mul = suffix_mul[::-1]\n for i in range(len(nums)):\n if i == 0:\n prefix = 1\n else: \n prefix = prefix_mul[i-1]\n\n if i == len(nums) - 1:\n suffix = 1\n else: \n suffix = suffix_mul[i+1] \n \n prod_ex_self.append(prefix * suffix)\n\n return prod_ex_self\n \n ","memory":"26700"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]: \n lprod = []\n rprod = []\n\n lp = rp = 1\n for i in range(len(nums)): \n if i == 0:\n lprod.append(lp)\n rprod.append(rp)\n else:\n lp *= nums[i-1]\n rp *= nums[-i]\n lprod.append(lp)\n rprod.append(rp)\n ans = []\n for i in range(len(lprod)):\n ans.append(lprod[i] * rprod[-i-1])\n\n return ans","memory":"26800"},{"code":"class Solution:\n def productExceptSelf(self, nums: List[int]) -> List[int]:\n pref = [0]*(len(nums))\n suff = [0]*(len(nums))\n res = [0]*(len(nums))\n pref[0] = nums[0]\n suff[-1] = nums[-1]\n\n for i in range(1, len(nums)):\n pref[i] = pref[i-1]*nums[i]\n for j in range(len(nums) - 2, -1, -1):\n suff[j] = suff[j+1]*nums[j]\n\n res[0] = suff[1]\n res[-1] = pref[-2]\n for j in range(1, len(nums) - 1):\n res[j] = suff[j+1]*pref[j-1]\n\n print(suff, pref)\n return(res)\n \n ","memory":"26800"}],"string":"[\n {\n \"code\": \"def productExceptSelf(nums: List[int]) -> List[int]:\\n totalWithZero = 1\\n totalWithOutZero = 1\\n cnt = 0\\n for i in nums:\\n if i == 0:\\n cnt += 1 \\n if cnt > 1:\\n return [0] * len(nums)\\n totalWithZero *= i\\n if i != 0:\\n totalWithOutZero *= i\\n return [totalWithZero//i if i != 0 else totalWithOutZero for i in nums]\\n\\nwith open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(str(productExceptSelf(case)).replace(\\\" \\\",\\\"\\\")+\\\"\\\\n\\\")\\n # print(str(productExceptSelf(case)).replace(\\\" \\\", \\\"\\\"), file=f) \\n# for i in stdin:\\n# nums = list(map(int,i.rstrip()[1:-1].split(r',')))\\n# print(str(productExceptSelf(nums)).replace(\\\" \\\", \\\"\\\"), file=f)\\n \\nexit(0)\\n \",\n \"memory\": \"19800\"\n },\n {\n \"code\": \"def productExceptSelf(nums):\\n # prefix and postfix are initialized to 1. These variables will store the product of numbers encountered so far when traversing nums in two \\n # directions (left-to-right and right-to-left).\\n prefix, postfix = 1, 1\\n answer = [1] * len(nums)\\n # First for loop (Left-to-right traversal). This loop ensures that answer[i] will have the product of all elements to the left of nums[i] \\n # after it completes.\\n for i in range(len(nums)):\\n # The current value of prefix (product of all elements before nums[i]) is multiplied with answer[i] and stored back into answer[i].\\n answer[i] *= prefix\\n # prefix is then updated by multiplying it with nums[i]. This prepares prefix to store the product of elements up to the next index.\\n prefix *= nums[i]\\n # Second for loop (Right-to-left traversal (len(nums) - 2 to 0)). After this loop finishes, answer[j] will hold the product of all elements both to the left and \\n # right of nums[j], which is the desired result.\\n for j in range(len(nums)-2, -1, -1):\\n # postfix is updated by multiplying it with nums[j+1] (i.e., the element to the right of nums[j]).\\n postfix *= nums[j+1]\\n # The current value of postfix (product of all elements after nums[j]) is multiplied with answer[j] and stored back into answer[j].\\n answer[j] *= postfix\\n return answer\\n# Checks if the script is being run as the main program. If this script is imported as a module in another script, the code block under this \\n# condition will not be executed. This is useful for code that should only run when the script is executed directly.\\nif __name__ == \\\"__main__\\\":\\n from sys import stdin\\n from json import loads\\n # Opens a file named 'user.out' as f in write mode ('w'). The 'with' statement ensures that the file is properly closed after the block of \\n # code is executed.\\n with open('user.out', 'w') as f:\\n # Iterates over each line of standard input ('stdin'). \\n # map(loads, stdin) applies the 'loads' function to each line of input. loads() parses a JSON string and converts it into a Python object.\\n # Each parsed input is assigned to the variable 'nums'\\n for nums in map(loads, stdin):\\n # For each 'nums', the 'canCompleteCircuit' function is called to compute the product of the array except itself.\\n # The result is then written to the file 'user.out', followed by a newline character ('\\\\n').\\n # replace(\\\" \\\",\\\"\\\") method replaces all spaces (\\\" \\\") in the string with nothing (\\\"\\\").\\n f.write(f\\\"{productExceptSelf(nums)}\\\\n\\\".replace(\\\" \\\",\\\"\\\"))\\n # Terminates the program with an exit status of `0`, indicating successful execution.\\n exit(0) \",\n \"memory\": \"20100\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n prefixSum = [1]\\n suffixSum = [1]\\n ans = []\\n for i in range(len(nums)-1):\\n prefixSum.append(nums[i]*prefixSum[i])\\n suffixSum.append(nums[-(i+1)]*suffixSum[i])\\n for i in range(0, len(nums)):\\n ans.append(prefixSum[i]*suffixSum[-(i+1)])\\n return ans\\n \\n with open('user.out', 'w') as f:\\n for c in map(loads, stdin):\\n print(str(productExceptSelf(c)).replace(\\\" \\\", \\\"\\\"), file=f)\\n exit(0)\",\n \"memory\": \"22600\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(nums: List[int]) -> List[int]:\\n prefixSum = [1]\\n suffixSum = [1]\\n ans = []\\n for i in range(len(nums)-1):\\n prefixSum.append(nums[i]*prefixSum[i])\\n suffixSum.append(nums[-(i+1)]*suffixSum[i])\\n for i in range(0, len(nums)):\\n ans.append(prefixSum[i]*suffixSum[-(i+1)])\\n return ans\\n \\n with open('user.out', 'w') as f:\\n for c in map(loads, stdin):\\n print(str(productExceptSelf(c)).replace(\\\" \\\", \\\"\\\"), file=f)\\n exit(0)\",\n \"memory\": \"22700\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n ans = [0]*len(nums)\\n l=1\\n ans[0]=1\\n for i in range(1,len(nums)):\\n l*=nums[i-1]\\n ans[i]=l\\n r=1\\n print(ans)\\n for i in range(len(nums)-2,-1,-1):\\n r*=nums[i+1]\\n ans[i]=ans[i]*r\\n return ans\",\n \"memory\": \"23300\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n length = len(nums)\\n products = [1] * length\\n for i in range(1, length):\\n products[i] = products[i-1] * nums[i-1]\\n\\n right = nums[-1]\\n for i in range(length-2, -1, -1):\\n products[i] *= right\\n right *= nums[i]\\n \\n return products\\n\",\n \"memory\": \"23700\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: list[int]) -> list[int]:\\n zero_count = 0\\n zero_index = 0\\n product = 1\\n for i in range(len(nums)):\\n if nums[i] == 0:\\n zero_count += 1\\n zero_index = i\\n else:\\n product *= nums[i]\\n if zero_count > 1:\\n return [0] * len(nums)\\n elif zero_count == 1:\\n ans = [0] * len(nums)\\n ans[zero_index] = product\\n return ans\\n for i in range(len(nums)):\\n nums[i] = product // nums[i]\\n return nums\",\n \"memory\": \"23800\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n if not nums: return []\\n L = len(nums)\\n\\n if L < 2: return [1]\\n\\n res = [1] * L\\n for i in range(1, L):\\n res[i] *= res[i-1] * nums[i-1]\\n\\n rl = 1\\n for i in reversed(range(0, L - 1)):\\n rl *= nums[i+1]\\n res[i] *= rl\\n\\n return res\",\n \"memory\": \"23900\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * (len(nums))\\n\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] = prefix\\n prefix *= nums[i]\\n postfix = 1\\n for i in range(len(nums) - 1, -1, -1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n return res \\n\\n\\n\\n \",\n \"memory\": \"24100\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]: \\n product=1\\n if 0 in nums:\\n if nums.count(0)>=2:\\n return [0]*len(nums)\\n else:\\n \\n for i in nums:\\n if i==0:\\n continue\\n product*=i\\n for i in range(len(nums)):\\n if nums[i]==0:\\n nums[i]=product\\n else:\\n nums[i]=0\\n return nums\\n for i in nums:\\n product*=i\\n \\n for i in range(len(nums)):\\n if nums[i]==0:\\n nums[i]=product\\n else:\\n nums[i]=(product//nums[i])\\n return nums\\n\\n\\n \",\n \"memory\": \"24200\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n pref=1\\n l=nums[:]\\n r=nums[:]\\n for i in range(len(nums)):\\n nums[i]=pref \\n pref*=l[i]\\n suff=1 \\n for i in range(len(nums)-1,-1,-1):\\n nums[i]*=suff\\n suff*=r[i]\\n return nums\",\n \"memory\": \"24300\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n total_product = 1\\n zero_count = 0\\n \\n for num in nums:\\n if num != 0:\\n total_product *= num\\n else:\\n zero_count += 1\\n \\n result = []\\n \\n if zero_count > 1:\\n return [0] * len(nums)\\n \\n for num in nums:\\n if num != 0:\\n if zero_count == 1:\\n result.append(0)\\n else:\\n result.append(total_product // num)\\n else:\\n result.append(total_product)\\n \\n return result\\n \",\n \"memory\": \"24400\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n # we can create two areas\\n # one that represents everything on the left\\n # another array that represents everything on the right\\n # we are going to have a current value\\n # we are going to multiply the current value by the element we are one\\n # then we append it to the output\\n\\n # we do the same for right side except we go backwards\\n # we start at the second to last element\\n # have the multiplier start at 1 and each time multiply by current\\n \\n # set value then update for next, \\n #[1,1,2,6]\\n #[24,12,4,1]\\n\\n prefix = [0] * len(nums)\\n postfix = [0] * len(nums)\\n\\n curr = 1\\n\\n for i in range(len(nums)):\\n prefix[i] = curr\\n curr *= nums[i]\\n \\n curr = 1\\n\\n for i in range(len(nums)-1,-1,-1):\\n prefix[i] *= curr\\n curr *= nums[i]\\n \\n\\n return prefix\\n\\n\\n\",\n \"memory\": \"24500\"\n },\n {\n \"code\": \"class Solution:\\n def prefixProducts(self, nums: List[int]) -> list[int]:\\n prefixProducts = [nums[0]]\\n\\n for i in range(1,len(nums)):\\n prefixProducts.append(prefixProducts[i-1] * nums[i])\\n\\n return prefixProducts\\n\\n def suffixProducts(self, nums: List[int]) -> list[int]:\\n i = len(nums)-2\\n suffixProducts = nums\\n\\n while i >= 0:\\n suffixProducts[i] = suffixProducts[i]*suffixProducts[i+1]\\n i -= 1\\n \\n return suffixProducts\\n\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n if len(nums) < 2:\\n return nums\\n\\n prefixProduct = self.prefixProducts(nums)\\n suffixProduct = self.suffixProducts(nums)\\n\\n products = []\\n\\n products.append(suffixProduct[1])\\n\\n for i in range(1,len(nums)-1):\\n products.append(prefixProduct[i-1]*suffixProduct[i+1])\\n\\n products.append(prefixProduct[len(nums)-2])\\n\\n return products\\n\\n\\n\\n \",\n \"memory\": \"24600\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n forward, backward = [], []\\n temp = 1\\n for i in nums:\\n temp *= i\\n forward.append(temp)\\n temp = 1\\n for i in reversed(nums):\\n temp *= i\\n backward.append(temp)\\n ans = []\\n for i in range(len(forward)):\\n if i == 0: ans.append(backward[-2])\\n elif i == len(forward) - 1: ans.append(forward[-2])\\n else:\\n ans.append(forward[i-1] * backward[len(backward)-i-2])\\n return ans\\n \",\n \"memory\": \"24800\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n=len(nums)\\n ps=[0]*n\\n ps[0]=nums[0]\\n for i in range(1,len(nums)):\\n ps[i] = ps[i-1]*nums[i]\\n sf=[0]*n\\n sf[n-1]=nums[n-1]\\n for j in range(n-2,-1,-1):\\n sf[j] = sf[j+1]*nums[j]\\n nums[0]=sf[1]\\n nums[n-1] = ps[-2]\\n for k in range(1,len(nums)-1):\\n nums[k] = ps[k-1]*sf[k+1]\\n return nums\",\n \"memory\": \"24900\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix, suffix = [0]*len(nums), [0]*len(nums)\\n prefix[0], suffix[-1] = 1, 1\\n for i in range(1, len(nums)):\\n prefix[i] = prefix[i-1]*nums[i-1]\\n for i in range(len(nums)-2,-1,-1):\\n suffix[i] = suffix[i+1]*nums[i+1]\\n for i in range(len(nums)):\\n nums[i] = prefix[i]*suffix[i]\\n return nums\\n \",\n \"memory\": \"24900\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix_mul = [1]*len(nums)\\n suffix_mul = [1]*len(nums)\\n n = len(nums)\\n prefix_mul[0] = nums[0]\\n suffix_mul[n-1] = nums[n-1]\\n for i in range(1,n-1):\\n prefix_mul[i] = prefix_mul[i-1]*nums[i]\\n suffix_mul[n-1-i] = suffix_mul[n-i]*nums[n-1-i]\\n nums[0]= suffix_mul[1]\\n nums[n-1] = prefix_mul[n-2]\\n for i in range(n-1):\\n if(i>0 and i<n-1):\\n nums[i] = prefix_mul[i-1]*suffix_mul[i+1]\\n \\n return nums\",\n \"memory\": \"25000\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n suffixProducts = nums.copy()\\n prefixProducts = nums.copy()\\n length = len(nums)\\n\\n # Calculate prefix products\\n for i in range(length - 2):\\n prefixProducts[i + 1] = prefixProducts[i] * prefixProducts[i + 1]\\n\\n # Calculate suffix products\\n for i in range(length - 2):\\n suffixProducts[length - 2 - i] = suffixProducts[length - 1 - i] * suffixProducts[length - 2 - i]\\n\\n # Calculate\\n for i in range(length - 2):\\n nums[i + 1] = prefixProducts[i] * suffixProducts[i + 2]#\\n nums[0] = suffixProducts[1]\\n nums[length - 1] = prefixProducts[length - 2]\\n\\n return nums\",\n \"memory\": \"25000\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n product = 1\\n num_zeros = 0\\n for i in nums:\\n if i != 0:\\n product *= i\\n else:\\n num_zeros += 1\\n \\n if num_zeros == 1:\\n for i, n in enumerate(nums):\\n if n == 0:\\n nums[i] = product\\n else:\\n nums[i] = 0 \\n return nums\\n\\n if num_zeros > 1:\\n for i, n in enumerate(nums):\\n nums[i] = 0 \\n return nums\\n \\n for i, n in enumerate(nums):\\n nums[i] = int(product/n)\\n\\n return nums \",\n \"memory\": \"25100\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n p=1\\n x=1\\n c=0\\n\\n for i in range(len(nums)):\\n if nums[i]!=0:\\n\\n x=x*nums[i]\\n else:\\n c+=1\\n p*=nums[i]\\n for i in range(len(nums)): \\n if nums[i]!=0:\\n nums[i]=p//nums[i]\\n else:\\n if c==1:\\n nums[i]=x\\n else:\\n nums[i]=0\\n \\n return nums\\n \",\n \"memory\": \"25100\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n=len(nums)\\n product=1\\n count=0\\n product2=1\\n for i in range(n):\\n product*=nums[i]\\n for l in range(n):\\n if nums[l]==0:\\n count+=1\\n if count==1:\\n for i in range(n):\\n if nums[i]==0:\\n continue\\n else:\\n product2*=nums[i]\\n for j in range(n):\\n if nums[j]==0:\\n nums[j]=product2\\n continue\\n else:\\n nums[j]=product\\n elif count>1:\\n for i in range(n):\\n nums[i]=0\\n else:\\n for i in range(n):\\n nums[i]=product//nums[i]\\n return nums\\n\\n\\n \",\n \"memory\": \"25200\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prod = 1\\n zero = 0\\n idx = -1\\n for i in range(len(nums)):\\n if nums[i] == 0:\\n zero += 1 \\n idx = i\\n else:\\n prod *= nums[i]\\n\\n if zero > 1:\\n return [0]*len(nums)\\n \\n if zero == 1:\\n arr = [0]*len(nums)\\n arr[idx]=prod\\n return arr\\n if zero == 0:\\n for i in range(len(nums)):\\n nums[i] = prod//nums[i]\\n return nums\\n \\n\",\n \"memory\": \"25200\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n answer = [1] * n\\n \\n # Calculate the prefix products\\n prefix = 1\\n for i in range(n):\\n answer[i] = prefix\\n prefix *= nums[i]\\n \\n # Calculate the suffix products and multiply with the prefix product\\n suffix = 1\\n for i in range(n - 1, -1, -1):\\n answer[i] *= suffix\\n suffix *= nums[i]\\n \\n return answer\\n\\n \",\n \"memory\": \"25300\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n l = len(nums)\\n pre = [1]*l\\n suf = [1]*l\\n\\n for i in range(l):\\n if i==0:\\n pre[i] = 1\\n else:\\n pre[i] = pre[i-1] * nums[i-1]\\n \\n print(pre)\\n \\n for i in range(l-1, -1, -1):\\n if i==(l-1):\\n suf[i] = 1\\n else:\\n suf[i] = suf[i+1] * nums[i+1]\\n \\n print(suf)\\n\\n for i in range(l):\\n nums[i] = pre[i] * suf[i]\\n\\n return nums\\n \",\n \"memory\": \"25300\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n out = nums[:]\\n prefix = nums[0]\\n for i in range(1,len(nums)):\\n temp = prefix\\n prefix*=nums[i]\\n nums[i]=temp\\n print(nums)\\n suffix = out[len(nums)-1]\\n for i in range(len(nums)-2,0,-1):\\n temp = suffix\\n suffix*=out[i]\\n nums[i]=nums[i]*temp\\n nums[0] = suffix\\n return nums\\n\\n \",\n \"memory\": \"25400\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res =[1]* len(nums)\\n\\n for i in range(1, len(nums)):\\n res[i] = nums[i-1] * res[i-1] \\n\\n \\n hold = 1\\n\\n\\n for i in range(len(nums)-2, -2, -1):\\n res[i+1] *= hold \\n hold *= nums[i+1]\\n\\n\\n return res\",\n \"memory\": \"25400\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n result = [None] * len(nums)\\n\\n prefix_value = 1\\n\\n for x in range(len(result)):\\n result[x] = prefix_value\\n prefix_value *= nums[x]\\n\\n postfix_value = 1\\n\\n for x in range(len(result) - 1, -1, -1):\\n result[x] *= postfix_value\\n postfix_value *= nums[x]\\n \\n return result\",\n \"memory\": \"25500\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n product = [1 for i in range(n)]\\n prefix = 1\\n for i in range(n):\\n product[i] *= prefix\\n prefix *= nums[i]\\n postfix = 1\\n for i in range(n-1,-1,-1):\\n product[i] *= postfix\\n postfix *= nums[i]\\n return product\",\n \"memory\": \"25500\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n result = [0]*n \\n \\n result[0] = 1\\n for i in range(1, n):\\n result[i] = result[i-1]*nums[i-1]\\n \\n right_product = 1\\n for i in range(n-1, -1, -1):\\n result[i] = result[i] * right_product\\n right_product *= nums[i]\\n return result\",\n \"memory\": \"25600\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix = 1\\n res = []\\n for n in nums:\\n res.append(prefix)\\n prefix *= n\\n\\n postfix = 1\\n for i in range(len(nums) - 1,-1,-1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n return res\",\n \"memory\": \"25600\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n product = 1\\n result = []\\n count_zero = 0\\n for i in nums:\\n if i != 0:\\n product *= i\\n else:\\n count_zero += 1\\n \\n for i in nums:\\n if count_zero > 1:\\n result.append(0)\\n elif count_zero == 1:\\n if i == 0:\\n result.append(product)\\n else:\\n result.append(0)\\n else:\\n result.append(int(product/i))\\n return result\",\n \"memory\": \"25700\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n answer = [0] * len(nums)\\n\\n prefix = 1\\n for i in range(len(nums)):\\n answer[i] = prefix\\n prefix *= nums[i]\\n\\n postfix = 1\\n for i in range(len(nums)-1, -1, -1):\\n answer[i] *= postfix\\n postfix *= nums[i]\\n \\n return answer\",\n \"memory\": \"25700\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n if not nums:\\n return nums\\n n = len(nums)\\n res = [1] * n\\n for i in range(1, n):\\n res[i] = res[i - 1] * nums[i - 1]\\n\\n temp = 1\\n for i in reversed(range(n-1)):\\n temp *= nums[i+1]\\n res[i] = temp * res[i]\\n\\n return res\\n\",\n \"memory\": \"25800\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res = [1] * len(nums)\\n prefix = 1\\n for i in range(len(nums)):\\n res[i] *= prefix\\n prefix *= nums[i]\\n postfix = 1\\n for i in range(len(nums) - 1, -1, -1):\\n res[i] *= postfix\\n postfix *= nums[i]\\n \\n return res\",\n \"memory\": \"25800\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n mul_p = [nums[0]]\\n mul_s = [nums[-1]]\\n for i in range(1,len(nums)):\\n mul_p.append(mul_p[-1]*nums[i])\\n \\n nums = nums[::-1]\\n for i in range(1,len(nums)):\\n mul_s.append(mul_s[-1]*nums[i])\\n mul_s = mul_s[::-1]\\n nums = []\\n for i in range(1,len(mul_s)-1):\\n nums.append(mul_p[i-1]*mul_s[i+1])\\n nums.append(mul_p[-2])\\n nums.insert(0,mul_s[1])\\n \\n return nums\",\n \"memory\": \"25900\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n ans = [1] * n\\n\\n for i in range(1, n):\\n ans[i] = ans[i - 1] * nums[i - 1]\\n\\n mult = 1\\n for i in range(n - 2, -1, -1):\\n mult = mult * nums[i + 1]\\n ans[i] *= mult\\n\\n return ans\",\n \"memory\": \"25900\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n=len(nums)\\n p=[1]*n\\n s=[1]*n\\n for i in range(1,n):\\n p[i]=p[i-1]*nums[i-1]\\n for i in range(n-2,-1,-1):\\n s[i]=s[i+1]*nums[i+1]\\n ans=[p[i]*s[i] for i in range(n)]\\n return ans\\n\\n \\n\\n \",\n \"memory\": \"26000\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n res=[]\\n p=1\\n size=len(nums)\\n res=size*[1]\\n \\n \\n for i in range(size-2,-1,-1):\\n print(i)\\n p=nums[i+1]*res[i+1]\\n res[i]=p\\n \\n\\n p=1\\n for i in range(1,size):\\n p=p*nums[i-1]\\n res[i]=res[i]*p\\n\\n return res\\n\\n \\n\\n \",\n \"memory\": \"26000\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n \\n prefix = [1] * n\\n suffix = [1] * n\\n \\n for i in range(1, n):\\n prefix[i] = prefix[i - 1] * nums[i - 1]\\n \\n for i in range(n - 2, -1, -1):\\n suffix[i] = suffix[i + 1] * nums[i + 1]\\n \\n answer = [prefix[i] * suffix[i] for i in range(n)]\\n \\n return answer\",\n \"memory\": \"26100\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix = [1] * len(nums)\\n postfix = [1] * len(nums)\\n res = []\\n\\n for i in range(1, len(nums)):\\n prefix[i] = nums[i - 1] * prefix[i - 1] \\n \\n for i in range(len(nums) - 2, -1, -1):\\n postfix[i] = nums[i + 1] * postfix[i + 1]\\n\\n\\n for i in range(len(nums)):\\n res.append(prefix[i] * postfix[i])\\n \\n return res\\n\",\n \"memory\": \"26100\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n prefix_mult, suffix_mult = [1] * n, [1] * n\\n for i in range(1, n):\\n prefix_mult[i] = prefix_mult[i - 1] * nums[i - 1]\\n for i in range(n - 2, -1, -1):\\n suffix_mult[i] = suffix_mult[i + 1] * nums[i + 1]\\n print(prefix_mult, suffix_mult)\\n answer = []\\n for i in range(n):\\n answer.append(prefix_mult[i] * suffix_mult[i])\\n\\n return answer\",\n \"memory\": \"26200\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n n = len(nums)\\n prefix_mult, suffix_mult = [1] * n, [1] * n\\n for i in range(1, n):\\n prefix_mult[i] = prefix_mult[i - 1] * nums[i - 1]\\n for i in range(n - 2, -1, -1):\\n suffix_mult[i] = suffix_mult[i + 1] * nums[i + 1]\\n print(prefix_mult, suffix_mult)\\n answer = []\\n for i in range(n):\\n answer.append(prefix_mult[i] * suffix_mult[i])\\n\\n return answer\",\n \"memory\": \"26200\"\n },\n {\n \"code\": \"class Solution:\\n def prefix_list(self, start_i, past_end_i, start_val, func):\\n answers = [None] * (abs(past_end_i - start_i) + 1)\\n \\n is_left_to_right = int(start_i < past_end_i)\\n base_i = (-1) * int(not is_left_to_right)\\n \\n answers[base_i] = start_val\\n stepsize = 1 if is_left_to_right else -1\\n for i in range(start_i, past_end_i, stepsize):\\n cum_i = i + int(is_left_to_right)\\n answers[cum_i] = func(answers[cum_i - stepsize], i)\\n \\n answers.pop(base_i)\\n return answers\\n\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n \\n left_prefix_mults = self.prefix_list(\\n 0, len(nums), 1, lambda prev, i: prev * nums[i]\\n )\\n right_prefix_mults = self.prefix_list(\\n len(nums) - 1, -1, 1, lambda prev, i: prev * nums[i]\\n )\\n\\n print(left_prefix_mults, right_prefix_mults)\\n\\n answers = []\\n for i, num in enumerate(nums):\\n left_ans = left_prefix_mults[i-1] if i > 0 else 1\\n right_ans = right_prefix_mults[i+1] if i < len(nums) - 1 else 1\\n answers.append(left_ans * right_ans)\\n \\n return answers\",\n \"memory\": \"26300\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n # print(nums)\\n p_sum = [1,nums[0]]\\n s_sum = [0]*len(nums)\\n s_sum[-1] = 1\\n s_sum[-2] = nums[-1]\\n for i in range(2,len(nums)):\\n p_sum.append(p_sum[i-1]*nums[i-1])\\n # print(p_sum)\\n # print(s_sum)\\n for i in range(len(s_sum)-3,-1,-1):\\n s_sum[i] = s_sum[i+1]*nums[i+1]\\n # print(s_sum)\\n res = [p_sum[i] * s_sum[i] for i in range(len(p_sum))]\\n return res\\n \\n \",\n \"memory\": \"26300\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n l = len(nums)\\n prefix = [0 for i in range(l)]\\n postfix = [0 for i in range(l)]\\n res = [0 for i in range(l)]\\n prefix[0] = nums[0]\\n for i in range(1,l):\\n prefix[i] = nums[i] * prefix[i-1]\\n \\n postfix[-1] = nums[-1]\\n for i in range(l-2,-1,-1):\\n postfix[i] = nums[i] * postfix[i+1]\\n # print(prefix, postfix)\\n for i in range(l):\\n if i == 0 :\\n res[i] = postfix[1]\\n elif i == l-1 :\\n res[i] = prefix[l-2]\\n else :\\n res[i] = prefix[i-1] * postfix[i+1]\\n\\n return res\\n\\n\\n \",\n \"memory\": \"26400\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n lp ,rp = [],[]\\n lr,rr = 1,1\\n for i in nums:\\n lr = lr*i\\n lp.append(lr)\\n for i in range(len(nums)-1,-1,-1):\\n rr = rr*nums[i]\\n rp.append(rr)\\n rp = rp[::-1]\\n ans = []\\n ans.append(rp[1])\\n for i in range(1,len(nums)-1):\\n ans.append(rp[i+1]*lp[i-1])\\n ans.append(lp[-2])\\n return ans\",\n \"memory\": \"26400\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n left_products = [1]\\n for i, element in enumerate(nums):\\n if len(left_products) == 0:\\n product = 1\\n else:\\n product = left_products[-1] * element\\n left_products.append(product)\\n left_products = left_products[:-1]\\n \\n right_products = [1]\\n for element in nums[::-1]:\\n if len(right_products) == 1:\\n product = nums[-1]\\n else:\\n product = right_products[-1] * element\\n right_products.append(product)\\n right_products = right_products[:-1]\\n\\n answer = []\\n for i, element in enumerate(nums):\\n left_side_len = i\\n right_side_len = len(nums) - i - 1\\n\\n left_product = left_products[left_side_len]\\n right_product = right_products[right_side_len]\\n answer.append(left_product * right_product)\\n \\n return answer\\n\",\n \"memory\": \"26500\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix = [1]\\n suffix = [1]\\n ans = []\\n\\n for index in range(len(nums)):\\n end_index = len(nums) - 1 - index \\n if index != len(nums) - 1:\\n prefix.append(prefix[-1] * nums[index])\\n if end_index != 0:\\n suffix.append(suffix[-1] * nums[end_index])\\n\\n for index in range(0, len(nums) ):\\n ans.append(prefix[index] * suffix[len(nums) - 1 - index])\\n\\n return ans\",\n \"memory\": \"26500\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix_mul = []\\n suffix_mul = []\\n prod_ex_self = []\\n prev = 1\\n after = 1\\n reversed_nums = nums[::-1]\\n\\n for i in range(len(nums)):\\n prev = prev * nums[i]\\n prefix_mul.append(prev)\\n\\n after = after * reversed_nums[i]\\n suffix_mul.append(after)\\n\\n suffix_mul = suffix_mul[::-1]\\n for i in range(len(nums)):\\n if i == 0:\\n prefix = 1\\n else: \\n prefix = prefix_mul[i-1]\\n\\n if i == len(nums) - 1:\\n suffix = 1\\n else: \\n suffix = suffix_mul[i+1] \\n \\n prod_ex_self.append(prefix * suffix)\\n\\n return prod_ex_self\\n \\n \",\n \"memory\": \"26600\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix_mul = []\\n suffix_mul = []\\n prod_ex_self = []\\n prev = 1\\n after = 1\\n reversed_nums = nums[::-1]\\n\\n for i in range(len(nums)):\\n prev = prev * nums[i]\\n prefix_mul.append(prev)\\n\\n after = after * reversed_nums[i]\\n suffix_mul.append(after)\\n\\n suffix_mul = suffix_mul[::-1]\\n for i in range(len(nums)):\\n if i == 0:\\n prefix = 1\\n else: \\n prefix = prefix_mul[i-1]\\n\\n if i == len(nums) - 1:\\n suffix = 1\\n else: \\n suffix = suffix_mul[i+1] \\n \\n prod_ex_self.append(prefix * suffix)\\n\\n return prod_ex_self\\n \\n \",\n \"memory\": \"26600\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]: \\n lprod = []\\n rprod = []\\n\\n for i in range(len(nums)): \\n if i == 0:\\n lprod.append(1)\\n rprod.append(1)\\n else:\\n lprod.append(lprod[-1] * nums[i-1])\\n rprod.append(rprod[-1] * nums[-i])\\n ans = []\\n for i in range(len(lprod)):\\n ans.append(lprod[i] * rprod[-i-1])\\n\\n return ans\",\n \"memory\": \"26700\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n prefix_mul = []\\n suffix_mul = []\\n prod_ex_self = []\\n prev = 1\\n after = 1\\n reversed_nums = nums[::-1]\\n\\n for i in range(len(nums)):\\n prev = prev * nums[i]\\n prefix_mul.append(prev)\\n\\n after = after * reversed_nums[i]\\n suffix_mul.append(after)\\n\\n suffix_mul = suffix_mul[::-1]\\n for i in range(len(nums)):\\n if i == 0:\\n prefix = 1\\n else: \\n prefix = prefix_mul[i-1]\\n\\n if i == len(nums) - 1:\\n suffix = 1\\n else: \\n suffix = suffix_mul[i+1] \\n \\n prod_ex_self.append(prefix * suffix)\\n\\n return prod_ex_self\\n \\n \",\n \"memory\": \"26700\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]: \\n lprod = []\\n rprod = []\\n\\n lp = rp = 1\\n for i in range(len(nums)): \\n if i == 0:\\n lprod.append(lp)\\n rprod.append(rp)\\n else:\\n lp *= nums[i-1]\\n rp *= nums[-i]\\n lprod.append(lp)\\n rprod.append(rp)\\n ans = []\\n for i in range(len(lprod)):\\n ans.append(lprod[i] * rprod[-i-1])\\n\\n return ans\",\n \"memory\": \"26800\"\n },\n {\n \"code\": \"class Solution:\\n def productExceptSelf(self, nums: List[int]) -> List[int]:\\n pref = [0]*(len(nums))\\n suff = [0]*(len(nums))\\n res = [0]*(len(nums))\\n pref[0] = nums[0]\\n suff[-1] = nums[-1]\\n\\n for i in range(1, len(nums)):\\n pref[i] = pref[i-1]*nums[i]\\n for j in range(len(nums) - 2, -1, -1):\\n suff[j] = suff[j+1]*nums[j]\\n\\n res[0] = suff[1]\\n res[-1] = pref[-2]\\n for j in range(1, len(nums) - 1):\\n res[j] = suff[j+1]*pref[j-1]\\n\\n print(suff, pref)\\n return(res)\\n \\n \",\n \"memory\": \"26800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":55,"string":"55"}}},{"rowIdx":63,"cells":{"question_id":{"kind":"number","value":239,"string":"239"},"name":{"kind":"string","value":"sliding-window-maximum"},"content":{"kind":"string","value":"<p>You are given an array of integers <code>nums</code>, there is a sliding window of size <code>k</code> which is moving from the very left of the array to the very right. You can only see the <code>k</code> numbers in the window. Each time the sliding window moves right by one position.</p>\n\n<p>Return <em>the max sliding window</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [1,3,-1,-3,5,3,6,7], k = 3\n<strong>Output:</strong> [3,3,5,5,6,7]\n<strong>Explanation:</strong> \nWindow position Max\n--------------- -----\n[1 3 -1] -3 5 3 6 7 <strong>3</strong>\n 1 [3 -1 -3] 5 3 6 7 <strong>3</strong>\n 1 3 [-1 -3 5] 3 6 7 <strong> 5</strong>\n 1 3 -1 [-3 5 3] 6 7 <strong>5</strong>\n 1 3 -1 -3 [5 3 6] 7 <strong>6</strong>\n 1 3 -1 -3 5 [3 6 7] <strong>7</strong>\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [1], k = 1\n<strong>Output:</strong> [1]\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>\n\t<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>\n\t<li><code>1 <= k <= nums.length</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":46.8348965386706,"string":"46.834897"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","queue","sliding-window","heap-priority-queue","monotonic-queue"],"string":"[\n \"array\",\n \"queue\",\n \"sliding-window\",\n \"heap-priority-queue\",\n \"monotonic-queue\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"249\", 0.08500000000000002], [\"266\", 0.0425], [\"283\", 0.0085], [\"301\", 0.0085], [\"318\", 0.0085], [\"335\", 0.0085], [\"352\", 0.0085], [\"369\", 0.0085], [\"386\", 0.017], [\"403\", 0.017], [\"421\", 0.0085], [\"438\", 0.017], [\"455\", 0.017], [\"472\", 0.0425], [\"489\", 0.0425], [\"506\", 0.0425], [\"523\", 0.0425], [\"541\", 0.0596], [\"558\", 0.0425], [\"575\", 0.0851], [\"592\", 0.017], [\"609\", 0.0766], [\"626\", 0.0255], [\"644\", 0.034], [\"661\", 0.1191], [\"678\", 0.0766], [\"695\", 0.1276], [\"712\", 0.0766], [\"729\", 0.0936], [\"746\", 0.1787], [\"764\", 0.1191], [\"781\", 0.2042], [\"798\", 0.2127], [\"815\", 0.1276], [\"832\", 0.2042], [\"849\", 0.2212], [\"866\", 0.2638], [\"884\", 0.4169], [\"901\", 0.2553], [\"918\", 0.2808], [\"935\", 0.3318], [\"952\", 0.4509], [\"969\", 0.4595], [\"987\", 0.4339], [\"1004\", 0.4254], [\"1021\", 0.4084], [\"1038\", 0.6381], [\"1055\", 0.4339], [\"1072\", 11.0866], [\"1089\", 17.731599999999997], [\"1107\", 18.6677], [\"1124\", 12.8052], [\"1141\", 6.985500000000001], [\"1158\", 3.658699999999999], [\"1175\", 1.7273], [\"1192\", 1.0809000000000002], [\"1209\", 0.7829], [\"1227\", 0.6976000000000001], [\"1244\", 0.5359], [\"1261\", 0.5016999999999999], [\"1278\", 0.7659999999999999], [\"1295\", 0.7573000000000001], [\"1312\", 1.0809], [\"1330\", 1.1063999999999998], [\"1347\", 0.9274], [\"1364\", 0.7400000000000001], [\"1381\", 0.6634], [\"1398\", 0.5187], [\"1415\", 0.4252000000000001], [\"1432\", 0.24660000000000004], [\"1450\", 0.21250000000000002], [\"1467\", 0.13600000000000007], [\"1484\", 0.1105], [\"1501\", 0.18700000000000006], [\"1518\", 0.27210000000000006], [\"1535\", 0.34010000000000007], [\"1552\", 0.6636], [\"1570\", 0.8678999999999999], [\"1587\", 0.672], [\"1604\", 0.7147]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"25698\", 0.0425], [\"25896\", 0.0425], [\"26093\", 0.0596], [\"26291\", 0.017], [\"26488\", 0.0085], [\"26686\", 0.0085], [\"26883\", 0.0596], [\"27081\", 0.0255], [\"27278\", 0.017], [\"27476\", 0.0085], [\"27673\", 0.0681], [\"27871\", 0.034], [\"28068\", 0.0596], [\"28266\", 0.1787], [\"28463\", 0.6126], [\"28661\", 1.2678], [\"28858\", 0.7913], [\"29056\", 1.4805], [\"29253\", 2.7908], [\"29451\", 1.472], [\"29648\", 3.514], [\"29846\", 5.7517], [\"30043\", 10.2272], [\"30241\", 9.7592], [\"30438\", 7.9639], [\"30636\", 4.5776], [\"30833\", 8.4149], [\"31031\", 5.9134], [\"31228\", 1.2422], [\"31426\", 1.1912], [\"31623\", 1.5145], [\"31821\", 1.9144], [\"32018\", 7.3258], [\"32216\", 7.9724], [\"32413\", 1.2678], [\"32611\", 1.2763], [\"32808\", 0.9444], [\"33006\", 0.2808], [\"33203\", 0.1021], [\"33401\", 0.0425], [\"33598\", 0.034], [\"33796\", 0.0255], [\"33993\", 0.0085], [\"34191\", 0.0255], [\"34388\", 0.0085], [\"34586\", 0.0085], [\"34783\", 0.034], [\"34981\", 0.034], [\"35178\", 0.034], [\"35376\", 0.0255], [\"35573\", 0.034], [\"35771\", 0.0596], [\"35968\", 0.0425], [\"36166\", 0.034], [\"36363\", 0.051], [\"36561\", 0.1191], [\"36758\", 0.034], [\"36956\", 0.07650000000000001], [\"37153\", 0.0936], [\"37351\", 0.1192], [\"37548\", 0.051000000000000004], [\"37746\", 0.1192], [\"37943\", 0.19569999999999999], [\"38141\", 0.1787], [\"38338\", 0.1617], [\"38536\", 0.3744], [\"38733\", 0.11069999999999999], [\"38931\", 0.19569999999999999], [\"39128\", 0.1361], [\"39326\", 0.059500000000000004], [\"39523\", 0.0595], [\"39721\", 0.051000000000000004], [\"39918\", 0.034], [\"40116\", 0.051000000000000004], [\"40313\", 0.051000000000000004], [\"40511\", 0.0936], [\"40708\", 0.1532], [\"40906\", 0.45089999999999997], [\"41103\", 0.7913], [\"41301\", 0.3829]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\n q = deque()\n # only keep track the biggest\n for i in range(k-1):\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans = []\n for i in range(k-1, len(nums)):\n if q and i >= q[0] + k:\n q.popleft()\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans.append(nums[q[0]])\n return ans\n it = iter(stdin)\n output = open('user.out', 'w')\n for array in it:\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\n')\n exit()\n \n ","runtime":"249"},{"code":"class Solution:\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\n q = deque()\n # only keep track the biggest\n for i in range(k-1):\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans = []\n for i in range(k-1, len(nums)):\n if q and i >= q[0] + k:\n q.popleft()\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans.append(nums[q[0]])\n return ans\n it = iter(stdin)\n output = open('user.out', 'w')\n for array in it:\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\n')\n exit()\n \n ","runtime":"249"},{"code":"class Solution:\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\n q = deque()\n # only keep track the biggest\n for i in range(k-1):\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans = []\n for i in range(k-1, len(nums)):\n if q and i >= q[0] + k:\n q.popleft()\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans.append(nums[q[0]])\n return ans\n it = iter(stdin)\n output = open('user.out', 'w')\n for array in it:\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\n')\n exit()\n \n ","runtime":"266"},{"code":"class Solution:\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\n q = deque()\n # only keep track the biggest\n for i in range(k-1):\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans = []\n for i in range(k-1, len(nums)):\n if q and i >= q[0] + k:\n q.popleft()\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans.append(nums[q[0]])\n return ans\n it = iter(stdin)\n output = open('user.out', 'w')\n for array in it:\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\n')\n exit()\n \n ","runtime":"266"},{"code":"class Solution:\n def maxSlidingWindow(nums, k):\n result = []\n max_heap = []\n counter = defaultdict(int)\n for v in nums[:k]:\n heapq.heappush(max_heap, -v)\n counter[v] += 1\n \n for i in range(k, len(nums)):\n to_add = nums[i] \n counter[nums[i-k]] -= 1\n counter[to_add] += 1\n result.append(-max_heap[0])\n heapq.heappush(max_heap, -to_add)\n while counter[-max_heap[0]] < 1:\n heapq.heappop(max_heap)\n\n result.append(-max_heap[0])\n\n return result\n\n it = iter(stdin)\n output = open('user.out', 'w')\n for array in it:\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\n')\n exit()\n \n\n\n \n \n\n ","runtime":"283"},{"code":"class Solution:\n def maxSlidingWindow(nums: list[int], k: int) -> list[int]:\n \n result = []\n max_stack = []\n \n for i in range(k-1):\n while max_stack and nums[max_stack[-1]] < nums[i]:\n max_stack.pop()\n max_stack.append(i)\n\n for i in range(k-1, len(nums)):\n if max_stack and i >= max_stack[0] + k:\n max_stack.pop(0)\n \n while max_stack and nums[max_stack[-1]] < nums[i]:\n max_stack.pop()\n \n max_stack.append(i)\n result.append(nums[max_stack[0]])\n \n return result\n\ninput_iter = iter(stdin)\noutput = open('user.out', 'w')\nfor array in input_iter:\n output.write(dumps(Solution.maxSlidingWindow(loads(array), int(next(input_iter)))).replace(' ', '') + '\\n')\nexit()\n","runtime":"301"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n \n window = deque([])\n result = []\n\n for i in range(k):\n while window and nums[i] > window[-1]:\n window.pop()\n window.append(nums[i])\n \n result.append(window[0])\n\n for i in range(k,len(nums)):\n while window and nums[i] > window[-1]:\n window.pop()\n window.append(nums[i])\n\n if nums[i-k] == window[0]:\n window.popleft()\n \n result.append(window[0])\n \n return result","runtime":"318"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n import collections\n q=collections.deque()\n r=[]\n for i in range(k):\n while q and q[-1]<nums[i]:\n q.pop()\n q.append(nums[i])\n r.append(q[0])\n for j in range(i+1,len(nums)):\n if nums[j-(i+1)]==q[0]:\n q.popleft()\n while q and q[-1]<nums[j]:\n q.pop()\n q.append(nums[j])\n r.append(q[0])\n return r\n \n","runtime":"335"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: 'List[int]', k: 'int') -> 'List[int]':\n queue = deque([])\n res = []\n for i in range(k-1):\n while queue and nums[queue[-1]] <= nums[i]:\n queue.pop()\n queue.append(i)\n for i in range(k-1, len(nums)):\n while queue and nums[queue[-1]] <= nums[i]:\n queue.pop()\n queue.append(i)\n while i - queue[0] >= k:\n queue.popleft()\n res.append(nums[queue[0]])\n return res\n\n\n\n\n\n \n \n \n ","runtime":"352"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n d = collections.deque()\n for x in range(k):\n while d and nums[d[-1]]<nums[x]:\n d.pop()\n d.append(x)\n res = [nums[d[0]]]\n #print('d-> ', d)\n for x in range(k, len(nums)):\n if d[0] == x-k:\n d.popleft()\n while d and nums[d[-1]]<nums[x]:\n d.pop()\n d.append(x)\n #print('d-> ', d)\n res.append(nums[d[0]])\n return res","runtime":"369"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n l,r=0,k-1\n ll=[]\n q=collections.deque()\n for i in range(k):\n while q and nums[i]>q[-1]:\n q.pop()\n q.append(nums[i])\n ll.append(q[0])\n for j in range(k,len(nums)):\n if nums[j-k]==q[0]:\n q.popleft()\n while q and nums[j]>q[-1]:\n q.pop()\n q.append(nums[j])\n ll.append(q[0])\n return ll\n \n\n\n \n\n ","runtime":"386"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n import collections \n q=collections.deque()\n l=[]\n for i in range(k):\n while q and nums[i]>q[-1]:\n q.pop()\n q.append(nums[i])\n l.append(q[0])\n print(q)\n for j in range(k,len(nums)):\n if nums[j-k]==q[0]:\n q.popleft()\n while q and nums[j]>q[-1]:\n q.pop()\n q.append(nums[j])\n l.append(q[0])\n return l\n \n \n\n\n \n\n ","runtime":"386"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n\n l = 1\n r = k-1\n res = []\n q = deque()\n for i in range(k):\n while q and nums[i] > q[-1]:\n q.pop()\n q.append(nums[i])\n\n for r in range(k, len(nums)):\n res.append(q[0])\n outgoing = nums[r-k]\n if outgoing == q[0]:\n q.popleft() \n while q and nums[r] > q[-1]:\n q.pop()\n q.append(nums[r])\n \n res.append(q[0]) \n return res\n\n \n \n ","runtime":"403"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n q = deque()\n for i in range(k):\n while q and nums[i] > q[-1]:\n q.pop()\n q.append(nums[i])\n\n res.append(q[0])\n l = 0\n for r in range(k, len(nums)):\n while q and nums[r] > q[-1]:\n q.pop()\n q.append(nums[r])\n\n if nums[l] == q[0]:\n q.popleft()\n res.append(q[0])\n l += 1\n return res \n\n\n","runtime":"421"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res=[]\n q=deque()\n q.append(nums[0])\n for i in range(1,k):\n while q and q[-1]<nums[i]:\n q.pop()\n q.append(nums[i])\n res.append(q[0])\n\n for i in range(k,len(nums)):\n \n # print(q)\n if q[0]==nums[i-k]:\n q.popleft()\n while q and nums[i]>q[-1]:\n q.pop()\n q.append(nums[i])\n\n res.append(q[0])\n return res\n\n# class Solution:\n# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n# res=[]\n# q=deque()\n# q.append(nums[0])\n# for i in range(1,k):\n# if nums[i] in q:\n# continue\n# if nums[i]>q[0]:\n# q.appendleft(nums[i])\n# else:\n# q.append(nums[i])\n# res.append(q[0])\n# for i in range(k,len(nums)):\n# print(q)\n# while q and nums[i]>q[-1]:\n# q.pop()\n# q.append(nums[i])\n\n# if q[0]==nums[i-k]:\n# q.popleft()\n# res.append(q[0])\n# return res\n\n# class Solution:\n# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n# q = collections.deque()\n# res, n = [], len(nums)\n# for i, j in zip(range(1 - k, n + 1 - k), range(n)):\n# if i > 0 and deque[0] == nums[i - 1]:\n# deque.popleft()\n# # 保持 deque 递减\n# while deque and deque[-1] < nums[j]:\n# deque.pop()\n# deque.append(nums[j])\n# # 记录窗口最大值\n# if i >= 0:\n# res.append(deque[0])\n# return res\n\n \n # class Solution:\n # def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # deque = collections.deque()\n # res, n = [], len(nums)\n # for i, j in zip(range(1 - k, n + 1 - k), range(n)):\n # # 删除 deque 中对应的 nums[i-1]\n # if i > 0 and deque[0] == nums[i - 1]:\n # deque.popleft()\n # # 保持 deque 递减\n # while deque and deque[-1] < nums[j]:\n # deque.pop()\n # deque.append(nums[j])\n # # 记录窗口最大值\n # if i >= 0:\n # res.append(deque[0])\n # return res\n","runtime":"438"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ret = []\n window = deque()\n\n if k > len(nums):\n k = len(nums)\n for i in range(k):\n while window and nums[i] > nums[window[-1]]:\n window.pop()\n window.append(i)\n ret.append(nums[window[0]])\n for i in range(k, len(nums)):\n while window and nums[i] > nums[window[-1]]:\n window.pop()\n if window and window[0] <= (i - k):\n window.popleft()\n window.append(i)\n ret.append(nums[window[0]])\n\n return ret","runtime":"455"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = deque()\n q.append(nums[0])\n for i in range(1, k):\n while q and q[-1] < nums[i]:\n q.pop()\n q.append(nums[i])\n res = [q[0]]\n for i in range(k, len(nums)):\n if nums[i - k] == q[0]:\n q.popleft()\n while q and q[-1] < nums[i]:\n q.pop()\n q.append(nums[i])\n res.append(q[0])\n return res","runtime":"472"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if len(nums) <= k:\n return [max(nums)]\n # [3,-1]\n moqu = deque()\n for i in range(k):\n while moqu and moqu[-1] < nums[i]:\n # For the forseeable future nums[i] could be the answer\n moqu.pop()\n moqu.append(nums[i])\n ret = [moqu[0]]\n\n for i in range(k, len(nums)):\n # See if we need to remove the top of the stack\n if moqu and moqu[0] == nums[i-k]: # remove it\n moqu.popleft()\n while moqu and moqu[-1] < nums[i]:\n moqu.pop() # Remove all the numbers from the stack which are smaller than me\n moqu.append(nums[i])\n ret.append(moqu[0])\n return ret\n \n\n ","runtime":"489"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n window = collections.deque()\n ans = []\n for i in range(k - 1):\n while window and nums[i] > window[-1]:\n window.pop()\n window.append(nums[i])\n l = 0\n for i in range(k - 1, len(nums)):\n while window and nums[i] > window[-1]:\n window.pop()\n window.append(nums[i])\n ans.append(window[0])\n if nums[l] == window[0]:\n window.popleft()\n l += 1\n return ans\n","runtime":"523"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n window = deque([])\n out = []\n\n for i in range(k):\n while window and nums[i] > window[-1]:\n window.pop()\n window.append(nums[i])\n \n out.append(window[0])\n\n for i in range(k, len(nums)):\n if window and nums[i - k] == window[0]:\n window.popleft()\n\n while window and nums[i] > window[-1]:\n window.pop()\n\n window.append(nums[i])\n\n out.append(window[0])\n \n return out","runtime":"541"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k==1:\n return nums\n \n res = []\n queue = collections.deque([])\n for i in range(k):\n while queue and nums[queue[-1]]<nums[i]:\n queue.pop()\n queue.append(i)\n res.append(nums[queue[0]])\n for i in range(k,len(nums)):\n if i-k == queue[0]:\n queue.popleft()\n while queue and nums[queue[-1]]<nums[i]:\n queue.pop()\n queue.append(i)\n res.append(nums[queue[0]])\n return res\n\n\n\n","runtime":"558"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n stack = deque([])\n results = []\n for i in range(k):\n while stack and stack[-1] < nums[i]:\n stack.pop()\n stack.append(nums[i])\n # if len(stack) == 0 or (stack and nums[i] < stack[-1]):\n # stack.append(nums[i])\n # print(nums[i], '->', stack)\n results.append(stack[0])\n for i in range(k, len(nums)):\n j = i - k\n if nums[j] == stack[0]:\n stack.popleft()\n\n while stack and stack[-1] < nums[i]:\n stack.pop()\n stack.append(nums[i])\n # if stack and stack[0] == nums[j]:\n # stack.popleft()\n\n # if len(stack) == 0 or stack and nums[i] < stack[-1]:\n # stack.append(nums[i])\n # print(nums[i], '->', stack)\n results.append(stack[0])\n return results\n \n\n\n","runtime":"575"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n q = collections.deque([])\n for idx, i in enumerate(nums):\n while q and q[-1] < i:\n q.pop()\n q.append(i)\n\n if idx >= k and q[0] == nums[idx-k]:\n q.popleft()\n\n if idx >= k - 1:\n res.append(q[0])\n return res","runtime":"592"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums or k == 0: return []\n deque = collections.deque()\n #未形成窗口\n for i in range(k):\n while deque and deque[-1] < nums[i]: ##因为生成的双端队列是要保证从左到右减小的 所以当位于队列最左端的数小于目前的num[i]时 就将它移出队列 直到出现比nums[i]更大的数\n deque.pop()\n deque.append(nums[i]) ##从右端添加上nums[i]\n res = [deque[0]] ##因为未形成窗口 这行代码实则是在比较前k个数中的最大值 因为在每一次for循环中deque[0]都是最大的\n #形成窗口后\n for i in range(k, len(nums)):\n if deque[0] == nums[i-k]: ##这两行代码看似难以理解时则十分简单：因为我们只想要当前窗口中的最大值 所以如果当前窗口中的（新的nums[i]还未加入）最大值deque[0] 是 上个窗口末尾的值nums[i - k]， 我们就将其移出 ##若不满足条件 则意味着最大值deque[0]还在新的窗口里\n deque.popleft()\n while deque and deque[-1] < nums[i]:\n deque.pop()\n deque.append(nums[i])\n res.append(deque[0])\n return res","runtime":"609"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], window_size: int) -> List[int]:\n d = deque()\n res = []\n for ix, num in enumerate(nums):\n while d and nums[d[-1]] < num:\n d.pop()\n d.append(ix)\n if d[0] == ix - window_size:\n d.popleft()\n if ix >= window_size-1:\n res.append(nums[d[0]])\n return res","runtime":"626"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # O(n) runtime, selective que\n \n maxList = []\n \n d = deque()\n \n # Initialize\n for i in range(k):\n while d and d[-1] < nums[i]:\n d.pop()\n d.append(nums[i])\n # Do sliding window\n left = 1\n right = k\n \n maxList.append(d[0])\n \n while right != len(nums):\n if nums[left-1] == d[0]:\n d.popleft()\n while d and d[-1] < nums[right]:\n d.pop() \n d.append(nums[right])\n maxList.append(d[0])\n \n left += 1\n right += 1\n \n return maxList\n \n \n ","runtime":"644"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n q = deque()\n \n for idx, num in enumerate(nums):\n\n #record the queue in descending order\n while q and q[-1]<num:\n #pop the queue until the number is in the right order\n q.pop()\n q.append(num)\n\n if idx>=k and nums[idx-k] == q[0]:\n # if the max num equals the out of index num, then should pop it\n q.popleft()\n \n if idx >= k-1:\n res.append(q[0])\n \n return res\n\n ","runtime":"644"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n #first solution is borrowed from editorial\n dq = deque()\n res = []\n \n for i in range(k):\n while dq and nums[i] >= nums[dq[-1]]:\n dq.pop()\n dq.append(i)\n\n res.append(nums[dq[0]])\n\n for i in range(k, len(nums)):\n if dq and dq[0] == i - k:\n dq.popleft()\n while dq and nums[i] >= nums[dq[-1]]:\n dq.pop()\n\n dq.append(i)\n res.append(nums[dq[0]])\n\n return res\n\n \n\n #time limit exceeds for the below approach\n left = 0\n right = k\n length = len(nums)\n output = []\n while right <= length:\n maximum = max(nums[left:right])\n output.append(maximum)\n right += 1\n left += 1\n \n return output\n","runtime":"661"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if len(nums) <= k:\n return [max(nums)]\n # [3,-1]\n moqu = deque()\n for i in range(k):\n while moqu and nums[i] > moqu[-1]:\n moqu.pop()\n moqu.append(nums[i])\n \n ret = [moqu[0]]\n for i in range(k, len(nums)):\n if moqu and nums[i-k] == moqu[0]:\n moqu.popleft()\n while moqu and nums[i] > moqu[-1]:\n moqu.pop()\n moqu.append(nums[i])\n ret.append(moqu[0])\n \n return ret\n \n\n ","runtime":"678"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n dq = deque()\n res = []\n\n for i in range(k):\n while dq and nums[i] >= nums[dq[-1]]:\n dq.pop()\n dq.append(i)\n\n res.append(nums[dq[0]])\n\n for i in range(k, len(nums)):\n if dq and dq[0] == i - k:\n dq.popleft()\n while dq and nums[i] >= nums[dq[-1]]:\n dq.pop()\n dq.append(i)\n res.append(nums[dq[0]])\n\n return res","runtime":"695"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n stack = collections.deque()\n # prcess first k\n for i in range(k):\n while stack and nums[i] > stack[-1]:\n stack.pop()\n stack.append(nums[i])\n # after this, largest value will be on position 0\n # then the second largest, third largest \n\n res = [stack[0]]\n for i in range(k, len(nums)):\n num_remove = nums[i-k]\n num_append = nums[i]\n if num_remove == stack[0]:\n stack.popleft()\n while stack and num_append > stack[-1]:\n stack.pop()\n stack.append(num_append)\n res.append(stack[0])\n # largest value will be the left most value\n\n return res\n \n ","runtime":"712"},{"code":"from collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums, k):\n q = deque()\n\n for i in range(k):\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n\n results = [nums[q[0]]]\n\n for i in range(k, len(nums)):\n if q and q[0] <= i - k:\n q.popleft()\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n results.append(nums[q[0]])\n \n return results\n","runtime":"729"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n stack = deque()\n res = []\n for idx in range(0, k-1):\n while len(stack) and nums[idx] > stack[-1]:\n stack.pop()\n stack.append(nums[idx])\n left = 0\n for right in range(k-1, len(nums)):\n while len(stack) and nums[right] > stack[-1]:\n stack.pop()\n stack.append(nums[right])\n \n \n res.append(stack[0])\n \n \n if stack[0] == nums[left]:\n stack.popleft()\n \n left += 1\n return res\n\n ","runtime":"746"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n n = len(nums)\n q = deque()\n res = []\n for i in range(k):\n while q and nums[q[-1]] <= nums[i]:\n q.pop()\n q.append(i)\n res.append(nums[q[0]])\n for i in range(k, n):\n if q and q[0] <= i-k:\n q.popleft()\n while q and nums[q[-1]] <= nums[i]:\n q.pop()\n q.append(i)\n res.append(nums[q[0]]) \n return res ","runtime":"764"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n n = len(nums)\n \n # monotonic deque method\n dq = deque()\n\n # first window\n for i in range(k):\n while dq and nums[dq[-1]] < nums[i]:\n dq.pop()\n dq.append(i)\n res.append(nums[dq[0]])\n # move to the right each time\n for i in range(k, len(nums)): # nums[i] newly added element each time\n if dq and dq[0] == i - k: # if previous id still in queue\n dq.popleft()\n while dq and nums[dq[-1]] < nums[i]:\n dq.pop()\n dq.append(i)\n res.append(nums[dq[0]])\n \n return res\n\n","runtime":"781"},{"code":"from collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n window = deque()\n for n in nums[:k]:\n while len(window) > 0 and window[-1] < n:\n window.pop()\n window.append(n)\n for last_n, n in zip(nums[:-k], nums[k:]):\n # print(f\"last_n: {last_n}, n: {n}, window: {window}\")\n tmp = window[0]\n if last_n == tmp:\n window.popleft()\n res.append(tmp)\n while len(window) > 0 and window[-1] < n:\n window.pop()\n window.append(n)\n res.append(window[0])\n return res\n","runtime":"798"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # Queue approach\n queue = deque()\n for i in range(k):\n while queue and nums[queue[-1]] <= nums[i]:\n queue.pop()\n queue.append(i)\n \n result = []\n result.append(nums[queue[0]])\n for i in range(k, len(nums)):\n if queue[0] + k <= i:\n queue.popleft()\n while queue and nums[queue[-1]] <= nums[i]:\n queue.pop()\n queue.append(i)\n result.append(nums[queue[0]])\n return result","runtime":"815"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n\n queue = deque()\n res = []\n\n for i in range(0, k):\n if i == 0:\n queue.append(i)\n elif nums[i] < nums[i -1]:\n queue.append(i)\n else:\n while queue and nums[queue[-1]] <= nums[i]:\n queue.pop()\n queue.append(i)\n \n res.append(nums[queue[0]])\n\n for i in range(k, len(nums)):\n if queue[0] < i - k + 1:\n queue.popleft()\n if nums[i] <= nums[i - 1]:\n queue.append(i)\n else:\n while queue and nums[queue[-1]] <= nums[i]:\n queue.pop()\n queue.append(i)\n \n res.append(nums[queue[0]])\n return res\n\n\n\n ","runtime":"832"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n from collections import deque\n queue = deque([])\n ans = []\n for i in range(k):\n while queue and nums[queue[-1]] <= nums[i]:\n queue.pop()\n queue.append(i)\n ans.append(nums[queue[0]])\n\n for i in range(k,len(nums)):\n if queue and queue[0] == i-k:\n queue.popleft()\n while queue and nums[queue[-1]] <= nums[i]:\n queue.pop()\n queue.append(i)\n ans.append(nums[queue[0]])\n return ans\n\n '''\n right = 0 \n window = nums[:k]\n ans = [max(nums[:k])]\n for i in range(k,len(nums)):\n window = window[1:] + [nums[i]]\n ans.append(max(window))\n \n return ans \n '''\n\n\n\n ","runtime":"849"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n from collections import deque\n res = [0] * (len(nums) - k + 1)\n queue = deque()\n\n #we use a monotonically decreasing stack\n for r in range(len(nums)):\n while queue and queue[-1] < nums[r]:\n queue.pop()\n queue.append(nums[r])\n\n\n if (r + 1) >= k:\n res[r - k + 1] = queue[0]\n if nums[r - k + 1] == queue[0]:\n queue.popleft()\n \n return res\n \n\n\n","runtime":"866"},{"code":"from collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n max_queue = deque()\n left = 0\n ans = []\n\n for right in range(k):\n while max_queue and nums[max_queue[-1]] < nums[right]:\n max_queue.pop()\n max_queue.append(right)\n \n # first element of answer array\n ans.append(nums[max_queue[0]])\n # print(max_queue)\n # print(ans)\n # sliiiide the window!\n for right in range(k, len(nums)):\n # check if the current max has fallen out of range of the sliding window\n if max_queue:\n if right - max_queue[0] >= k:\n max_queue.popleft()\n \n while max_queue and nums[max_queue[-1]] < nums[right]:\n max_queue.pop()\n \n max_queue.append(right)\n # at this point we should have a valid subarray of length k, with max at deque[0]\n ans.append(nums[max_queue[0]])\n \n return ans","runtime":"884"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ans = []\n q = deque()\n for i in range(k):\n while q and nums[i] >= nums[q[-1]]:\n q.pop()\n q.append(i)\n \n ans.append(nums[q[0]])\n\n for i in range(k, len(nums)):\n if q and q[0] == i - k:\n q.popleft()\n while q and nums[i] >= nums[q[-1]]:\n q.pop()\n \n q.append(i)\n ans.append(nums[q[0]])\n\n return ans","runtime":"901"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = deque() #monotonic decreasing q\n l = 0\n res = []\n for i,n in enumerate(nums):\n while q and n > nums[q[-1]]:\n q.pop()\n q.append(i)\n\n if l > q[0]:\n q.popleft()\n \n if (i+1) >= k:\n res.append(nums[q[0]])\n l+=1\n return res\n\n","runtime":"918"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n queue = deque()\n result = []\n n = len(nums)\n for i in range(k):\n while queue and nums[queue[-1]] < nums[i]:\n queue.pop()\n queue.append(i)\n result.append(nums[queue[0]])\n\n for i in range(k,n):\n if queue and queue[0] <= i-k:\n queue.popleft()\n while queue and nums[queue[-1]] < nums[i]:\n queue.pop()\n queue.append(i)\n\n result.append(nums[queue[0]])\n\n return result","runtime":"935"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ret=[]\n q = deque()\n for i in range(len(nums)):\n num = nums[i]\n while q and q[-1] < num:\n q.pop()\n q.append(num)\n\n if i >= k and q[0] == nums[i-k]:\n q.popleft()\n if i >= k -1:\n ret.append(q[0])\n return ret\n\n \n ","runtime":"952"},{"code":"from collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n queue = deque()\n res = []\n\n for idx, val in enumerate(nums):\n while queue and queue[-1] < val:\n queue.pop()\n\n queue.append(val)\n if idx >= k and queue[0] == nums[idx - k]:\n queue.popleft()\n\n if idx >= k - 1:\n res.append(queue[0])\n\n return res\n","runtime":"969"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n buffer = deque()\n\n for i in range(0, k):\n while len(buffer) > 0 and nums[i] > buffer[-1]:\n buffer.pop()\n\n buffer.append(nums[i])\n\n result = [buffer[0]]\n\n for i in range(k, len(nums)):\n if buffer[0] == nums[i - k]:\n buffer.popleft()\n \n while len(buffer) > 0 and nums[i] > buffer[-1]:\n buffer.pop()\n\n buffer.append(nums[i])\n result.append(buffer[0])\n \n return result\n","runtime":"969"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n stack = deque()\n res = []\n for idx in range(0, k-1):\n while len(stack) and nums[idx] > stack[-1]:\n stack.pop()\n stack.append(nums[idx])\n left = 0\n for right in range(k-1, len(nums)):\n while len(stack) and nums[right] > stack[-1]:\n stack.pop()\n stack.append(nums[right])\n \n \n res.append(stack[0])\n \n \n if stack[0] == nums[left]:\n stack.popleft()\n \n left += 1\n return res\n\n ","runtime":"987"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = collections.deque([])\n r = []\n\n for i in range(k):\n while q and nums[i] > nums[q[-1]]:\n q.pop()\n q.append(i)\n \n r.append(nums[q[0]])\n\n for i in range(k ,len(nums)):\n if q and q[0] == i - k: \n q.popleft() # expired \n while q and nums[i] >= nums[q[-1]]:\n q.pop()\n \n q.append(i)\n r.append(nums[q[0]])\n \n return r","runtime":"987"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n stack = deque()\n\n for i in range(len(nums)):\n while stack and nums[i] > stack[-1]:\n stack.pop()\n stack.append(nums[i])\n\n if i >= k and nums[i - k] == stack[0]:\n stack.popleft()\n\n if i >= k - 1:\n res.append(stack[0])\n\n return res","runtime":"1004"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n stack = deque()\n for i in range(k):\n if len(stack) == 0:\n stack.append(nums[i])\n else:\n while stack and nums[i] > stack[-1]:\n stack.pop()\n stack.append(nums[i])\n result = []\n result.append(stack[0])\n for i in range(k, len(nums)):\n pop_val = nums[i - k]\n if pop_val == stack[0]:\n stack.popleft()\n while stack and nums[i] > stack[-1]:\n stack.pop()\n stack.append(nums[i]) \n result.append(stack[0])\n return result\n\n\n\n\n\n","runtime":"1004"},{"code":"from collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n dq = deque()\n n = len(nums)\n result = []\n for i in range(n):\n # print(dq)\n if i >= k:\n result.append(dq[0])\n if nums[i - k] == dq[0]:\n dq.popleft()\n while len(dq) > 0 and dq[-1] < nums[i]:\n dq.pop()\n dq.append(nums[i])\n \n result.append(dq[0])\n return result\n","runtime":"1021"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = deque()\n i = 0\n res = []\n while i < k:\n while q and nums[i] > nums[q[-1]]:\n q.pop()\n q.append(i)\n i += 1\n res.append(nums[q[0]])\n while i < len(nums):\n while q and nums[i] > nums[q[-1]]:\n q.pop()\n q.append(i)\n if q[0] <= i - k:\n q.popleft()\n res.append(nums[q[0]])\n i += 1\n return res\n \n","runtime":"1038"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n\n queue = deque()\n for i in range(k):\n while queue and nums[i]>queue[-1]:\n queue.pop()\n queue.append(nums[i])\n \n ans = []\n ans.append(queue[0])\n\n for i in range(k,len(nums)):\n going_index = i-k\n coming_index = i\n\n while queue and nums[coming_index]>queue[-1]:\n queue.pop()\n queue.append(nums[coming_index])\n if queue and nums[going_index] == queue[0]:\n queue.popleft()\n \n ans.append(queue[0])\n return ans\n\n\n\n ","runtime":"1055"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n\n from collections import deque\n\n # build the initial deque\n dq = deque()\n\n for i in range(k):\n while (len(dq)!=0) and (dq[-1]<nums[i]):\n dq.pop()\n dq.append(nums[i])\n \n result = [dq[0]]\n \n for idx in range(k, len(nums)):\n\n if result[-1]==nums[idx-k]:\n dq.popleft()\n\n while (len(dq)!=0) and (dq[-1]<nums[idx]):\n dq.pop()\n \n dq.append(nums[idx])\n\n result.append(dq[0])\n \n return result","runtime":"1055"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k >= len(nums): return [max(nums)]\n dq = deque()\n for i in range(k):\n num = nums[i]\n while dq and dq[-1] < num:\n dq.pop()\n dq.append(num)\n ans = []\n ans.append(dq[0])\n left = 0\n for right in range(k,len(nums)):\n num = nums[right]\n leftnum = nums[left]\n if leftnum == dq[0]:\n dq.popleft()\n while dq and dq[-1] < num:\n dq.pop()\n dq.append(num)\n ans.append(dq[0])\n left += 1\n return ans","runtime":"1072"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n dq = deque()\n res= []\n for i in range(k):\n while dq and nums[dq[-1]]<= nums[i]:\n dq.pop()\n dq.append(i)\n\n res.append(nums[dq[0]])\n left = 0\n for i in range(k,len(nums)):\n while dq and dq[0] <=left:\n dq.popleft()\n while dq and nums[dq[-1]]<= nums[i]:\n dq.pop()\n dq.append(i)\n left+=1\n res.append(nums[dq[0]])\n return res\n \n\n \n\n ","runtime":"1072"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ans = []\n dq = deque()\n i, j = 0, 0\n\n for i in range(len(nums)):\n # Remove elements from the deque if they are out of the window\n if dq and dq[0] < i - k + 1:\n dq.popleft()\n \n # Remove elements from the deque if they are smaller than the current element\n # because they are not useful anymore\n while dq and nums[dq[-1]] < nums[i]:\n dq.pop()\n\n # Add the current element index to the deque\n dq.append(i)\n \n # Start appending results once the window size reaches k\n if i >= k - 1:\n ans.append(nums[dq[0]])\n\n return ans","runtime":"1089"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n q = deque()\n\n for idx, num in enumerate(nums):\n while q and q[-1]<num:\n q.pop()\n q.append(num)\n\n if idx>=k and nums[idx-k] == q[0]:\n q.popleft()\n\n if idx>=k-1:\n res.append(q[0])\n return res","runtime":"1089"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ans = []\n queue = deque()\n for i in range(len(nums)):\n # maintain monotonic decreasing.\n # all elements in the deque smaller than the current one\n # have no chance of being the maximum, so get rid of them\n while queue and nums[i] > nums[queue[-1]]:\n queue.pop()\n\n queue.append(i)\n\n # queue[0] is the index of the maximum element.\n # if queue[0] + k == i, then it is outside the window\n if queue[0] + k == i:\n queue.popleft()\n \n # only add to the answer once our window has reached size k\n if i >= k - 1:\n ans.append(nums[queue[0]])\n\n return ans\n ","runtime":"1107"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n l = 0\n r = 0\n res = []\n queue = deque()\n # basically we want to maintain a monotonic decreasing queue\n while r<len(nums):\n if r-l+1<k:\n while queue and nums[r]>queue[-1]:\n queue.pop()\n queue.append(nums[r])\n r+=1\n continue\n\n while queue and nums[r]>queue[-1]:\n queue.pop()\n queue.append(nums[r])\n\n res.append(queue[0])\n \n # if window moves\n if queue[0]==nums[l]:\n queue.popleft()\n l+=1\n r+=1\n return res\n","runtime":"1107"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n from collections import deque\n deque_window = deque()\n ans = []\n for i in range(len(nums)):\n if deque_window and deque_window[0] == i - k:\n deque_window.popleft()\n \n while deque_window and nums[deque_window[-1]] < nums[i]:\n deque_window.pop()\n \n deque_window.append(i)\n\n if i >= k - 1:\n ans.append(nums[deque_window[0]])\n \n return ans","runtime":"1124"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if len(nums) < k or len(nums) == 0 or k == 0:\n return []\n \n window = deque()\n res = []\n\n for l, r in enumerate(nums):\n while window and window[0] < l-k+1:\n window.popleft()\n \n while window and r > nums[window[-1]]:\n window.pop()\n\n window.append(l)\n\n if l >= k-1:\n res.append(nums[window[0]])\n\n return res\n \n return res\n ","runtime":"1124"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n\n stack = Deque()\n out = []\n for i in range(len(nums)):\n while stack and (nums[i] >= nums[stack[-1]] or i - stack[-1] >= k):\n stack.pop()\n \n while stack and i - stack[0] >= k:\n stack.popleft()\n\n stack.append(i)\n if i >= k - 1:\n out.append(nums[stack[0]])\n \n return out\n\n \n\n\n","runtime":"1141"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n output = []\n q = collections.deque()\n l = r = 0\n\n while r < len(nums):\n while q and nums[q[-1]] < nums[r]:\n q.pop()\n q.append(r)\n\n # remove left val from window\n if l > q[0]:\n q.popleft()\n\n if r + 1 >= k:\n output.append(nums[q[0]])\n l += 1\n\n r += 1\n\n return output","runtime":"1141"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k == 1:\n return nums\n\n queue = deque()\n result = []\n left, right = 0, 0\n\n while right < len(nums):\n num = nums[right]\n while len(queue) and queue[-1] < num:\n queue.pop()\n queue.append(num)\n\n \n length = right - left + 1\n if length == k:\n result.append(queue[0])\n if queue[0] == nums[left]:\n queue.popleft()\n left += 1\n\n\n right += 1\n\n return result\n\n ","runtime":"1158"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n output = []\n q = deque() # index\n l = r = 0\n\n while r < len(nums):\n while q and nums[q[-1]] < nums[r]:\n q.pop()\n q.append(r)\n\n if l > q[0]:\n q.popleft()\n\n if (r + 1) >= k:\n output.append(nums[q[0]])\n l += 1\n r += 1\n\n return output","runtime":"1158"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n \n listOut = []\n l,r = 0,0\n queue = deque()\n localM = 0\n \n while r< len(nums):\n while len(queue) > 0 and nums[queue[-1]]<nums[r]:\n queue.pop()\n queue.append(r)\n \n if l>queue[0]:\n queue.popleft()\n\n if (r+1) >= k:\n listOut.append(nums[queue[0]])\n l+=1\n r+=1\n return listOut","runtime":"1175"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n \"\"\"\n nums = [1,3,-1,-3,5,3,6,7], k = 3\n num = 1: push its index and num (0,1) to the q.\n num = 3: while 3 is greater than last num of q, pop the last item, and finally push (1, 3) to q.\n ...\n Check the window size: Remove earlier element from q that is out of current window.\n \"\"\"\n\n res = []\n q = deque()\n\n for i, num in enumerate(nums):\n while q and q[-1][1] < num:\n q.pop()\n\n q.append((i, num))\n\n if q[-1][0] - q[0][0] + 1 > k:\n q.popleft()\n\n res.append(q[0][1])\n\n return res[k-1:]","runtime":"1175"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = deque()\n res = []\n l = r = 0\n\n while r < len(nums):\n # pop smaller val\n while q and nums[q[-1]] < nums[r]:\n q.pop()\n q.append(r)\n\n # remove left val\n if l > q[0]:\n q.popleft()\n \n if (r + 1) >= k:\n res.append(nums[q[0]])\n l += 1\n\n r += 1\n return res\n\n \n ","runtime":"1192"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n win, rslt =[],[] \n for i,x in enumerate(nums):\n # 两种方式需要进行移除操作\n # 一种是维持一个单调递减队列，如果之前数据小于当前数据直接pop移除之前数据（这里是一i那位添加当前数据的操作在后面所以可以保证第一个元素是最大值）\n # 一种是达到窗口数量k需要直接pop移除最先进度队列的数据\n if i>=k and win[0]<=i-k:\n win.pop(0)\n # 维护一个单调递减队列\n while win and nums[win[-1]]<=x:\n win.pop()\n win.append(i)\n if i>=k-1:\n rslt.append(nums[win[0]])\n return rslt\n\n\n","runtime":"1192"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n idx_Q, maxes = deque(), [] \n INIT,LN = 0,len(nums)\n\n def next_greater_right():\n next_val = nums[right]\n return next_val > nums[idx_Q[-1]]\n\n def left_out_of_bounds():\n prev_left = idx_Q[0]\n return prev_left < left\n\n left = right = INIT\n while right < LN:\n while idx_Q and next_greater_right():\n idx_Q.pop()\n \n idx_Q.append(right)\n\n if left_out_of_bounds(): idx_Q.popleft()\n\n next=right+1\n if next >= k:\n maxes.append(nums[idx_Q[0]])\n left += 1\n right += 1\n\n return maxes","runtime":"1209"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n q = deque()\n l = 0\n for r in range(len(nums)):\n while q and q[-1] < nums[r]:\n q.pop()\n q.append(nums[r])\n while (r - l + 1) > k:\n if nums[l] == q[0]:\n q.popleft()\n l += 1\n if (r - l + 1) == k:\n res.append(q[0])\n return res","runtime":"1209"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ub = []\n result = []\n for i in range(k):\n heapq.heappush(ub, -nums[i])\n result.append(-ub[0]) \n todo = [] # also a heap\n for i in range(k, len(nums)):\n # number to be removed\n kick = nums[i-k]\n new = nums[i]\n if kick == -ub[0]:\n heapq.heappop(ub)\n else:\n heapq.heappush(todo, -kick)\n\n\n while len(todo) != 0:\n if todo[0] == ub[0]:\n heapq.heappop(ub)\n heapq.heappop(todo)\n else:\n break\n\n\n\n heapq.heappush(ub, -new)\n result.append(-ub[0])\n return result\n","runtime":"1227"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n deque = []\n ans = []\n for i in range(len(nums)):\n while len(deque) > 0 and deque[0] < i-k+1:\n deque.pop(0)\n while len(deque) > 0 and nums[deque[-1]] <= nums[i]:\n deque.pop(-1)\n deque.append(i)\n if i >= k-1:\n ans.append(nums[deque[0]])\n\n return ans","runtime":"1227"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n numCount = {}\n queue = deque()\n for n in nums[:k]:\n numCount[n] = numCount.get(n, 0) + 1\n while queue and queue[-1] <= n:\n queue.pop()\n queue.append(n)\n\n ans = [queue[0]]\n for i in range(0, len(nums) - k): # O(n)\n # remove\n numCount[nums[i]] -= 1\n while queue and numCount[queue[0]] == 0:\n queue.popleft()\n # append\n numCount[nums[i + k]] = numCount.get(nums[i + k], 0) + 1\n while queue and queue[-1] <= nums[i + k]:\n queue.pop()\n queue.append(nums[i + k])\n ans.append(queue[0])\n return ans","runtime":"1244"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k >= len(nums):\n return [max(nums)]\n stack = []\n ans = []\n for i in range(k):\n if not stack:\n stack.append((nums[i],i))\n continue\n if nums[i] >= stack[0][0]:\n stack = [(nums[i],i)]\n else:\n while stack and (stack[-1][0] <= nums[i]):\n stack.pop()\n stack.append((nums[i],i))\n # stack.append((nums[i],i))\n ans.append(stack[0][0])\n for i in range(k,len(nums)):\n if stack[0][1] < i-k +1:\n stack.pop(0)\n if not stack or (nums[i] >= stack[0][0]):\n stack = [(nums[i],i)]\n ans.append(nums[i])\n else:\n while stack and (stack[-1][0] <= nums[i]):\n stack.pop()\n stack.append((nums[i],i))\n ans.append(stack[0][0])\n return ans\n","runtime":"1244"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n i = 0\n j = 0\n queue = []\n ans = []\n while j < k:\n if len(queue) == 0:\n queue.append((nums[j],j))\n else:\n cur = (nums[j], j)\n while len(queue) > 0 and queue[-1][0] <= cur[0]:\n queue.pop()\n queue.append(cur)\n\n j+=1\n ans.append(queue[0][0])\n j-=1\n while j < len(nums):\n if queue[0][1] == i:\n queue.pop(0)\n i+=1\n j+=1\n if j == len(nums):\n break\n cur = (nums[j], j)\n while len(queue) > 0 and queue[-1][0] <= cur[0]:\n queue.pop()\n queue.append(cur)\n ans.append(queue[0][0])\n return ans","runtime":"1261"},{"code":"from collections import deque\nimport heapq\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = deque()\n heap = []\n ans = []\n if k == 1:\n return nums\n\n max = float('-inf')\n for j, i in enumerate(nums):\n if len(q) < k:\n q.append(i)\n if i > max:\n max = i\n heap = []\n else:\n heapq.heappush(heap, (-1*i, j))\n else:\n ans.append(max)\n pop = q.popleft()\n if pop == max:\n pop, index = heapq.heappop(heap)\n max = pop*-1\n while heap:\n if heap[0][1] < index:\n heapq.heappop(heap)\n else:\n break\n q.append(i)\n if i > max:\n heap = []\n max = i\n else:\n heapq.heappush(heap, (-1*i, j))\n ans.append(max)\n return ans\n\n \n\n# 1 3 -1 : 3 : -1 \n# 3 -1 -3 : 3 : -1 -3\n# -1 -3 5 : if next one is larger, clear heap \n\n# -7 -8 7 5 : 7 : 5\n# -8 7 5 7 : 7 : \n# 7 5 7 1 : 7 : 1\n# 5 7 1 6 : 7 : 6 1\n\n# 3 8 3 3 3 6 3 7 3 4 3 3 3 3 \n# 3 8 3 3 3 6 3 7 : 8 : 7 6 \n# 3 3 3 6 3 7 3 4 : 7 : 6 4","runtime":"1295"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n heap = []\n for i in range(k):\n heapq.heappush(heap,(-1 * nums[i],i + k - 1))\n ans = [-1 * heap[0][0]]\n for i in range(k,len(nums)):\n heapq.heappush(heap,(-1 * nums[i],i + k - 1))\n while heap[0][1] < i:\n heapq.heappop(heap)\n\n ans.append(-1 * heap[0][0])\n \n \n return ans","runtime":"1295"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k == 1:\n return nums\n\n left = [0] * len(nums)\n right = [0] * len(nums)\n left[0] = nums[0]\n right[-1] = nums[-1]\n result = []\n\n for i in range(1, len(nums)):\n if i % k == 0:\n left[i] = nums[i]\n\n else:\n left[i] = max(left[i - 1], nums[i])\n\n j = len(nums) - i - 1\n\n if (j + 1) % k == 0:\n right[j] = nums[j]\n\n else:\n right[j] = max(right[j + 1], nums[j])\n\n for start in range(len(nums) - k + 1):\n end = start + k - 1\n result.append(max(left[end], right[start]))\n\n return result","runtime":"1312"},{"code":"import heapq\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n window = []\n max_sliding_window = []\n for index, num in enumerate(nums):\n if index < k - 1:\n heapq.heappush(window, (-num, index))\n elif index >= k - 1:\n heapq.heappush(window, (-num, index))\n while window[0][1] < len(max_sliding_window):\n heapq.heappop(window)\n max_sliding_window.append(-window[0][0])\n return max_sliding_window","runtime":"1312"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n a = []\n res = []\n for i in range(k):\n heapq.heappush(a,(-nums[i],i))\n res.append(-a[0][0])\n for i in range(0,len(nums)-k):\n heapq.heappush(a,(-nums[i+k],i+k))\n while a[0][1]<=i:\n heapq.heappop(a)\n res.append(-a[0][0])\n return res","runtime":"1330"},{"code":"from collections import deque \n\nclass QueueElem:\n def __init__(self, val, idx) -> None:\n self.val = val\n self.idx = idx\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxWindow = []\n dequeue = deque([])\n\n for i in range(0, len(nums)):\n # clean queue:\n while len(dequeue) > 0 and dequeue[0].idx <= i-k:\n dequeue.popleft()\n while len(dequeue) > 0 and dequeue[len(dequeue) -1].val < nums[i]:\n dequeue.pop()\n dequeue.append(QueueElem(nums[i], i))\n \n if i>= k-1:\n maxWindow.append(dequeue[0].val)\n\n return maxWindow\n ","runtime":"1330"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n N = len(nums)\n freq = defaultdict(int)\n heap = [] # Max heap so negate values\n \n l, r = 0, 0\n for r in range(k):\n freq[nums[r]] += 1\n heapq.heappush(heap, -nums[r])\n res = []\n while r < N:\n curr_max = -heap[0]\n while heap and freq[curr_max] == 0:\n heapq.heappop(heap)\n curr_max = -heap[0]\n res.append(curr_max)\n if r == N-1:\n break\n r += 1\n heapq.heappush(heap, -nums[r])\n freq[nums[r]] += 1\n freq[nums[l]] -= 1\n l += 1\n return res","runtime":"1347"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if len(nums) == 1:\n return [nums[0]]\n elif k == 1:\n return nums\n \n h = []\n out = []\n for i, n in enumerate(nums):\n if i < k:\n heapq.heappush(h, (-1*n, i))\n if i == k-1:\n out.append(h[0][0]*-1)\n continue\n while i-k >= h[0][1]:\n heapq.heappop(h)\n\n heapq.heappush(h, (-1*n, i))\n out.append(h[0][0]*-1)\n\n return out","runtime":"1347"},{"code":"import heapq\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n n = len(nums)\n heap = []\n res = []\n\n for i in range(n):\n while len(heap) > 0 and i - heap[0][1] >= k:\n heapq.heappop(heap)\n\n heapq.heappush(heap, (-nums[i], i))\n\n if i + 1 >= k:\n res.append(-heap[0][0])\n\n return res\n\n \n\n","runtime":"1364"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k == 1:\n return nums\n \n rwind = [(-val,i) for i,val in enumerate(nums[:k])]\n\n heapq.heapify(rwind)\n\n res = [-rwind[0][0]]\n\n for i in range(k,len(nums)):\n while rwind[0][1] <= i-k: \n heapq.heappop(rwind)\n heapq.heappush(rwind, (-nums[i],i))\n res.append(-rwind[0][0])\n \n return res\n\n ","runtime":"1364"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n h,ans =[],[]\n for i in range(k):heappush(h,(-nums[i],i))\n ans.append(-h[0][0])\n for i in range(k,len(nums)):\n heappush(h, (-nums[i],i)) \n while h and (i - h[0][1]) >=k:heappop(h) \n ans.append((-h[0][0]))\n return ans\n\n ","runtime":"1381"},{"code":"# 需要一种新的队列结构，既能够维护队列元素「先进先出」的时间顺序，又能够正确维护队列中所有元素的最值，这就是「单调队列」结构。\n# 判断一个窗口中最值的例子，你无法单凭移出窗口的那个元素更新窗口的最值，除非重新遍历所有元素\n# 此题维护一个单调递减序列\n############ Solution 1: Monotonic Deque ############ \n# #!!! 非常简洁的写法,推荐！使用了 deque(pop是O1)和index（而非value）\n# 使用单调递减队列而不是单调递增的原因在于我们希望快速获取当前窗口的最大值。通过维护一个单调递减队列，我们可以【确保队列头部元素始终是当前窗口的最大值】。每次窗口移动时，头部元素若过期则移除，使得新的头部元素始终是当前窗口的最大值。这种方法在时间复杂度和空间复杂度上都是最优的方案。\n\n# # time: O(n)\n# # space: O(k)\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxq = deque()\n res = []\n\n for i in range(len(nums)):\n \n # 移除不在窗口范围内的索引\n while maxq and maxq[0] < i - k + 1:\n maxq.popleft()\n \n # 移除所有小于当前元素的索引\n while maxq and nums[maxq[-1]] < nums[i]: #！！！ < 或 <= 都可以，< 构成的序列是单调递减，<= 构成【严格】单调递减序列。\n maxq.pop()\n # 将当前元素的索引加入双端队列\n maxq.append(i)\n\n # 从窗口第一个完整的窗口开始记录最大值\n if i >= k - 1:\n res.append(nums[maxq[0]])\n\n return res\n\n############ Solution 2: maxHeap ############ \n# 如果懒得写deque，也可以使用pq(heap)\n# - 时间复杂度: O(N log k)\n# - 空间复杂度: O(k)\n# minHeap 要改成 - 才是maxHeap\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n max_heap = [] # Max heap to store (-value, index) pairs\n result = []\n \n for i in range(len(nums)):\n # 将当前元素插入堆中，注意存入的是负值以模拟最大堆，同时记录下标\n heapq.heappush(max_heap, (-nums[i], i))\n \n # 确保堆顶元素在当前窗口范围内\n while max_heap and max_heap[0][1] < i - k + 1: #\n heapq.heappop(max_heap)\n\n # 当窗口的大小达到k时，记录当前的最大值\n if i >= k - 1:\n result.append(-max_heap[0][0])\n\n return result\n\n\n############ Solution 2: labuldong模版，帮助理解。但我不喜欢这个方法。############ \n# from collections import deque\n# class MonotonicQueue:\n# def __init__(self):\n# self.maxq = deque()\n\n# def popleft(self, n):\n# if self.maxq and self.maxq[0] == n: # 看头元素！\n# self.maxq.popleft()\n\n# def push(self, n):\n# # 将小于 n 的元素全部删除\n# while (self.maxq and self.maxq[-1] < n):\n# self.maxq.pop()\n# # 然后将 n 加入尾部\n# self.maxq.append(n)\n\n# def max(self):\n# return self.maxq[0]\n\n\n# class Solution:\n# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n\n# window = MonotonicQueue()\n# res = []\n# for i in range(len((nums))):\n# if i < k - 1:\n# window.push(nums[i])\n# else:\n# window.push(nums[i])\n# window_max = window.max()\n# res.append(window_max)\n# # print(window.maxq, i, i - k + 1, nums[i - k + 1])\n# # [2, 3, 3, 2], k = 2这个case过不了。如果使用这个方法，第40行必须构造单调递减序列，而不是严格单调递减序列，因为这里的下一行是按照value进行判断的，不是按照index进行判断。\n# window.popleft(nums[i - k + 1]) \n# return res","runtime":"1381"},{"code":"# 需要一种新的队列结构，既能够维护队列元素「先进先出」的时间顺序，又能够正确维护队列中所有元素的最值，这就是「单调队列」结构。\n# 判断一个窗口中最值的例子，你无法单凭移出窗口的那个元素更新窗口的最值，除非重新遍历所有元素\n# 此题维护一个单调递减序列\n############ Solution 1: Monotonic Deque ############ \n# #!!! 非常简洁的写法,推荐！使用了 deque(pop是O1)和index（而非value）\n# 使用单调递减队列而不是单调递增的原因在于我们希望快速获取当前窗口的最大值。通过维护一个单调递减队列，我们可以【确保队列头部元素始终是当前窗口的最大值】。每次窗口移动时，头部元素若过期则移除，使得新的头部元素始终是当前窗口的最大值。这种方法在时间复杂度和空间复杂度上都是最优的方案。\n\n# # time: O(n)\n# # space: O(k)\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxq = deque() # decreasing queue, 把答案放在开头\n res = []\n\n for i in range(len(nums)):\n\n # Remove elements smaller than the current element from the back\n while maxq and nums[maxq[-1]] < nums[i]: #！！！ < 或 <= 都可以，< 构成的序列是单调递减，<= 构成【严格】单调递减序列。\n maxq.pop()\n \n # Remove elements that are out of the current window\n while maxq and maxq[0] < i - k + 1:\n maxq.popleft()\n \n # Add the current index to the deque\n maxq.append(i)\n\n # Append the maximum element in the current window to the result\n if i >= k - 1:\n res.append(nums[maxq[0]])\n\n return res\n\n############ Solution 2: maxHeap ############ \n# 如果懒得写deque，也可以使用pq(heap)\n# - 时间复杂度: O(N log k)\n# - 空间复杂度: O(k)\n# minHeap 要改成 - 才是maxHeap\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n max_heap = [] # Max heap to store (-value, index) pairs\n result = []\n \n for i in range(len(nums)):\n # 将当前元素插入堆中，注意存入的是负值以模拟最大堆，同时记录下标\n heapq.heappush(max_heap, (-nums[i], i))\n \n # 确保堆顶元素在当前窗口范围内\n while max_heap and max_heap[0][1] < i - k + 1: #\n heapq.heappop(max_heap)\n\n # 当窗口的大小达到k时，记录当前的最大值\n if i >= k - 1:\n result.append(-max_heap[0][0])\n\n return result\n\n\n############ Solution 2: labuldong模版，帮助理解。但我不喜欢这个方法。############ \n# from collections import deque\n# class MonotonicQueue:\n# def __init__(self):\n# self.maxq = deque()\n\n# def popleft(self, n):\n# if self.maxq and self.maxq[0] == n: # 看头元素！\n# self.maxq.popleft()\n\n# def push(self, n):\n# # 将小于 n 的元素全部删除\n# while (self.maxq and self.maxq[-1] < n):\n# self.maxq.pop()\n# # 然后将 n 加入尾部\n# self.maxq.append(n)\n\n# def max(self):\n# return self.maxq[0]\n\n\n# class Solution:\n# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n\n# window = MonotonicQueue()\n# res = []\n# for i in range(len((nums))):\n# if i < k - 1:\n# window.push(nums[i])\n# else:\n# window.push(nums[i])\n# window_max = window.max()\n# res.append(window_max)\n# # print(window.maxq, i, i - k + 1, nums[i - k + 1])\n# # [2, 3, 3, 2], k = 2这个case过不了。如果使用这个方法，第40行必须构造单调递减序列，而不是严格单调递减序列，因为这里的下一行是按照value进行判断的，不是按照index进行判断。\n# window.popleft(nums[i - k + 1]) \n# return res","runtime":"1398"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums or k == 0:\n return []\n \n # Initialize\n max_heap = []\n count = defaultdict(int)\n result = []\n \n # Process the first k elements\n for i in range(k):\n heapq.heappush(max_heap, -nums[i])\n count[nums[i]] += 1\n \n # Add the maximum for the first window\n result.append(-max_heap[0])\n \n # Process the rest of the elements\n for i in range(k, len(nums)):\n # Add new element to the heap and count\n heapq.heappush(max_heap, -nums[i])\n count[nums[i]] += 1\n \n # Remove the element that is out of the window\n outgoing = nums[i - k]\n count[outgoing] -= 1\n \n # Remove invalid elements from the heap\n while max_heap and count[-max_heap[0]] == 0:\n print(max_heap[0])\n heapq.heappop(max_heap)\n \n # The current maximum is the root of the heap\n result.append(-max_heap[0])\n \n return result","runtime":"1398"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n a=[[-nums[i],i] for i in range(k-1)]\n heapq.heapify(a)\n ans=[]\n for i in range(k-1,len(nums)):\n heapq.heappush(a,[-nums[i],i])\n while a[0][1]<=i-k:\n heapq.heappop(a)\n ans.append(-a[0][0])\n return ans\n \n\n\n\n","runtime":"1415"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n import heapq\n max_heap = [ ] # building max heap\n for i in range(k):\n max_heap.append( [-nums[i], i] ) # (value , index)\n heapq.heapify( max_heap ) # heapify\n max_window = [ -max_heap[0][0] ]\n left = 0\n right = k - 1\n\n while(right + 1 < len(nums)):\n right += 1\n heapq.heappush( max_heap, [-nums[right], right] )\n # remove stale max from max_heap\n while ( max_heap[0][1] <= left ):\n heapq.heappop( max_heap )\n \n left += 1\n\n max_window.append( -max_heap[0][0] )\n\n return max_window \n \n \n\n ","runtime":"1415"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n n = len(nums)\n max_heap = []\n for i in range(k):\n heappush(max_heap, (-nums[i], i))\n result = [-max_heap[0][0]]\n start = 0\n stale = {}\n for end in range(k, n):\n new_num = nums[end]\n old_num = nums[start]\n if old_num == result[-1]:\n heappop(max_heap)\n heappush(max_heap, (-new_num, end))\n while max_heap[0][1] < start:\n heappop(max_heap)\n result.append(-max_heap[0][0])\n start += 1\n return result\n","runtime":"1432"},{"code":"import heapq\n\nclass Solution:\n myheap = []\n remheap = []\n def add_elem(self, val):\n heapq.heappush(self.myheap, val)\n def rem_elem(self, val):\n heapq.heappush(self.remheap, val)\n def peek_top(self):\n if len(self.myheap) == 0:\n return None\n while len(self.remheap) > 0 and self.remheap[0] < self.myheap[0]:\n heapq.heappop(self.remheap)\n while len(self.myheap) > 0 and len(self.remheap) > 0 and self.myheap[0] == self.remheap[0]:\n heapq.heappop(self.myheap)\n heapq.heappop(self.remheap)\n \n if len(self.myheap) == 0:\n return None\n return self.myheap[0]\n\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n self.myheap = []\n self.remheap = []\n for i in range(k):\n self.add_elem(-nums[i])\n ans = [-self.peek_top()]\n for i in range(k, len(nums)):\n self.add_elem(-nums[i])\n self.rem_elem(-nums[i-k])\n ans.append(-self.peek_top())\n return ans","runtime":"1432"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # this is a max heap problem, but the issue is removing an element\n # of arbitrary index from the heap (when the window moves).\n \n window = Counter()\n heap = []\n for i in range(k):\n num = nums[i]\n window[num] += 1\n heapq.heappush(heap, -num)\n \n res = [-heap[0]]\n for i in range(k, len(nums)):\n heapq.heappush(heap, -nums[i])\n\n window[nums[i]] += 1\n window[nums[i-k]] -= 1\n\n while window[-heap[0]] <= 0:\n heapq.heappop(heap)\n \n curr = -heap[0]\n res.append(curr)\n \n return res\n","runtime":"1450"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res, heap = [], []\n\n for i in range(k):\n heapq.heappush(heap, [-nums[i], i])\n\n curr_max = -heap[0][0]\n res.append(curr_max)\n\n for i in range(k, len(nums)):\n heapq.heappush(heap, [-nums[i], i])\n curr_max = heap[0]\n\n while curr_max[1] <= i-k:\n heapq.heappop(heap)\n curr_max = heap[0]\n \n res.append(-curr_max[0])\n\n return res\n\n ","runtime":"1450"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxes = []\n q = []\n trash = set()\n for i, n in enumerate(nums):\n heapq.heappush(q, (-n, i))\n if len(q) < k:\n continue\n trash.add(i - k)\n while True:\n top, topI = q[0]\n if topI not in trash:\n maxes.append(-top)\n break\n trash.remove(topI)\n heapq.heappop(q)\n return maxes\n \n \n \n ","runtime":"1467"},{"code":"import heapq\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxes = []\n maxHeap = []\n for i in range(k):\n heapq.heappush(maxHeap, (-nums[i], i))\n maxes.append(-maxHeap[0][0])\n \n for i in range(k, len(nums)):\n while maxHeap and -nums[i] < maxHeap[0][0]:\n heapq.heappop(maxHeap)\n heapq.heappush(maxHeap, (-nums[i], i))\n while maxHeap[0][1] < i-k+1:\n heapq.heappop(maxHeap)\n maxes.append(-maxHeap[0][0])\n return maxes","runtime":"1467"},{"code":"import heapq\nfrom typing import List\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums:\n return []\n\n res = []\n maxHeap = [] # Max-heap to store the negative values for max functionality\n indexHeap = [] # Min-heap to store the indices of elements in the window\n valid = {} # Dictionary to check if an index is valid in the heap\n\n # Initialize the heaps and valid dictionary\n for i in range(k):\n heapq.heappush(indexHeap, i)\n heapq.heappush(maxHeap, (-nums[i], i))\n valid[i] = True\n\n # Function to remove invalid indices from the maxHeap\n def clean_up():\n while maxHeap and not valid[maxHeap[0][1]]:\n heapq.heappop(maxHeap)\n\n # Process the first window\n clean_up()\n res.append(-maxHeap[0][0])\n\n for i in range(k, len(nums)):\n # Add new element\n heapq.heappush(indexHeap, i)\n heapq.heappush(maxHeap, (-nums[i], i))\n valid[i] = True\n\n # Remove the element that's sliding out of the window\n out_index = i - k\n valid[out_index] = False\n\n # Clean up the heaps\n clean_up()\n res.append(-maxHeap[0][0])\n\n return res\n","runtime":"1484"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n heap = []\n res = []\n\n for i in range(k):\n heapq.heappush(heap, (-nums[i], i))\n\n res.append(-heap[0][0])\n\n for R in range(k, len(nums)):\n heapq.heappush(heap, (-nums[R], R))\n while heap[0][1] not in range(R - k + 1, R + 1):\n heapq.heappop(heap)\n res.append(-heap[0][0])\n\n return res\n","runtime":"1484"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n queue = collections.deque()\n for i in range(0, k):\n while queue and queue[-1][0] <= nums[i]:\n queue.pop()\n queue.append((nums[i], i))\n res.append(queue[0][0])\n r = k\n print('queue after inital push',queue)\n while r < len(nums):\n l = r - k + 1\n print('new bounds', l, r)\n while queue and queue[0][1] < l:\n queue.popleft()\n while queue and queue[-1][0] <= nums[r]:\n queue.pop()\n queue.append((nums[r], r))\n res.append(queue[0][0])\n r += 1\n return res","runtime":"1501"},{"code":"from typing import List\nimport heapq\nfrom collections import defaultdict\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums or k == 0:\n return []\n if k == 1:\n return nums\n if k == len(nums):\n return [max(nums)]\n \n heap = []\n hmap = defaultdict(int)\n idx_map = {}\n \n # Initialize the first window\n for idx in range(k):\n num = nums[idx]\n heapq.heappush(heap, (-num, idx))\n hmap[num] += 1\n idx_map[num] = idx\n \n res = [-heap[0][0]] # Add the max of the first window\n \n for r in range(k, len(nums)):\n # Add the new element\n num = nums[r]\n heapq.heappush(heap, (-num, r))\n hmap[num] += 1\n idx_map[num] = r\n \n # Remove elements outside the window\n while heap and heap[0][1] <= r - k:\n _, old_idx = heapq.heappop(heap)\n old_num = nums[old_idx]\n hmap[old_num] -= 1\n \n # Add the current max to the result\n res.append(-heap[0][0])\n \n return res","runtime":"1501"},{"code":"from collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n dq = deque([])\n ## first k numbers\n maxList = []\n for i, num in enumerate(nums[:k]):\n if len(dq) > 0 and num > dq[-1][0]:\n while len(dq) > 0 and dq[-1][0] < num:\n dq.pop()\n if len(dq) > 0 and num > dq[0][0]:\n while len(dq) > 0 and dq[0][0] < num:\n dq.popleft()\n dq.appendleft((num, i))\n maxList.append(dq[-1][0])\n for i, num in enumerate(nums[k:]):\n print(i)\n print(dq[-1][1])\n if dq[-1][1] == i:\n dq.pop()\n\n if len(dq) > 0 and num > dq[-1][0]:\n while len(dq) > 0 and dq[-1][0] < num:\n dq.pop()\n if len(dq) > 0 and num > dq[0][0]:\n while len(dq) > 0 and dq[0][0] < num:\n dq.popleft()\n dq.appendleft((num, i + k))\n maxList.append(dq[-1][0])\n return maxList\n ","runtime":"1518"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = []\n heapq.heapify(q)\n ans = []\n for i in range(len(nums)):\n if i < k - 1:\n heapq.heappush(q, [-nums[i], i])\n continue\n \n heapq.heappush(q, [-nums[i], i])\n\n while q[0][1] <= i - k or (len(q) > 0 and -nums[i] < q[0][0]):\n heapq.heappop(q)\n\n ans.append(-q[0][0])\n \n return ans\n\n\"\"\"\n[ 3 -1] -3 5 3 6 7 3\n[3 -1 -3] 5 3 6 7 3\n[5]\n5 5\n[5 3 6]\n 1 3 -1 -3 5 [3 6 7] 7\n\n\"\"\"","runtime":"1518"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n #monotonically decreasing queue\n q = []\n res = []\n #q.append(0)\n l,r=0,0\n for r in range(len(nums)):\n while q and nums[r]>nums[q[-1]]:\n q.pop()\n q.append(r)\n \n if l>q[0]:\n q.pop(0)\n\n if r+1>=k: \n res.append(nums[q[0]]) \n l+=1\n return res \n \n\n ","runtime":"1535"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q, ans, l = [], [], 0\n for r in range(len(nums)):\n while q and nums[q[-1]] < nums[r]:\n q.pop()\n if q and l > q[0]:\n q.pop(0)\n q.append(r)\n if r > k-2:\n ans.append(nums[q[0]])\n l += 1\n return ans","runtime":"1535"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n start, end = 0, k - 1\n\n resMax = []\n deque = []\n\n for itr in range(len(nums) - k + 1):\n if itr == 0:\n for num in nums[start:end + 1]:\n while deque and deque[-1] < num:\n deque.pop(-1)\n deque.append(num)\n resMax.append(deque[0])\n else:\n # If loc max is old start num, remove it\n if deque[0] == nums[start]:\n deque.pop(0)\n start += 1\n\n # Get new end val and remove all vals less than it from deq, then append it\n end += 1\n while deque and deque[-1] < nums[end]:\n deque.pop(-1)\n deque.append(nums[end])\n resMax.append(deque[0])\n \n return resMax","runtime":"1552"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums or k == 0:\n return []\n \n n = len(nums)\n if k > n:\n return []\n\n # Result list to store the maximums for each window\n result = []\n # List to act as a deque to store indices of array elements\n deq = []\n\n for i in range(n):\n # Remove indices that are out of the current window\n if deq and deq[0] < i - k + 1:\n deq.pop(0)\n \n # Remove elements from deque that are less than current element\n while deq and nums[deq[-1]] < nums[i]:\n deq.pop()\n \n # Add the current element's index to the deque\n deq.append(i)\n \n # Append the maximum for the current window to result list\n if i >= k - 1:\n result.append(nums[deq[0]])\n \n return result","runtime":"1552"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n l = 0\n r = k-1\n res = []\n queue = []\n # Basically,我们要维护一个decreasing的deque\n for i in range(r):\n while queue and nums[i]>queue[-1]:\n queue.pop()\n queue.append(nums[i])\n # print(r,queue)\n while r<len(nums):\n while queue and nums[r]>queue[-1]:\n queue.pop()\n queue.append(nums[r])\n \n res.append(queue[0])\n \n # 如果window移动了\n if queue[0]==nums[l]:\n queue.pop(0)\n l+=1\n r+=1\n \n return res\n","runtime":"1570"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n output = []\n maximums = []\n l = 0\n for r in range(len(nums)):\n while maximums and nums[r] > maximums[-1]:\n maximums.pop()\n maximums.append(nums[r])\n\n if r - l + 1 == k:\n output.append(maximums[0])\n if nums[l] == maximums[0]:\n maximums.pop(0)\n l += 1\n \n return output","runtime":"1570"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxes = []\n\n ret = []\n for i, num in enumerate(nums):\n while maxes and maxes[-1] < num:\n maxes.pop()\n maxes.append(num)\n if i >=k and nums[i-k] == maxes[0]: maxes.pop(0)\n if i >= k-1:\n ret.append(maxes[0])\n return ret","runtime":"1587"},{"code":"from collections import deque\nfrom typing import List\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums:\n return []\n if k == 1:\n return nums\n\n # This will store indices of elements, not the elements themselves\n deq = []\n max_nums = []\n\n for i in range(len(nums)):\n # Remove indices that are out of this window\n if deq and deq[0] < i - k + 1:\n deq.pop(0)\n\n # Maintain deq such that it contains indices of elements in decreasing order\n while deq and nums[deq[-1]] < nums[i]:\n deq.pop()\n\n # Append the current index at the end of the deq\n deq.append(i)\n\n # Start appending results from the index when the first window is completed\n if i >= k - 1:\n max_nums.append(nums[deq[0]])\n\n return max_nums","runtime":"1587"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n q = []\n l = r = 0\n\n while r < len(nums):\n while q and nums[q[-1]] < nums[r]:\n q.pop()\n q.append(r)\n\n if q[0] < l:\n q.pop(0)\n \n if (r-l+1) == k:\n res.append(nums[q[0]])\n l += 1\n r += 1\n return res","runtime":"1604"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n n = len(nums)\n result = []\n stack = []\n \n for i in range(n):\n while stack and stack[0] <= i - k:\n stack.pop(0)\n while stack and nums[stack[-1]] < nums[i]:\n stack.pop()\n stack.append(i)\n if i >= k - 1:\n result.append(nums[stack[0]])\n \n return result\n # n=len(nums)\n # st=[]\n # for i in range(0,n-k+1):\n # sub_arr=nums[i:i+k]\n # st.append(list(sorted(sub_arr)))\n # res=[]\n # for sub_arr in st:\n # res.append(sub_arr[-1])\n # return res \n\n\n \n","runtime":"1604"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\\n q = deque()\\n # only keep track the biggest\\n for i in range(k-1):\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans = []\\n for i in range(k-1, len(nums)):\\n if q and i >= q[0] + k:\\n q.popleft()\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans.append(nums[q[0]])\\n return ans\\n it = iter(stdin)\\n output = open('user.out', 'w')\\n for array in it:\\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\\\n')\\n exit()\\n \\n \",\n \"runtime\": \"249\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\\n q = deque()\\n # only keep track the biggest\\n for i in range(k-1):\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans = []\\n for i in range(k-1, len(nums)):\\n if q and i >= q[0] + k:\\n q.popleft()\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans.append(nums[q[0]])\\n return ans\\n it = iter(stdin)\\n output = open('user.out', 'w')\\n for array in it:\\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\\\n')\\n exit()\\n \\n \",\n \"runtime\": \"249\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\\n q = deque()\\n # only keep track the biggest\\n for i in range(k-1):\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans = []\\n for i in range(k-1, len(nums)):\\n if q and i >= q[0] + k:\\n q.popleft()\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans.append(nums[q[0]])\\n return ans\\n it = iter(stdin)\\n output = open('user.out', 'w')\\n for array in it:\\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\\\n')\\n exit()\\n \\n \",\n \"runtime\": \"266\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\\n q = deque()\\n # only keep track the biggest\\n for i in range(k-1):\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans = []\\n for i in range(k-1, len(nums)):\\n if q and i >= q[0] + k:\\n q.popleft()\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans.append(nums[q[0]])\\n return ans\\n it = iter(stdin)\\n output = open('user.out', 'w')\\n for array in it:\\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\\\n')\\n exit()\\n \\n \",\n \"runtime\": \"266\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums, k):\\n result = []\\n max_heap = []\\n counter = defaultdict(int)\\n for v in nums[:k]:\\n heapq.heappush(max_heap, -v)\\n counter[v] += 1\\n \\n for i in range(k, len(nums)):\\n to_add = nums[i] \\n counter[nums[i-k]] -= 1\\n counter[to_add] += 1\\n result.append(-max_heap[0])\\n heapq.heappush(max_heap, -to_add)\\n while counter[-max_heap[0]] < 1:\\n heapq.heappop(max_heap)\\n\\n result.append(-max_heap[0])\\n\\n return result\\n\\n it = iter(stdin)\\n output = open('user.out', 'w')\\n for array in it:\\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\\\n')\\n exit()\\n \\n\\n\\n \\n \\n\\n \",\n \"runtime\": \"283\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums: list[int], k: int) -> list[int]:\\n \\n result = []\\n max_stack = []\\n \\n for i in range(k-1):\\n while max_stack and nums[max_stack[-1]] < nums[i]:\\n max_stack.pop()\\n max_stack.append(i)\\n\\n for i in range(k-1, len(nums)):\\n if max_stack and i >= max_stack[0] + k:\\n max_stack.pop(0)\\n \\n while max_stack and nums[max_stack[-1]] < nums[i]:\\n max_stack.pop()\\n \\n max_stack.append(i)\\n result.append(nums[max_stack[0]])\\n \\n return result\\n\\ninput_iter = iter(stdin)\\noutput = open('user.out', 'w')\\nfor array in input_iter:\\n output.write(dumps(Solution.maxSlidingWindow(loads(array), int(next(input_iter)))).replace(' ', '') + '\\\\n')\\nexit()\\n\",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n \\n window = deque([])\\n result = []\\n\\n for i in range(k):\\n while window and nums[i] > window[-1]:\\n window.pop()\\n window.append(nums[i])\\n \\n result.append(window[0])\\n\\n for i in range(k,len(nums)):\\n while window and nums[i] > window[-1]:\\n window.pop()\\n window.append(nums[i])\\n\\n if nums[i-k] == window[0]:\\n window.popleft()\\n \\n result.append(window[0])\\n \\n return result\",\n \"runtime\": \"318\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n import collections\\n q=collections.deque()\\n r=[]\\n for i in range(k):\\n while q and q[-1]<nums[i]:\\n q.pop()\\n q.append(nums[i])\\n r.append(q[0])\\n for j in range(i+1,len(nums)):\\n if nums[j-(i+1)]==q[0]:\\n q.popleft()\\n while q and q[-1]<nums[j]:\\n q.pop()\\n q.append(nums[j])\\n r.append(q[0])\\n return r\\n \\n\",\n \"runtime\": \"335\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: 'List[int]', k: 'int') -> 'List[int]':\\n queue = deque([])\\n res = []\\n for i in range(k-1):\\n while queue and nums[queue[-1]] <= nums[i]:\\n queue.pop()\\n queue.append(i)\\n for i in range(k-1, len(nums)):\\n while queue and nums[queue[-1]] <= nums[i]:\\n queue.pop()\\n queue.append(i)\\n while i - queue[0] >= k:\\n queue.popleft()\\n res.append(nums[queue[0]])\\n return res\\n\\n\\n\\n\\n\\n \\n \\n \\n \",\n \"runtime\": \"352\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n d = collections.deque()\\n for x in range(k):\\n while d and nums[d[-1]]<nums[x]:\\n d.pop()\\n d.append(x)\\n res = [nums[d[0]]]\\n #print('d-> ', d)\\n for x in range(k, len(nums)):\\n if d[0] == x-k:\\n d.popleft()\\n while d and nums[d[-1]]<nums[x]:\\n d.pop()\\n d.append(x)\\n #print('d-> ', d)\\n res.append(nums[d[0]])\\n return res\",\n \"runtime\": \"369\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n l,r=0,k-1\\n ll=[]\\n q=collections.deque()\\n for i in range(k):\\n while q and nums[i]>q[-1]:\\n q.pop()\\n q.append(nums[i])\\n ll.append(q[0])\\n for j in range(k,len(nums)):\\n if nums[j-k]==q[0]:\\n q.popleft()\\n while q and nums[j]>q[-1]:\\n q.pop()\\n q.append(nums[j])\\n ll.append(q[0])\\n return ll\\n \\n\\n\\n \\n\\n \",\n \"runtime\": \"386\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n import collections \\n q=collections.deque()\\n l=[]\\n for i in range(k):\\n while q and nums[i]>q[-1]:\\n q.pop()\\n q.append(nums[i])\\n l.append(q[0])\\n print(q)\\n for j in range(k,len(nums)):\\n if nums[j-k]==q[0]:\\n q.popleft()\\n while q and nums[j]>q[-1]:\\n q.pop()\\n q.append(nums[j])\\n l.append(q[0])\\n return l\\n \\n \\n\\n\\n \\n\\n \",\n \"runtime\": \"386\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n\\n l = 1\\n r = k-1\\n res = []\\n q = deque()\\n for i in range(k):\\n while q and nums[i] > q[-1]:\\n q.pop()\\n q.append(nums[i])\\n\\n for r in range(k, len(nums)):\\n res.append(q[0])\\n outgoing = nums[r-k]\\n if outgoing == q[0]:\\n q.popleft() \\n while q and nums[r] > q[-1]:\\n q.pop()\\n q.append(nums[r])\\n \\n res.append(q[0]) \\n return res\\n\\n \\n \\n \",\n \"runtime\": \"403\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n q = deque()\\n for i in range(k):\\n while q and nums[i] > q[-1]:\\n q.pop()\\n q.append(nums[i])\\n\\n res.append(q[0])\\n l = 0\\n for r in range(k, len(nums)):\\n while q and nums[r] > q[-1]:\\n q.pop()\\n q.append(nums[r])\\n\\n if nums[l] == q[0]:\\n q.popleft()\\n res.append(q[0])\\n l += 1\\n return res \\n\\n\\n\",\n \"runtime\": \"421\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res=[]\\n q=deque()\\n q.append(nums[0])\\n for i in range(1,k):\\n while q and q[-1]<nums[i]:\\n q.pop()\\n q.append(nums[i])\\n res.append(q[0])\\n\\n for i in range(k,len(nums)):\\n \\n # print(q)\\n if q[0]==nums[i-k]:\\n q.popleft()\\n while q and nums[i]>q[-1]:\\n q.pop()\\n q.append(nums[i])\\n\\n res.append(q[0])\\n return res\\n\\n# class Solution:\\n# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n# res=[]\\n# q=deque()\\n# q.append(nums[0])\\n# for i in range(1,k):\\n# if nums[i] in q:\\n# continue\\n# if nums[i]>q[0]:\\n# q.appendleft(nums[i])\\n# else:\\n# q.append(nums[i])\\n# res.append(q[0])\\n# for i in range(k,len(nums)):\\n# print(q)\\n# while q and nums[i]>q[-1]:\\n# q.pop()\\n# q.append(nums[i])\\n\\n# if q[0]==nums[i-k]:\\n# q.popleft()\\n# res.append(q[0])\\n# return res\\n\\n# class Solution:\\n# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n# q = collections.deque()\\n# res, n = [], len(nums)\\n# for i, j in zip(range(1 - k, n + 1 - k), range(n)):\\n# if i > 0 and deque[0] == nums[i - 1]:\\n# deque.popleft()\\n# # 保持 deque 递减\\n# while deque and deque[-1] < nums[j]:\\n# deque.pop()\\n# deque.append(nums[j])\\n# # 记录窗口最大值\\n# if i >= 0:\\n# res.append(deque[0])\\n# return res\\n\\n \\n # class Solution:\\n # def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # deque = collections.deque()\\n # res, n = [], len(nums)\\n # for i, j in zip(range(1 - k, n + 1 - k), range(n)):\\n # # 删除 deque 中对应的 nums[i-1]\\n # if i > 0 and deque[0] == nums[i - 1]:\\n # deque.popleft()\\n # # 保持 deque 递减\\n # while deque and deque[-1] < nums[j]:\\n # deque.pop()\\n # deque.append(nums[j])\\n # # 记录窗口最大值\\n # if i >= 0:\\n # res.append(deque[0])\\n # return res\\n\",\n \"runtime\": \"438\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ret = []\\n window = deque()\\n\\n if k > len(nums):\\n k = len(nums)\\n for i in range(k):\\n while window and nums[i] > nums[window[-1]]:\\n window.pop()\\n window.append(i)\\n ret.append(nums[window[0]])\\n for i in range(k, len(nums)):\\n while window and nums[i] > nums[window[-1]]:\\n window.pop()\\n if window and window[0] <= (i - k):\\n window.popleft()\\n window.append(i)\\n ret.append(nums[window[0]])\\n\\n return ret\",\n \"runtime\": \"455\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = deque()\\n q.append(nums[0])\\n for i in range(1, k):\\n while q and q[-1] < nums[i]:\\n q.pop()\\n q.append(nums[i])\\n res = [q[0]]\\n for i in range(k, len(nums)):\\n if nums[i - k] == q[0]:\\n q.popleft()\\n while q and q[-1] < nums[i]:\\n q.pop()\\n q.append(nums[i])\\n res.append(q[0])\\n return res\",\n \"runtime\": \"472\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if len(nums) <= k:\\n return [max(nums)]\\n # [3,-1]\\n moqu = deque()\\n for i in range(k):\\n while moqu and moqu[-1] < nums[i]:\\n # For the forseeable future nums[i] could be the answer\\n moqu.pop()\\n moqu.append(nums[i])\\n ret = [moqu[0]]\\n\\n for i in range(k, len(nums)):\\n # See if we need to remove the top of the stack\\n if moqu and moqu[0] == nums[i-k]: # remove it\\n moqu.popleft()\\n while moqu and moqu[-1] < nums[i]:\\n moqu.pop() # Remove all the numbers from the stack which are smaller than me\\n moqu.append(nums[i])\\n ret.append(moqu[0])\\n return ret\\n \\n\\n \",\n \"runtime\": \"489\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n window = collections.deque()\\n ans = []\\n for i in range(k - 1):\\n while window and nums[i] > window[-1]:\\n window.pop()\\n window.append(nums[i])\\n l = 0\\n for i in range(k - 1, len(nums)):\\n while window and nums[i] > window[-1]:\\n window.pop()\\n window.append(nums[i])\\n ans.append(window[0])\\n if nums[l] == window[0]:\\n window.popleft()\\n l += 1\\n return ans\\n\",\n \"runtime\": \"523\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n window = deque([])\\n out = []\\n\\n for i in range(k):\\n while window and nums[i] > window[-1]:\\n window.pop()\\n window.append(nums[i])\\n \\n out.append(window[0])\\n\\n for i in range(k, len(nums)):\\n if window and nums[i - k] == window[0]:\\n window.popleft()\\n\\n while window and nums[i] > window[-1]:\\n window.pop()\\n\\n window.append(nums[i])\\n\\n out.append(window[0])\\n \\n return out\",\n \"runtime\": \"541\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k==1:\\n return nums\\n \\n res = []\\n queue = collections.deque([])\\n for i in range(k):\\n while queue and nums[queue[-1]]<nums[i]:\\n queue.pop()\\n queue.append(i)\\n res.append(nums[queue[0]])\\n for i in range(k,len(nums)):\\n if i-k == queue[0]:\\n queue.popleft()\\n while queue and nums[queue[-1]]<nums[i]:\\n queue.pop()\\n queue.append(i)\\n res.append(nums[queue[0]])\\n return res\\n\\n\\n\\n\",\n \"runtime\": \"558\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n stack = deque([])\\n results = []\\n for i in range(k):\\n while stack and stack[-1] < nums[i]:\\n stack.pop()\\n stack.append(nums[i])\\n # if len(stack) == 0 or (stack and nums[i] < stack[-1]):\\n # stack.append(nums[i])\\n # print(nums[i], '->', stack)\\n results.append(stack[0])\\n for i in range(k, len(nums)):\\n j = i - k\\n if nums[j] == stack[0]:\\n stack.popleft()\\n\\n while stack and stack[-1] < nums[i]:\\n stack.pop()\\n stack.append(nums[i])\\n # if stack and stack[0] == nums[j]:\\n # stack.popleft()\\n\\n # if len(stack) == 0 or stack and nums[i] < stack[-1]:\\n # stack.append(nums[i])\\n # print(nums[i], '->', stack)\\n results.append(stack[0])\\n return results\\n \\n\\n\\n\",\n \"runtime\": \"575\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n q = collections.deque([])\\n for idx, i in enumerate(nums):\\n while q and q[-1] < i:\\n q.pop()\\n q.append(i)\\n\\n if idx >= k and q[0] == nums[idx-k]:\\n q.popleft()\\n\\n if idx >= k - 1:\\n res.append(q[0])\\n return res\",\n \"runtime\": \"592\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums or k == 0: return []\\n deque = collections.deque()\\n #未形成窗口\\n for i in range(k):\\n while deque and deque[-1] < nums[i]: ##因为生成的双端队列是要保证从左到右减小的 所以当位于队列最左端的数小于目前的num[i]时 就将它移出队列 直到出现比nums[i]更大的数\\n deque.pop()\\n deque.append(nums[i]) ##从右端添加上nums[i]\\n res = [deque[0]] ##因为未形成窗口 这行代码实则是在比较前k个数中的最大值 因为在每一次for循环中deque[0]都是最大的\\n #形成窗口后\\n for i in range(k, len(nums)):\\n if deque[0] == nums[i-k]: ##这两行代码看似难以理解时则十分简单：因为我们只想要当前窗口中的最大值 所以如果当前窗口中的（新的nums[i]还未加入）最大值deque[0] 是 上个窗口末尾的值nums[i - k]， 我们就将其移出 ##若不满足条件 则意味着最大值deque[0]还在新的窗口里\\n deque.popleft()\\n while deque and deque[-1] < nums[i]:\\n deque.pop()\\n deque.append(nums[i])\\n res.append(deque[0])\\n return res\",\n \"runtime\": \"609\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], window_size: int) -> List[int]:\\n d = deque()\\n res = []\\n for ix, num in enumerate(nums):\\n while d and nums[d[-1]] < num:\\n d.pop()\\n d.append(ix)\\n if d[0] == ix - window_size:\\n d.popleft()\\n if ix >= window_size-1:\\n res.append(nums[d[0]])\\n return res\",\n \"runtime\": \"626\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # O(n) runtime, selective que\\n \\n maxList = []\\n \\n d = deque()\\n \\n # Initialize\\n for i in range(k):\\n while d and d[-1] < nums[i]:\\n d.pop()\\n d.append(nums[i])\\n # Do sliding window\\n left = 1\\n right = k\\n \\n maxList.append(d[0])\\n \\n while right != len(nums):\\n if nums[left-1] == d[0]:\\n d.popleft()\\n while d and d[-1] < nums[right]:\\n d.pop() \\n d.append(nums[right])\\n maxList.append(d[0])\\n \\n left += 1\\n right += 1\\n \\n return maxList\\n \\n \\n \",\n \"runtime\": \"644\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n q = deque()\\n \\n for idx, num in enumerate(nums):\\n\\n #record the queue in descending order\\n while q and q[-1]<num:\\n #pop the queue until the number is in the right order\\n q.pop()\\n q.append(num)\\n\\n if idx>=k and nums[idx-k] == q[0]:\\n # if the max num equals the out of index num, then should pop it\\n q.popleft()\\n \\n if idx >= k-1:\\n res.append(q[0])\\n \\n return res\\n\\n \",\n \"runtime\": \"644\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n #first solution is borrowed from editorial\\n dq = deque()\\n res = []\\n \\n for i in range(k):\\n while dq and nums[i] >= nums[dq[-1]]:\\n dq.pop()\\n dq.append(i)\\n\\n res.append(nums[dq[0]])\\n\\n for i in range(k, len(nums)):\\n if dq and dq[0] == i - k:\\n dq.popleft()\\n while dq and nums[i] >= nums[dq[-1]]:\\n dq.pop()\\n\\n dq.append(i)\\n res.append(nums[dq[0]])\\n\\n return res\\n\\n \\n\\n #time limit exceeds for the below approach\\n left = 0\\n right = k\\n length = len(nums)\\n output = []\\n while right <= length:\\n maximum = max(nums[left:right])\\n output.append(maximum)\\n right += 1\\n left += 1\\n \\n return output\\n\",\n \"runtime\": \"661\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if len(nums) <= k:\\n return [max(nums)]\\n # [3,-1]\\n moqu = deque()\\n for i in range(k):\\n while moqu and nums[i] > moqu[-1]:\\n moqu.pop()\\n moqu.append(nums[i])\\n \\n ret = [moqu[0]]\\n for i in range(k, len(nums)):\\n if moqu and nums[i-k] == moqu[0]:\\n moqu.popleft()\\n while moqu and nums[i] > moqu[-1]:\\n moqu.pop()\\n moqu.append(nums[i])\\n ret.append(moqu[0])\\n \\n return ret\\n \\n\\n \",\n \"runtime\": \"678\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n dq = deque()\\n res = []\\n\\n for i in range(k):\\n while dq and nums[i] >= nums[dq[-1]]:\\n dq.pop()\\n dq.append(i)\\n\\n res.append(nums[dq[0]])\\n\\n for i in range(k, len(nums)):\\n if dq and dq[0] == i - k:\\n dq.popleft()\\n while dq and nums[i] >= nums[dq[-1]]:\\n dq.pop()\\n dq.append(i)\\n res.append(nums[dq[0]])\\n\\n return res\",\n \"runtime\": \"695\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n stack = collections.deque()\\n # prcess first k\\n for i in range(k):\\n while stack and nums[i] > stack[-1]:\\n stack.pop()\\n stack.append(nums[i])\\n # after this, largest value will be on position 0\\n # then the second largest, third largest \\n\\n res = [stack[0]]\\n for i in range(k, len(nums)):\\n num_remove = nums[i-k]\\n num_append = nums[i]\\n if num_remove == stack[0]:\\n stack.popleft()\\n while stack and num_append > stack[-1]:\\n stack.pop()\\n stack.append(num_append)\\n res.append(stack[0])\\n # largest value will be the left most value\\n\\n return res\\n \\n \",\n \"runtime\": \"712\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums, k):\\n q = deque()\\n\\n for i in range(k):\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n\\n results = [nums[q[0]]]\\n\\n for i in range(k, len(nums)):\\n if q and q[0] <= i - k:\\n q.popleft()\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n results.append(nums[q[0]])\\n \\n return results\\n\",\n \"runtime\": \"729\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n stack = deque()\\n res = []\\n for idx in range(0, k-1):\\n while len(stack) and nums[idx] > stack[-1]:\\n stack.pop()\\n stack.append(nums[idx])\\n left = 0\\n for right in range(k-1, len(nums)):\\n while len(stack) and nums[right] > stack[-1]:\\n stack.pop()\\n stack.append(nums[right])\\n \\n \\n res.append(stack[0])\\n \\n \\n if stack[0] == nums[left]:\\n stack.popleft()\\n \\n left += 1\\n return res\\n\\n \",\n \"runtime\": \"746\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n n = len(nums)\\n q = deque()\\n res = []\\n for i in range(k):\\n while q and nums[q[-1]] <= nums[i]:\\n q.pop()\\n q.append(i)\\n res.append(nums[q[0]])\\n for i in range(k, n):\\n if q and q[0] <= i-k:\\n q.popleft()\\n while q and nums[q[-1]] <= nums[i]:\\n q.pop()\\n q.append(i)\\n res.append(nums[q[0]]) \\n return res \",\n \"runtime\": \"764\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n n = len(nums)\\n \\n # monotonic deque method\\n dq = deque()\\n\\n # first window\\n for i in range(k):\\n while dq and nums[dq[-1]] < nums[i]:\\n dq.pop()\\n dq.append(i)\\n res.append(nums[dq[0]])\\n # move to the right each time\\n for i in range(k, len(nums)): # nums[i] newly added element each time\\n if dq and dq[0] == i - k: # if previous id still in queue\\n dq.popleft()\\n while dq and nums[dq[-1]] < nums[i]:\\n dq.pop()\\n dq.append(i)\\n res.append(nums[dq[0]])\\n \\n return res\\n\\n\",\n \"runtime\": \"781\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n window = deque()\\n for n in nums[:k]:\\n while len(window) > 0 and window[-1] < n:\\n window.pop()\\n window.append(n)\\n for last_n, n in zip(nums[:-k], nums[k:]):\\n # print(f\\\"last_n: {last_n}, n: {n}, window: {window}\\\")\\n tmp = window[0]\\n if last_n == tmp:\\n window.popleft()\\n res.append(tmp)\\n while len(window) > 0 and window[-1] < n:\\n window.pop()\\n window.append(n)\\n res.append(window[0])\\n return res\\n\",\n \"runtime\": \"798\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # Queue approach\\n queue = deque()\\n for i in range(k):\\n while queue and nums[queue[-1]] <= nums[i]:\\n queue.pop()\\n queue.append(i)\\n \\n result = []\\n result.append(nums[queue[0]])\\n for i in range(k, len(nums)):\\n if queue[0] + k <= i:\\n queue.popleft()\\n while queue and nums[queue[-1]] <= nums[i]:\\n queue.pop()\\n queue.append(i)\\n result.append(nums[queue[0]])\\n return result\",\n \"runtime\": \"815\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n\\n queue = deque()\\n res = []\\n\\n for i in range(0, k):\\n if i == 0:\\n queue.append(i)\\n elif nums[i] < nums[i -1]:\\n queue.append(i)\\n else:\\n while queue and nums[queue[-1]] <= nums[i]:\\n queue.pop()\\n queue.append(i)\\n \\n res.append(nums[queue[0]])\\n\\n for i in range(k, len(nums)):\\n if queue[0] < i - k + 1:\\n queue.popleft()\\n if nums[i] <= nums[i - 1]:\\n queue.append(i)\\n else:\\n while queue and nums[queue[-1]] <= nums[i]:\\n queue.pop()\\n queue.append(i)\\n \\n res.append(nums[queue[0]])\\n return res\\n\\n\\n\\n \",\n \"runtime\": \"832\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n from collections import deque\\n queue = deque([])\\n ans = []\\n for i in range(k):\\n while queue and nums[queue[-1]] <= nums[i]:\\n queue.pop()\\n queue.append(i)\\n ans.append(nums[queue[0]])\\n\\n for i in range(k,len(nums)):\\n if queue and queue[0] == i-k:\\n queue.popleft()\\n while queue and nums[queue[-1]] <= nums[i]:\\n queue.pop()\\n queue.append(i)\\n ans.append(nums[queue[0]])\\n return ans\\n\\n '''\\n right = 0 \\n window = nums[:k]\\n ans = [max(nums[:k])]\\n for i in range(k,len(nums)):\\n window = window[1:] + [nums[i]]\\n ans.append(max(window))\\n \\n return ans \\n '''\\n\\n\\n\\n \",\n \"runtime\": \"849\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n from collections import deque\\n res = [0] * (len(nums) - k + 1)\\n queue = deque()\\n\\n #we use a monotonically decreasing stack\\n for r in range(len(nums)):\\n while queue and queue[-1] < nums[r]:\\n queue.pop()\\n queue.append(nums[r])\\n\\n\\n if (r + 1) >= k:\\n res[r - k + 1] = queue[0]\\n if nums[r - k + 1] == queue[0]:\\n queue.popleft()\\n \\n return res\\n \\n\\n\\n\",\n \"runtime\": \"866\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n max_queue = deque()\\n left = 0\\n ans = []\\n\\n for right in range(k):\\n while max_queue and nums[max_queue[-1]] < nums[right]:\\n max_queue.pop()\\n max_queue.append(right)\\n \\n # first element of answer array\\n ans.append(nums[max_queue[0]])\\n # print(max_queue)\\n # print(ans)\\n # sliiiide the window!\\n for right in range(k, len(nums)):\\n # check if the current max has fallen out of range of the sliding window\\n if max_queue:\\n if right - max_queue[0] >= k:\\n max_queue.popleft()\\n \\n while max_queue and nums[max_queue[-1]] < nums[right]:\\n max_queue.pop()\\n \\n max_queue.append(right)\\n # at this point we should have a valid subarray of length k, with max at deque[0]\\n ans.append(nums[max_queue[0]])\\n \\n return ans\",\n \"runtime\": \"884\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ans = []\\n q = deque()\\n for i in range(k):\\n while q and nums[i] >= nums[q[-1]]:\\n q.pop()\\n q.append(i)\\n \\n ans.append(nums[q[0]])\\n\\n for i in range(k, len(nums)):\\n if q and q[0] == i - k:\\n q.popleft()\\n while q and nums[i] >= nums[q[-1]]:\\n q.pop()\\n \\n q.append(i)\\n ans.append(nums[q[0]])\\n\\n return ans\",\n \"runtime\": \"901\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = deque() #monotonic decreasing q\\n l = 0\\n res = []\\n for i,n in enumerate(nums):\\n while q and n > nums[q[-1]]:\\n q.pop()\\n q.append(i)\\n\\n if l > q[0]:\\n q.popleft()\\n \\n if (i+1) >= k:\\n res.append(nums[q[0]])\\n l+=1\\n return res\\n\\n\",\n \"runtime\": \"918\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n queue = deque()\\n result = []\\n n = len(nums)\\n for i in range(k):\\n while queue and nums[queue[-1]] < nums[i]:\\n queue.pop()\\n queue.append(i)\\n result.append(nums[queue[0]])\\n\\n for i in range(k,n):\\n if queue and queue[0] <= i-k:\\n queue.popleft()\\n while queue and nums[queue[-1]] < nums[i]:\\n queue.pop()\\n queue.append(i)\\n\\n result.append(nums[queue[0]])\\n\\n return result\",\n \"runtime\": \"935\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ret=[]\\n q = deque()\\n for i in range(len(nums)):\\n num = nums[i]\\n while q and q[-1] < num:\\n q.pop()\\n q.append(num)\\n\\n if i >= k and q[0] == nums[i-k]:\\n q.popleft()\\n if i >= k -1:\\n ret.append(q[0])\\n return ret\\n\\n \\n \",\n \"runtime\": \"952\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n queue = deque()\\n res = []\\n\\n for idx, val in enumerate(nums):\\n while queue and queue[-1] < val:\\n queue.pop()\\n\\n queue.append(val)\\n if idx >= k and queue[0] == nums[idx - k]:\\n queue.popleft()\\n\\n if idx >= k - 1:\\n res.append(queue[0])\\n\\n return res\\n\",\n \"runtime\": \"969\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n buffer = deque()\\n\\n for i in range(0, k):\\n while len(buffer) > 0 and nums[i] > buffer[-1]:\\n buffer.pop()\\n\\n buffer.append(nums[i])\\n\\n result = [buffer[0]]\\n\\n for i in range(k, len(nums)):\\n if buffer[0] == nums[i - k]:\\n buffer.popleft()\\n \\n while len(buffer) > 0 and nums[i] > buffer[-1]:\\n buffer.pop()\\n\\n buffer.append(nums[i])\\n result.append(buffer[0])\\n \\n return result\\n\",\n \"runtime\": \"969\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n stack = deque()\\n res = []\\n for idx in range(0, k-1):\\n while len(stack) and nums[idx] > stack[-1]:\\n stack.pop()\\n stack.append(nums[idx])\\n left = 0\\n for right in range(k-1, len(nums)):\\n while len(stack) and nums[right] > stack[-1]:\\n stack.pop()\\n stack.append(nums[right])\\n \\n \\n res.append(stack[0])\\n \\n \\n if stack[0] == nums[left]:\\n stack.popleft()\\n \\n left += 1\\n return res\\n\\n \",\n \"runtime\": \"987\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = collections.deque([])\\n r = []\\n\\n for i in range(k):\\n while q and nums[i] > nums[q[-1]]:\\n q.pop()\\n q.append(i)\\n \\n r.append(nums[q[0]])\\n\\n for i in range(k ,len(nums)):\\n if q and q[0] == i - k: \\n q.popleft() # expired \\n while q and nums[i] >= nums[q[-1]]:\\n q.pop()\\n \\n q.append(i)\\n r.append(nums[q[0]])\\n \\n return r\",\n \"runtime\": \"987\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n stack = deque()\\n\\n for i in range(len(nums)):\\n while stack and nums[i] > stack[-1]:\\n stack.pop()\\n stack.append(nums[i])\\n\\n if i >= k and nums[i - k] == stack[0]:\\n stack.popleft()\\n\\n if i >= k - 1:\\n res.append(stack[0])\\n\\n return res\",\n \"runtime\": \"1004\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n stack = deque()\\n for i in range(k):\\n if len(stack) == 0:\\n stack.append(nums[i])\\n else:\\n while stack and nums[i] > stack[-1]:\\n stack.pop()\\n stack.append(nums[i])\\n result = []\\n result.append(stack[0])\\n for i in range(k, len(nums)):\\n pop_val = nums[i - k]\\n if pop_val == stack[0]:\\n stack.popleft()\\n while stack and nums[i] > stack[-1]:\\n stack.pop()\\n stack.append(nums[i]) \\n result.append(stack[0])\\n return result\\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"1004\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n dq = deque()\\n n = len(nums)\\n result = []\\n for i in range(n):\\n # print(dq)\\n if i >= k:\\n result.append(dq[0])\\n if nums[i - k] == dq[0]:\\n dq.popleft()\\n while len(dq) > 0 and dq[-1] < nums[i]:\\n dq.pop()\\n dq.append(nums[i])\\n \\n result.append(dq[0])\\n return result\\n\",\n \"runtime\": \"1021\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = deque()\\n i = 0\\n res = []\\n while i < k:\\n while q and nums[i] > nums[q[-1]]:\\n q.pop()\\n q.append(i)\\n i += 1\\n res.append(nums[q[0]])\\n while i < len(nums):\\n while q and nums[i] > nums[q[-1]]:\\n q.pop()\\n q.append(i)\\n if q[0] <= i - k:\\n q.popleft()\\n res.append(nums[q[0]])\\n i += 1\\n return res\\n \\n\",\n \"runtime\": \"1038\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n\\n queue = deque()\\n for i in range(k):\\n while queue and nums[i]>queue[-1]:\\n queue.pop()\\n queue.append(nums[i])\\n \\n ans = []\\n ans.append(queue[0])\\n\\n for i in range(k,len(nums)):\\n going_index = i-k\\n coming_index = i\\n\\n while queue and nums[coming_index]>queue[-1]:\\n queue.pop()\\n queue.append(nums[coming_index])\\n if queue and nums[going_index] == queue[0]:\\n queue.popleft()\\n \\n ans.append(queue[0])\\n return ans\\n\\n\\n\\n \",\n \"runtime\": \"1055\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n\\n from collections import deque\\n\\n # build the initial deque\\n dq = deque()\\n\\n for i in range(k):\\n while (len(dq)!=0) and (dq[-1]<nums[i]):\\n dq.pop()\\n dq.append(nums[i])\\n \\n result = [dq[0]]\\n \\n for idx in range(k, len(nums)):\\n\\n if result[-1]==nums[idx-k]:\\n dq.popleft()\\n\\n while (len(dq)!=0) and (dq[-1]<nums[idx]):\\n dq.pop()\\n \\n dq.append(nums[idx])\\n\\n result.append(dq[0])\\n \\n return result\",\n \"runtime\": \"1055\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k >= len(nums): return [max(nums)]\\n dq = deque()\\n for i in range(k):\\n num = nums[i]\\n while dq and dq[-1] < num:\\n dq.pop()\\n dq.append(num)\\n ans = []\\n ans.append(dq[0])\\n left = 0\\n for right in range(k,len(nums)):\\n num = nums[right]\\n leftnum = nums[left]\\n if leftnum == dq[0]:\\n dq.popleft()\\n while dq and dq[-1] < num:\\n dq.pop()\\n dq.append(num)\\n ans.append(dq[0])\\n left += 1\\n return ans\",\n \"runtime\": \"1072\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n dq = deque()\\n res= []\\n for i in range(k):\\n while dq and nums[dq[-1]]<= nums[i]:\\n dq.pop()\\n dq.append(i)\\n\\n res.append(nums[dq[0]])\\n left = 0\\n for i in range(k,len(nums)):\\n while dq and dq[0] <=left:\\n dq.popleft()\\n while dq and nums[dq[-1]]<= nums[i]:\\n dq.pop()\\n dq.append(i)\\n left+=1\\n res.append(nums[dq[0]])\\n return res\\n \\n\\n \\n\\n \",\n \"runtime\": \"1072\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ans = []\\n dq = deque()\\n i, j = 0, 0\\n\\n for i in range(len(nums)):\\n # Remove elements from the deque if they are out of the window\\n if dq and dq[0] < i - k + 1:\\n dq.popleft()\\n \\n # Remove elements from the deque if they are smaller than the current element\\n # because they are not useful anymore\\n while dq and nums[dq[-1]] < nums[i]:\\n dq.pop()\\n\\n # Add the current element index to the deque\\n dq.append(i)\\n \\n # Start appending results once the window size reaches k\\n if i >= k - 1:\\n ans.append(nums[dq[0]])\\n\\n return ans\",\n \"runtime\": \"1089\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n q = deque()\\n\\n for idx, num in enumerate(nums):\\n while q and q[-1]<num:\\n q.pop()\\n q.append(num)\\n\\n if idx>=k and nums[idx-k] == q[0]:\\n q.popleft()\\n\\n if idx>=k-1:\\n res.append(q[0])\\n return res\",\n \"runtime\": \"1089\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ans = []\\n queue = deque()\\n for i in range(len(nums)):\\n # maintain monotonic decreasing.\\n # all elements in the deque smaller than the current one\\n # have no chance of being the maximum, so get rid of them\\n while queue and nums[i] > nums[queue[-1]]:\\n queue.pop()\\n\\n queue.append(i)\\n\\n # queue[0] is the index of the maximum element.\\n # if queue[0] + k == i, then it is outside the window\\n if queue[0] + k == i:\\n queue.popleft()\\n \\n # only add to the answer once our window has reached size k\\n if i >= k - 1:\\n ans.append(nums[queue[0]])\\n\\n return ans\\n \",\n \"runtime\": \"1107\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n l = 0\\n r = 0\\n res = []\\n queue = deque()\\n # basically we want to maintain a monotonic decreasing queue\\n while r<len(nums):\\n if r-l+1<k:\\n while queue and nums[r]>queue[-1]:\\n queue.pop()\\n queue.append(nums[r])\\n r+=1\\n continue\\n\\n while queue and nums[r]>queue[-1]:\\n queue.pop()\\n queue.append(nums[r])\\n\\n res.append(queue[0])\\n \\n # if window moves\\n if queue[0]==nums[l]:\\n queue.popleft()\\n l+=1\\n r+=1\\n return res\\n\",\n \"runtime\": \"1107\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n from collections import deque\\n deque_window = deque()\\n ans = []\\n for i in range(len(nums)):\\n if deque_window and deque_window[0] == i - k:\\n deque_window.popleft()\\n \\n while deque_window and nums[deque_window[-1]] < nums[i]:\\n deque_window.pop()\\n \\n deque_window.append(i)\\n\\n if i >= k - 1:\\n ans.append(nums[deque_window[0]])\\n \\n return ans\",\n \"runtime\": \"1124\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if len(nums) < k or len(nums) == 0 or k == 0:\\n return []\\n \\n window = deque()\\n res = []\\n\\n for l, r in enumerate(nums):\\n while window and window[0] < l-k+1:\\n window.popleft()\\n \\n while window and r > nums[window[-1]]:\\n window.pop()\\n\\n window.append(l)\\n\\n if l >= k-1:\\n res.append(nums[window[0]])\\n\\n return res\\n \\n return res\\n \",\n \"runtime\": \"1124\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n\\n stack = Deque()\\n out = []\\n for i in range(len(nums)):\\n while stack and (nums[i] >= nums[stack[-1]] or i - stack[-1] >= k):\\n stack.pop()\\n \\n while stack and i - stack[0] >= k:\\n stack.popleft()\\n\\n stack.append(i)\\n if i >= k - 1:\\n out.append(nums[stack[0]])\\n \\n return out\\n\\n \\n\\n\\n\",\n \"runtime\": \"1141\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n output = []\\n q = collections.deque()\\n l = r = 0\\n\\n while r < len(nums):\\n while q and nums[q[-1]] < nums[r]:\\n q.pop()\\n q.append(r)\\n\\n # remove left val from window\\n if l > q[0]:\\n q.popleft()\\n\\n if r + 1 >= k:\\n output.append(nums[q[0]])\\n l += 1\\n\\n r += 1\\n\\n return output\",\n \"runtime\": \"1141\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k == 1:\\n return nums\\n\\n queue = deque()\\n result = []\\n left, right = 0, 0\\n\\n while right < len(nums):\\n num = nums[right]\\n while len(queue) and queue[-1] < num:\\n queue.pop()\\n queue.append(num)\\n\\n \\n length = right - left + 1\\n if length == k:\\n result.append(queue[0])\\n if queue[0] == nums[left]:\\n queue.popleft()\\n left += 1\\n\\n\\n right += 1\\n\\n return result\\n\\n \",\n \"runtime\": \"1158\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n output = []\\n q = deque() # index\\n l = r = 0\\n\\n while r < len(nums):\\n while q and nums[q[-1]] < nums[r]:\\n q.pop()\\n q.append(r)\\n\\n if l > q[0]:\\n q.popleft()\\n\\n if (r + 1) >= k:\\n output.append(nums[q[0]])\\n l += 1\\n r += 1\\n\\n return output\",\n \"runtime\": \"1158\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n \\n listOut = []\\n l,r = 0,0\\n queue = deque()\\n localM = 0\\n \\n while r< len(nums):\\n while len(queue) > 0 and nums[queue[-1]]<nums[r]:\\n queue.pop()\\n queue.append(r)\\n \\n if l>queue[0]:\\n queue.popleft()\\n\\n if (r+1) >= k:\\n listOut.append(nums[queue[0]])\\n l+=1\\n r+=1\\n return listOut\",\n \"runtime\": \"1175\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n \\\"\\\"\\\"\\n nums = [1,3,-1,-3,5,3,6,7], k = 3\\n num = 1: push its index and num (0,1) to the q.\\n num = 3: while 3 is greater than last num of q, pop the last item, and finally push (1, 3) to q.\\n ...\\n Check the window size: Remove earlier element from q that is out of current window.\\n \\\"\\\"\\\"\\n\\n res = []\\n q = deque()\\n\\n for i, num in enumerate(nums):\\n while q and q[-1][1] < num:\\n q.pop()\\n\\n q.append((i, num))\\n\\n if q[-1][0] - q[0][0] + 1 > k:\\n q.popleft()\\n\\n res.append(q[0][1])\\n\\n return res[k-1:]\",\n \"runtime\": \"1175\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = deque()\\n res = []\\n l = r = 0\\n\\n while r < len(nums):\\n # pop smaller val\\n while q and nums[q[-1]] < nums[r]:\\n q.pop()\\n q.append(r)\\n\\n # remove left val\\n if l > q[0]:\\n q.popleft()\\n \\n if (r + 1) >= k:\\n res.append(nums[q[0]])\\n l += 1\\n\\n r += 1\\n return res\\n\\n \\n \",\n \"runtime\": \"1192\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n win, rslt =[],[] \\n for i,x in enumerate(nums):\\n # 两种方式需要进行移除操作\\n # 一种是维持一个单调递减队列，如果之前数据小于当前数据直接pop移除之前数据（这里是一i那位添加当前数据的操作在后面所以可以保证第一个元素是最大值）\\n # 一种是达到窗口数量k需要直接pop移除最先进度队列的数据\\n if i>=k and win[0]<=i-k:\\n win.pop(0)\\n # 维护一个单调递减队列\\n while win and nums[win[-1]]<=x:\\n win.pop()\\n win.append(i)\\n if i>=k-1:\\n rslt.append(nums[win[0]])\\n return rslt\\n\\n\\n\",\n \"runtime\": \"1192\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n idx_Q, maxes = deque(), [] \\n INIT,LN = 0,len(nums)\\n\\n def next_greater_right():\\n next_val = nums[right]\\n return next_val > nums[idx_Q[-1]]\\n\\n def left_out_of_bounds():\\n prev_left = idx_Q[0]\\n return prev_left < left\\n\\n left = right = INIT\\n while right < LN:\\n while idx_Q and next_greater_right():\\n idx_Q.pop()\\n \\n idx_Q.append(right)\\n\\n if left_out_of_bounds(): idx_Q.popleft()\\n\\n next=right+1\\n if next >= k:\\n maxes.append(nums[idx_Q[0]])\\n left += 1\\n right += 1\\n\\n return maxes\",\n \"runtime\": \"1209\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n q = deque()\\n l = 0\\n for r in range(len(nums)):\\n while q and q[-1] < nums[r]:\\n q.pop()\\n q.append(nums[r])\\n while (r - l + 1) > k:\\n if nums[l] == q[0]:\\n q.popleft()\\n l += 1\\n if (r - l + 1) == k:\\n res.append(q[0])\\n return res\",\n \"runtime\": \"1209\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ub = []\\n result = []\\n for i in range(k):\\n heapq.heappush(ub, -nums[i])\\n result.append(-ub[0]) \\n todo = [] # also a heap\\n for i in range(k, len(nums)):\\n # number to be removed\\n kick = nums[i-k]\\n new = nums[i]\\n if kick == -ub[0]:\\n heapq.heappop(ub)\\n else:\\n heapq.heappush(todo, -kick)\\n\\n\\n while len(todo) != 0:\\n if todo[0] == ub[0]:\\n heapq.heappop(ub)\\n heapq.heappop(todo)\\n else:\\n break\\n\\n\\n\\n heapq.heappush(ub, -new)\\n result.append(-ub[0])\\n return result\\n\",\n \"runtime\": \"1227\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n deque = []\\n ans = []\\n for i in range(len(nums)):\\n while len(deque) > 0 and deque[0] < i-k+1:\\n deque.pop(0)\\n while len(deque) > 0 and nums[deque[-1]] <= nums[i]:\\n deque.pop(-1)\\n deque.append(i)\\n if i >= k-1:\\n ans.append(nums[deque[0]])\\n\\n return ans\",\n \"runtime\": \"1227\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n numCount = {}\\n queue = deque()\\n for n in nums[:k]:\\n numCount[n] = numCount.get(n, 0) + 1\\n while queue and queue[-1] <= n:\\n queue.pop()\\n queue.append(n)\\n\\n ans = [queue[0]]\\n for i in range(0, len(nums) - k): # O(n)\\n # remove\\n numCount[nums[i]] -= 1\\n while queue and numCount[queue[0]] == 0:\\n queue.popleft()\\n # append\\n numCount[nums[i + k]] = numCount.get(nums[i + k], 0) + 1\\n while queue and queue[-1] <= nums[i + k]:\\n queue.pop()\\n queue.append(nums[i + k])\\n ans.append(queue[0])\\n return ans\",\n \"runtime\": \"1244\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k >= len(nums):\\n return [max(nums)]\\n stack = []\\n ans = []\\n for i in range(k):\\n if not stack:\\n stack.append((nums[i],i))\\n continue\\n if nums[i] >= stack[0][0]:\\n stack = [(nums[i],i)]\\n else:\\n while stack and (stack[-1][0] <= nums[i]):\\n stack.pop()\\n stack.append((nums[i],i))\\n # stack.append((nums[i],i))\\n ans.append(stack[0][0])\\n for i in range(k,len(nums)):\\n if stack[0][1] < i-k +1:\\n stack.pop(0)\\n if not stack or (nums[i] >= stack[0][0]):\\n stack = [(nums[i],i)]\\n ans.append(nums[i])\\n else:\\n while stack and (stack[-1][0] <= nums[i]):\\n stack.pop()\\n stack.append((nums[i],i))\\n ans.append(stack[0][0])\\n return ans\\n\",\n \"runtime\": \"1244\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n i = 0\\n j = 0\\n queue = []\\n ans = []\\n while j < k:\\n if len(queue) == 0:\\n queue.append((nums[j],j))\\n else:\\n cur = (nums[j], j)\\n while len(queue) > 0 and queue[-1][0] <= cur[0]:\\n queue.pop()\\n queue.append(cur)\\n\\n j+=1\\n ans.append(queue[0][0])\\n j-=1\\n while j < len(nums):\\n if queue[0][1] == i:\\n queue.pop(0)\\n i+=1\\n j+=1\\n if j == len(nums):\\n break\\n cur = (nums[j], j)\\n while len(queue) > 0 and queue[-1][0] <= cur[0]:\\n queue.pop()\\n queue.append(cur)\\n ans.append(queue[0][0])\\n return ans\",\n \"runtime\": \"1261\"\n },\n {\n \"code\": \"from collections import deque\\nimport heapq\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = deque()\\n heap = []\\n ans = []\\n if k == 1:\\n return nums\\n\\n max = float('-inf')\\n for j, i in enumerate(nums):\\n if len(q) < k:\\n q.append(i)\\n if i > max:\\n max = i\\n heap = []\\n else:\\n heapq.heappush(heap, (-1*i, j))\\n else:\\n ans.append(max)\\n pop = q.popleft()\\n if pop == max:\\n pop, index = heapq.heappop(heap)\\n max = pop*-1\\n while heap:\\n if heap[0][1] < index:\\n heapq.heappop(heap)\\n else:\\n break\\n q.append(i)\\n if i > max:\\n heap = []\\n max = i\\n else:\\n heapq.heappush(heap, (-1*i, j))\\n ans.append(max)\\n return ans\\n\\n \\n\\n# 1 3 -1 : 3 : -1 \\n# 3 -1 -3 : 3 : -1 -3\\n# -1 -3 5 : if next one is larger, clear heap \\n\\n# -7 -8 7 5 : 7 : 5\\n# -8 7 5 7 : 7 : \\n# 7 5 7 1 : 7 : 1\\n# 5 7 1 6 : 7 : 6 1\\n\\n# 3 8 3 3 3 6 3 7 3 4 3 3 3 3 \\n# 3 8 3 3 3 6 3 7 : 8 : 7 6 \\n# 3 3 3 6 3 7 3 4 : 7 : 6 4\",\n \"runtime\": \"1295\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n heap = []\\n for i in range(k):\\n heapq.heappush(heap,(-1 * nums[i],i + k - 1))\\n ans = [-1 * heap[0][0]]\\n for i in range(k,len(nums)):\\n heapq.heappush(heap,(-1 * nums[i],i + k - 1))\\n while heap[0][1] < i:\\n heapq.heappop(heap)\\n\\n ans.append(-1 * heap[0][0])\\n \\n \\n return ans\",\n \"runtime\": \"1295\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k == 1:\\n return nums\\n\\n left = [0] * len(nums)\\n right = [0] * len(nums)\\n left[0] = nums[0]\\n right[-1] = nums[-1]\\n result = []\\n\\n for i in range(1, len(nums)):\\n if i % k == 0:\\n left[i] = nums[i]\\n\\n else:\\n left[i] = max(left[i - 1], nums[i])\\n\\n j = len(nums) - i - 1\\n\\n if (j + 1) % k == 0:\\n right[j] = nums[j]\\n\\n else:\\n right[j] = max(right[j + 1], nums[j])\\n\\n for start in range(len(nums) - k + 1):\\n end = start + k - 1\\n result.append(max(left[end], right[start]))\\n\\n return result\",\n \"runtime\": \"1312\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n window = []\\n max_sliding_window = []\\n for index, num in enumerate(nums):\\n if index < k - 1:\\n heapq.heappush(window, (-num, index))\\n elif index >= k - 1:\\n heapq.heappush(window, (-num, index))\\n while window[0][1] < len(max_sliding_window):\\n heapq.heappop(window)\\n max_sliding_window.append(-window[0][0])\\n return max_sliding_window\",\n \"runtime\": \"1312\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n a = []\\n res = []\\n for i in range(k):\\n heapq.heappush(a,(-nums[i],i))\\n res.append(-a[0][0])\\n for i in range(0,len(nums)-k):\\n heapq.heappush(a,(-nums[i+k],i+k))\\n while a[0][1]<=i:\\n heapq.heappop(a)\\n res.append(-a[0][0])\\n return res\",\n \"runtime\": \"1330\"\n },\n {\n \"code\": \"from collections import deque \\n\\nclass QueueElem:\\n def __init__(self, val, idx) -> None:\\n self.val = val\\n self.idx = idx\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxWindow = []\\n dequeue = deque([])\\n\\n for i in range(0, len(nums)):\\n # clean queue:\\n while len(dequeue) > 0 and dequeue[0].idx <= i-k:\\n dequeue.popleft()\\n while len(dequeue) > 0 and dequeue[len(dequeue) -1].val < nums[i]:\\n dequeue.pop()\\n dequeue.append(QueueElem(nums[i], i))\\n \\n if i>= k-1:\\n maxWindow.append(dequeue[0].val)\\n\\n return maxWindow\\n \",\n \"runtime\": \"1330\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n N = len(nums)\\n freq = defaultdict(int)\\n heap = [] # Max heap so negate values\\n \\n l, r = 0, 0\\n for r in range(k):\\n freq[nums[r]] += 1\\n heapq.heappush(heap, -nums[r])\\n res = []\\n while r < N:\\n curr_max = -heap[0]\\n while heap and freq[curr_max] == 0:\\n heapq.heappop(heap)\\n curr_max = -heap[0]\\n res.append(curr_max)\\n if r == N-1:\\n break\\n r += 1\\n heapq.heappush(heap, -nums[r])\\n freq[nums[r]] += 1\\n freq[nums[l]] -= 1\\n l += 1\\n return res\",\n \"runtime\": \"1347\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if len(nums) == 1:\\n return [nums[0]]\\n elif k == 1:\\n return nums\\n \\n h = []\\n out = []\\n for i, n in enumerate(nums):\\n if i < k:\\n heapq.heappush(h, (-1*n, i))\\n if i == k-1:\\n out.append(h[0][0]*-1)\\n continue\\n while i-k >= h[0][1]:\\n heapq.heappop(h)\\n\\n heapq.heappush(h, (-1*n, i))\\n out.append(h[0][0]*-1)\\n\\n return out\",\n \"runtime\": \"1347\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n n = len(nums)\\n heap = []\\n res = []\\n\\n for i in range(n):\\n while len(heap) > 0 and i - heap[0][1] >= k:\\n heapq.heappop(heap)\\n\\n heapq.heappush(heap, (-nums[i], i))\\n\\n if i + 1 >= k:\\n res.append(-heap[0][0])\\n\\n return res\\n\\n \\n\\n\",\n \"runtime\": \"1364\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k == 1:\\n return nums\\n \\n rwind = [(-val,i) for i,val in enumerate(nums[:k])]\\n\\n heapq.heapify(rwind)\\n\\n res = [-rwind[0][0]]\\n\\n for i in range(k,len(nums)):\\n while rwind[0][1] <= i-k: \\n heapq.heappop(rwind)\\n heapq.heappush(rwind, (-nums[i],i))\\n res.append(-rwind[0][0])\\n \\n return res\\n\\n \",\n \"runtime\": \"1364\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n h,ans =[],[]\\n for i in range(k):heappush(h,(-nums[i],i))\\n ans.append(-h[0][0])\\n for i in range(k,len(nums)):\\n heappush(h, (-nums[i],i)) \\n while h and (i - h[0][1]) >=k:heappop(h) \\n ans.append((-h[0][0]))\\n return ans\\n\\n \",\n \"runtime\": \"1381\"\n },\n {\n \"code\": \"# 需要一种新的队列结构，既能够维护队列元素「先进先出」的时间顺序，又能够正确维护队列中所有元素的最值，这就是「单调队列」结构。\\n# 判断一个窗口中最值的例子，你无法单凭移出窗口的那个元素更新窗口的最值，除非重新遍历所有元素\\n# 此题维护一个单调递减序列\\n############ Solution 1: Monotonic Deque ############ \\n# #!!! 非常简洁的写法,推荐！使用了 deque(pop是O1)和index（而非value）\\n# 使用单调递减队列而不是单调递增的原因在于我们希望快速获取当前窗口的最大值。通过维护一个单调递减队列，我们可以【确保队列头部元素始终是当前窗口的最大值】。每次窗口移动时，头部元素若过期则移除，使得新的头部元素始终是当前窗口的最大值。这种方法在时间复杂度和空间复杂度上都是最优的方案。\\n\\n# # time: O(n)\\n# # space: O(k)\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxq = deque()\\n res = []\\n\\n for i in range(len(nums)):\\n \\n # 移除不在窗口范围内的索引\\n while maxq and maxq[0] < i - k + 1:\\n maxq.popleft()\\n \\n # 移除所有小于当前元素的索引\\n while maxq and nums[maxq[-1]] < nums[i]: #！！！ < 或 <= 都可以，< 构成的序列是单调递减，<= 构成【严格】单调递减序列。\\n maxq.pop()\\n # 将当前元素的索引加入双端队列\\n maxq.append(i)\\n\\n # 从窗口第一个完整的窗口开始记录最大值\\n if i >= k - 1:\\n res.append(nums[maxq[0]])\\n\\n return res\\n\\n############ Solution 2: maxHeap ############ \\n# 如果懒得写deque，也可以使用pq(heap)\\n# - 时间复杂度: O(N log k)\\n# - 空间复杂度: O(k)\\n# minHeap 要改成 - 才是maxHeap\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n max_heap = [] # Max heap to store (-value, index) pairs\\n result = []\\n \\n for i in range(len(nums)):\\n # 将当前元素插入堆中，注意存入的是负值以模拟最大堆，同时记录下标\\n heapq.heappush(max_heap, (-nums[i], i))\\n \\n # 确保堆顶元素在当前窗口范围内\\n while max_heap and max_heap[0][1] < i - k + 1: #\\n heapq.heappop(max_heap)\\n\\n # 当窗口的大小达到k时，记录当前的最大值\\n if i >= k - 1:\\n result.append(-max_heap[0][0])\\n\\n return result\\n\\n\\n############ Solution 2: labuldong模版，帮助理解。但我不喜欢这个方法。############ \\n# from collections import deque\\n# class MonotonicQueue:\\n# def __init__(self):\\n# self.maxq = deque()\\n\\n# def popleft(self, n):\\n# if self.maxq and self.maxq[0] == n: # 看头元素！\\n# self.maxq.popleft()\\n\\n# def push(self, n):\\n# # 将小于 n 的元素全部删除\\n# while (self.maxq and self.maxq[-1] < n):\\n# self.maxq.pop()\\n# # 然后将 n 加入尾部\\n# self.maxq.append(n)\\n\\n# def max(self):\\n# return self.maxq[0]\\n\\n\\n# class Solution:\\n# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n\\n# window = MonotonicQueue()\\n# res = []\\n# for i in range(len((nums))):\\n# if i < k - 1:\\n# window.push(nums[i])\\n# else:\\n# window.push(nums[i])\\n# window_max = window.max()\\n# res.append(window_max)\\n# # print(window.maxq, i, i - k + 1, nums[i - k + 1])\\n# # [2, 3, 3, 2], k = 2这个case过不了。如果使用这个方法，第40行必须构造单调递减序列，而不是严格单调递减序列，因为这里的下一行是按照value进行判断的，不是按照index进行判断。\\n# window.popleft(nums[i - k + 1]) \\n# return res\",\n \"runtime\": \"1381\"\n },\n {\n \"code\": \"# 需要一种新的队列结构，既能够维护队列元素「先进先出」的时间顺序，又能够正确维护队列中所有元素的最值，这就是「单调队列」结构。\\n# 判断一个窗口中最值的例子，你无法单凭移出窗口的那个元素更新窗口的最值，除非重新遍历所有元素\\n# 此题维护一个单调递减序列\\n############ Solution 1: Monotonic Deque ############ \\n# #!!! 非常简洁的写法,推荐！使用了 deque(pop是O1)和index（而非value）\\n# 使用单调递减队列而不是单调递增的原因在于我们希望快速获取当前窗口的最大值。通过维护一个单调递减队列，我们可以【确保队列头部元素始终是当前窗口的最大值】。每次窗口移动时，头部元素若过期则移除，使得新的头部元素始终是当前窗口的最大值。这种方法在时间复杂度和空间复杂度上都是最优的方案。\\n\\n# # time: O(n)\\n# # space: O(k)\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxq = deque() # decreasing queue, 把答案放在开头\\n res = []\\n\\n for i in range(len(nums)):\\n\\n # Remove elements smaller than the current element from the back\\n while maxq and nums[maxq[-1]] < nums[i]: #！！！ < 或 <= 都可以，< 构成的序列是单调递减，<= 构成【严格】单调递减序列。\\n maxq.pop()\\n \\n # Remove elements that are out of the current window\\n while maxq and maxq[0] < i - k + 1:\\n maxq.popleft()\\n \\n # Add the current index to the deque\\n maxq.append(i)\\n\\n # Append the maximum element in the current window to the result\\n if i >= k - 1:\\n res.append(nums[maxq[0]])\\n\\n return res\\n\\n############ Solution 2: maxHeap ############ \\n# 如果懒得写deque，也可以使用pq(heap)\\n# - 时间复杂度: O(N log k)\\n# - 空间复杂度: O(k)\\n# minHeap 要改成 - 才是maxHeap\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n max_heap = [] # Max heap to store (-value, index) pairs\\n result = []\\n \\n for i in range(len(nums)):\\n # 将当前元素插入堆中，注意存入的是负值以模拟最大堆，同时记录下标\\n heapq.heappush(max_heap, (-nums[i], i))\\n \\n # 确保堆顶元素在当前窗口范围内\\n while max_heap and max_heap[0][1] < i - k + 1: #\\n heapq.heappop(max_heap)\\n\\n # 当窗口的大小达到k时，记录当前的最大值\\n if i >= k - 1:\\n result.append(-max_heap[0][0])\\n\\n return result\\n\\n\\n############ Solution 2: labuldong模版，帮助理解。但我不喜欢这个方法。############ \\n# from collections import deque\\n# class MonotonicQueue:\\n# def __init__(self):\\n# self.maxq = deque()\\n\\n# def popleft(self, n):\\n# if self.maxq and self.maxq[0] == n: # 看头元素！\\n# self.maxq.popleft()\\n\\n# def push(self, n):\\n# # 将小于 n 的元素全部删除\\n# while (self.maxq and self.maxq[-1] < n):\\n# self.maxq.pop()\\n# # 然后将 n 加入尾部\\n# self.maxq.append(n)\\n\\n# def max(self):\\n# return self.maxq[0]\\n\\n\\n# class Solution:\\n# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n\\n# window = MonotonicQueue()\\n# res = []\\n# for i in range(len((nums))):\\n# if i < k - 1:\\n# window.push(nums[i])\\n# else:\\n# window.push(nums[i])\\n# window_max = window.max()\\n# res.append(window_max)\\n# # print(window.maxq, i, i - k + 1, nums[i - k + 1])\\n# # [2, 3, 3, 2], k = 2这个case过不了。如果使用这个方法，第40行必须构造单调递减序列，而不是严格单调递减序列，因为这里的下一行是按照value进行判断的，不是按照index进行判断。\\n# window.popleft(nums[i - k + 1]) \\n# return res\",\n \"runtime\": \"1398\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums or k == 0:\\n return []\\n \\n # Initialize\\n max_heap = []\\n count = defaultdict(int)\\n result = []\\n \\n # Process the first k elements\\n for i in range(k):\\n heapq.heappush(max_heap, -nums[i])\\n count[nums[i]] += 1\\n \\n # Add the maximum for the first window\\n result.append(-max_heap[0])\\n \\n # Process the rest of the elements\\n for i in range(k, len(nums)):\\n # Add new element to the heap and count\\n heapq.heappush(max_heap, -nums[i])\\n count[nums[i]] += 1\\n \\n # Remove the element that is out of the window\\n outgoing = nums[i - k]\\n count[outgoing] -= 1\\n \\n # Remove invalid elements from the heap\\n while max_heap and count[-max_heap[0]] == 0:\\n print(max_heap[0])\\n heapq.heappop(max_heap)\\n \\n # The current maximum is the root of the heap\\n result.append(-max_heap[0])\\n \\n return result\",\n \"runtime\": \"1398\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n a=[[-nums[i],i] for i in range(k-1)]\\n heapq.heapify(a)\\n ans=[]\\n for i in range(k-1,len(nums)):\\n heapq.heappush(a,[-nums[i],i])\\n while a[0][1]<=i-k:\\n heapq.heappop(a)\\n ans.append(-a[0][0])\\n return ans\\n \\n\\n\\n\\n\",\n \"runtime\": \"1415\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n import heapq\\n max_heap = [ ] # building max heap\\n for i in range(k):\\n max_heap.append( [-nums[i], i] ) # (value , index)\\n heapq.heapify( max_heap ) # heapify\\n max_window = [ -max_heap[0][0] ]\\n left = 0\\n right = k - 1\\n\\n while(right + 1 < len(nums)):\\n right += 1\\n heapq.heappush( max_heap, [-nums[right], right] )\\n # remove stale max from max_heap\\n while ( max_heap[0][1] <= left ):\\n heapq.heappop( max_heap )\\n \\n left += 1\\n\\n max_window.append( -max_heap[0][0] )\\n\\n return max_window \\n \\n \\n\\n \",\n \"runtime\": \"1415\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n n = len(nums)\\n max_heap = []\\n for i in range(k):\\n heappush(max_heap, (-nums[i], i))\\n result = [-max_heap[0][0]]\\n start = 0\\n stale = {}\\n for end in range(k, n):\\n new_num = nums[end]\\n old_num = nums[start]\\n if old_num == result[-1]:\\n heappop(max_heap)\\n heappush(max_heap, (-new_num, end))\\n while max_heap[0][1] < start:\\n heappop(max_heap)\\n result.append(-max_heap[0][0])\\n start += 1\\n return result\\n\",\n \"runtime\": \"1432\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n myheap = []\\n remheap = []\\n def add_elem(self, val):\\n heapq.heappush(self.myheap, val)\\n def rem_elem(self, val):\\n heapq.heappush(self.remheap, val)\\n def peek_top(self):\\n if len(self.myheap) == 0:\\n return None\\n while len(self.remheap) > 0 and self.remheap[0] < self.myheap[0]:\\n heapq.heappop(self.remheap)\\n while len(self.myheap) > 0 and len(self.remheap) > 0 and self.myheap[0] == self.remheap[0]:\\n heapq.heappop(self.myheap)\\n heapq.heappop(self.remheap)\\n \\n if len(self.myheap) == 0:\\n return None\\n return self.myheap[0]\\n\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n self.myheap = []\\n self.remheap = []\\n for i in range(k):\\n self.add_elem(-nums[i])\\n ans = [-self.peek_top()]\\n for i in range(k, len(nums)):\\n self.add_elem(-nums[i])\\n self.rem_elem(-nums[i-k])\\n ans.append(-self.peek_top())\\n return ans\",\n \"runtime\": \"1432\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # this is a max heap problem, but the issue is removing an element\\n # of arbitrary index from the heap (when the window moves).\\n \\n window = Counter()\\n heap = []\\n for i in range(k):\\n num = nums[i]\\n window[num] += 1\\n heapq.heappush(heap, -num)\\n \\n res = [-heap[0]]\\n for i in range(k, len(nums)):\\n heapq.heappush(heap, -nums[i])\\n\\n window[nums[i]] += 1\\n window[nums[i-k]] -= 1\\n\\n while window[-heap[0]] <= 0:\\n heapq.heappop(heap)\\n \\n curr = -heap[0]\\n res.append(curr)\\n \\n return res\\n\",\n \"runtime\": \"1450\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res, heap = [], []\\n\\n for i in range(k):\\n heapq.heappush(heap, [-nums[i], i])\\n\\n curr_max = -heap[0][0]\\n res.append(curr_max)\\n\\n for i in range(k, len(nums)):\\n heapq.heappush(heap, [-nums[i], i])\\n curr_max = heap[0]\\n\\n while curr_max[1] <= i-k:\\n heapq.heappop(heap)\\n curr_max = heap[0]\\n \\n res.append(-curr_max[0])\\n\\n return res\\n\\n \",\n \"runtime\": \"1450\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxes = []\\n q = []\\n trash = set()\\n for i, n in enumerate(nums):\\n heapq.heappush(q, (-n, i))\\n if len(q) < k:\\n continue\\n trash.add(i - k)\\n while True:\\n top, topI = q[0]\\n if topI not in trash:\\n maxes.append(-top)\\n break\\n trash.remove(topI)\\n heapq.heappop(q)\\n return maxes\\n \\n \\n \\n \",\n \"runtime\": \"1467\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxes = []\\n maxHeap = []\\n for i in range(k):\\n heapq.heappush(maxHeap, (-nums[i], i))\\n maxes.append(-maxHeap[0][0])\\n \\n for i in range(k, len(nums)):\\n while maxHeap and -nums[i] < maxHeap[0][0]:\\n heapq.heappop(maxHeap)\\n heapq.heappush(maxHeap, (-nums[i], i))\\n while maxHeap[0][1] < i-k+1:\\n heapq.heappop(maxHeap)\\n maxes.append(-maxHeap[0][0])\\n return maxes\",\n \"runtime\": \"1467\"\n },\n {\n \"code\": \"import heapq\\nfrom typing import List\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums:\\n return []\\n\\n res = []\\n maxHeap = [] # Max-heap to store the negative values for max functionality\\n indexHeap = [] # Min-heap to store the indices of elements in the window\\n valid = {} # Dictionary to check if an index is valid in the heap\\n\\n # Initialize the heaps and valid dictionary\\n for i in range(k):\\n heapq.heappush(indexHeap, i)\\n heapq.heappush(maxHeap, (-nums[i], i))\\n valid[i] = True\\n\\n # Function to remove invalid indices from the maxHeap\\n def clean_up():\\n while maxHeap and not valid[maxHeap[0][1]]:\\n heapq.heappop(maxHeap)\\n\\n # Process the first window\\n clean_up()\\n res.append(-maxHeap[0][0])\\n\\n for i in range(k, len(nums)):\\n # Add new element\\n heapq.heappush(indexHeap, i)\\n heapq.heappush(maxHeap, (-nums[i], i))\\n valid[i] = True\\n\\n # Remove the element that's sliding out of the window\\n out_index = i - k\\n valid[out_index] = False\\n\\n # Clean up the heaps\\n clean_up()\\n res.append(-maxHeap[0][0])\\n\\n return res\\n\",\n \"runtime\": \"1484\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n heap = []\\n res = []\\n\\n for i in range(k):\\n heapq.heappush(heap, (-nums[i], i))\\n\\n res.append(-heap[0][0])\\n\\n for R in range(k, len(nums)):\\n heapq.heappush(heap, (-nums[R], R))\\n while heap[0][1] not in range(R - k + 1, R + 1):\\n heapq.heappop(heap)\\n res.append(-heap[0][0])\\n\\n return res\\n\",\n \"runtime\": \"1484\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n queue = collections.deque()\\n for i in range(0, k):\\n while queue and queue[-1][0] <= nums[i]:\\n queue.pop()\\n queue.append((nums[i], i))\\n res.append(queue[0][0])\\n r = k\\n print('queue after inital push',queue)\\n while r < len(nums):\\n l = r - k + 1\\n print('new bounds', l, r)\\n while queue and queue[0][1] < l:\\n queue.popleft()\\n while queue and queue[-1][0] <= nums[r]:\\n queue.pop()\\n queue.append((nums[r], r))\\n res.append(queue[0][0])\\n r += 1\\n return res\",\n \"runtime\": \"1501\"\n },\n {\n \"code\": \"from typing import List\\nimport heapq\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums or k == 0:\\n return []\\n if k == 1:\\n return nums\\n if k == len(nums):\\n return [max(nums)]\\n \\n heap = []\\n hmap = defaultdict(int)\\n idx_map = {}\\n \\n # Initialize the first window\\n for idx in range(k):\\n num = nums[idx]\\n heapq.heappush(heap, (-num, idx))\\n hmap[num] += 1\\n idx_map[num] = idx\\n \\n res = [-heap[0][0]] # Add the max of the first window\\n \\n for r in range(k, len(nums)):\\n # Add the new element\\n num = nums[r]\\n heapq.heappush(heap, (-num, r))\\n hmap[num] += 1\\n idx_map[num] = r\\n \\n # Remove elements outside the window\\n while heap and heap[0][1] <= r - k:\\n _, old_idx = heapq.heappop(heap)\\n old_num = nums[old_idx]\\n hmap[old_num] -= 1\\n \\n # Add the current max to the result\\n res.append(-heap[0][0])\\n \\n return res\",\n \"runtime\": \"1501\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n dq = deque([])\\n ## first k numbers\\n maxList = []\\n for i, num in enumerate(nums[:k]):\\n if len(dq) > 0 and num > dq[-1][0]:\\n while len(dq) > 0 and dq[-1][0] < num:\\n dq.pop()\\n if len(dq) > 0 and num > dq[0][0]:\\n while len(dq) > 0 and dq[0][0] < num:\\n dq.popleft()\\n dq.appendleft((num, i))\\n maxList.append(dq[-1][0])\\n for i, num in enumerate(nums[k:]):\\n print(i)\\n print(dq[-1][1])\\n if dq[-1][1] == i:\\n dq.pop()\\n\\n if len(dq) > 0 and num > dq[-1][0]:\\n while len(dq) > 0 and dq[-1][0] < num:\\n dq.pop()\\n if len(dq) > 0 and num > dq[0][0]:\\n while len(dq) > 0 and dq[0][0] < num:\\n dq.popleft()\\n dq.appendleft((num, i + k))\\n maxList.append(dq[-1][0])\\n return maxList\\n \",\n \"runtime\": \"1518\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = []\\n heapq.heapify(q)\\n ans = []\\n for i in range(len(nums)):\\n if i < k - 1:\\n heapq.heappush(q, [-nums[i], i])\\n continue\\n \\n heapq.heappush(q, [-nums[i], i])\\n\\n while q[0][1] <= i - k or (len(q) > 0 and -nums[i] < q[0][0]):\\n heapq.heappop(q)\\n\\n ans.append(-q[0][0])\\n \\n return ans\\n\\n\\\"\\\"\\\"\\n[ 3 -1] -3 5 3 6 7 3\\n[3 -1 -3] 5 3 6 7 3\\n[5]\\n5 5\\n[5 3 6]\\n 1 3 -1 -3 5 [3 6 7] 7\\n\\n\\\"\\\"\\\"\",\n \"runtime\": \"1518\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n #monotonically decreasing queue\\n q = []\\n res = []\\n #q.append(0)\\n l,r=0,0\\n for r in range(len(nums)):\\n while q and nums[r]>nums[q[-1]]:\\n q.pop()\\n q.append(r)\\n \\n if l>q[0]:\\n q.pop(0)\\n\\n if r+1>=k: \\n res.append(nums[q[0]]) \\n l+=1\\n return res \\n \\n\\n \",\n \"runtime\": \"1535\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q, ans, l = [], [], 0\\n for r in range(len(nums)):\\n while q and nums[q[-1]] < nums[r]:\\n q.pop()\\n if q and l > q[0]:\\n q.pop(0)\\n q.append(r)\\n if r > k-2:\\n ans.append(nums[q[0]])\\n l += 1\\n return ans\",\n \"runtime\": \"1535\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n start, end = 0, k - 1\\n\\n resMax = []\\n deque = []\\n\\n for itr in range(len(nums) - k + 1):\\n if itr == 0:\\n for num in nums[start:end + 1]:\\n while deque and deque[-1] < num:\\n deque.pop(-1)\\n deque.append(num)\\n resMax.append(deque[0])\\n else:\\n # If loc max is old start num, remove it\\n if deque[0] == nums[start]:\\n deque.pop(0)\\n start += 1\\n\\n # Get new end val and remove all vals less than it from deq, then append it\\n end += 1\\n while deque and deque[-1] < nums[end]:\\n deque.pop(-1)\\n deque.append(nums[end])\\n resMax.append(deque[0])\\n \\n return resMax\",\n \"runtime\": \"1552\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums or k == 0:\\n return []\\n \\n n = len(nums)\\n if k > n:\\n return []\\n\\n # Result list to store the maximums for each window\\n result = []\\n # List to act as a deque to store indices of array elements\\n deq = []\\n\\n for i in range(n):\\n # Remove indices that are out of the current window\\n if deq and deq[0] < i - k + 1:\\n deq.pop(0)\\n \\n # Remove elements from deque that are less than current element\\n while deq and nums[deq[-1]] < nums[i]:\\n deq.pop()\\n \\n # Add the current element's index to the deque\\n deq.append(i)\\n \\n # Append the maximum for the current window to result list\\n if i >= k - 1:\\n result.append(nums[deq[0]])\\n \\n return result\",\n \"runtime\": \"1552\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n l = 0\\n r = k-1\\n res = []\\n queue = []\\n # Basically,我们要维护一个decreasing的deque\\n for i in range(r):\\n while queue and nums[i]>queue[-1]:\\n queue.pop()\\n queue.append(nums[i])\\n # print(r,queue)\\n while r<len(nums):\\n while queue and nums[r]>queue[-1]:\\n queue.pop()\\n queue.append(nums[r])\\n \\n res.append(queue[0])\\n \\n # 如果window移动了\\n if queue[0]==nums[l]:\\n queue.pop(0)\\n l+=1\\n r+=1\\n \\n return res\\n\",\n \"runtime\": \"1570\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n output = []\\n maximums = []\\n l = 0\\n for r in range(len(nums)):\\n while maximums and nums[r] > maximums[-1]:\\n maximums.pop()\\n maximums.append(nums[r])\\n\\n if r - l + 1 == k:\\n output.append(maximums[0])\\n if nums[l] == maximums[0]:\\n maximums.pop(0)\\n l += 1\\n \\n return output\",\n \"runtime\": \"1570\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxes = []\\n\\n ret = []\\n for i, num in enumerate(nums):\\n while maxes and maxes[-1] < num:\\n maxes.pop()\\n maxes.append(num)\\n if i >=k and nums[i-k] == maxes[0]: maxes.pop(0)\\n if i >= k-1:\\n ret.append(maxes[0])\\n return ret\",\n \"runtime\": \"1587\"\n },\n {\n \"code\": \"from collections import deque\\nfrom typing import List\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums:\\n return []\\n if k == 1:\\n return nums\\n\\n # This will store indices of elements, not the elements themselves\\n deq = []\\n max_nums = []\\n\\n for i in range(len(nums)):\\n # Remove indices that are out of this window\\n if deq and deq[0] < i - k + 1:\\n deq.pop(0)\\n\\n # Maintain deq such that it contains indices of elements in decreasing order\\n while deq and nums[deq[-1]] < nums[i]:\\n deq.pop()\\n\\n # Append the current index at the end of the deq\\n deq.append(i)\\n\\n # Start appending results from the index when the first window is completed\\n if i >= k - 1:\\n max_nums.append(nums[deq[0]])\\n\\n return max_nums\",\n \"runtime\": \"1587\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n q = []\\n l = r = 0\\n\\n while r < len(nums):\\n while q and nums[q[-1]] < nums[r]:\\n q.pop()\\n q.append(r)\\n\\n if q[0] < l:\\n q.pop(0)\\n \\n if (r-l+1) == k:\\n res.append(nums[q[0]])\\n l += 1\\n r += 1\\n return res\",\n \"runtime\": \"1604\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n n = len(nums)\\n result = []\\n stack = []\\n \\n for i in range(n):\\n while stack and stack[0] <= i - k:\\n stack.pop(0)\\n while stack and nums[stack[-1]] < nums[i]:\\n stack.pop()\\n stack.append(i)\\n if i >= k - 1:\\n result.append(nums[stack[0]])\\n \\n return result\\n # n=len(nums)\\n # st=[]\\n # for i in range(0,n-k+1):\\n # sub_arr=nums[i:i+k]\\n # st.append(list(sorted(sub_arr)))\\n # res=[]\\n # for sub_arr in st:\\n # res.append(sub_arr[-1])\\n # return res \\n\\n\\n \\n\",\n \"runtime\": \"1604\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":116,"string":"116"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxSlidingWindow(nums: list[int], k: int) -> list[int]:\n \n result = []\n max_stack = []\n \n for i in range(k-1):\n while max_stack and nums[max_stack[-1]] < nums[i]:\n max_stack.pop()\n max_stack.append(i)\n\n for i in range(k-1, len(nums)):\n if max_stack and i >= max_stack[0] + k:\n max_stack.pop(0)\n \n while max_stack and nums[max_stack[-1]] < nums[i]:\n max_stack.pop()\n \n max_stack.append(i)\n result.append(nums[max_stack[0]])\n \n return result\n\ninput_iter = iter(stdin)\noutput = open('user.out', 'w')\nfor array in input_iter:\n output.write(dumps(Solution.maxSlidingWindow(loads(array), int(next(input_iter)))).replace(' ', '') + '\\n')\nexit()\n","memory":"25698"},{"code":"class Solution:\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\n q = deque()\n # only keep track the biggest\n for i in range(k-1):\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans = []\n for i in range(k-1, len(nums)):\n if q and i >= q[0] + k:\n q.popleft()\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans.append(nums[q[0]])\n return ans\n it = iter(stdin)\n output = open('user.out', 'w')\n for array in it:\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\n')\n exit()\n \n ","memory":"25698"},{"code":"class Solution:\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\n q = deque()\n # only keep track the biggest\n for i in range(k-1):\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans = []\n for i in range(k-1, len(nums)):\n if q and i >= q[0] + k:\n q.popleft()\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans.append(nums[q[0]])\n return ans\n it = iter(stdin)\n output = open('user.out', 'w')\n for array in it:\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\n')\n exit()\n \n ","memory":"25896"},{"code":"class Solution:\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\n q = deque()\n # only keep track the biggest\n for i in range(k-1):\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans = []\n for i in range(k-1, len(nums)):\n if q and i >= q[0] + k:\n q.popleft()\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans.append(nums[q[0]])\n return ans\n it = iter(stdin)\n output = open('user.out', 'w')\n for array in it:\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\n')\n exit()\n \n ","memory":"26093"},{"code":"class Solution:\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\n q = deque()\n # only keep track the biggest\n for i in range(k-1):\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans = []\n for i in range(k-1, len(nums)):\n if q and i >= q[0] + k:\n q.popleft()\n while q and nums[q[-1]] < nums[i]:\n q.pop()\n q.append(i)\n ans.append(nums[q[0]])\n return ans\n it = iter(stdin)\n output = open('user.out', 'w')\n for array in it:\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\n')\n exit()\n \n ","memory":"26093"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n\n\n dq = deque()\n result = []\n\n for i in range(len(nums)):\n # Remove elements out of the current window\n if dq and dq[0] < i - k + 1:\n dq.popleft()\n\n # Remove elements from the deque that are smaller than the current element\n while dq and nums[dq[-1]] < nums[i]:\n dq.pop()\n\n # Add the current element's index to the deque\n dq.append(i)\n\n # Append the maximum for the current window to the result\n if i >= k - 1:\n result.append(nums[dq[0]])\n\n return result\n","memory":"26291"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n q = collections.deque()\n left = 0\n right = 0\n\n while right < len(nums):\n while q and nums[q[len(q) - 1]] < nums[right]:\n q.pop()\n q.append(right)\n\n if left > q[0]:\n q.popleft()\n \n if (right - left) + 1 >= k:\n res.append(nums[q[0]])\n left += 1\n\n right += 1\n\n return res\n","memory":"26488"},{"code":"from collections import deque\n\n\nclass MyQueue: #单调队列（从大到小\n def __init__(self):\n self.queue = deque() \n \n def pop(self, value):\n if self.queue and value == self.queue[0]:\n self.queue.popleft()\n\n def push(self, value):\n while self.queue and value > self.queue[-1]:\n self.queue.pop()\n self.queue.append(value)\n \n\n def front(self):\n return self.queue[0]\n \nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n que = MyQueue()\n result = []\n for i in range(k): #先将前k的元素放进队列\n que.push(nums[i])\n result.append(que.front()) #result 记录前k的元素的最大值\n for i in range(k, len(nums)):\n que.pop(nums[i - k]) #滑动窗口移除最前面元素\n que.push(nums[i]) #滑动窗口前加入最后面的元素\n result.append(que.front()) #记录对应的最大值\n return result","memory":"26686"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n window = MonotonicQueue()\n res = []\n for i in range(len(nums)):\n if i < k - 1:\n window.push(nums[i])\n else:\n window.push(nums[i])\n res.append(window.maxVal())\n # 移出旧数字\n window.pop(nums[i - k + 1])\n # window keep k - 1 numbers\n return res\n \nclass MonotonicQueue:\n def __init__(self):\n self.maxq = deque()\n \n def push(self, n):\n while self.maxq and self.maxq[-1] < n:\n self.maxq.pop()\n self.maxq.append(n)\n \n def maxVal(self):\n return self.maxq[0]\n \n def pop(self, n):\n if self.maxq[0] == n:\n self.maxq.popleft()\n ","memory":"26883"},{"code":"from collections import deque\n\nfrom collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n window_max = deque([]) # Double-ended queue to store potential window maximums\n result = []\n\n for i in range(len(nums)):\n val = nums[i]\n\n # Remove elements from the deque that are smaller than the current element,\n # because they can't be the max in the window if a larger element is present.\n while window_max and window_max[-1] < val:\n window_max.pop()\n \n # Add the current element to the deque. The deque maintains values in non-increasing order.\n window_max.append(val)\n\n # When we have processed at least k elements (i.e., starts sliding),\n # remove the front element from the deque if it's no longer in the window.\n if i + 1 > k:\n # If the element going out of the window is the same as the front of the deque,\n # it should be removed since it no longer contributes to the max in the window.\n if window_max[0] == nums[i - k]:\n window_max.popleft()\n\n # Once the window reaches the size of k, add the maximum of the current window to the result.\n if i + 1 >= k:\n result.append(window_max[0]) # The front of the deque always holds the current max value.\n \n return result\n\n ","memory":"27081"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n out = []\n r,l = 0,0\n q = collections.deque()\n while r < len(nums):\n while q and q[-1] < nums[r]:\n q.pop()\n q.append(nums[r])\n if r+1 >= k:\n out.append(q[0])\n if nums[l] == q[0]:\n q.popleft()\n l+=1\n r+=1\n return out","memory":"27278"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxArray = []\n\n q = deque()\n # maintain q of size k \n\n for i in range(len(nums)):\n # print(i, q)\n # append i to the appropriate position of decreasing q\n while q and q[-1] < nums[i]:\n q.pop()\n q.append(nums[i])\n\n # remove out of bounds value from left side\n if i >= k and q[0] == nums[i-k]:\n q.popleft()\n \n # q[0] will be the max of window\n if i >= k - 1:\n maxArray.append(q[0])\n\n return maxArray","memory":"27476"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n def cleanUp(queue: List[int], val: int, index: int):\n while queue and val >= nums[queue[-1]]:\n queue.pop()\n queue.append(index)\n res = []\n queue = deque()\n for i in range(k):\n cleanUp(queue, nums[i], i)\n res.append(nums[queue[0]])\n \n for i in range(k, len(nums)):\n if queue and queue[0] == i - k:\n queue.popleft()\n cleanUp(queue, nums[i], i)\n res.append(nums[queue[0]])\n\n return res\n\n \n","memory":"27673"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n left, right = 0, 0\n\n q = collections.deque()\n\n while right < len(nums):\n while q and nums[q[-1]] < nums[right]:\n q.pop()\n q.append(right)\n \n if left > q[0]:\n q.popleft()\n \n if right + 1 >= k:\n res.append(nums[q[0]])\n left += 1\n right += 1\n return res","memory":"27871"},{"code":"from collections import Counter\n\nfrom sortedcontainers import SortedDict\n\n\n# add and remove to/from window is time complex\n# finding the biggest is complex\n# some tree structure with logn operations time should do\n\n# c++ sorted map would do so well here. O(1) to get largest, log(n) to insert/delete\n# nlog(n) time which is good for 10**5\n\n# maintain sorted list with binary search? Not an option, logn to find place and n to place it in list\n\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n btree = SortedDict()\n btree.update(Counter(nums[:k]))\n\n result = list()\n for i in range(0, len(nums) - k + 1):\n max_key, _ = btree.peekitem(-1)\n result.append(max_key)\n\n counter = btree.pop(nums[i])\n if counter := counter - 1:\n btree[nums[i]] = counter\n\n if i + k < len(nums):\n new_key = nums[i + k]\n if new_key in btree:\n btree[new_key] = btree[new_key] + 1\n else:\n btree[new_key] = 1 \n\n return result","memory":"28068"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n l = 0\n queue = deque()\n for r in range(len(nums)):\n while queue and queue[-1] < nums[r]:\n queue.pop()\n queue.append(nums[r])\n if (r-l+1) == k:\n res.append(queue[0])\n if nums[l] == queue[0]:\n queue.popleft()\n l += 1\n return res\n # res = []\n # for i in range(len(nums) - k + 1):\n # maxV = float(\"-inf\")\n # for j in range(k):\n # maxV = max(maxV, nums[i+j])\n # res.append(maxV)\n # return res","memory":"28266"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n stack = deque()\n\n for i in range(len(nums)):\n while stack and nums[i] > stack[-1]:\n stack.pop()\n stack.append(nums[i])\n\n if i >= k and nums[i - k] == stack[0]:\n stack.popleft()\n\n if i >= k - 1:\n res.append(stack[0])\n\n return res","memory":"28463"},{"code":"from collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n left = 0\n right = k - 1\n currMax = deque()\n for i in range(k):\n while len(currMax) != 0 and nums[i] > currMax[-1]:\n currMax.pop()\n currMax.append(nums[i])\n res.append(currMax[0])\n while right < len(nums):\n if nums[left] == currMax[0]:\n currMax.popleft()\n left += 1\n right += 1\n if right == len(nums): break\n while len(currMax) != 0 and nums[right] > currMax[-1]:\n currMax.pop()\n currMax.append(nums[right])\n res.append(currMax[0])\n return res\n\n \n \n\n\n \n ","memory":"28463"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n l = r = 0\n maxWindow = []\n dq = deque()\n\n while r < len(nums):\n\n if dq and r - dq[0] + 1 > k:\n dq.popleft()\n \n while dq and nums[dq[-1]] < nums[r]:\n dq.pop()\n\n dq.append(r)\n \n if r >= k - 1:\n maxWindow.append(nums[dq[0]])\n\n r += 1\n\n return maxWindow\n \n\n","memory":"28661"},{"code":"'''\nGoal:\n- Return a list of all max values from every iteration of the sliding window (slide + 1)\n\nApproach: O(n) linear, O(1) space\n- create some queue to only hold max values\n - every incoming number will be checked against the last number of the queue\n - the last number will be popped() out of the queue if the incoming is greater\n - add the current max number to queue\n- Check if the pos is \"out of bounds\" -> store pos of nums in the queue\n- Check if atleast window size # of iterations have occurred to add that first max into our results\n\n'''\nfrom collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = deque([])\n result = []\n\n for i in range(len(nums)):\n while q and nums[i] > nums[q[-1]]:\n q.pop()\n\n q.append(i)\n\n if q[0] <= i - k:\n q.popleft()\n\n if i >= k - 1:\n result.append(nums[q[0]])\n return result\n\n \n\n ","memory":"28661"},{"code":"from collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n window = deque([])\n max_sliding_window = []\n\n for index, num in enumerate(nums):\n while len(window) > 0 and window[0] < index - k + 1:\n window.popleft()\n\n while len(window) > 0 and nums[window[-1]] <= num:\n window.pop()\n\n window.append(index)\n\n if index >= k - 1:\n max_sliding_window.append(nums[window[0]])\n\n return max_sliding_window","memory":"28858"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n dq = deque()\n result = []\n for i in range(len(nums)):\n while dq and nums[i] > dq[-1][0]:\n dq.pop()\n dq.append((nums[i], i))\n while dq[0][1] + k <= i:\n dq.popleft()\n if i >= (k-1):\n result.append(dq[0][0])\n return result\n\n\n\n heap = []\n for i in range(k):\n heapq.heappush(heap, (-nums[i], i))\n \n result = [-heap[0][0]]\n \n for i in range(k, len(nums)):\n heapq.heappush(heap, (-nums[i], i))\n while heap[0][1]+k <= i:\n heapq.heappop(heap)\n \n result.append(-heap[0][0])\n \n return result\n\n ","memory":"28858"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n curr = SortedList()\n res= []\n for i in range(k):\n curr.add(nums[i])\n\n res.append(max(curr))\n\n for i in range(k,len(nums)):\n curr.add(nums[i])\n curr.remove(nums[i-k])\n res.append(curr[-1])\n return res\n \n\n \n\n ","memory":"29451"},{"code":"from collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n n, mwind, i, mwind_max = len(nums), deque(), 0, []\n while True:\n if i>=n: break\n while mwind and mwind[0][0]<i-k+1:\n mwind.popleft()\n while len(mwind)>0 and nums[i]>=mwind[-1][1]:\n mwind.pop()\n mwind.append((i, nums[i]))\n if i>=k-1:\n mwind_max.append(mwind[0][1])\n i += 1\n \n return mwind_max\n","memory":"29451"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k == 1:\n return nums\n\n queue = deque()\n result = []\n left, right = 0, 0\n\n while right < len(nums):\n num = nums[right]\n while len(queue) and queue[-1] < num:\n queue.pop()\n queue.append(num)\n\n \n length = right - left + 1\n if length == k:\n result.append(queue[0])\n if queue[0] == nums[left]:\n queue.popleft()\n left += 1\n\n\n right += 1\n\n return result\n\n ","memory":"29648"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = deque()\n start = 0\n result = []\n for i in range(k):\n while q and q[-1] < nums[i]:\n q.pop()\n q.append(nums[i])\n result.append(q[0])\n for i in range(1, len(nums)-k+1):\n if q and nums[i-1] == q[0]:\n q.popleft()\n\n while q and q[-1] < nums[i+k-1]:\n q.pop()\n \n q.append(nums[i+k-1])\n result.append(q[0])\n return result\n\n # [1,2,1,0,4,2,6]\n # [4,1]\n 2,2,4,4,6\n count = {}\n curr_max = float('-inf')\n for c in range(k):\n count[nums[c]] = count.get(nums[c], 0) + 1\n curr_max = max(curr_max, nums[c])\n result = [curr_max]\n for i in range(1, len(nums)-k+1):\n count[nums[i-1]] -= 1\n if count[nums[i-1]] == 0:\n del count[nums[i-1]]\n count[nums[i+k-1]] = count.get(nums[i+k-1], 0) + 1\n if curr_max in count:\n curr_max = max(curr_max, nums[i+k-1])\n else:\n curr_max = max(count)\n result.append(curr_max)\n return result","memory":"29648"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k == 1:\n return nums\n\n queue = deque()\n result = []\n left, right = 0, 0\n\n while right < len(nums):\n num = nums[right]\n while len(queue) and queue[-1] < num:\n queue.pop()\n queue.append(num)\n\n \n length = right - left + 1\n if length == k:\n result.append(queue[0])\n if queue[0] == nums[left]:\n queue.popleft()\n left += 1\n\n\n right += 1\n\n return result\n\n ","memory":"29846"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k == 1:\n return nums\n\n queue = deque()\n result = []\n left, right = 0, 0\n\n while right < len(nums):\n num = nums[right]\n while len(queue) and queue[-1] < num:\n queue.pop()\n queue.append(num)\n\n \n length = right - left + 1\n if length == k:\n result.append(queue[0])\n if queue[0] == nums[left]:\n queue.popleft()\n left += 1\n\n\n right += 1\n\n return result\n\n ","memory":"29846"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n result = []\n counter = {}\n currMax = nums[0]\n for i in range(k - 1):\n if nums[i] not in counter:\n counter[nums[i]] = 0\n counter[nums[i]] += 1\n currMax = max(currMax, nums[i])\n\n l = 0\n for r in range(k - 1, len(nums)):\n left = nums[l]\n right = nums[r]\n if right not in counter:\n counter[right] = 0\n counter[right] += 1\n if currMax < right:\n currMax = right\n elif currMax not in counter:\n currMax = max(counter.keys())\n \n result.append(currMax)\n if counter[left] <= 1:\n counter.pop(left)\n else:\n counter[left] -= 1\n l += 1\n\n return result\n","memory":"30043"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = collections.deque() # monotootic decreasing queqe\n l, r = 0, 0\n res = []\n while r < len(nums):\n # removing all smaller numbers from the queue\n while len(q) != 0 and nums[q[-1]]< nums[r]:\n q.pop()\n \n q.append(r)\n\n # remove out of bound value\n if q[0]<l:\n q.popleft()\n\n if r-l+1 == k:\n res.append(nums[q[0]])\n l+=1 # in the start we dont increase left\n r+=1\n\n return res","memory":"30043"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n \n # 超时\n '''\n if k < 1:\n return []\n if len(nums) < k:\n return max(nums)\n\n res = []\n res.append(max(nums[:k]))\n for l in range(1,len(nums)-k+1):\n r = l+k\n \n if nums[r-1] >= res[l-1]: #如果右边新加入的数大于等于前一个滑动窗口的最大值，则当前滑动窗口的最大值为新加入的数\n res.append(nums[r-1])\n elif nums[l-1] < res[l-1]: #如果左边删除的数小于前一个滑动窗口的最大值，则当前滑动窗口的最大值等于上一个滑动窗口的最大值\n res.append(res[l-1])\n else: #如果左边删除的数等于前一个滑动窗口的最大值 且 右边新加入的数小于前一个滑动窗口的最大值\n res.append(max(nums[l:r]))\n\n return res\n '''\n\n res = []\n q = deque()\n\n #维护长度为k的非增队列\n for idx, num in enumerate(nums):\n while q and q[-1] < num: \n q.pop()\n q.append(num)\n\n if idx >= k and nums[idx - k] == q[0]: \n q.popleft()\n \n if idx >= k - 1:\n res.append(q[0])\n \n return res\n","memory":"30241"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n dq = deque()\n res= []\n for i in range(k):\n while dq and nums[dq[-1]]<= nums[i]:\n dq.pop()\n dq.append(i)\n\n res.append(nums[dq[0]])\n\n for i in range(k,len(nums)):\n if dq and dq[0] <=i-k:\n dq.popleft()\n while dq and nums[dq[-1]]<= nums[i]:\n dq.pop()\n dq.append(i)\n\n res.append(nums[dq[0]])\n return res\n \n\n \n\n ","memory":"30241"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n queue = []\n res = []\n for i, num in enumerate(nums):\n while queue and nums[queue[-1]] < num:\n queue.pop(-1)\n queue.append(i)\n if i >= k and queue[0] <= i-k:\n queue.pop(0)\n if i >= k-1: res.append(nums[queue[0]])\n return res\n \n\n","memory":"30438"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n queue = deque()\n res = []\n for i, num in enumerate(nums):\n while queue and nums[queue[-1]] < num:\n queue.pop()\n queue.append(i)\n if i >= k-1:\n while queue[0] <= i-k:\n queue.popleft()\n res.append(nums[queue[0]])\n return res\n \n\n","memory":"30438"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n result = []\n counter = {}\n currMax = nums[0]\n for i in range(k - 1):\n if nums[i] not in counter:\n counter[nums[i]] = 0\n counter[nums[i]] += 1\n currMax = max(currMax, nums[i])\n\n l = 0\n for r in range(k - 1, len(nums)):\n left = nums[l]\n right = nums[r]\n if right not in counter:\n counter[right] = 0\n counter[right] += 1\n if currMax < right:\n currMax = right\n elif currMax not in counter:\n currMax = max(counter.keys())\n\n if r == k + 3:\n print(counter.keys())\n result.append(currMax)\n if counter[left] <= 1:\n counter.pop(left)\n else:\n counter[left] -= 1\n l += 1\n\n return result\n","memory":"30636"},{"code":"from queue import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n dq = deque()\n\n if k == 1:\n return nums\n \n if len(nums) == k:\n return [max(nums)]\n \n for i in range(k):\n if len(dq) == 0:\n dq.append(i)\n else:\n if nums[i] >= nums[dq[-1]]:\n dq.clear()\n dq.append(i)\n else:\n while nums[i] >= nums[dq[0]]:\n dq.popleft()\n dq.appendleft(i)\n\n ans = []\n for i in range(k - 1, len(nums)):\n ans.append(nums[dq[-1]])\n if i - k + 1 == dq[-1]:\n dq.pop()\n if i < len(nums) - 1:\n if len(dq) == 0:\n dq.append(i + 1)\n else:\n if nums[i + 1] >= nums[dq[-1]]:\n dq.clear()\n dq.append(i + 1)\n else:\n while nums[i + 1] >= nums[dq[0]]:\n dq.popleft()\n dq.appendleft(i + 1)\n \n \n\n return ans","memory":"30636"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n q = deque()\n\n for idx, num in enumerate(nums):\n while q and q[-1]<num:\n q.pop()\n q.append(num)\n\n if idx>=k and nums[idx-k] == q[0]:\n q.popleft()\n\n if idx>=k-1:\n res.append(q[0])\n return res","memory":"30833"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n output = []\n q = collections.deque()\n l = r = 0\n while r < len(nums):\n #pop smaller values from q\n while q and nums[q[-1]] < nums[r]:\n q.pop()\n q.append(r)\n #remove left val fromm window\n if l > q[0]:\n q.popleft()\n\n if (r+1) >= k:\n output.append(nums[q[0]])\n l += 1\n r +=1 \n\n return output\n","memory":"30833"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n queue = []\n res = []\n for i, num in enumerate(nums):\n while queue and nums[queue[-1]] < num:\n queue.pop(-1)\n queue.append(i)\n if i >= k-1:\n while queue[0] <= i-k:\n queue.pop(0)\n res.append(nums[queue[0]])\n return res\n \n\n","memory":"31031"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k==1: return nums\n window=list(range(0,k))\n z=[]\n for i in range(k):\n if z==[]:\n z.append(i)\n continue\n if nums[i]<nums[z[-1]]:\n z.append(i)\n else:\n while z and nums[i]>nums[z[-1]]:\n z.pop(-1)\n z.append(i)\n res=[nums[z[0]]]\n for i in range(k,len(nums)):\n new_ele=i\n x=window.pop(0)\n window.append(new_ele)\n if x==z[0]:\n z.pop(0)\n if nums[i]<nums[z[-1]]:\n z.append(i)\n else:\n while z and nums[i]>nums[z[-1]]:\n z.pop(-1)\n z.append(i)\n res.append(nums[z[0]])\n return res","memory":"31031"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n output = []\n q = collections.deque()\n l = r = 0\n\n while r<len(nums):\n while q and nums[q[-1]] < nums[r]:\n q.pop()\n q.append(r)\n if l >q[0]:\n q.popleft()\n if (r+1)>=k:\n output.append(nums[q[0]])\n l +=1\n r+=1\n return output\n \n\n","memory":"31228"},{"code":"from collections import deque\n\nclass MyQueue:\n def __init__(self):\n self.queue = deque()\n\n def pop(self, value):\n if self.queue and value == self.queue[0]:\n self.queue.popleft()\n \n def push(self, value):\n while self.queue and value > self.queue[-1]:\n self.queue.pop()\n self.queue.append(value)\n \n def front(self):\n return self.queue[0]\n\n\n\nclass Solution: \n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n que = MyQueue()\n result = []\n for i in range(k):\n que.push(nums[i])\n result.append(que.front())\n for i in range(k, len(nums)):\n que.pop(nums[i - k])\n que.push(nums[i])\n result.append(que.front())\n return result","memory":"31228"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n result = []\n dq = deque()\n for i in range(k):\n while len(dq) != 0 and dq[-1][0] <= nums[i]:\n dq.pop()\n dq.append([nums[i], i])\n \n result.append(dq[0][0])\n\n for i in range(k, len(nums)):\n print(i)\n while len(dq) != 0 and dq[-1][0] <= nums[i]:\n dq.pop()\n dq.append([nums[i], i])\n\n while dq[0][1] <= i - k:\n dq.popleft()\n\n result.append(dq[0][0])\n \n return result","memory":"31426"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxNum = float(\"-inf\")\n\n maxIdx = -1\n result = []\n maxStack = []\n left = 0\n for right in range(0, len(nums)):\n if maxStack and maxStack[0] < left:\n maxStack.pop(0)\n while maxStack and nums[maxStack[-1]] < nums[right]:\n maxStack.pop()\n maxStack.append(right)\n if right - left + 1 == k:\n result.append(nums[maxStack[0]])\n left += 1\n return result","memory":"31426"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n stack = [] \n N = []\n for i, v in enumerate(nums):\n if i<k-1:\n if not stack: stack.append( (v,i) )\n else: \n while stack and stack[-1][0]<=v: stack.pop()\n stack.append( (v,i) )\n else:\n while stack and stack[-1][0]<=v: stack.pop()\n stack.append( (v,i) )\n if stack and stack[0][1]<=i-k: stack.pop(0) \n N.append(stack[0][0])\n return N ","memory":"31623"},{"code":"from collections import deque\n\nclass MonotonicQueue:\n def __init__(self):\n self.queue = deque()\n \n def push(self, val, i):\n while self.queue and val > self.queue[-1][0]:\n self.queue.pop()\n self.queue.append((val, i))\n \n def pop(self, i):\n while self.queue and i >= self.queue[0][1]:\n self.queue.popleft()\n \n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n\n mq = MonotonicQueue()\n\n for i in range(k):\n mq.push(nums[i], i)\n \n res = [mq.queue[0][0]]\n\n for i in range(k, len(nums)):\n mq.pop(i - k)\n mq.push(nums[i], i)\n res.append(mq.queue[0][0])\n return res\n\n ","memory":"31821"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ans=[]\n q=deque()\n l,r=0,0\n while r<len(nums):\n while q and nums[q[-1]]<nums[r]:\n q.pop()\n q.append(r)\n if l>q[0]:\n q.popleft()\n if (r-l+1)==k:\n ans.append(nums[q[0]])\n l+=1\n r+=1\n return ans\n\n ","memory":"31821"},{"code":"from collections import deque\nfrom typing import List\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n d = deque() # Deque to store indices of the elements\n result = [] # List to store the result\n \n for i, v in enumerate(nums):\n # Remove indices that are out of the current window\n if d and i - k >= d[0]:\n d.popleft()\n \n # Remove indices of elements that are less than the current element\n while d and nums[d[-1]] <= v:\n d.pop()\n \n # Add current element index to the deque\n d.append(i)\n \n # Add the maximum value of the current window to the result\n if i >= k - 1:\n result.append(nums[d[0]])\n \n return result\n","memory":"32018"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n n = len(nums)\n res = []\n dq = deque()\n\n for i in range(n):\n if dq and dq[0] < i - k + 1:\n dq.popleft()\n \n while dq and nums[dq[-1]] < nums[i]:\n dq.pop()\n\n dq.append(i)\n if i + 1 >= k:\n res.append(nums[dq[0]])\n\n return res\n\n","memory":"32018"},{"code":"import collections\n\n# идея: сделать монотонно убывающий дек (т.е. снизу лежит самый большой элемент)\n# дек нужен, чтобы за единицу добавлять сверху и удалять снизу элемент\n# (при этом просто очередьь не подойдет, тк нужно будет ещё и удалять сверху чтобы поддерживать заданный на стеке порядок)\n# то есть мы сверху: добавляем, удаляем ; снизу: удаляем\n# заметим, что не хватит просто хранить 1 максимум на данном окне размера k, тк возможна ситуация:\n# [4 3 -1] [-1 -5 -6], то есть если в первом окне будем хранить только 4, то потеряем (-1), которая максимум во втором окне\n\n# еще особенность в том, что тут не нужен левый индекс, потому что для проверки нахождения в границах достаточно сделать\n# deque[0] < right - k + 1, тк в деке храним индексы => они по построению идут по возрастанию и поэтому наименьший индекс,\n# который отвечает за (потенциально возможную) левую границу нашего окна будет лежать всегда внизу дека.\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ans = list()\n deq = collections.deque()\n\n for right in range(len(nums)):\n\n while deq and nums[deq[-1]] < nums[right]:\n deq.pop()\n \n deq.append(right)\n\n if deq and deq[0] < right - k + 1:\n deq.popleft()\n \n if right >= k - 1:\n ans.append(nums[deq[0]])\n \n return ans","memory":"32216"},{"code":"class Solution:\n def maxSlidingWindow(self, nums, k):\n result = []\n window = deque()\n\n for i, num in enumerate(nums):\n while window and window[0] < i - k + 1:\n window.popleft()\n\n while window and nums[window[-1]] < num:\n window.pop()\n\n window.append(i)\n\n if i >= k - 1:\n result.append(nums[window[0]])\n\n return result","memory":"32216"},{"code":"from collections import deque\n\nclass Solution:\n \"\"\"\n sliding window of size k\n very left of the array to the very right\n You can only see the k numbers in the window. \n Each time the sliding window moves right by one position.\n\n nums.length large [1, 100000]\n\n nums value medium [-10000, 10000]\n\n k [1, nums.length]\n\n only need to consider next new element in the window.\n if the newest element is bigger than all the others, we can just remove all\n other elements from consideration \n\n ex 1: [1 3 -1] -> [3 -1 -3] -> [-1 5 5] -> [5 5 3] -> [5 6 6] -> [6 7 7] \n\n indexes 2, 2, 4, 4, 6, 7\n [2, 3] -> [2, 4] -> [4] -> [4, 5] -> [6] -> [7]\n keep track of indexes, if \n\n for each window, append max to list\n \"\"\"\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n max_window: List[int] = []\n max_current_elems = deque([])\n\n def slide_deque(new_index: int) -> None:\n nonlocal max_current_elems\n\n # Empty deque, just add\n if not max_current_elems:\n max_current_elems.append(new_index)\n return\n\n # Remove index if out of window, we are only ever popping 1 element after all\n # Any indexes smaller than this one should have already been filtered out\n if max_current_elems[0] < (new_index - (k - 1)):\n max_current_elems.popleft() \n\n # If any elements before the new value are smaller, remove them\n new_value: int = nums[new_index]\n \n while max_current_elems and nums[max_current_elems[-1]] <= new_value:\n max_current_elems.pop()\n\n # Add the new element to the end of the current elems deque\n max_current_elems.append(new_index)\n \n for i in range(len(nums)):\n # Building the deque in the first k - 1 iterations\n if i < (k - 1):\n slide_deque(i)\n continue\n\n \n # Otherwise, slide and take the max element\n slide_deque(i)\n max_window.append(nums[max_current_elems[0]])\n\n return max_window","memory":"32413"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n idx_Q, maxes = deque(), [] \n INIT,LN = 0,len(nums)\n\n def next_greater_right():\n next_val = nums[right]\n return next_val > nums[idx_Q[-1]]\n\n def left_out_of_bounds():\n prev_left = idx_Q[0]\n return prev_left < left\n\n left = right = INIT\n while right < LN:\n while idx_Q and next_greater_right():\n idx_Q.pop()\n \n idx_Q.append(right)\n\n if left_out_of_bounds(): idx_Q.popleft()\n\n next=right+1\n if next >= k:\n maxes.append(nums[idx_Q[0]])\n left += 1\n right += 1\n\n return maxes","memory":"32413"},{"code":"from collections import deque\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n result = []\n dq = deque()\n for i in range(k):\n while dq and dq[-1][0] <= nums[i]:\n dq.pop()\n dq.append([nums[i], i])\n \n result.append(dq[0][0])\n\n for i in range(k, len(nums)):\n while dq and dq[-1][0] <= nums[i]:\n dq.pop()\n dq.append([nums[i], i])\n\n if dq[0][1] <= i - k:\n dq.popleft()\n\n result.append(dq[0][0])\n \n return result","memory":"32611"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n queue = collections.deque()\n output = []\n for i in range(len(nums)):\n while len(queue) and (queue[0][0] <= (i - k) or queue[0][1] <= nums[i]):\n queue.popleft()\n while len(queue) and (queue[-1][1] <= nums[i]):\n queue.pop()\n queue.append((i,nums[i]))\n\n if i < (k - 1):\n continue\n output.append(queue[0][1])\n return output","memory":"32611"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n stack = collections.deque() \n N = []\n for i, v in enumerate(nums):\n if i<k-1:\n if not stack: stack.append( (v,i) )\n else: \n while stack and stack[-1][0]<=v: stack.pop()\n stack.append( (v,i) )\n else:\n while stack and stack[-1][0]<=v: stack.pop()\n stack.append( (v,i) )\n if stack and stack[0][1]<=i-k: stack.popleft() \n N.append(stack[0][0])\n return N ","memory":"32808"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n n = len(nums)\n ans = []\n maxHeap = SortedList([])\n i = 0\n j = 0\n while j < n:\n maxHeap.add((nums[j],j))\n if j-i+1 < k:\n j += 1\n elif j-i + 1 == k:\n ans.append(maxHeap[-1][0])\n maxHeap.remove((nums[i],i))\n i += 1\n j += 1\n return ans\n","memory":"33006"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ans = []\n curList = deque([[-inf,-inf]])\n \n for i in range(len(nums)):\n if curList[0][1] <= (i-k):\n curList.popleft()\n while len(curList) and nums[i] > curList[-1][0]:\n curList.pop()\n curList.append([nums[i],i])\n if i >= k-1:\n ans.append(curList[0][0])\n return ans\n ","memory":"33203"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n deque = [0] * 100001\n head = tail = 0\n l = 0\n r = k-1\n ansNum = len(nums) - k + 1\n ans = [0] * ansNum\n \n for i in range(k-1):\n while head < tail and nums[deque[tail-1]] <= nums[i]:\n tail -= 1\n deque[tail] = i\n tail += 1\n \n for l in range(ansNum):\n while head < tail and nums[deque[tail-1]] <= nums[r]:\n tail -= 1\n deque[tail] = r\n tail += 1\n ans[l] = nums[deque[head]]\n if deque[head] == l:\n head += 1\n r += 1\n return ans\n\n # deq = deque() # Initialize a deque\n # ans = [] # List to store results\n\n # for i in range(len(nums)):\n # # Remove elements not in the sliding window\n # if deq and deq[0] < i - k + 1:\n # deq.popleft()\n \n # # Remove elements smaller than the current element\n # # from the deque\n # while deq and nums[deq[-1]] <= nums[i]:\n # deq.pop()\n \n # # Add the current element's index to the deque\n # deq.append(i)\n \n # # Append the maximum element in the current sliding window to ans\n # if i >= k - 1:\n # ans.append(nums[deq[0]])\n \n # return ans\n\n ","memory":"33401"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n output = []\n q = collections.deque() # index\n l = r = 0\n # O(n) O(n)\n while r < len(nums):\n # pop smaller values from q\n while q and nums[q[-1]] < nums[r]:\n q.pop()\n q.append(r)\n\n # remove left val from window\n if l > q[0]:\n q.popleft()\n print(r - l + 1)\n if (r - l + 1) == k:\n output.append(nums[q[0]])\n l += 1\n r += 1\n\n return output\n\n\n\n ","memory":"33598"},{"code":"from collections import deque\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n \n max_sliding_window = []\n cur_window = deque()\n\n # initialize the queue\n first_window_sorted = sorted(list(enumerate(nums[:k-1])), key=(lambda t: t[1]))\n for x in first_window_sorted:\n cur_window.append(x[0]) # the right side element is the max\n\n for i in range(k - 1, len(nums)):\n num = nums[i]\n #print([str(x) for x in cur_window])\n while cur_window and (nums[cur_window[0]] <= num or cur_window[0] <= i - k):\n #print(\"popping \", cur_window[0])\n # for all future windows we no longer need this elem\n cur_window.popleft()\n cur_window.appendleft(i)\n\n # rightmost element is always the max\n while cur_window[len(cur_window) - 1] <= i - k:\n #print(\"Pop right for \", cur_window[len(cur_window) - 1])\n cur_window.pop()\n max_in_window = nums[cur_window[len(cur_window) - 1]]\n #print(\"max of this window is \", max_in_window)\n max_sliding_window.append(max_in_window)\n return max_sliding_window","memory":"33796"},{"code":"class MaxHeap:\n\n\n def __init__(self):\n self.heap = [None]\n\n def up_heap(self, index):\n if index <= 1:\n return\n parent_index = index // 2\n # print(self.heap[parent_index][0])\n if self.heap[parent_index][0] < self.heap[index][0]:\n self.heap[index], self.heap[parent_index] = self.heap[parent_index], self.heap[index]\n self.up_heap(parent_index)\n \n def down_heap(self, index):\n left_index = index * 2\n right_index = index * 2 + 1\n biggest_index = index\n\n if left_index < len(self.heap) and self.heap[biggest_index][0] < self.heap[left_index][0]:\n biggest_index = left_index\n\n if right_index < len(self.heap) and self.heap[biggest_index][0] < self.heap[right_index][0]:\n biggest_index = right_index\n\n if biggest_index != index:\n self.heap[biggest_index], self.heap[index] = self.heap[index], self.heap[biggest_index]\n self.down_heap(biggest_index)\n \n def insert(self, value, index):\n self.heap.append((value, index))\n self.up_heap(len(self.heap)-1)\n\n def pop(self):\n if len(self.heap) <= 1:\n return None\n if len(self.heap) == 2:\n return self.heap.pop()\n\n max_value, max_index = self.heap[1]\n self.heap[1] = self.heap.pop()\n self.down_heap(1)\n\n return max_value, max_index\n \n\n def max(self):\n if len(self.heap) <= 1:\n return None\n return self.heap[1]\n\n def size(self):\n return len(self.heap) - 1\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n answer = []\n max_heap = MaxHeap()\n i = 0\n for v in nums:\n max_heap.insert(v, i)\n i += 1\n if i >= k:\n smallest_window_index = i - k\n print(f\"{smallest_window_index}-{i}\")\n while max_heap.size() > 0:\n max_value, max_index = max_heap.max()\n if max_index < smallest_window_index:\n max_heap.pop()\n else:\n answer.append(max_value)\n break\n return answer\n\n","memory":"33993"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n n, heap = len(nums), []\n for num in nums[:k]:\n heappush(heap, (-num, num))\n _, first_max = heap[0]\n maxes = [first_max]\n ignore = defaultdict(int)\n for i in range(k, n):\n heappush(heap, (-nums[i], nums[i]))\n ignore[nums[i - k]] += 1\n _, current_max = heap[0]\n while ignore[current_max] > 0:\n heappop(heap)\n ignore[current_max] -= 1\n _, current_max = heap[0]\n maxes.append(current_max)\n return maxes","memory":"34191"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n n, heap = len(nums), []\n for num in nums[:k]:\n heappush(heap, (-num, num))\n _, first_max = heap[0]\n maxes = [first_max]\n ignore = defaultdict(int)\n for i in range(k, n):\n heappush(heap, (-nums[i], nums[i]))\n ignore[nums[i - k]] += 1\n _, current_max = heap[0]\n while ignore[current_max] > 0:\n heappop(heap)\n ignore[current_max] -= 1\n _, current_max = heap[0]\n maxes.append(current_max)\n return maxes","memory":"34191"},{"code":"class Solution:\n def maxSlidingWindow(self, nums, k):\n ans = [max(nums[:k])]\n pq = []\n out = defaultdict(int)\n\n for i in range(k):\n heapq.heappush(pq, (-nums[i], nums[i]))\n \n idx = k\n while idx < len(nums):\n heapq.heappush(pq, (-nums[idx], nums[idx]))\n out[nums[idx-k]] += 1\n\n while True:\n top = heapq.heappop(pq)[1]\n if out[top] == 0:\n heapq.heappush(pq, (-top, top))\n break\n out[top] -= 1\n\n ans.append(top)\n idx += 1\n return ans","memory":"34388"},{"code":"class Pair(namedtuple(\"Pair\", [\"index\", \"value\"])):\n def __lt__(self, other):\n return self.value > other.value or self.value == other.value and self.index < other.index\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # Complexity O(Nlog(2k)) = O(Nlogk)\n pq = [Pair(i, nums[i]) for i in range(k - 1)]\n heapq.heapify(pq)\n max_window = []\n for index, value in enumerate(nums[k - 1:], k - 1):\n while pq and pq[0].index <= index - k:\n heapq.heappop(pq)\n heapq.heappush(pq, Pair(index, value))\n max_window.append(pq[0].value)\n return max_window\n","memory":"34586"},{"code":"class node:\n def __init__(self, val = None, prev = None, next = None, index = None):\n self.val = val\n self.prev = prev\n self.next = next\n self.index = index\n\nclass deque:\n def __init__(self):\n self.head = node()\n self.tail = node()\n self.head.next = self.tail\n self.tail.prev = self.head\n self.size = 0\n \n def append(self, node):\n node.prev = self.tail.prev\n node.next = self.tail\n self.tail.prev.next = node\n self.tail.prev = node \n self.size += 1\n \n def remove(self, node):\n p, n = node.prev, node.next\n p.next = n\n n.prev = p\n self.size -= 1\n\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n Q = deque()\n for i in range(k):\n n = node(nums[i], index = i)\n end = Q.tail.prev\n while (Q.size > 0 and end.val <= nums[i]):\n prev = end.prev\n Q.remove(end)\n end = prev\n Q.append(n)\n res = [Q.head.next.val]\n\n for i in range(k, len(nums)):\n # remove old\n if (Q.head.next.index == i - k):\n Q.remove(Q.head.next)\n end = Q.tail.prev\n while (Q.size > 0 and end.val <= nums[i]):\n prev = end.prev\n Q.remove(end)\n end = prev\n # add new\n n = node(nums[i], index = i)\n Q.append(n)\n res.append(Q.head.next.val)\n return res\n\n\n","memory":"34783"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n heap = []\n\n for r in range(len(nums)):\n heapq.heappush(heap, (-nums[r], r)) # -nums[r] ?\n if len(heap) < k:\n continue\n while heap[0][1] <= r - k:\n heapq.heappop(heap)\n if heap:\n res.append(nums[heap[0][1]])\n\n return res","memory":"34981"},{"code":"class MaxHeap:\n def __init__(self) -> None:\n self.heap = []\n\n def size(self) -> int:\n return len(self.heap)\n\n def push(self, x: int) -> None:\n heapq.heappush(self.heap, -x)\n\n def pop(self) -> int:\n return -heapq.heappop(self.heap)\n\n def top(self) -> int:\n return -self.heap[0]\n\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k == 1:\n return nums\n ans = []\n tmp = nums[0]\n max_heap = MaxHeap()\n mydict = defaultdict(int)\n for i in range(k):\n tmp = max(tmp, nums[i])\n max_heap.push(nums[i])\n mydict[nums[i]] += 1\n ans.append(tmp)\n\n for i in range(1, len(nums) - k + 1):\n prev_max = ans[-1]\n mydict[nums[i-1]] -= 1\n\n if nums[i-1] == prev_max:\n while mydict[prev_max] == 0 and max_heap.size() > 1:\n max_heap.pop()\n prev_max = max_heap.top()\n if nums[i+k-1] > prev_max:\n ans.append(nums[i+k-1])\n else:\n ans.append(prev_max)\n \n max_heap.push(nums[i+k-1])\n mydict[nums[i+k-1]] += 1\n return ans\n\n","memory":"35178"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n d=dict()\n maxi = -1001\n out=[]\n for j in range(k):\n maxi = max(maxi,nums[j])\n d[nums[j]] = d.get(nums[j],0)+1\n out.append(maxi)\n left=0\n right=k\n while(right<len(nums)):\n d[nums[right]]=d.get(nums[right],0)+1\n maxi=max(maxi,nums[right])\n d[nums[left]]=d[nums[left]]-1\n if(d[nums[left]]==0):\n del d[nums[left]]\n if(nums[left]==maxi):\n localMaxi=-1001\n maxi=maxi-1\n while(d.get(maxi,0)==0):\n maxi-=1\n out.append(maxi)\n left+=1\n right+=1\n return out\n\n\n\n","memory":"35376"},{"code":"import heapq\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n result = []\n\n ptr1 = 0\n ptr2 = k\n\n nums_neg = [i*-1 for i in nums]\n remove_dict = {}\n\n h = nums_neg[ptr1:ptr2]\n heapq.heapify(h)\n print(h)\n result.append(h[0]*-1)\n remove_dict[nums_neg[ptr1]] = 1\n\n ptr1 +=1\n ptr2 +=1\n\n while ptr2 < len(nums) + 1:\n\n while len(h) > 0 and remove_dict.get(h[0], None) != None: \n \n remove_dict[h[0]] -= 1\n\n if remove_dict[h[0]] == 0:\n remove_dict.pop(h[0])\n\n heapq.heappop(h)\n\n heapq.heappush(h, nums_neg[ptr2-1])\n\n result.append(h[0]*-1)\n\n if remove_dict.get(nums_neg[ptr1], None) != None:\n remove_dict[nums_neg[ptr1]] += 1\n else:\n remove_dict[nums_neg[ptr1]] = 1\n\n ptr1 +=1\n ptr2 +=1\n\n return result\n ","memory":"35573"},{"code":"import heapq\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n result = []\n\n ptr1 = 0\n ptr2 = k\n\n nums_neg = [i*-1 for i in nums]\n remove_dict = {}\n\n h = nums_neg[ptr1:ptr2]\n heapq.heapify(h)\n print(h)\n result.append(h[0]*-1)\n remove_dict[nums_neg[ptr1]] = 1\n\n ptr1 +=1\n ptr2 +=1\n\n while ptr2 < len(nums) + 1:\n\n while len(h) > 0 and remove_dict.get(h[0], 0) > 0: \n \n remove_dict[h[0]] -= 1\n\n # if remove_dict[h[0]] == 0:\n # remove_dict.pop(h[0])\n\n heapq.heappop(h)\n\n heapq.heappush(h, nums_neg[ptr2-1])\n\n result.append(h[0]*-1)\n\n if remove_dict.get(nums_neg[ptr1], None) != None:\n remove_dict[nums_neg[ptr1]] += 1\n else:\n remove_dict[nums_neg[ptr1]] = 1\n\n ptr1 +=1\n ptr2 +=1\n\n return result\n ","memory":"35573"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n result = []\n max_heap = []\n for v in nums[:k]:\n heapq.heappush(max_heap, -v)\n\n c = Counter(nums[:k])\n \n for i in range(k, len(nums)):\n curr = nums[i]\n prev = nums[i-k]\n max_val = -max_heap[0] \n c[prev] -= 1\n c[curr] += 1\n result.append(max_val)\n\n if prev == max_val:\n heapq.heapreplace(max_heap, -curr)\n while not c[-max_heap[0]]:\n heapq.heappop(max_heap)\n elif curr > max_val:\n max_heap = []\n heapq.heappush(max_heap, -curr)\n else: \n heapq.heappush(max_heap, -curr)\n\n result.append(-max_heap[0])\n\n return result\n\n \n\n\n \n \n\n ","memory":"35771"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n result = []\n max_heap = []\n counter = defaultdict(int)\n for v in nums[:k]:\n heapq.heappush(max_heap, -v)\n counter[v] += 1\n \n for i in range(k, len(nums)):\n curr = nums[i]\n prev = nums[i-k]\n max_val = -max_heap[0] \n counter[prev] -= 1\n counter[curr] += 1\n result.append(max_val)\n\n if prev == max_val:\n heapq.heapreplace(max_heap, -curr)\n while not counter[-max_heap[0]]:\n heapq.heappop(max_heap)\n elif curr > max_val:\n max_heap = []\n heapq.heappush(max_heap, -curr)\n else: \n heapq.heappush(max_heap, -curr)\n\n result.append(-max_heap[0])\n\n return result\n\n \n\n\n \n \n\n ","memory":"35771"},{"code":"import heapq\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ans = []\n l = 0\n r = k - 1\n largestIndex = -1\n\n heap = []\n\n # initial\n for i in range(k):\n heapq.heappush(heap, (nums[i] * -1, i))\n\n while r < len(nums):\n heapq.heappush(heap, (nums[r] * -1, r))\n\n while largestIndex < l:\n element = heapq.heappop(heap)\n largestIndex = element[1]\n\n if (nums[r] >= nums[largestIndex]):\n largestIndex = r\n\n ans.append(nums[largestIndex])\n\n l += 1\n r += 1\n\n return ans\n","memory":"35968"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums or k == 0:\n return []\n \n n = len(nums)\n if k == 1:\n return nums\n\n # Initialize result list and sliding window management structures\n result = []\n indices = [] # List to simulate the deque for maintaining indices in decreasing order\n index_set = set() # Set to quickly check if an index is in the window\n\n for i in range(n):\n # Remove indices from the set and list that are out of the current window\n if indices and indices[0] < i - k + 1:\n removed_index = indices.pop(0)\n index_set.remove(removed_index)\n\n # Maintain the indices in decreasing order based on their values\n while indices and nums[indices[-1]] < nums[i]:\n index_set.remove(indices.pop())\n \n # Add the current index to the list and set\n indices.append(i)\n index_set.add(i)\n \n # Append the maximum for the current window\n if i >= k - 1:\n result.append(nums[indices[0]])\n\n return result","memory":"36166"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums or k == 0:\n return []\n \n n = len(nums)\n # Return the original list if window size k is 1\n if k == 1:\n return nums\n\n # List to store the maximum values of each window\n result = []\n # List to keep indices of elements in the current window\n indices = []\n # Set to quickly check if an index is in the window\n index_set = set()\n\n for i in range(n):\n # Remove indices that are out of the current window\n if indices and indices[0] < i - k + 1:\n removed_index = indices.pop(0)\n index_set.remove(removed_index)\n\n # Maintain indices in decreasing order based on their values\n while indices and nums[indices[-1]] < nums[i]:\n index_set.remove(indices.pop())\n \n # Add the current index to both list and set\n indices.append(i)\n index_set.add(i)\n \n # Append the maximum value of the current window to result\n if i >= k - 1:\n result.append(nums[indices[0]])\n\n return result","memory":"36166"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums or k == 0:\n return []\n \n n = len(nums)\n # Return the original list if window size k is 1\n if k == 1:\n return nums\n\n # List to store the maximum values of each window\n result = []\n # List to keep indices of elements in the current window\n indices = []\n # Set to quickly check if an index is in the window\n index_set = set()\n\n for i in range(n):\n # Remove indices that are out of the current window\n if indices and indices[0] < i - k + 1:\n removed_index = indices.pop(0)\n index_set.remove(removed_index)\n\n # Maintain indices in decreasing order based on their values\n while indices and nums[indices[-1]] < nums[i]:\n index_set.remove(indices.pop())\n \n # Add the current index to both list and set\n indices.append(i)\n index_set.add(i)\n \n # Append the maximum value of the current window to result\n if i >= k - 1:\n result.append(nums[indices[0]])\n\n return result","memory":"36363"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums or k == 0:\n return []\n \n n = len(nums)\n # Return the original list if window size k is 1\n if k == 1:\n return nums\n\n # List to store the maximum values of each window\n result = []\n # List to keep indices of elements in the current window\n indices = []\n # Set to quickly check if an index is in the window\n window = set()\n\n for i in range(n):\n # Remove indices that are out of the current window\n if indices and indices[0] < i - k + 1:\n removed_index = indices.pop(0)\n window.remove(removed_index)\n\n # Maintain indices in decreasing order based on their values\n while indices and nums[indices[-1]] < nums[i]:\n window.remove(indices.pop())\n \n # Add the current index to both list and set\n indices.append(i)\n window.add(i)\n \n # Append the maximum value of the current window to result\n if i >= k - 1:\n result.append(nums[indices[0]])\n\n return result","memory":"36363"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n end = 0\n queue = collections.deque()\n\n while end < k - 1:\n while queue and queue[-1][0] < nums[end]:\n queue.pop()\n queue.append((nums[end], end))\n while queue and queue[0][0] < nums[end]:\n queue.popleft()\n end += 1\n \n output = []\n while end < len(nums):\n while queue and queue[-1][0] < nums[end]:\n queue.pop()\n queue.append((nums[end], end))\n while queue and (queue[0][0] < nums[end] or end - queue[0][1] + 1 > k):\n queue.popleft()\n output.append(queue[0])\n end += 1\n \n return [x[0] for x in output]\n\n\n ","memory":"36561"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n end = 0\n queue = collections.deque()\n\n while end < k - 1:\n while queue and queue[-1][0] < nums[end]:\n queue.pop()\n queue.append((nums[end], end))\n while queue and queue[0][0] < nums[end]:\n queue.popleft()\n end += 1\n \n output = []\n while end < len(nums):\n while queue and queue[-1][0] < nums[end]:\n queue.pop()\n queue.append((nums[end], end))\n while queue and (queue[0][0] < nums[end] or end - queue[0][1] + 1 > k):\n queue.popleft()\n output.append(queue[0])\n end += 1\n \n return [x[0] for x in output]\n\n\n ","memory":"36561"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maximum = []\n window = []\n head = 0\n tail = 0\n for i in range(k):\n while window != [] and window[tail-1][0] < nums[i]:\n window.pop(-1)\n tail -= 1\n window.append((nums[i], i+k))\n tail += 1 \n maximum.append(window[head][0])\n for i in range(k, len(nums)):\n if window[head][1] == i:\n head += 1\n while tail > head and window[tail-1][0] < nums[i]:\n window.pop(-1)\n tail -= 1\n window.append((nums[i], i+k))\n tail += 1\n maximum.append(window[head][0])\n return maximum\n ","memory":"36758"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n queue = [] # each element is (value, index)\n head = 0\n ans = []\n for i, v in enumerate(nums):\n while head < len(queue) and queue[-1][0] < v:\n queue.pop()\n queue.append((v, i))\n if queue[head][1] <= i - k:\n head += 1\n if i >= k - 1:\n ans.append(queue[head][0])\n return ans\n \n","memory":"36956"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # Brute force: As the window moves, rescan the whole window to find the maximum.\n # Slightly better brute force: As you move along the nums, maintain a check for the current maximum\n # If the current maximum is removed, then rescan the entire window for the new maximum\n # Keep count of all the numbers in the list, and maxheap that maintains the maximum numbers\n # Once the current max is popped, then keep popping until you find a number that is still in the dictionary\n\n # Dictionary to track counts of characters in current window\n nDict = {}\n\n # Heap to track the maximum value within the current window\n maxHeap = []\n\n # Prepare result array\n res = []\n\n # Start by instantiating nDict\n for i in range(k):\n nDict[nums[i]] = nDict.get(nums[i], 0) + 1\n heapq.heappush(maxHeap, -nums[i])\n\n # print(f\"strating heap: {maxHeap}\")\n # print(f\"starting nDict: {nDict}\")\n\n # Append first result\n res.append(-maxHeap[0])\n\n # Now looop through teh whole list\n l = 0\n for r in range(k, len(nums)):\n # Add incoming number\n nDict[nums[r]] = nDict.get(nums[r], 0) + 1\n heapq.heappush(maxHeap, -nums[r])\n\n # Remove start number\n nDict[nums[l]] = nDict.get(nums[l], 0) - 1\n\n # CHeck if removed number was the maximum\n if nums[l] == -maxHeap[0]:\n # print(f\"{nums[l]} found to be equal to top of maxheap: {-maxHeap[0]}\")\n # print(f\"nDict: {nDict}\")\n while -maxHeap[0] not in nDict or nDict[-maxHeap[0]] == 0:\n # Pop from the top\n print(f'Popped {heapq.heappop(maxHeap)}')\n # print(f'Updated heap: {maxHeap}')\n\n res.append(-maxHeap[0])\n\n l += 1\n\n\n return res","memory":"36956"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n N = len(nums)\n freq = defaultdict(int)\n heap = [] # Max heap so negate values\n \n l, r = 0, 0\n for r in range(k):\n freq[nums[r]] += 1\n heapq.heappush(heap, -nums[r])\n res = []\n while r < N:\n curr_max = -heap[0]\n while heap and freq[curr_max] == 0:\n heapq.heappop(heap)\n curr_max = -heap[0]\n res.append(curr_max)\n if r == N-1:\n break\n r += 1\n heapq.heappush(heap, -nums[r])\n freq[nums[r]] += 1\n freq[nums[l]] -= 1\n l += 1\n return res","memory":"37153"},{"code":"from collections import deque\nimport heapq\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n q = deque()\n heap = []\n ans = []\n if k == 1:\n return nums\n\n max = float('-inf')\n for j, i in enumerate(nums):\n if len(q) < k:\n q.append(i)\n if i > max:\n max = i\n heap = []\n else:\n heapq.heappush(heap, (-1*i, j))\n else:\n ans.append(max)\n pop = q.popleft()\n if pop == max:\n pop, index = heapq.heappop(heap)\n max = pop*-1\n while heap:\n if heap[0][1] < index:\n heapq.heappop(heap)\n else:\n break\n q.append(i)\n if i > max:\n heap = []\n max = i\n else:\n heapq.heappush(heap, (-1*i, j))\n ans.append(max)\n return ans\n\n \n\n# 1 3 -1 : 3 : -1 \n# 3 -1 -3 : 3 : -1 -3\n# -1 -3 5 : if next one is larger, clear heap \n\n# -7 -8 7 5 : 7 : 5\n# -8 7 5 7 : 7 : \n# 7 5 7 1 : 7 : 1\n# 5 7 1 6 : 7 : 6 1\n\n# 3 8 3 3 3 6 3 7 3 4 3 3 3 3 \n# 3 8 3 3 3 6 3 7 : 8 : 7 6 \n# 3 3 3 6 3 7 3 4 : 7 : 6 4","memory":"37153"},{"code":"from collections import deque\n\n# Window position Max\n# --------------- -----\n# [1 3 -1] -3 5 3 6 7 3 -1 3 (removed 1)\n# 1 [3 -1 -3] 5 3 6 7 3 -3 -1 3\n# 1 3 [-1 -3 5] 3 6 7 5 5 (removed 3 (OOW), -1, -3)\n# 1 3 -1 [-3 5 3] 6 7 5 3 5\n# 1 3 -1 -3 [5 3 6] 7 6 6 (removed 3, 5)\n# 1 3 -1 -3 5 [3 6 7] 7 7 (removed 6)\n# \n# 1 3 -2 -1 -1 3\n \n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n dq = deque()\n blacklist = set()\n res = []\n\n # Get initial max\n for i in range(k):\n while len(dq) > 0 and nums[i] > nums[dq[0]]:\n dq.popleft()\n dq.appendleft(i)\n res.append(nums[dq[-1]])\n\n # Get remaining maxes\n for i in range(k, len(nums)):\n blacklist.add(i - k)\n #print([nums[i] for i in dq])\n while len(dq) > 0 and nums[i] > nums[dq[0]]:\n dq.popleft()\n dq.appendleft(i)\n #print([nums[i] for i in dq])\n while dq[0] in blacklist:\n dq.popleft()\n while dq[-1] in blacklist:\n dq.pop()\n #print([nums[i] for i in dq])\n res.append(nums[dq[-1]])\n\n return res","memory":"37351"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n #assume there's a way to find the next index that contains a bigger number for each given index in O(n) time\n #monotonic stack\n nextBiggerNumIndex = [-1] * len(nums)\n stack = []\n for index, num in enumerate(nums):\n while len(stack) > 0 and num > stack[-1][1]:\n smallerIndex, smallerNum = stack[-1]\n nextBiggerNumIndex[smallerIndex] = index\n stack.pop()\n stack.append((index, num))\n \n ans = []\n maxPointer = 0\n for startIndex in range(len(nums) - (k - 1)):\n endIndex = startIndex + k\n while startIndex <= nextBiggerNumIndex[maxPointer] < endIndex:\n maxPointer = nextBiggerNumIndex[maxPointer]\n ans.append(nums[maxPointer])\n if maxPointer == startIndex:\n maxPointer += 1\n return ans","memory":"37351"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n dq = collections.deque()\n ans = []\n\n for i, n in enumerate(nums):\n while len(dq) > 0 and n > dq[-1][\"num\"]:\n dq.pop()\n \n while len(dq) > 0 and dq[0][\"idx\"] <= (i - k):\n dq.popleft()\n \n dq.append({\"idx\": i, \"num\": n})\n \n if i >= k - 1:\n ans.append(dq[0][\"num\"])\n\n return ans\n\n","memory":"37548"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n cnt, heap, res = collections.Counter(), [], []\n for i, num in enumerate(nums):\n heapq.heappush(heap, -num)\n cnt[num] += 1\n while not cnt[-heap[0]]:\n heapq.heappop(heap)\n if i >= k - 1:\n res.append(-heap[0])\n cnt[nums[i - k + 1]] -= 1\n return res\n ","memory":"37548"},{"code":"import heapq\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n window = defaultdict(int)\n\n ans = []\n\n heap = []\n\n for i in range(k):\n window[nums[i]] += 1\n heapq.heappush(heap, -1 * nums[i])\n\n l = 0\n\n while l + k - 1 < len(nums):\n # print(l, window)\n # print(heap, ans)\n while -1 * heap[0] not in window:\n heapq.heappop(heap)\n ans.append(-1 * heap[0])\n window[nums[l]] -= 1\n if window[nums[l]] == 0:\n window.pop(nums[l])\n if not l + k == len(nums):\n window[nums[l + k]] += 1\n heapq.heappush(heap, -1 * nums[l + k])\n l += 1\n return ans\n\n #[1, 2, 3, 4, 5], k = 2\n\n","memory":"37746"},{"code":"import heapq\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n window = defaultdict(int)\n\n ans = []\n\n heap = []\n\n for i in range(k):\n window[nums[i]] += 1\n heapq.heappush(heap, -1 * nums[i])\n\n l = 0\n\n while l + k - 1 < len(nums):\n # print(l, window)\n # print(heap, ans)\n while -1 * heap[0] not in window:\n heapq.heappop(heap)\n ans.append(-1 * heap[0])\n window[nums[l]] -= 1\n if window[nums[l]] == 0:\n window.pop(nums[l])\n if not l + k == len(nums):\n window[nums[l + k]] += 1\n heapq.heappush(heap, -1 * nums[l + k])\n l += 1\n return ans\n\n #[1, 2, 3, 4, 5], k = 2\n\n","memory":"37746"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if not nums or k == 0:\n return []\n \n # Initialize\n max_heap = []\n count = defaultdict(int)\n result = []\n \n # Process the first k elements\n for i in range(k):\n heapq.heappush(max_heap, -nums[i])\n count[nums[i]] += 1\n \n # Add the maximum for the first window\n result.append(-max_heap[0])\n \n # Process the rest of the elements\n for i in range(k, len(nums)):\n # Add new element to the heap and count\n heapq.heappush(max_heap, -nums[i])\n count[nums[i]] += 1\n \n # Remove the element that is out of the window\n outgoing = nums[i - k]\n count[outgoing] -= 1\n \n # Remove invalid elements from the heap\n while max_heap and count[-max_heap[0]] == 0:\n print(max_heap[0])\n heapq.heappop(max_heap)\n \n # The current maximum is the root of the heap\n result.append(-max_heap[0])\n \n return result","memory":"37943"},{"code":"from heapq import heappop, heappush \nfrom collections import Counter\n\n\nclass Solution:\n # TC: O(n * log w); O(w);\n def solve_by_brute_force(self, nums: List[int], width: int) -> List[int]:\n result = []\n curr = Counter()\n l = 0\n mins = []\n\n for r, r_num in enumerate(nums):\n curr[r_num] += 1\n heappush(mins, -r_num)\n\n if r < width - 1:\n continue\n \n l_num = nums[l]\n\n if l <= r - width:\n curr[l_num] -= 1\n l += 1\n \n if curr[l_num] == 0:\n curr.pop(l_num)\n \n while -mins[0] not in curr:\n heappop(mins)\n \n result.append(-mins[0])\n \n return result\n\n\n def maxSlidingWindow(self, nums: List[int], width: int) -> List[int]:\n return self.solve_by_brute_force(nums, width) ","memory":"37943"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n arr = []\n for i in range(k):\n heapq.heappush(arr,-1 * nums[i])\n\n res = [-1 * arr[0]]\n delete = dict()\n for i in range(k,len(nums)):\n heapq.heappush(arr,-1 * nums[i])\n if nums[i - k] in delete:\n delete[nums[i - k]] += 1\n else:\n delete[nums[i - k]] = 1\n\n while -1 * arr[0] in delete: \n delete[-1 * arr[0]] -= 1\n if delete[ -1 * arr[0]] == 0: \n del delete[ -1 * arr[0]]\n heapq.heappop(arr) \n\n res.append(-1 * arr[0])\n return res","memory":"38141"},{"code":"from collections import deque\n\n# Window position Max\n# --------------- -----\n# [1 3 -1] -3 5 3 6 7 3 -1 3 (removed 1)\n# 1 [3 -1 -3] 5 3 6 7 3 -3 -1 3\n# 1 3 [-1 -3 5] 3 6 7 5 5 (removed 3 (OOW), -1, -3)\n# 1 3 -1 [-3 5 3] 6 7 5 3 5\n# 1 3 -1 -3 [5 3 6] 7 6 6 (removed 3, 5)\n# 1 3 -1 -3 5 [3 6 7] 7 7 (removed 6)\n# \n# 1 3 -2 -1 -1 3\n \n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n dq = deque()\n blacklist = set()\n res = []\n\n # Get initial max\n for i in range(k):\n while len(dq) > 0 and nums[i] > nums[dq[0]]:\n dq.popleft()\n dq.appendleft(i)\n res.append(nums[dq[-1]])\n\n # Get remaining maxes\n for i in range(k, len(nums)):\n blacklist.add(i - k)\n #print([nums[i] for i in dq])\n while len(dq) > 0 and nums[i] > nums[dq[0]]:\n dq.popleft()\n dq.appendleft(i)\n #print([nums[i] for i in dq])\n while dq[-1] in blacklist:\n dq.pop()\n #print([nums[i] for i in dq])\n res.append(nums[dq[-1]])\n\n return res","memory":"38141"},{"code":"class Solution:\n import heapq\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n res = []\n word_freq_in_window = defaultdict(int)\n window_heap = []\n \n #initialize the word_freq_in_window\n for i in range(k):\n word_freq_in_window[nums[i]] += 1\n window_heap.append(-1*nums[i]) # heapq is min heap we want max heap\n \n heapq.heapify(window_heap)\n res.append(-1*window_heap[0])\n\n window_start = 0\n window_end = k-1\n \n\n while window_end<len(nums)-1:\n # Removing the start value from freq dict\n word_freq_in_window[nums[window_start]] -= 1\n if word_freq_in_window[nums[window_start]] == 0:\n del word_freq_in_window[nums[window_start]]\n \n while window_heap and -1*window_heap[0] not in word_freq_in_window:\n heapq.heappop(window_heap)\n \n window_start += 1\n window_end += 1\n # insert the new word at the end of the window\n word_freq_in_window[nums[window_end]] += 1\n heapq.heappush(window_heap,-1*nums[window_end])\n\n res.append(-1*window_heap[0])\n\n return res \n","memory":"38338"},{"code":"import heapq\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n window = {}\n heap = [-n for n in nums[:k]]\n for n in heap:\n window[-n] = window.get(-n, 0) + 1\n \n heapq.heapify(heap)\n\n res = []\n left = 0\n for right in range(k, len(nums)+1):\n # make sure top of heap is always a number in the window\n while heap and -heap[0] not in window:\n heapq.heappop(heap)\n\n res.append(-heap[0])\n\n if right >= len(nums):\n break\n\n heapq.heappush(heap, -nums[right])\n window[nums[right]] = window.get(nums[right], 0) + 1\n\n window[nums[left]] -= 1\n if window[nums[left]] <= 0:\n del window[nums[left]]\n\n if nums[left] == -heap[0]:\n heapq.heappop(heap)\n\n left += 1\n\n return res\n ","memory":"38338"},{"code":"import heapq\nfrom collections import defaultdict\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if len(nums) == 1:\n return [nums[0]]\n # assumptions will len(nums) >= k?\n # will nums be valid inputs?\n # ints, floats? \n # range of these numbers?\n # range of k?\n\n heap = [-nums[i] for i in range(k)]\n heapq.heapify(heap)\n \n # first idea is just have a heap that keeps track of the max\n # pop that max from the heap once it leaves\n # problem its hard to pop the 2nd biggest item in \n # keep track of nums to pop in a hashmap\n\n nums_to_pop = defaultdict(int) #{num: how many}\n max_in_window = [-heap[0]]\n # pop {-1: 1, -3: 1}\n # heap [-1, -3, 1, 3, -5]\n # output: 3, 3, 5, \n # rn edge case if i == 1: solved\n for i in range(1, len(nums) - k + 1):\n nums_to_pop[-nums[i - 1]] += 1\n heapq.heappush(heap, -nums[i + k - 1])\n\n while nums_to_pop[heap[0]] > 0:\n nums_to_pop[heap[0]] -= 1\n heapq.heappop(heap)\n max_in_window.append(-heap[0])\n\n return max_in_window\n\n\n\n\n\n\n \n\n\n","memory":"38536"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n max_heap = [-1 * x for x in nums[0:k]]\n heapq.heapify(max_heap)\n curr_counts = Counter(nums[0:k])\n\n\n def clean_out_queue():\n while max_heap and (-1 * max_heap[0] not in curr_counts or curr_counts[-1 * max_heap[0]] == 0):\n heapq.heappop(max_heap)\n\n out = []\n for i in range(k, len(nums)):\n clean_out_queue()\n out.append(max_heap[0] * -1)\n\n to_remove = nums[i - k]\n curr_counts[to_remove] -= 1\n\n to_add = nums[i]\n curr_counts[to_add] += 1\n heapq.heappush(max_heap, -1 * to_add)\n \n\n clean_out_queue()\n out.append(max_heap[0] * -1)\n \n return out\n\n\n \n\n\n","memory":"38536"},{"code":"import heapq\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n heap = []\n heapq.heapify(heap)\n\n curWindow = defaultdict(int)\n\n for i in range(k):\n heapq.heappush(heap, -nums[i])\n curWindow[nums[i]] += 1\n \n out = []\n\n i = k - 1\n while True:\n while True:\n mn = heapq.heappop(heap)\n if curWindow[-mn] != 0:\n heapq.heappush(heap, mn)\n out.append(-mn)\n break\n \n if i == len(nums) - 1:\n break\n \n i += 1\n heapq.heappush(heap, -nums[i])\n curWindow[nums[i]] += 1\n curWindow[nums[i - k]] -= 1\n \n return out\n \n \n\n \n\n\n","memory":"38733"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n import heapq\n res = []\n maxHeap = []\n # initalise window\n for i in range(len(nums)):\n if i < k-1:\n heapq.heappush(maxHeap, (-nums[i], i))\n else:\n # if top of heap is less than the current or index is not valid remove\n while maxHeap and (-maxHeap[0][0] < nums[i] or maxHeap[0][1]+k <= i ):\n heapq.heappop(maxHeap)\n heapq.heappush(maxHeap, (-nums[i], i))\n res.append(-maxHeap[0][0])\n return res\n","memory":"38733"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # need to maintain ordering -> heap\n # need to remove based on index\n # intialize window\n curr = []\n for i in range(k):\n heapq.heappush(curr, -1 * nums[i])\n\n deleted = defaultdict(int)\n res = [-1 * curr[0]]\n for i in range(k, len(nums)):\n heapq.heappush(curr, -1 * nums[i])\n deleted[-1 * nums[i-k]] += 1\n while curr[0] in deleted and deleted[curr[0]] > 0:\n deleted[curr[0]] -= 1\n heapq.heappop(curr)\n res.append(-1 * curr[0])\n return res","memory":"38931"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # need to maintain ordering -> heap\n # need to remove based on index\n # intialize window\n curr = []\n for i in range(k):\n heapq.heappush(curr, -1 * nums[i])\n\n deleted = defaultdict(int)\n res = [-1 * curr[0]]\n for i in range(k, len(nums)):\n heapq.heappush(curr, -1 * nums[i])\n deleted[-1 * nums[i-k]] += 1\n while curr[0] in deleted and deleted[curr[0]] > 0:\n deleted[curr[0]] -= 1\n heapq.heappop(curr)\n res.append(-1 * curr[0])\n return res","memory":"38931"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n track = []\n cnt = defaultdict(int)\n heap = []\n ans = []\n for i in range(len(nums)):\n cnt[nums[i]] += 1\n track.append(nums[i])\n heapq.heappush(heap,-nums[i])\n if i >= k:\n last = track[0]\n cnt[last] -= 1\n track.pop(0)\n if i >= k-1:\n while len(heap) > 0 and cnt[-heap[0]] == 0:\n heapq.heappop(heap)\n ans.append(-heap[0])\n return ans","memory":"39128"},{"code":"class Solution:\n import heapq\n def removeOldElements(self, maxHeap, removed):\n while len(maxHeap) > 0 and maxHeap[0] in removed and removed[maxHeap[0]] > 0:\n removed[maxHeap[0]] -= 1 \n heapq.heappop(maxHeap)\n\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxHeap, removed = [], {}\n sol = []\n for i in range(0, k):\n heapq.heappush(maxHeap, -nums[i])\n\n sol.append(-maxHeap[0])\n\n for i in range(k, len(nums)):\n remove = -nums[i - k]\n if remove in removed:\n removed[remove] += 1\n else:\n removed[remove] = 1\n\n self.removeOldElements(maxHeap, removed)\n heapq.heappush(maxHeap, -nums[i])\n sol.append(-maxHeap[0])\n return sol\n \n\n\n","memory":"39128"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n i = 0\n heap = []\n res = []\n m = {}\n\n while i < k:\n heapq.heappush(heap, -1 * nums[i])\n i += 1\n\n res.append(heap[0] * -1)\n\n while i < len(nums):\n removeIdx = i - k\n removeVal = nums[removeIdx]\n nextVal = nums[i]\n\n if removeVal == heap[0]*-1:\n heapq.heappop(heap)\n\n while heap and (heap[0]*-1) in m and m[(heap[0]*-1)] > 0:\n popped = heapq.heappop(heap) * -1\n m[popped] -= 1\n\n heapq.heappush(heap, nextVal * -1)\n res.append(heap[0] * -1)\n else:\n if removeVal in m:\n m[removeVal] += 1\n else:\n m[removeVal] = 1\n heapq.heappush(heap, nextVal * -1)\n res.append(heap[0] * -1)\n\n i += 1\n\n return res\n","memory":"39326"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n i = 0\n heap = []\n res = []\n m = {}\n\n while i < k:\n heapq.heappush(heap, -1 * nums[i])\n i += 1\n\n res.append(heap[0] * -1)\n\n while i < len(nums):\n removeIdx = i - k\n removeVal = nums[removeIdx]\n nextVal = nums[i]\n\n if removeVal == heap[0]*-1:\n heapq.heappop(heap)\n\n while heap and (heap[0]*-1) in m and m[(heap[0]*-1)] > 0:\n popped = heapq.heappop(heap) * -1\n m[popped] -= 1\n\n heapq.heappush(heap, nextVal * -1)\n res.append(heap[0] * -1)\n else:\n if removeVal in m:\n m[removeVal] += 1\n else:\n m[removeVal] = 1\n heapq.heappush(heap, nextVal * -1)\n res.append(heap[0] * -1)\n\n i += 1\n\n return res\n","memory":"39326"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n heap = []\n for i in range(k):\n heapq.heappush(heap, -nums[i])\n ans = [-heap[0]]\n p = 0\n removed = set()\n counter = Counter(heap)\n for i in range(k, len(nums)):\n removed.add(-nums[p])\n counter[-nums[p]] -= 1\n\n heapq.heappush(heap, -nums[i])\n counter[-nums[i]] += 1\n while heap[0] in removed and counter[heap[0]] == 0:\n heapq.heappop(heap)\n # heap[0] not in removed or in removed but counter[nums[p]] >= 1\n ans.append(-heap[0])\n p += 1\n return ans\n","memory":"39523"},{"code":"import heapq as hq\nfrom collections import defaultdict\nclass Solution:\n def maxSlidingWindow(self, a: List[int], k: int) -> List[int]:\n n = len(a)\n heap = []\n d = defaultdict(int)\n for i in range(k):\n hq.heappush(heap, -1 * a[i])\n d[a[i]] += 1\n res = []\n s, e = 0, k - 1\n while e < n:\n maxm = -1 * hq.heappop(heap)\n while True:\n if d[maxm] == 0:\n maxm = -1 * hq.heappop(heap)\n continue\n break\n res.append(maxm)\n if a[s] != maxm:\n hq.heappush(heap, -1 * maxm)\n d[a[s]] -= 1\n s += 1\n e += 1\n if e < n: \n d[a[e]] += 1\n hq.heappush(heap, -1 * a[e])\n return res\n","memory":"39523"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n heap = []\n for index, val in enumerate(nums[:k-1]):\n heapq.heappush(heap, (-1*val, index))\n result = []\n for i in range(k-1, len(nums)):\n if heap:\n v_check, i_check = heapq.heappop(heap)\n if nums[i] > v_check*-1:\n while heap != []:\n heapq.heappop(heap)\n else:\n heapq.heappush(heap, (v_check, i_check))\n heapq.heappush(heap, (nums[i] * -1, i))\n while True:\n v, pop_i = heapq.heappop(heap)\n v *= -1\n if pop_i > i - k:\n break\n if pop_i > i - k + 1:\n heapq.heappush(heap, (v * -1, pop_i))\n result.append(v)\n return result\n ","memory":"39721"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # monotonic queue\n from sortedcontainers import SortedList\n pq = SortedList([(nums[i], i) for i in range(k)])\n res = [pq[-1][0]]\n for i in range(k, len(nums)):\n pq.add((nums[i], i))\n while i - pq[-1][1] >= k:\n pq.pop()\n res.append(pq[-1][0])\n return res","memory":"39721"},{"code":"import heapq\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxes = []\n maxHeap = []\n for i in range(k):\n heapq.heappush(maxHeap, (-nums[i], i))\n maxes.append(-maxHeap[0][0])\n \n for i in range(k, len(nums)):\n while maxHeap and -nums[i] < maxHeap[0][0]:\n heapq.heappop(maxHeap)\n heapq.heappush(maxHeap, (-nums[i], i))\n while maxHeap[0][1] < i-k+1:\n heapq.heappop(maxHeap)\n maxes.append(-maxHeap[0][0])\n return maxes","memory":"39918"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n maxHeap = []\n res = []\n numOutOfFrame = defaultdict(int)\n\n if len(nums) < k:\n return res\n \n for i in range(k):\n heapq.heappush(maxHeap, -nums[i])\n \n res.append(-maxHeap[0])\n \n for i in range(k, len(nums)):\n heapq.heappush(maxHeap, -nums[i])\n numOutOfFrame[nums[i-k]] += 1\n while numOutOfFrame[-maxHeap[0]] > 0:\n val = -heapq.heappop(maxHeap)\n numOutOfFrame[val] -= 1\n res.append(-maxHeap[0])\n \n return res\n","memory":"39918"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ub = []\n result = []\n for i in range(k):\n heapq.heappush(ub, -nums[i])\n result.append(-ub[0]) \n todo = [] # also a heap\n for i in range(k, len(nums)):\n # number to be removed\n kick = nums[i-k]\n new = nums[i]\n if kick == -ub[0]:\n heapq.heappop(ub)\n else:\n heapq.heappush(todo, -kick)\n\n\n while len(todo) != 0:\n if todo[0] == ub[0]:\n heapq.heappop(ub)\n heapq.heappop(todo)\n else:\n break\n\n\n\n heapq.heappush(ub, -new)\n result.append(-ub[0])\n return result\n","memory":"40116"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n ub = []\n result = []\n for i in range(k):\n heapq.heappush(ub, -nums[i])\n result.append(-ub[0]) \n todo = [] # also a heap\n for i in range(k, len(nums)):\n # number to be removed\n kick = nums[i-k]\n new = nums[i]\n if kick == -ub[0]:\n heapq.heappop(ub)\n else:\n heapq.heappush(todo, -kick)\n\n while len(todo) != 0:\n if todo[0] == ub[0]:\n heapq.heappop(ub)\n heapq.heappop(todo)\n else:\n break\n\n heapq.heappush(ub, -new)\n result.append(-ub[0])\n return result\n","memory":"40116"},{"code":"import heapq\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # Heap to store the elements as (-value, index)\n max_heap = []\n result = []\n \n for i in range(len(nums)):\n # Push the current element onto the heap (storing negative to simulate max-heap)\n heapq.heappush(max_heap, (-nums[i], i))\n \n # If the index of the current element is greater than or equal to (k-1),\n # we are at a valid window.\n if i >= k - 1:\n # Pop elements from the heap that are out of the current window\n while max_heap[0][1] <= i - k:\n heapq.heappop(max_heap)\n \n # The root of the heap is the largest element in the current window\n result.append(-max_heap[0][0])\n \n return result\n","memory":"40313"},{"code":"\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n \"\"\"\n [1, 3, -1, -3, 5, 1, 2, 3]\n\n 1 : [1] []\n 3 : [3,1] []\n -1 : [3,1,-1] []\n -3 : [3,1,-1,-3] [1]\n 4 : [4,-1,-3] []\n 5 : [5,4,-1,-3] [-1]\n 1 : [5,4,1,-1,-3] [-1,-3]\n 2 : [5,4,2,1,-1,-3] [4,-1,-3]\n 3 : [3,2,1,-1,-3] [-1,-3]\n \"\"\"\n maxHeap = [-x for x in nums[:k]]\n heapq.heapify(maxHeap)\n tombstones = []\n result = [-maxHeap[0]]\n for i in range(k, len(nums)):\n remove = nums[i - k]\n if maxHeap[0] == -remove:\n heapq.heappop(maxHeap)\n while maxHeap and tombstones and maxHeap[0] == tombstones[0]:\n heapq.heappop(maxHeap)\n heapq.heappop(tombstones)\n else:\n heapq.heappush(tombstones, -remove)\n heapq.heappush(maxHeap, -nums[i])\n result.append(-maxHeap[0])\n return result","memory":"40313"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n n = len(nums)\n results = []\n heap = []\n\n for i in range(k):\n heapq.heappush(heap, (-nums[i], i))\n results.append(-heap[0][0])\n\n for i in range(0, n - k):\n \n new_digit = nums[i + k]\n old_digit = nums[i]\n\n # remove invalid number\n while heap and heap[0][1] <= i:\n heapq.heappop(heap)\n \n # add new\n heapq.heappush(heap, (-new_digit, i + k))\n \n # add result\n results.append(-heap[0][0])\n \n return results\n \n\n","memory":"40511"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n if k == 1: return nums\n rwindow = [(-val, i) for i, val in enumerate(nums[:k])]\n heapq.heapify(rwindow)\n res = [-rwindow[0][0]]\n\n for i in range(k, len(nums)):\n while rwindow[0][1] <= i - k: heapq.heappop(rwindow)\n heapq.heappush(rwindow, (-nums[i], i))\n res.append(-rwindow[0][0])\n\n return res\n\n","memory":"40511"},{"code":"import heapq\n\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n heap = []\n i = 0\n ret = []\n\n while i < k - 1:\n heapq.heappush(heap, (-nums[i], i))\n i += 1\n\n while i < len(nums):\n heapq.heappush(heap, (-nums[i], i))\n while heap[0][1] < i - k + 1:\n heapq.heappop(heap)\n ret.append(heap[0][0] * -1)\n i += 1\n \n return ret","memory":"40708"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n # initialize a max heap\n # initialize a map\n # initialize left and right pointer starting at 0\n # loop from 0 to len(nums):\n # if l is larger than current maxIndex value: \n # pop the top of the heap\n # remove maxIndex value\n # add each value into the maxheap\n # if the max value changes: change maxIndex value to the current index\n # when the window size = k:\n # add the current top of heap to ansList\n # increment l\n # return ansList\n\n if k == 1:\n return nums\n\n maxH = []\n ans = []\n\n for i in range(k):\n heapq.heappush(maxH, (-nums[i], i))\n \n ans.append(-maxH[0][0])\n\n l = 1\n\n for r in range(k, len(nums)):\n \n\n while maxH[0][1] < l:\n heapq.heappop(maxH)\n\n heapq.heappush(maxH, (-nums[r], r))\n\n ans.append(-maxH[0][0])\n\n l += 1\n \n return ans","memory":"40708"},{"code":"import heapq\n\nclass Solution:\n myheap = []\n remheap = []\n def add_elem(self, val):\n heapq.heappush(self.myheap, val)\n def rem_elem(self, val):\n heapq.heappush(self.remheap, val)\n def peek_top(self):\n if len(self.myheap) == 0:\n return None\n while len(self.remheap) > 0 and self.remheap[0] < self.myheap[0]:\n heapq.heappop(self.remheap)\n while len(self.myheap) > 0 and len(self.remheap) > 0 and self.myheap[0] == self.remheap[0]:\n heapq.heappop(self.myheap)\n heapq.heappop(self.remheap)\n \n if len(self.myheap) == 0:\n return None\n return self.myheap[0]\n\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n self.myheap = []\n self.remheap = []\n for i in range(k):\n self.add_elem(-nums[i])\n ans = [-self.peek_top()]\n for i in range(k, len(nums)):\n self.add_elem(-nums[i])\n self.rem_elem(-nums[i-k])\n ans.append(-self.peek_top())\n return ans","memory":"40906"},{"code":"# class Solution:\n# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n# # left = 0\n# # right = k-1\n\n# # max_windows = []\n# # while right < len(nums):\n# # max_window = max(nums[left:right+1])\n# # max_windows.append(max_window)\n# # return max_windows\n# # k*n\n\n# # instead of max, remove last element from heap and add newly added element\n# # logK * n\n\nimport heapq\n\nclass Solution:\n def maxSlidingWindow(self, nums, k):\n heap = []\n result = []\n\n for i in range(len(nums)):\n # Push the negative value to simulate a max heap\n heapq.heappush(heap, (-nums[i], i))\n \n # Remove elements outside the current window\n while heap[0][1] <= i - k:\n heapq.heappop(heap)\n \n # Append the maximum value to the result once the first window is formed\n if i >= k - 1:\n result.append(-heap[0][0])\n \n return result\n","memory":"40906"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n heap = []\n for i in range(k):\n heapq.heappush(heap, (-nums[i], i))\n \n result = [-heap[0][0]]\n \n for i in range(k, len(nums)):\n heapq.heappush(heap, (-nums[i], i))\n while heap[0][1]+k <= i:\n heapq.heappop(heap)\n \n result.append(-heap[0][0])\n \n return result\n\n \n return maxSum\n\n ","memory":"41103"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n h = []\n for i in range(k - 1):\n h.append((-nums[i], i))\n heapify(h)\n res = []\n l, r = 0, k - 1\n while r < len(nums):\n heappush(h, (-nums[r], r))\n while not l <= h[0][1] <= r:\n heappop(h)\n res.append(-h[0][0])\n l += 1\n r += 1\n return res\n ","memory":"41103"},{"code":"class Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n result = []\n max_heap = []\n \n for i in range(len(nums)):\n heapq.heappush(max_heap, (-nums[i], i))\n while max_heap[0][1] <= i - k:\n heapq.heappop(max_heap)\n if i >= k - 1:\n result.append(-max_heap[0][0])\n \n return result\n ","memory":"41301"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums: list[int], k: int) -> list[int]:\\n \\n result = []\\n max_stack = []\\n \\n for i in range(k-1):\\n while max_stack and nums[max_stack[-1]] < nums[i]:\\n max_stack.pop()\\n max_stack.append(i)\\n\\n for i in range(k-1, len(nums)):\\n if max_stack and i >= max_stack[0] + k:\\n max_stack.pop(0)\\n \\n while max_stack and nums[max_stack[-1]] < nums[i]:\\n max_stack.pop()\\n \\n max_stack.append(i)\\n result.append(nums[max_stack[0]])\\n \\n return result\\n\\ninput_iter = iter(stdin)\\noutput = open('user.out', 'w')\\nfor array in input_iter:\\n output.write(dumps(Solution.maxSlidingWindow(loads(array), int(next(input_iter)))).replace(' ', '') + '\\\\n')\\nexit()\\n\",\n \"memory\": \"25698\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\\n q = deque()\\n # only keep track the biggest\\n for i in range(k-1):\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans = []\\n for i in range(k-1, len(nums)):\\n if q and i >= q[0] + k:\\n q.popleft()\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans.append(nums[q[0]])\\n return ans\\n it = iter(stdin)\\n output = open('user.out', 'w')\\n for array in it:\\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\\\n')\\n exit()\\n \\n \",\n \"memory\": \"25698\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\\n q = deque()\\n # only keep track the biggest\\n for i in range(k-1):\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans = []\\n for i in range(k-1, len(nums)):\\n if q and i >= q[0] + k:\\n q.popleft()\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans.append(nums[q[0]])\\n return ans\\n it = iter(stdin)\\n output = open('user.out', 'w')\\n for array in it:\\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\\\n')\\n exit()\\n \\n \",\n \"memory\": \"25896\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\\n q = deque()\\n # only keep track the biggest\\n for i in range(k-1):\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans = []\\n for i in range(k-1, len(nums)):\\n if q and i >= q[0] + k:\\n q.popleft()\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans.append(nums[q[0]])\\n return ans\\n it = iter(stdin)\\n output = open('user.out', 'w')\\n for array in it:\\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\\\n')\\n exit()\\n \\n \",\n \"memory\": \"26093\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(nums: List[int], k: int) -> List[int]:\\n q = deque()\\n # only keep track the biggest\\n for i in range(k-1):\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans = []\\n for i in range(k-1, len(nums)):\\n if q and i >= q[0] + k:\\n q.popleft()\\n while q and nums[q[-1]] < nums[i]:\\n q.pop()\\n q.append(i)\\n ans.append(nums[q[0]])\\n return ans\\n it = iter(stdin)\\n output = open('user.out', 'w')\\n for array in it:\\n output.write(dumps(maxSlidingWindow(loads(array), int(next(it)))).replace(' ', '') + '\\\\n')\\n exit()\\n \\n \",\n \"memory\": \"26093\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n\\n\\n dq = deque()\\n result = []\\n\\n for i in range(len(nums)):\\n # Remove elements out of the current window\\n if dq and dq[0] < i - k + 1:\\n dq.popleft()\\n\\n # Remove elements from the deque that are smaller than the current element\\n while dq and nums[dq[-1]] < nums[i]:\\n dq.pop()\\n\\n # Add the current element's index to the deque\\n dq.append(i)\\n\\n # Append the maximum for the current window to the result\\n if i >= k - 1:\\n result.append(nums[dq[0]])\\n\\n return result\\n\",\n \"memory\": \"26291\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n q = collections.deque()\\n left = 0\\n right = 0\\n\\n while right < len(nums):\\n while q and nums[q[len(q) - 1]] < nums[right]:\\n q.pop()\\n q.append(right)\\n\\n if left > q[0]:\\n q.popleft()\\n \\n if (right - left) + 1 >= k:\\n res.append(nums[q[0]])\\n left += 1\\n\\n right += 1\\n\\n return res\\n\",\n \"memory\": \"26488\"\n },\n {\n \"code\": \"from collections import deque\\n\\n\\nclass MyQueue: #单调队列（从大到小\\n def __init__(self):\\n self.queue = deque() \\n \\n def pop(self, value):\\n if self.queue and value == self.queue[0]:\\n self.queue.popleft()\\n\\n def push(self, value):\\n while self.queue and value > self.queue[-1]:\\n self.queue.pop()\\n self.queue.append(value)\\n \\n\\n def front(self):\\n return self.queue[0]\\n \\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n que = MyQueue()\\n result = []\\n for i in range(k): #先将前k的元素放进队列\\n que.push(nums[i])\\n result.append(que.front()) #result 记录前k的元素的最大值\\n for i in range(k, len(nums)):\\n que.pop(nums[i - k]) #滑动窗口移除最前面元素\\n que.push(nums[i]) #滑动窗口前加入最后面的元素\\n result.append(que.front()) #记录对应的最大值\\n return result\",\n \"memory\": \"26686\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n window = MonotonicQueue()\\n res = []\\n for i in range(len(nums)):\\n if i < k - 1:\\n window.push(nums[i])\\n else:\\n window.push(nums[i])\\n res.append(window.maxVal())\\n # 移出旧数字\\n window.pop(nums[i - k + 1])\\n # window keep k - 1 numbers\\n return res\\n \\nclass MonotonicQueue:\\n def __init__(self):\\n self.maxq = deque()\\n \\n def push(self, n):\\n while self.maxq and self.maxq[-1] < n:\\n self.maxq.pop()\\n self.maxq.append(n)\\n \\n def maxVal(self):\\n return self.maxq[0]\\n \\n def pop(self, n):\\n if self.maxq[0] == n:\\n self.maxq.popleft()\\n \",\n \"memory\": \"26883\"\n },\n {\n \"code\": \"from collections import deque\\n\\nfrom collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n window_max = deque([]) # Double-ended queue to store potential window maximums\\n result = []\\n\\n for i in range(len(nums)):\\n val = nums[i]\\n\\n # Remove elements from the deque that are smaller than the current element,\\n # because they can't be the max in the window if a larger element is present.\\n while window_max and window_max[-1] < val:\\n window_max.pop()\\n \\n # Add the current element to the deque. The deque maintains values in non-increasing order.\\n window_max.append(val)\\n\\n # When we have processed at least k elements (i.e., starts sliding),\\n # remove the front element from the deque if it's no longer in the window.\\n if i + 1 > k:\\n # If the element going out of the window is the same as the front of the deque,\\n # it should be removed since it no longer contributes to the max in the window.\\n if window_max[0] == nums[i - k]:\\n window_max.popleft()\\n\\n # Once the window reaches the size of k, add the maximum of the current window to the result.\\n if i + 1 >= k:\\n result.append(window_max[0]) # The front of the deque always holds the current max value.\\n \\n return result\\n\\n \",\n \"memory\": \"27081\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n out = []\\n r,l = 0,0\\n q = collections.deque()\\n while r < len(nums):\\n while q and q[-1] < nums[r]:\\n q.pop()\\n q.append(nums[r])\\n if r+1 >= k:\\n out.append(q[0])\\n if nums[l] == q[0]:\\n q.popleft()\\n l+=1\\n r+=1\\n return out\",\n \"memory\": \"27278\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxArray = []\\n\\n q = deque()\\n # maintain q of size k \\n\\n for i in range(len(nums)):\\n # print(i, q)\\n # append i to the appropriate position of decreasing q\\n while q and q[-1] < nums[i]:\\n q.pop()\\n q.append(nums[i])\\n\\n # remove out of bounds value from left side\\n if i >= k and q[0] == nums[i-k]:\\n q.popleft()\\n \\n # q[0] will be the max of window\\n if i >= k - 1:\\n maxArray.append(q[0])\\n\\n return maxArray\",\n \"memory\": \"27476\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n def cleanUp(queue: List[int], val: int, index: int):\\n while queue and val >= nums[queue[-1]]:\\n queue.pop()\\n queue.append(index)\\n res = []\\n queue = deque()\\n for i in range(k):\\n cleanUp(queue, nums[i], i)\\n res.append(nums[queue[0]])\\n \\n for i in range(k, len(nums)):\\n if queue and queue[0] == i - k:\\n queue.popleft()\\n cleanUp(queue, nums[i], i)\\n res.append(nums[queue[0]])\\n\\n return res\\n\\n \\n\",\n \"memory\": \"27673\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n left, right = 0, 0\\n\\n q = collections.deque()\\n\\n while right < len(nums):\\n while q and nums[q[-1]] < nums[right]:\\n q.pop()\\n q.append(right)\\n \\n if left > q[0]:\\n q.popleft()\\n \\n if right + 1 >= k:\\n res.append(nums[q[0]])\\n left += 1\\n right += 1\\n return res\",\n \"memory\": \"27871\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nfrom sortedcontainers import SortedDict\\n\\n\\n# add and remove to/from window is time complex\\n# finding the biggest is complex\\n# some tree structure with logn operations time should do\\n\\n# c++ sorted map would do so well here. O(1) to get largest, log(n) to insert/delete\\n# nlog(n) time which is good for 10**5\\n\\n# maintain sorted list with binary search? Not an option, logn to find place and n to place it in list\\n\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n btree = SortedDict()\\n btree.update(Counter(nums[:k]))\\n\\n result = list()\\n for i in range(0, len(nums) - k + 1):\\n max_key, _ = btree.peekitem(-1)\\n result.append(max_key)\\n\\n counter = btree.pop(nums[i])\\n if counter := counter - 1:\\n btree[nums[i]] = counter\\n\\n if i + k < len(nums):\\n new_key = nums[i + k]\\n if new_key in btree:\\n btree[new_key] = btree[new_key] + 1\\n else:\\n btree[new_key] = 1 \\n\\n return result\",\n \"memory\": \"28068\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n l = 0\\n queue = deque()\\n for r in range(len(nums)):\\n while queue and queue[-1] < nums[r]:\\n queue.pop()\\n queue.append(nums[r])\\n if (r-l+1) == k:\\n res.append(queue[0])\\n if nums[l] == queue[0]:\\n queue.popleft()\\n l += 1\\n return res\\n # res = []\\n # for i in range(len(nums) - k + 1):\\n # maxV = float(\\\"-inf\\\")\\n # for j in range(k):\\n # maxV = max(maxV, nums[i+j])\\n # res.append(maxV)\\n # return res\",\n \"memory\": \"28266\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n stack = deque()\\n\\n for i in range(len(nums)):\\n while stack and nums[i] > stack[-1]:\\n stack.pop()\\n stack.append(nums[i])\\n\\n if i >= k and nums[i - k] == stack[0]:\\n stack.popleft()\\n\\n if i >= k - 1:\\n res.append(stack[0])\\n\\n return res\",\n \"memory\": \"28463\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n left = 0\\n right = k - 1\\n currMax = deque()\\n for i in range(k):\\n while len(currMax) != 0 and nums[i] > currMax[-1]:\\n currMax.pop()\\n currMax.append(nums[i])\\n res.append(currMax[0])\\n while right < len(nums):\\n if nums[left] == currMax[0]:\\n currMax.popleft()\\n left += 1\\n right += 1\\n if right == len(nums): break\\n while len(currMax) != 0 and nums[right] > currMax[-1]:\\n currMax.pop()\\n currMax.append(nums[right])\\n res.append(currMax[0])\\n return res\\n\\n \\n \\n\\n\\n \\n \",\n \"memory\": \"28463\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n l = r = 0\\n maxWindow = []\\n dq = deque()\\n\\n while r < len(nums):\\n\\n if dq and r - dq[0] + 1 > k:\\n dq.popleft()\\n \\n while dq and nums[dq[-1]] < nums[r]:\\n dq.pop()\\n\\n dq.append(r)\\n \\n if r >= k - 1:\\n maxWindow.append(nums[dq[0]])\\n\\n r += 1\\n\\n return maxWindow\\n \\n\\n\",\n \"memory\": \"28661\"\n },\n {\n \"code\": \"'''\\nGoal:\\n- Return a list of all max values from every iteration of the sliding window (slide + 1)\\n\\nApproach: O(n) linear, O(1) space\\n- create some queue to only hold max values\\n - every incoming number will be checked against the last number of the queue\\n - the last number will be popped() out of the queue if the incoming is greater\\n - add the current max number to queue\\n- Check if the pos is \\\"out of bounds\\\" -> store pos of nums in the queue\\n- Check if atleast window size # of iterations have occurred to add that first max into our results\\n\\n'''\\nfrom collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = deque([])\\n result = []\\n\\n for i in range(len(nums)):\\n while q and nums[i] > nums[q[-1]]:\\n q.pop()\\n\\n q.append(i)\\n\\n if q[0] <= i - k:\\n q.popleft()\\n\\n if i >= k - 1:\\n result.append(nums[q[0]])\\n return result\\n\\n \\n\\n \",\n \"memory\": \"28661\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n window = deque([])\\n max_sliding_window = []\\n\\n for index, num in enumerate(nums):\\n while len(window) > 0 and window[0] < index - k + 1:\\n window.popleft()\\n\\n while len(window) > 0 and nums[window[-1]] <= num:\\n window.pop()\\n\\n window.append(index)\\n\\n if index >= k - 1:\\n max_sliding_window.append(nums[window[0]])\\n\\n return max_sliding_window\",\n \"memory\": \"28858\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n dq = deque()\\n result = []\\n for i in range(len(nums)):\\n while dq and nums[i] > dq[-1][0]:\\n dq.pop()\\n dq.append((nums[i], i))\\n while dq[0][1] + k <= i:\\n dq.popleft()\\n if i >= (k-1):\\n result.append(dq[0][0])\\n return result\\n\\n\\n\\n heap = []\\n for i in range(k):\\n heapq.heappush(heap, (-nums[i], i))\\n \\n result = [-heap[0][0]]\\n \\n for i in range(k, len(nums)):\\n heapq.heappush(heap, (-nums[i], i))\\n while heap[0][1]+k <= i:\\n heapq.heappop(heap)\\n \\n result.append(-heap[0][0])\\n \\n return result\\n\\n \",\n \"memory\": \"28858\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n curr = SortedList()\\n res= []\\n for i in range(k):\\n curr.add(nums[i])\\n\\n res.append(max(curr))\\n\\n for i in range(k,len(nums)):\\n curr.add(nums[i])\\n curr.remove(nums[i-k])\\n res.append(curr[-1])\\n return res\\n \\n\\n \\n\\n \",\n \"memory\": \"29451\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n n, mwind, i, mwind_max = len(nums), deque(), 0, []\\n while True:\\n if i>=n: break\\n while mwind and mwind[0][0]<i-k+1:\\n mwind.popleft()\\n while len(mwind)>0 and nums[i]>=mwind[-1][1]:\\n mwind.pop()\\n mwind.append((i, nums[i]))\\n if i>=k-1:\\n mwind_max.append(mwind[0][1])\\n i += 1\\n \\n return mwind_max\\n\",\n \"memory\": \"29451\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k == 1:\\n return nums\\n\\n queue = deque()\\n result = []\\n left, right = 0, 0\\n\\n while right < len(nums):\\n num = nums[right]\\n while len(queue) and queue[-1] < num:\\n queue.pop()\\n queue.append(num)\\n\\n \\n length = right - left + 1\\n if length == k:\\n result.append(queue[0])\\n if queue[0] == nums[left]:\\n queue.popleft()\\n left += 1\\n\\n\\n right += 1\\n\\n return result\\n\\n \",\n \"memory\": \"29648\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = deque()\\n start = 0\\n result = []\\n for i in range(k):\\n while q and q[-1] < nums[i]:\\n q.pop()\\n q.append(nums[i])\\n result.append(q[0])\\n for i in range(1, len(nums)-k+1):\\n if q and nums[i-1] == q[0]:\\n q.popleft()\\n\\n while q and q[-1] < nums[i+k-1]:\\n q.pop()\\n \\n q.append(nums[i+k-1])\\n result.append(q[0])\\n return result\\n\\n # [1,2,1,0,4,2,6]\\n # [4,1]\\n 2,2,4,4,6\\n count = {}\\n curr_max = float('-inf')\\n for c in range(k):\\n count[nums[c]] = count.get(nums[c], 0) + 1\\n curr_max = max(curr_max, nums[c])\\n result = [curr_max]\\n for i in range(1, len(nums)-k+1):\\n count[nums[i-1]] -= 1\\n if count[nums[i-1]] == 0:\\n del count[nums[i-1]]\\n count[nums[i+k-1]] = count.get(nums[i+k-1], 0) + 1\\n if curr_max in count:\\n curr_max = max(curr_max, nums[i+k-1])\\n else:\\n curr_max = max(count)\\n result.append(curr_max)\\n return result\",\n \"memory\": \"29648\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k == 1:\\n return nums\\n\\n queue = deque()\\n result = []\\n left, right = 0, 0\\n\\n while right < len(nums):\\n num = nums[right]\\n while len(queue) and queue[-1] < num:\\n queue.pop()\\n queue.append(num)\\n\\n \\n length = right - left + 1\\n if length == k:\\n result.append(queue[0])\\n if queue[0] == nums[left]:\\n queue.popleft()\\n left += 1\\n\\n\\n right += 1\\n\\n return result\\n\\n \",\n \"memory\": \"29846\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k == 1:\\n return nums\\n\\n queue = deque()\\n result = []\\n left, right = 0, 0\\n\\n while right < len(nums):\\n num = nums[right]\\n while len(queue) and queue[-1] < num:\\n queue.pop()\\n queue.append(num)\\n\\n \\n length = right - left + 1\\n if length == k:\\n result.append(queue[0])\\n if queue[0] == nums[left]:\\n queue.popleft()\\n left += 1\\n\\n\\n right += 1\\n\\n return result\\n\\n \",\n \"memory\": \"29846\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n result = []\\n counter = {}\\n currMax = nums[0]\\n for i in range(k - 1):\\n if nums[i] not in counter:\\n counter[nums[i]] = 0\\n counter[nums[i]] += 1\\n currMax = max(currMax, nums[i])\\n\\n l = 0\\n for r in range(k - 1, len(nums)):\\n left = nums[l]\\n right = nums[r]\\n if right not in counter:\\n counter[right] = 0\\n counter[right] += 1\\n if currMax < right:\\n currMax = right\\n elif currMax not in counter:\\n currMax = max(counter.keys())\\n \\n result.append(currMax)\\n if counter[left] <= 1:\\n counter.pop(left)\\n else:\\n counter[left] -= 1\\n l += 1\\n\\n return result\\n\",\n \"memory\": \"30043\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = collections.deque() # monotootic decreasing queqe\\n l, r = 0, 0\\n res = []\\n while r < len(nums):\\n # removing all smaller numbers from the queue\\n while len(q) != 0 and nums[q[-1]]< nums[r]:\\n q.pop()\\n \\n q.append(r)\\n\\n # remove out of bound value\\n if q[0]<l:\\n q.popleft()\\n\\n if r-l+1 == k:\\n res.append(nums[q[0]])\\n l+=1 # in the start we dont increase left\\n r+=1\\n\\n return res\",\n \"memory\": \"30043\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n \\n # 超时\\n '''\\n if k < 1:\\n return []\\n if len(nums) < k:\\n return max(nums)\\n\\n res = []\\n res.append(max(nums[:k]))\\n for l in range(1,len(nums)-k+1):\\n r = l+k\\n \\n if nums[r-1] >= res[l-1]: #如果右边新加入的数大于等于前一个滑动窗口的最大值，则当前滑动窗口的最大值为新加入的数\\n res.append(nums[r-1])\\n elif nums[l-1] < res[l-1]: #如果左边删除的数小于前一个滑动窗口的最大值，则当前滑动窗口的最大值等于上一个滑动窗口的最大值\\n res.append(res[l-1])\\n else: #如果左边删除的数等于前一个滑动窗口的最大值 且 右边新加入的数小于前一个滑动窗口的最大值\\n res.append(max(nums[l:r]))\\n\\n return res\\n '''\\n\\n res = []\\n q = deque()\\n\\n #维护长度为k的非增队列\\n for idx, num in enumerate(nums):\\n while q and q[-1] < num: \\n q.pop()\\n q.append(num)\\n\\n if idx >= k and nums[idx - k] == q[0]: \\n q.popleft()\\n \\n if idx >= k - 1:\\n res.append(q[0])\\n \\n return res\\n\",\n \"memory\": \"30241\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n dq = deque()\\n res= []\\n for i in range(k):\\n while dq and nums[dq[-1]]<= nums[i]:\\n dq.pop()\\n dq.append(i)\\n\\n res.append(nums[dq[0]])\\n\\n for i in range(k,len(nums)):\\n if dq and dq[0] <=i-k:\\n dq.popleft()\\n while dq and nums[dq[-1]]<= nums[i]:\\n dq.pop()\\n dq.append(i)\\n\\n res.append(nums[dq[0]])\\n return res\\n \\n\\n \\n\\n \",\n \"memory\": \"30241\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n queue = []\\n res = []\\n for i, num in enumerate(nums):\\n while queue and nums[queue[-1]] < num:\\n queue.pop(-1)\\n queue.append(i)\\n if i >= k and queue[0] <= i-k:\\n queue.pop(0)\\n if i >= k-1: res.append(nums[queue[0]])\\n return res\\n \\n\\n\",\n \"memory\": \"30438\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n queue = deque()\\n res = []\\n for i, num in enumerate(nums):\\n while queue and nums[queue[-1]] < num:\\n queue.pop()\\n queue.append(i)\\n if i >= k-1:\\n while queue[0] <= i-k:\\n queue.popleft()\\n res.append(nums[queue[0]])\\n return res\\n \\n\\n\",\n \"memory\": \"30438\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n result = []\\n counter = {}\\n currMax = nums[0]\\n for i in range(k - 1):\\n if nums[i] not in counter:\\n counter[nums[i]] = 0\\n counter[nums[i]] += 1\\n currMax = max(currMax, nums[i])\\n\\n l = 0\\n for r in range(k - 1, len(nums)):\\n left = nums[l]\\n right = nums[r]\\n if right not in counter:\\n counter[right] = 0\\n counter[right] += 1\\n if currMax < right:\\n currMax = right\\n elif currMax not in counter:\\n currMax = max(counter.keys())\\n\\n if r == k + 3:\\n print(counter.keys())\\n result.append(currMax)\\n if counter[left] <= 1:\\n counter.pop(left)\\n else:\\n counter[left] -= 1\\n l += 1\\n\\n return result\\n\",\n \"memory\": \"30636\"\n },\n {\n \"code\": \"from queue import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n dq = deque()\\n\\n if k == 1:\\n return nums\\n \\n if len(nums) == k:\\n return [max(nums)]\\n \\n for i in range(k):\\n if len(dq) == 0:\\n dq.append(i)\\n else:\\n if nums[i] >= nums[dq[-1]]:\\n dq.clear()\\n dq.append(i)\\n else:\\n while nums[i] >= nums[dq[0]]:\\n dq.popleft()\\n dq.appendleft(i)\\n\\n ans = []\\n for i in range(k - 1, len(nums)):\\n ans.append(nums[dq[-1]])\\n if i - k + 1 == dq[-1]:\\n dq.pop()\\n if i < len(nums) - 1:\\n if len(dq) == 0:\\n dq.append(i + 1)\\n else:\\n if nums[i + 1] >= nums[dq[-1]]:\\n dq.clear()\\n dq.append(i + 1)\\n else:\\n while nums[i + 1] >= nums[dq[0]]:\\n dq.popleft()\\n dq.appendleft(i + 1)\\n \\n \\n\\n return ans\",\n \"memory\": \"30636\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n q = deque()\\n\\n for idx, num in enumerate(nums):\\n while q and q[-1]<num:\\n q.pop()\\n q.append(num)\\n\\n if idx>=k and nums[idx-k] == q[0]:\\n q.popleft()\\n\\n if idx>=k-1:\\n res.append(q[0])\\n return res\",\n \"memory\": \"30833\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n output = []\\n q = collections.deque()\\n l = r = 0\\n while r < len(nums):\\n #pop smaller values from q\\n while q and nums[q[-1]] < nums[r]:\\n q.pop()\\n q.append(r)\\n #remove left val fromm window\\n if l > q[0]:\\n q.popleft()\\n\\n if (r+1) >= k:\\n output.append(nums[q[0]])\\n l += 1\\n r +=1 \\n\\n return output\\n\",\n \"memory\": \"30833\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n queue = []\\n res = []\\n for i, num in enumerate(nums):\\n while queue and nums[queue[-1]] < num:\\n queue.pop(-1)\\n queue.append(i)\\n if i >= k-1:\\n while queue[0] <= i-k:\\n queue.pop(0)\\n res.append(nums[queue[0]])\\n return res\\n \\n\\n\",\n \"memory\": \"31031\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k==1: return nums\\n window=list(range(0,k))\\n z=[]\\n for i in range(k):\\n if z==[]:\\n z.append(i)\\n continue\\n if nums[i]<nums[z[-1]]:\\n z.append(i)\\n else:\\n while z and nums[i]>nums[z[-1]]:\\n z.pop(-1)\\n z.append(i)\\n res=[nums[z[0]]]\\n for i in range(k,len(nums)):\\n new_ele=i\\n x=window.pop(0)\\n window.append(new_ele)\\n if x==z[0]:\\n z.pop(0)\\n if nums[i]<nums[z[-1]]:\\n z.append(i)\\n else:\\n while z and nums[i]>nums[z[-1]]:\\n z.pop(-1)\\n z.append(i)\\n res.append(nums[z[0]])\\n return res\",\n \"memory\": \"31031\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n output = []\\n q = collections.deque()\\n l = r = 0\\n\\n while r<len(nums):\\n while q and nums[q[-1]] < nums[r]:\\n q.pop()\\n q.append(r)\\n if l >q[0]:\\n q.popleft()\\n if (r+1)>=k:\\n output.append(nums[q[0]])\\n l +=1\\n r+=1\\n return output\\n \\n\\n\",\n \"memory\": \"31228\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass MyQueue:\\n def __init__(self):\\n self.queue = deque()\\n\\n def pop(self, value):\\n if self.queue and value == self.queue[0]:\\n self.queue.popleft()\\n \\n def push(self, value):\\n while self.queue and value > self.queue[-1]:\\n self.queue.pop()\\n self.queue.append(value)\\n \\n def front(self):\\n return self.queue[0]\\n\\n\\n\\nclass Solution: \\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n que = MyQueue()\\n result = []\\n for i in range(k):\\n que.push(nums[i])\\n result.append(que.front())\\n for i in range(k, len(nums)):\\n que.pop(nums[i - k])\\n que.push(nums[i])\\n result.append(que.front())\\n return result\",\n \"memory\": \"31228\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n result = []\\n dq = deque()\\n for i in range(k):\\n while len(dq) != 0 and dq[-1][0] <= nums[i]:\\n dq.pop()\\n dq.append([nums[i], i])\\n \\n result.append(dq[0][0])\\n\\n for i in range(k, len(nums)):\\n print(i)\\n while len(dq) != 0 and dq[-1][0] <= nums[i]:\\n dq.pop()\\n dq.append([nums[i], i])\\n\\n while dq[0][1] <= i - k:\\n dq.popleft()\\n\\n result.append(dq[0][0])\\n \\n return result\",\n \"memory\": \"31426\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxNum = float(\\\"-inf\\\")\\n\\n maxIdx = -1\\n result = []\\n maxStack = []\\n left = 0\\n for right in range(0, len(nums)):\\n if maxStack and maxStack[0] < left:\\n maxStack.pop(0)\\n while maxStack and nums[maxStack[-1]] < nums[right]:\\n maxStack.pop()\\n maxStack.append(right)\\n if right - left + 1 == k:\\n result.append(nums[maxStack[0]])\\n left += 1\\n return result\",\n \"memory\": \"31426\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n stack = [] \\n N = []\\n for i, v in enumerate(nums):\\n if i<k-1:\\n if not stack: stack.append( (v,i) )\\n else: \\n while stack and stack[-1][0]<=v: stack.pop()\\n stack.append( (v,i) )\\n else:\\n while stack and stack[-1][0]<=v: stack.pop()\\n stack.append( (v,i) )\\n if stack and stack[0][1]<=i-k: stack.pop(0) \\n N.append(stack[0][0])\\n return N \",\n \"memory\": \"31623\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass MonotonicQueue:\\n def __init__(self):\\n self.queue = deque()\\n \\n def push(self, val, i):\\n while self.queue and val > self.queue[-1][0]:\\n self.queue.pop()\\n self.queue.append((val, i))\\n \\n def pop(self, i):\\n while self.queue and i >= self.queue[0][1]:\\n self.queue.popleft()\\n \\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n\\n mq = MonotonicQueue()\\n\\n for i in range(k):\\n mq.push(nums[i], i)\\n \\n res = [mq.queue[0][0]]\\n\\n for i in range(k, len(nums)):\\n mq.pop(i - k)\\n mq.push(nums[i], i)\\n res.append(mq.queue[0][0])\\n return res\\n\\n \",\n \"memory\": \"31821\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ans=[]\\n q=deque()\\n l,r=0,0\\n while r<len(nums):\\n while q and nums[q[-1]]<nums[r]:\\n q.pop()\\n q.append(r)\\n if l>q[0]:\\n q.popleft()\\n if (r-l+1)==k:\\n ans.append(nums[q[0]])\\n l+=1\\n r+=1\\n return ans\\n\\n \",\n \"memory\": \"31821\"\n },\n {\n \"code\": \"from collections import deque\\nfrom typing import List\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n d = deque() # Deque to store indices of the elements\\n result = [] # List to store the result\\n \\n for i, v in enumerate(nums):\\n # Remove indices that are out of the current window\\n if d and i - k >= d[0]:\\n d.popleft()\\n \\n # Remove indices of elements that are less than the current element\\n while d and nums[d[-1]] <= v:\\n d.pop()\\n \\n # Add current element index to the deque\\n d.append(i)\\n \\n # Add the maximum value of the current window to the result\\n if i >= k - 1:\\n result.append(nums[d[0]])\\n \\n return result\\n\",\n \"memory\": \"32018\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n n = len(nums)\\n res = []\\n dq = deque()\\n\\n for i in range(n):\\n if dq and dq[0] < i - k + 1:\\n dq.popleft()\\n \\n while dq and nums[dq[-1]] < nums[i]:\\n dq.pop()\\n\\n dq.append(i)\\n if i + 1 >= k:\\n res.append(nums[dq[0]])\\n\\n return res\\n\\n\",\n \"memory\": \"32018\"\n },\n {\n \"code\": \"import collections\\n\\n# идея: сделать монотонно убывающий дек (т.е. снизу лежит самый большой элемент)\\n# дек нужен, чтобы за единицу добавлять сверху и удалять снизу элемент\\n# (при этом просто очередьь не подойдет, тк нужно будет ещё и удалять сверху чтобы поддерживать заданный на стеке порядок)\\n# то есть мы сверху: добавляем, удаляем ; снизу: удаляем\\n# заметим, что не хватит просто хранить 1 максимум на данном окне размера k, тк возможна ситуация:\\n# [4 3 -1] [-1 -5 -6], то есть если в первом окне будем хранить только 4, то потеряем (-1), которая максимум во втором окне\\n\\n# еще особенность в том, что тут не нужен левый индекс, потому что для проверки нахождения в границах достаточно сделать\\n# deque[0] < right - k + 1, тк в деке храним индексы => они по построению идут по возрастанию и поэтому наименьший индекс,\\n# который отвечает за (потенциально возможную) левую границу нашего окна будет лежать всегда внизу дека.\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ans = list()\\n deq = collections.deque()\\n\\n for right in range(len(nums)):\\n\\n while deq and nums[deq[-1]] < nums[right]:\\n deq.pop()\\n \\n deq.append(right)\\n\\n if deq and deq[0] < right - k + 1:\\n deq.popleft()\\n \\n if right >= k - 1:\\n ans.append(nums[deq[0]])\\n \\n return ans\",\n \"memory\": \"32216\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums, k):\\n result = []\\n window = deque()\\n\\n for i, num in enumerate(nums):\\n while window and window[0] < i - k + 1:\\n window.popleft()\\n\\n while window and nums[window[-1]] < num:\\n window.pop()\\n\\n window.append(i)\\n\\n if i >= k - 1:\\n result.append(nums[window[0]])\\n\\n return result\",\n \"memory\": \"32216\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n \\\"\\\"\\\"\\n sliding window of size k\\n very left of the array to the very right\\n You can only see the k numbers in the window. \\n Each time the sliding window moves right by one position.\\n\\n nums.length large [1, 100000]\\n\\n nums value medium [-10000, 10000]\\n\\n k [1, nums.length]\\n\\n only need to consider next new element in the window.\\n if the newest element is bigger than all the others, we can just remove all\\n other elements from consideration \\n\\n ex 1: [1 3 -1] -> [3 -1 -3] -> [-1 5 5] -> [5 5 3] -> [5 6 6] -> [6 7 7] \\n\\n indexes 2, 2, 4, 4, 6, 7\\n [2, 3] -> [2, 4] -> [4] -> [4, 5] -> [6] -> [7]\\n keep track of indexes, if \\n\\n for each window, append max to list\\n \\\"\\\"\\\"\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n max_window: List[int] = []\\n max_current_elems = deque([])\\n\\n def slide_deque(new_index: int) -> None:\\n nonlocal max_current_elems\\n\\n # Empty deque, just add\\n if not max_current_elems:\\n max_current_elems.append(new_index)\\n return\\n\\n # Remove index if out of window, we are only ever popping 1 element after all\\n # Any indexes smaller than this one should have already been filtered out\\n if max_current_elems[0] < (new_index - (k - 1)):\\n max_current_elems.popleft() \\n\\n # If any elements before the new value are smaller, remove them\\n new_value: int = nums[new_index]\\n \\n while max_current_elems and nums[max_current_elems[-1]] <= new_value:\\n max_current_elems.pop()\\n\\n # Add the new element to the end of the current elems deque\\n max_current_elems.append(new_index)\\n \\n for i in range(len(nums)):\\n # Building the deque in the first k - 1 iterations\\n if i < (k - 1):\\n slide_deque(i)\\n continue\\n\\n \\n # Otherwise, slide and take the max element\\n slide_deque(i)\\n max_window.append(nums[max_current_elems[0]])\\n\\n return max_window\",\n \"memory\": \"32413\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n idx_Q, maxes = deque(), [] \\n INIT,LN = 0,len(nums)\\n\\n def next_greater_right():\\n next_val = nums[right]\\n return next_val > nums[idx_Q[-1]]\\n\\n def left_out_of_bounds():\\n prev_left = idx_Q[0]\\n return prev_left < left\\n\\n left = right = INIT\\n while right < LN:\\n while idx_Q and next_greater_right():\\n idx_Q.pop()\\n \\n idx_Q.append(right)\\n\\n if left_out_of_bounds(): idx_Q.popleft()\\n\\n next=right+1\\n if next >= k:\\n maxes.append(nums[idx_Q[0]])\\n left += 1\\n right += 1\\n\\n return maxes\",\n \"memory\": \"32413\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n result = []\\n dq = deque()\\n for i in range(k):\\n while dq and dq[-1][0] <= nums[i]:\\n dq.pop()\\n dq.append([nums[i], i])\\n \\n result.append(dq[0][0])\\n\\n for i in range(k, len(nums)):\\n while dq and dq[-1][0] <= nums[i]:\\n dq.pop()\\n dq.append([nums[i], i])\\n\\n if dq[0][1] <= i - k:\\n dq.popleft()\\n\\n result.append(dq[0][0])\\n \\n return result\",\n \"memory\": \"32611\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n queue = collections.deque()\\n output = []\\n for i in range(len(nums)):\\n while len(queue) and (queue[0][0] <= (i - k) or queue[0][1] <= nums[i]):\\n queue.popleft()\\n while len(queue) and (queue[-1][1] <= nums[i]):\\n queue.pop()\\n queue.append((i,nums[i]))\\n\\n if i < (k - 1):\\n continue\\n output.append(queue[0][1])\\n return output\",\n \"memory\": \"32611\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n stack = collections.deque() \\n N = []\\n for i, v in enumerate(nums):\\n if i<k-1:\\n if not stack: stack.append( (v,i) )\\n else: \\n while stack and stack[-1][0]<=v: stack.pop()\\n stack.append( (v,i) )\\n else:\\n while stack and stack[-1][0]<=v: stack.pop()\\n stack.append( (v,i) )\\n if stack and stack[0][1]<=i-k: stack.popleft() \\n N.append(stack[0][0])\\n return N \",\n \"memory\": \"32808\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n n = len(nums)\\n ans = []\\n maxHeap = SortedList([])\\n i = 0\\n j = 0\\n while j < n:\\n maxHeap.add((nums[j],j))\\n if j-i+1 < k:\\n j += 1\\n elif j-i + 1 == k:\\n ans.append(maxHeap[-1][0])\\n maxHeap.remove((nums[i],i))\\n i += 1\\n j += 1\\n return ans\\n\",\n \"memory\": \"33006\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ans = []\\n curList = deque([[-inf,-inf]])\\n \\n for i in range(len(nums)):\\n if curList[0][1] <= (i-k):\\n curList.popleft()\\n while len(curList) and nums[i] > curList[-1][0]:\\n curList.pop()\\n curList.append([nums[i],i])\\n if i >= k-1:\\n ans.append(curList[0][0])\\n return ans\\n \",\n \"memory\": \"33203\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n deque = [0] * 100001\\n head = tail = 0\\n l = 0\\n r = k-1\\n ansNum = len(nums) - k + 1\\n ans = [0] * ansNum\\n \\n for i in range(k-1):\\n while head < tail and nums[deque[tail-1]] <= nums[i]:\\n tail -= 1\\n deque[tail] = i\\n tail += 1\\n \\n for l in range(ansNum):\\n while head < tail and nums[deque[tail-1]] <= nums[r]:\\n tail -= 1\\n deque[tail] = r\\n tail += 1\\n ans[l] = nums[deque[head]]\\n if deque[head] == l:\\n head += 1\\n r += 1\\n return ans\\n\\n # deq = deque() # Initialize a deque\\n # ans = [] # List to store results\\n\\n # for i in range(len(nums)):\\n # # Remove elements not in the sliding window\\n # if deq and deq[0] < i - k + 1:\\n # deq.popleft()\\n \\n # # Remove elements smaller than the current element\\n # # from the deque\\n # while deq and nums[deq[-1]] <= nums[i]:\\n # deq.pop()\\n \\n # # Add the current element's index to the deque\\n # deq.append(i)\\n \\n # # Append the maximum element in the current sliding window to ans\\n # if i >= k - 1:\\n # ans.append(nums[deq[0]])\\n \\n # return ans\\n\\n \",\n \"memory\": \"33401\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n output = []\\n q = collections.deque() # index\\n l = r = 0\\n # O(n) O(n)\\n while r < len(nums):\\n # pop smaller values from q\\n while q and nums[q[-1]] < nums[r]:\\n q.pop()\\n q.append(r)\\n\\n # remove left val from window\\n if l > q[0]:\\n q.popleft()\\n print(r - l + 1)\\n if (r - l + 1) == k:\\n output.append(nums[q[0]])\\n l += 1\\n r += 1\\n\\n return output\\n\\n\\n\\n \",\n \"memory\": \"33598\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n \\n max_sliding_window = []\\n cur_window = deque()\\n\\n # initialize the queue\\n first_window_sorted = sorted(list(enumerate(nums[:k-1])), key=(lambda t: t[1]))\\n for x in first_window_sorted:\\n cur_window.append(x[0]) # the right side element is the max\\n\\n for i in range(k - 1, len(nums)):\\n num = nums[i]\\n #print([str(x) for x in cur_window])\\n while cur_window and (nums[cur_window[0]] <= num or cur_window[0] <= i - k):\\n #print(\\\"popping \\\", cur_window[0])\\n # for all future windows we no longer need this elem\\n cur_window.popleft()\\n cur_window.appendleft(i)\\n\\n # rightmost element is always the max\\n while cur_window[len(cur_window) - 1] <= i - k:\\n #print(\\\"Pop right for \\\", cur_window[len(cur_window) - 1])\\n cur_window.pop()\\n max_in_window = nums[cur_window[len(cur_window) - 1]]\\n #print(\\\"max of this window is \\\", max_in_window)\\n max_sliding_window.append(max_in_window)\\n return max_sliding_window\",\n \"memory\": \"33796\"\n },\n {\n \"code\": \"class MaxHeap:\\n\\n\\n def __init__(self):\\n self.heap = [None]\\n\\n def up_heap(self, index):\\n if index <= 1:\\n return\\n parent_index = index // 2\\n # print(self.heap[parent_index][0])\\n if self.heap[parent_index][0] < self.heap[index][0]:\\n self.heap[index], self.heap[parent_index] = self.heap[parent_index], self.heap[index]\\n self.up_heap(parent_index)\\n \\n def down_heap(self, index):\\n left_index = index * 2\\n right_index = index * 2 + 1\\n biggest_index = index\\n\\n if left_index < len(self.heap) and self.heap[biggest_index][0] < self.heap[left_index][0]:\\n biggest_index = left_index\\n\\n if right_index < len(self.heap) and self.heap[biggest_index][0] < self.heap[right_index][0]:\\n biggest_index = right_index\\n\\n if biggest_index != index:\\n self.heap[biggest_index], self.heap[index] = self.heap[index], self.heap[biggest_index]\\n self.down_heap(biggest_index)\\n \\n def insert(self, value, index):\\n self.heap.append((value, index))\\n self.up_heap(len(self.heap)-1)\\n\\n def pop(self):\\n if len(self.heap) <= 1:\\n return None\\n if len(self.heap) == 2:\\n return self.heap.pop()\\n\\n max_value, max_index = self.heap[1]\\n self.heap[1] = self.heap.pop()\\n self.down_heap(1)\\n\\n return max_value, max_index\\n \\n\\n def max(self):\\n if len(self.heap) <= 1:\\n return None\\n return self.heap[1]\\n\\n def size(self):\\n return len(self.heap) - 1\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n answer = []\\n max_heap = MaxHeap()\\n i = 0\\n for v in nums:\\n max_heap.insert(v, i)\\n i += 1\\n if i >= k:\\n smallest_window_index = i - k\\n print(f\\\"{smallest_window_index}-{i}\\\")\\n while max_heap.size() > 0:\\n max_value, max_index = max_heap.max()\\n if max_index < smallest_window_index:\\n max_heap.pop()\\n else:\\n answer.append(max_value)\\n break\\n return answer\\n\\n\",\n \"memory\": \"33993\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n n, heap = len(nums), []\\n for num in nums[:k]:\\n heappush(heap, (-num, num))\\n _, first_max = heap[0]\\n maxes = [first_max]\\n ignore = defaultdict(int)\\n for i in range(k, n):\\n heappush(heap, (-nums[i], nums[i]))\\n ignore[nums[i - k]] += 1\\n _, current_max = heap[0]\\n while ignore[current_max] > 0:\\n heappop(heap)\\n ignore[current_max] -= 1\\n _, current_max = heap[0]\\n maxes.append(current_max)\\n return maxes\",\n \"memory\": \"34191\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n n, heap = len(nums), []\\n for num in nums[:k]:\\n heappush(heap, (-num, num))\\n _, first_max = heap[0]\\n maxes = [first_max]\\n ignore = defaultdict(int)\\n for i in range(k, n):\\n heappush(heap, (-nums[i], nums[i]))\\n ignore[nums[i - k]] += 1\\n _, current_max = heap[0]\\n while ignore[current_max] > 0:\\n heappop(heap)\\n ignore[current_max] -= 1\\n _, current_max = heap[0]\\n maxes.append(current_max)\\n return maxes\",\n \"memory\": \"34191\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums, k):\\n ans = [max(nums[:k])]\\n pq = []\\n out = defaultdict(int)\\n\\n for i in range(k):\\n heapq.heappush(pq, (-nums[i], nums[i]))\\n \\n idx = k\\n while idx < len(nums):\\n heapq.heappush(pq, (-nums[idx], nums[idx]))\\n out[nums[idx-k]] += 1\\n\\n while True:\\n top = heapq.heappop(pq)[1]\\n if out[top] == 0:\\n heapq.heappush(pq, (-top, top))\\n break\\n out[top] -= 1\\n\\n ans.append(top)\\n idx += 1\\n return ans\",\n \"memory\": \"34388\"\n },\n {\n \"code\": \"class Pair(namedtuple(\\\"Pair\\\", [\\\"index\\\", \\\"value\\\"])):\\n def __lt__(self, other):\\n return self.value > other.value or self.value == other.value and self.index < other.index\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # Complexity O(Nlog(2k)) = O(Nlogk)\\n pq = [Pair(i, nums[i]) for i in range(k - 1)]\\n heapq.heapify(pq)\\n max_window = []\\n for index, value in enumerate(nums[k - 1:], k - 1):\\n while pq and pq[0].index <= index - k:\\n heapq.heappop(pq)\\n heapq.heappush(pq, Pair(index, value))\\n max_window.append(pq[0].value)\\n return max_window\\n\",\n \"memory\": \"34586\"\n },\n {\n \"code\": \"class node:\\n def __init__(self, val = None, prev = None, next = None, index = None):\\n self.val = val\\n self.prev = prev\\n self.next = next\\n self.index = index\\n\\nclass deque:\\n def __init__(self):\\n self.head = node()\\n self.tail = node()\\n self.head.next = self.tail\\n self.tail.prev = self.head\\n self.size = 0\\n \\n def append(self, node):\\n node.prev = self.tail.prev\\n node.next = self.tail\\n self.tail.prev.next = node\\n self.tail.prev = node \\n self.size += 1\\n \\n def remove(self, node):\\n p, n = node.prev, node.next\\n p.next = n\\n n.prev = p\\n self.size -= 1\\n\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n Q = deque()\\n for i in range(k):\\n n = node(nums[i], index = i)\\n end = Q.tail.prev\\n while (Q.size > 0 and end.val <= nums[i]):\\n prev = end.prev\\n Q.remove(end)\\n end = prev\\n Q.append(n)\\n res = [Q.head.next.val]\\n\\n for i in range(k, len(nums)):\\n # remove old\\n if (Q.head.next.index == i - k):\\n Q.remove(Q.head.next)\\n end = Q.tail.prev\\n while (Q.size > 0 and end.val <= nums[i]):\\n prev = end.prev\\n Q.remove(end)\\n end = prev\\n # add new\\n n = node(nums[i], index = i)\\n Q.append(n)\\n res.append(Q.head.next.val)\\n return res\\n\\n\\n\",\n \"memory\": \"34783\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n heap = []\\n\\n for r in range(len(nums)):\\n heapq.heappush(heap, (-nums[r], r)) # -nums[r] ?\\n if len(heap) < k:\\n continue\\n while heap[0][1] <= r - k:\\n heapq.heappop(heap)\\n if heap:\\n res.append(nums[heap[0][1]])\\n\\n return res\",\n \"memory\": \"34981\"\n },\n {\n \"code\": \"class MaxHeap:\\n def __init__(self) -> None:\\n self.heap = []\\n\\n def size(self) -> int:\\n return len(self.heap)\\n\\n def push(self, x: int) -> None:\\n heapq.heappush(self.heap, -x)\\n\\n def pop(self) -> int:\\n return -heapq.heappop(self.heap)\\n\\n def top(self) -> int:\\n return -self.heap[0]\\n\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k == 1:\\n return nums\\n ans = []\\n tmp = nums[0]\\n max_heap = MaxHeap()\\n mydict = defaultdict(int)\\n for i in range(k):\\n tmp = max(tmp, nums[i])\\n max_heap.push(nums[i])\\n mydict[nums[i]] += 1\\n ans.append(tmp)\\n\\n for i in range(1, len(nums) - k + 1):\\n prev_max = ans[-1]\\n mydict[nums[i-1]] -= 1\\n\\n if nums[i-1] == prev_max:\\n while mydict[prev_max] == 0 and max_heap.size() > 1:\\n max_heap.pop()\\n prev_max = max_heap.top()\\n if nums[i+k-1] > prev_max:\\n ans.append(nums[i+k-1])\\n else:\\n ans.append(prev_max)\\n \\n max_heap.push(nums[i+k-1])\\n mydict[nums[i+k-1]] += 1\\n return ans\\n\\n\",\n \"memory\": \"35178\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n d=dict()\\n maxi = -1001\\n out=[]\\n for j in range(k):\\n maxi = max(maxi,nums[j])\\n d[nums[j]] = d.get(nums[j],0)+1\\n out.append(maxi)\\n left=0\\n right=k\\n while(right<len(nums)):\\n d[nums[right]]=d.get(nums[right],0)+1\\n maxi=max(maxi,nums[right])\\n d[nums[left]]=d[nums[left]]-1\\n if(d[nums[left]]==0):\\n del d[nums[left]]\\n if(nums[left]==maxi):\\n localMaxi=-1001\\n maxi=maxi-1\\n while(d.get(maxi,0)==0):\\n maxi-=1\\n out.append(maxi)\\n left+=1\\n right+=1\\n return out\\n\\n\\n\\n\",\n \"memory\": \"35376\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n result = []\\n\\n ptr1 = 0\\n ptr2 = k\\n\\n nums_neg = [i*-1 for i in nums]\\n remove_dict = {}\\n\\n h = nums_neg[ptr1:ptr2]\\n heapq.heapify(h)\\n print(h)\\n result.append(h[0]*-1)\\n remove_dict[nums_neg[ptr1]] = 1\\n\\n ptr1 +=1\\n ptr2 +=1\\n\\n while ptr2 < len(nums) + 1:\\n\\n while len(h) > 0 and remove_dict.get(h[0], None) != None: \\n \\n remove_dict[h[0]] -= 1\\n\\n if remove_dict[h[0]] == 0:\\n remove_dict.pop(h[0])\\n\\n heapq.heappop(h)\\n\\n heapq.heappush(h, nums_neg[ptr2-1])\\n\\n result.append(h[0]*-1)\\n\\n if remove_dict.get(nums_neg[ptr1], None) != None:\\n remove_dict[nums_neg[ptr1]] += 1\\n else:\\n remove_dict[nums_neg[ptr1]] = 1\\n\\n ptr1 +=1\\n ptr2 +=1\\n\\n return result\\n \",\n \"memory\": \"35573\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n result = []\\n\\n ptr1 = 0\\n ptr2 = k\\n\\n nums_neg = [i*-1 for i in nums]\\n remove_dict = {}\\n\\n h = nums_neg[ptr1:ptr2]\\n heapq.heapify(h)\\n print(h)\\n result.append(h[0]*-1)\\n remove_dict[nums_neg[ptr1]] = 1\\n\\n ptr1 +=1\\n ptr2 +=1\\n\\n while ptr2 < len(nums) + 1:\\n\\n while len(h) > 0 and remove_dict.get(h[0], 0) > 0: \\n \\n remove_dict[h[0]] -= 1\\n\\n # if remove_dict[h[0]] == 0:\\n # remove_dict.pop(h[0])\\n\\n heapq.heappop(h)\\n\\n heapq.heappush(h, nums_neg[ptr2-1])\\n\\n result.append(h[0]*-1)\\n\\n if remove_dict.get(nums_neg[ptr1], None) != None:\\n remove_dict[nums_neg[ptr1]] += 1\\n else:\\n remove_dict[nums_neg[ptr1]] = 1\\n\\n ptr1 +=1\\n ptr2 +=1\\n\\n return result\\n \",\n \"memory\": \"35573\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n result = []\\n max_heap = []\\n for v in nums[:k]:\\n heapq.heappush(max_heap, -v)\\n\\n c = Counter(nums[:k])\\n \\n for i in range(k, len(nums)):\\n curr = nums[i]\\n prev = nums[i-k]\\n max_val = -max_heap[0] \\n c[prev] -= 1\\n c[curr] += 1\\n result.append(max_val)\\n\\n if prev == max_val:\\n heapq.heapreplace(max_heap, -curr)\\n while not c[-max_heap[0]]:\\n heapq.heappop(max_heap)\\n elif curr > max_val:\\n max_heap = []\\n heapq.heappush(max_heap, -curr)\\n else: \\n heapq.heappush(max_heap, -curr)\\n\\n result.append(-max_heap[0])\\n\\n return result\\n\\n \\n\\n\\n \\n \\n\\n \",\n \"memory\": \"35771\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n result = []\\n max_heap = []\\n counter = defaultdict(int)\\n for v in nums[:k]:\\n heapq.heappush(max_heap, -v)\\n counter[v] += 1\\n \\n for i in range(k, len(nums)):\\n curr = nums[i]\\n prev = nums[i-k]\\n max_val = -max_heap[0] \\n counter[prev] -= 1\\n counter[curr] += 1\\n result.append(max_val)\\n\\n if prev == max_val:\\n heapq.heapreplace(max_heap, -curr)\\n while not counter[-max_heap[0]]:\\n heapq.heappop(max_heap)\\n elif curr > max_val:\\n max_heap = []\\n heapq.heappush(max_heap, -curr)\\n else: \\n heapq.heappush(max_heap, -curr)\\n\\n result.append(-max_heap[0])\\n\\n return result\\n\\n \\n\\n\\n \\n \\n\\n \",\n \"memory\": \"35771\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ans = []\\n l = 0\\n r = k - 1\\n largestIndex = -1\\n\\n heap = []\\n\\n # initial\\n for i in range(k):\\n heapq.heappush(heap, (nums[i] * -1, i))\\n\\n while r < len(nums):\\n heapq.heappush(heap, (nums[r] * -1, r))\\n\\n while largestIndex < l:\\n element = heapq.heappop(heap)\\n largestIndex = element[1]\\n\\n if (nums[r] >= nums[largestIndex]):\\n largestIndex = r\\n\\n ans.append(nums[largestIndex])\\n\\n l += 1\\n r += 1\\n\\n return ans\\n\",\n \"memory\": \"35968\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums or k == 0:\\n return []\\n \\n n = len(nums)\\n if k == 1:\\n return nums\\n\\n # Initialize result list and sliding window management structures\\n result = []\\n indices = [] # List to simulate the deque for maintaining indices in decreasing order\\n index_set = set() # Set to quickly check if an index is in the window\\n\\n for i in range(n):\\n # Remove indices from the set and list that are out of the current window\\n if indices and indices[0] < i - k + 1:\\n removed_index = indices.pop(0)\\n index_set.remove(removed_index)\\n\\n # Maintain the indices in decreasing order based on their values\\n while indices and nums[indices[-1]] < nums[i]:\\n index_set.remove(indices.pop())\\n \\n # Add the current index to the list and set\\n indices.append(i)\\n index_set.add(i)\\n \\n # Append the maximum for the current window\\n if i >= k - 1:\\n result.append(nums[indices[0]])\\n\\n return result\",\n \"memory\": \"36166\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums or k == 0:\\n return []\\n \\n n = len(nums)\\n # Return the original list if window size k is 1\\n if k == 1:\\n return nums\\n\\n # List to store the maximum values of each window\\n result = []\\n # List to keep indices of elements in the current window\\n indices = []\\n # Set to quickly check if an index is in the window\\n index_set = set()\\n\\n for i in range(n):\\n # Remove indices that are out of the current window\\n if indices and indices[0] < i - k + 1:\\n removed_index = indices.pop(0)\\n index_set.remove(removed_index)\\n\\n # Maintain indices in decreasing order based on their values\\n while indices and nums[indices[-1]] < nums[i]:\\n index_set.remove(indices.pop())\\n \\n # Add the current index to both list and set\\n indices.append(i)\\n index_set.add(i)\\n \\n # Append the maximum value of the current window to result\\n if i >= k - 1:\\n result.append(nums[indices[0]])\\n\\n return result\",\n \"memory\": \"36166\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums or k == 0:\\n return []\\n \\n n = len(nums)\\n # Return the original list if window size k is 1\\n if k == 1:\\n return nums\\n\\n # List to store the maximum values of each window\\n result = []\\n # List to keep indices of elements in the current window\\n indices = []\\n # Set to quickly check if an index is in the window\\n index_set = set()\\n\\n for i in range(n):\\n # Remove indices that are out of the current window\\n if indices and indices[0] < i - k + 1:\\n removed_index = indices.pop(0)\\n index_set.remove(removed_index)\\n\\n # Maintain indices in decreasing order based on their values\\n while indices and nums[indices[-1]] < nums[i]:\\n index_set.remove(indices.pop())\\n \\n # Add the current index to both list and set\\n indices.append(i)\\n index_set.add(i)\\n \\n # Append the maximum value of the current window to result\\n if i >= k - 1:\\n result.append(nums[indices[0]])\\n\\n return result\",\n \"memory\": \"36363\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums or k == 0:\\n return []\\n \\n n = len(nums)\\n # Return the original list if window size k is 1\\n if k == 1:\\n return nums\\n\\n # List to store the maximum values of each window\\n result = []\\n # List to keep indices of elements in the current window\\n indices = []\\n # Set to quickly check if an index is in the window\\n window = set()\\n\\n for i in range(n):\\n # Remove indices that are out of the current window\\n if indices and indices[0] < i - k + 1:\\n removed_index = indices.pop(0)\\n window.remove(removed_index)\\n\\n # Maintain indices in decreasing order based on their values\\n while indices and nums[indices[-1]] < nums[i]:\\n window.remove(indices.pop())\\n \\n # Add the current index to both list and set\\n indices.append(i)\\n window.add(i)\\n \\n # Append the maximum value of the current window to result\\n if i >= k - 1:\\n result.append(nums[indices[0]])\\n\\n return result\",\n \"memory\": \"36363\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n end = 0\\n queue = collections.deque()\\n\\n while end < k - 1:\\n while queue and queue[-1][0] < nums[end]:\\n queue.pop()\\n queue.append((nums[end], end))\\n while queue and queue[0][0] < nums[end]:\\n queue.popleft()\\n end += 1\\n \\n output = []\\n while end < len(nums):\\n while queue and queue[-1][0] < nums[end]:\\n queue.pop()\\n queue.append((nums[end], end))\\n while queue and (queue[0][0] < nums[end] or end - queue[0][1] + 1 > k):\\n queue.popleft()\\n output.append(queue[0])\\n end += 1\\n \\n return [x[0] for x in output]\\n\\n\\n \",\n \"memory\": \"36561\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n end = 0\\n queue = collections.deque()\\n\\n while end < k - 1:\\n while queue and queue[-1][0] < nums[end]:\\n queue.pop()\\n queue.append((nums[end], end))\\n while queue and queue[0][0] < nums[end]:\\n queue.popleft()\\n end += 1\\n \\n output = []\\n while end < len(nums):\\n while queue and queue[-1][0] < nums[end]:\\n queue.pop()\\n queue.append((nums[end], end))\\n while queue and (queue[0][0] < nums[end] or end - queue[0][1] + 1 > k):\\n queue.popleft()\\n output.append(queue[0])\\n end += 1\\n \\n return [x[0] for x in output]\\n\\n\\n \",\n \"memory\": \"36561\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maximum = []\\n window = []\\n head = 0\\n tail = 0\\n for i in range(k):\\n while window != [] and window[tail-1][0] < nums[i]:\\n window.pop(-1)\\n tail -= 1\\n window.append((nums[i], i+k))\\n tail += 1 \\n maximum.append(window[head][0])\\n for i in range(k, len(nums)):\\n if window[head][1] == i:\\n head += 1\\n while tail > head and window[tail-1][0] < nums[i]:\\n window.pop(-1)\\n tail -= 1\\n window.append((nums[i], i+k))\\n tail += 1\\n maximum.append(window[head][0])\\n return maximum\\n \",\n \"memory\": \"36758\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n queue = [] # each element is (value, index)\\n head = 0\\n ans = []\\n for i, v in enumerate(nums):\\n while head < len(queue) and queue[-1][0] < v:\\n queue.pop()\\n queue.append((v, i))\\n if queue[head][1] <= i - k:\\n head += 1\\n if i >= k - 1:\\n ans.append(queue[head][0])\\n return ans\\n \\n\",\n \"memory\": \"36956\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # Brute force: As the window moves, rescan the whole window to find the maximum.\\n # Slightly better brute force: As you move along the nums, maintain a check for the current maximum\\n # If the current maximum is removed, then rescan the entire window for the new maximum\\n # Keep count of all the numbers in the list, and maxheap that maintains the maximum numbers\\n # Once the current max is popped, then keep popping until you find a number that is still in the dictionary\\n\\n # Dictionary to track counts of characters in current window\\n nDict = {}\\n\\n # Heap to track the maximum value within the current window\\n maxHeap = []\\n\\n # Prepare result array\\n res = []\\n\\n # Start by instantiating nDict\\n for i in range(k):\\n nDict[nums[i]] = nDict.get(nums[i], 0) + 1\\n heapq.heappush(maxHeap, -nums[i])\\n\\n # print(f\\\"strating heap: {maxHeap}\\\")\\n # print(f\\\"starting nDict: {nDict}\\\")\\n\\n # Append first result\\n res.append(-maxHeap[0])\\n\\n # Now looop through teh whole list\\n l = 0\\n for r in range(k, len(nums)):\\n # Add incoming number\\n nDict[nums[r]] = nDict.get(nums[r], 0) + 1\\n heapq.heappush(maxHeap, -nums[r])\\n\\n # Remove start number\\n nDict[nums[l]] = nDict.get(nums[l], 0) - 1\\n\\n # CHeck if removed number was the maximum\\n if nums[l] == -maxHeap[0]:\\n # print(f\\\"{nums[l]} found to be equal to top of maxheap: {-maxHeap[0]}\\\")\\n # print(f\\\"nDict: {nDict}\\\")\\n while -maxHeap[0] not in nDict or nDict[-maxHeap[0]] == 0:\\n # Pop from the top\\n print(f'Popped {heapq.heappop(maxHeap)}')\\n # print(f'Updated heap: {maxHeap}')\\n\\n res.append(-maxHeap[0])\\n\\n l += 1\\n\\n\\n return res\",\n \"memory\": \"36956\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n N = len(nums)\\n freq = defaultdict(int)\\n heap = [] # Max heap so negate values\\n \\n l, r = 0, 0\\n for r in range(k):\\n freq[nums[r]] += 1\\n heapq.heappush(heap, -nums[r])\\n res = []\\n while r < N:\\n curr_max = -heap[0]\\n while heap and freq[curr_max] == 0:\\n heapq.heappop(heap)\\n curr_max = -heap[0]\\n res.append(curr_max)\\n if r == N-1:\\n break\\n r += 1\\n heapq.heappush(heap, -nums[r])\\n freq[nums[r]] += 1\\n freq[nums[l]] -= 1\\n l += 1\\n return res\",\n \"memory\": \"37153\"\n },\n {\n \"code\": \"from collections import deque\\nimport heapq\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n q = deque()\\n heap = []\\n ans = []\\n if k == 1:\\n return nums\\n\\n max = float('-inf')\\n for j, i in enumerate(nums):\\n if len(q) < k:\\n q.append(i)\\n if i > max:\\n max = i\\n heap = []\\n else:\\n heapq.heappush(heap, (-1*i, j))\\n else:\\n ans.append(max)\\n pop = q.popleft()\\n if pop == max:\\n pop, index = heapq.heappop(heap)\\n max = pop*-1\\n while heap:\\n if heap[0][1] < index:\\n heapq.heappop(heap)\\n else:\\n break\\n q.append(i)\\n if i > max:\\n heap = []\\n max = i\\n else:\\n heapq.heappush(heap, (-1*i, j))\\n ans.append(max)\\n return ans\\n\\n \\n\\n# 1 3 -1 : 3 : -1 \\n# 3 -1 -3 : 3 : -1 -3\\n# -1 -3 5 : if next one is larger, clear heap \\n\\n# -7 -8 7 5 : 7 : 5\\n# -8 7 5 7 : 7 : \\n# 7 5 7 1 : 7 : 1\\n# 5 7 1 6 : 7 : 6 1\\n\\n# 3 8 3 3 3 6 3 7 3 4 3 3 3 3 \\n# 3 8 3 3 3 6 3 7 : 8 : 7 6 \\n# 3 3 3 6 3 7 3 4 : 7 : 6 4\",\n \"memory\": \"37153\"\n },\n {\n \"code\": \"from collections import deque\\n\\n# Window position Max\\n# --------------- -----\\n# [1 3 -1] -3 5 3 6 7 3 -1 3 (removed 1)\\n# 1 [3 -1 -3] 5 3 6 7 3 -3 -1 3\\n# 1 3 [-1 -3 5] 3 6 7 5 5 (removed 3 (OOW), -1, -3)\\n# 1 3 -1 [-3 5 3] 6 7 5 3 5\\n# 1 3 -1 -3 [5 3 6] 7 6 6 (removed 3, 5)\\n# 1 3 -1 -3 5 [3 6 7] 7 7 (removed 6)\\n# \\n# 1 3 -2 -1 -1 3\\n \\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n dq = deque()\\n blacklist = set()\\n res = []\\n\\n # Get initial max\\n for i in range(k):\\n while len(dq) > 0 and nums[i] > nums[dq[0]]:\\n dq.popleft()\\n dq.appendleft(i)\\n res.append(nums[dq[-1]])\\n\\n # Get remaining maxes\\n for i in range(k, len(nums)):\\n blacklist.add(i - k)\\n #print([nums[i] for i in dq])\\n while len(dq) > 0 and nums[i] > nums[dq[0]]:\\n dq.popleft()\\n dq.appendleft(i)\\n #print([nums[i] for i in dq])\\n while dq[0] in blacklist:\\n dq.popleft()\\n while dq[-1] in blacklist:\\n dq.pop()\\n #print([nums[i] for i in dq])\\n res.append(nums[dq[-1]])\\n\\n return res\",\n \"memory\": \"37351\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n #assume there's a way to find the next index that contains a bigger number for each given index in O(n) time\\n #monotonic stack\\n nextBiggerNumIndex = [-1] * len(nums)\\n stack = []\\n for index, num in enumerate(nums):\\n while len(stack) > 0 and num > stack[-1][1]:\\n smallerIndex, smallerNum = stack[-1]\\n nextBiggerNumIndex[smallerIndex] = index\\n stack.pop()\\n stack.append((index, num))\\n \\n ans = []\\n maxPointer = 0\\n for startIndex in range(len(nums) - (k - 1)):\\n endIndex = startIndex + k\\n while startIndex <= nextBiggerNumIndex[maxPointer] < endIndex:\\n maxPointer = nextBiggerNumIndex[maxPointer]\\n ans.append(nums[maxPointer])\\n if maxPointer == startIndex:\\n maxPointer += 1\\n return ans\",\n \"memory\": \"37351\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n dq = collections.deque()\\n ans = []\\n\\n for i, n in enumerate(nums):\\n while len(dq) > 0 and n > dq[-1][\\\"num\\\"]:\\n dq.pop()\\n \\n while len(dq) > 0 and dq[0][\\\"idx\\\"] <= (i - k):\\n dq.popleft()\\n \\n dq.append({\\\"idx\\\": i, \\\"num\\\": n})\\n \\n if i >= k - 1:\\n ans.append(dq[0][\\\"num\\\"])\\n\\n return ans\\n\\n\",\n \"memory\": \"37548\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n cnt, heap, res = collections.Counter(), [], []\\n for i, num in enumerate(nums):\\n heapq.heappush(heap, -num)\\n cnt[num] += 1\\n while not cnt[-heap[0]]:\\n heapq.heappop(heap)\\n if i >= k - 1:\\n res.append(-heap[0])\\n cnt[nums[i - k + 1]] -= 1\\n return res\\n \",\n \"memory\": \"37548\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n window = defaultdict(int)\\n\\n ans = []\\n\\n heap = []\\n\\n for i in range(k):\\n window[nums[i]] += 1\\n heapq.heappush(heap, -1 * nums[i])\\n\\n l = 0\\n\\n while l + k - 1 < len(nums):\\n # print(l, window)\\n # print(heap, ans)\\n while -1 * heap[0] not in window:\\n heapq.heappop(heap)\\n ans.append(-1 * heap[0])\\n window[nums[l]] -= 1\\n if window[nums[l]] == 0:\\n window.pop(nums[l])\\n if not l + k == len(nums):\\n window[nums[l + k]] += 1\\n heapq.heappush(heap, -1 * nums[l + k])\\n l += 1\\n return ans\\n\\n #[1, 2, 3, 4, 5], k = 2\\n\\n\",\n \"memory\": \"37746\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n window = defaultdict(int)\\n\\n ans = []\\n\\n heap = []\\n\\n for i in range(k):\\n window[nums[i]] += 1\\n heapq.heappush(heap, -1 * nums[i])\\n\\n l = 0\\n\\n while l + k - 1 < len(nums):\\n # print(l, window)\\n # print(heap, ans)\\n while -1 * heap[0] not in window:\\n heapq.heappop(heap)\\n ans.append(-1 * heap[0])\\n window[nums[l]] -= 1\\n if window[nums[l]] == 0:\\n window.pop(nums[l])\\n if not l + k == len(nums):\\n window[nums[l + k]] += 1\\n heapq.heappush(heap, -1 * nums[l + k])\\n l += 1\\n return ans\\n\\n #[1, 2, 3, 4, 5], k = 2\\n\\n\",\n \"memory\": \"37746\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if not nums or k == 0:\\n return []\\n \\n # Initialize\\n max_heap = []\\n count = defaultdict(int)\\n result = []\\n \\n # Process the first k elements\\n for i in range(k):\\n heapq.heappush(max_heap, -nums[i])\\n count[nums[i]] += 1\\n \\n # Add the maximum for the first window\\n result.append(-max_heap[0])\\n \\n # Process the rest of the elements\\n for i in range(k, len(nums)):\\n # Add new element to the heap and count\\n heapq.heappush(max_heap, -nums[i])\\n count[nums[i]] += 1\\n \\n # Remove the element that is out of the window\\n outgoing = nums[i - k]\\n count[outgoing] -= 1\\n \\n # Remove invalid elements from the heap\\n while max_heap and count[-max_heap[0]] == 0:\\n print(max_heap[0])\\n heapq.heappop(max_heap)\\n \\n # The current maximum is the root of the heap\\n result.append(-max_heap[0])\\n \\n return result\",\n \"memory\": \"37943\"\n },\n {\n \"code\": \"from heapq import heappop, heappush \\nfrom collections import Counter\\n\\n\\nclass Solution:\\n # TC: O(n * log w); O(w);\\n def solve_by_brute_force(self, nums: List[int], width: int) -> List[int]:\\n result = []\\n curr = Counter()\\n l = 0\\n mins = []\\n\\n for r, r_num in enumerate(nums):\\n curr[r_num] += 1\\n heappush(mins, -r_num)\\n\\n if r < width - 1:\\n continue\\n \\n l_num = nums[l]\\n\\n if l <= r - width:\\n curr[l_num] -= 1\\n l += 1\\n \\n if curr[l_num] == 0:\\n curr.pop(l_num)\\n \\n while -mins[0] not in curr:\\n heappop(mins)\\n \\n result.append(-mins[0])\\n \\n return result\\n\\n\\n def maxSlidingWindow(self, nums: List[int], width: int) -> List[int]:\\n return self.solve_by_brute_force(nums, width) \",\n \"memory\": \"37943\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n arr = []\\n for i in range(k):\\n heapq.heappush(arr,-1 * nums[i])\\n\\n res = [-1 * arr[0]]\\n delete = dict()\\n for i in range(k,len(nums)):\\n heapq.heappush(arr,-1 * nums[i])\\n if nums[i - k] in delete:\\n delete[nums[i - k]] += 1\\n else:\\n delete[nums[i - k]] = 1\\n\\n while -1 * arr[0] in delete: \\n delete[-1 * arr[0]] -= 1\\n if delete[ -1 * arr[0]] == 0: \\n del delete[ -1 * arr[0]]\\n heapq.heappop(arr) \\n\\n res.append(-1 * arr[0])\\n return res\",\n \"memory\": \"38141\"\n },\n {\n \"code\": \"from collections import deque\\n\\n# Window position Max\\n# --------------- -----\\n# [1 3 -1] -3 5 3 6 7 3 -1 3 (removed 1)\\n# 1 [3 -1 -3] 5 3 6 7 3 -3 -1 3\\n# 1 3 [-1 -3 5] 3 6 7 5 5 (removed 3 (OOW), -1, -3)\\n# 1 3 -1 [-3 5 3] 6 7 5 3 5\\n# 1 3 -1 -3 [5 3 6] 7 6 6 (removed 3, 5)\\n# 1 3 -1 -3 5 [3 6 7] 7 7 (removed 6)\\n# \\n# 1 3 -2 -1 -1 3\\n \\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n dq = deque()\\n blacklist = set()\\n res = []\\n\\n # Get initial max\\n for i in range(k):\\n while len(dq) > 0 and nums[i] > nums[dq[0]]:\\n dq.popleft()\\n dq.appendleft(i)\\n res.append(nums[dq[-1]])\\n\\n # Get remaining maxes\\n for i in range(k, len(nums)):\\n blacklist.add(i - k)\\n #print([nums[i] for i in dq])\\n while len(dq) > 0 and nums[i] > nums[dq[0]]:\\n dq.popleft()\\n dq.appendleft(i)\\n #print([nums[i] for i in dq])\\n while dq[-1] in blacklist:\\n dq.pop()\\n #print([nums[i] for i in dq])\\n res.append(nums[dq[-1]])\\n\\n return res\",\n \"memory\": \"38141\"\n },\n {\n \"code\": \"class Solution:\\n import heapq\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n res = []\\n word_freq_in_window = defaultdict(int)\\n window_heap = []\\n \\n #initialize the word_freq_in_window\\n for i in range(k):\\n word_freq_in_window[nums[i]] += 1\\n window_heap.append(-1*nums[i]) # heapq is min heap we want max heap\\n \\n heapq.heapify(window_heap)\\n res.append(-1*window_heap[0])\\n\\n window_start = 0\\n window_end = k-1\\n \\n\\n while window_end<len(nums)-1:\\n # Removing the start value from freq dict\\n word_freq_in_window[nums[window_start]] -= 1\\n if word_freq_in_window[nums[window_start]] == 0:\\n del word_freq_in_window[nums[window_start]]\\n \\n while window_heap and -1*window_heap[0] not in word_freq_in_window:\\n heapq.heappop(window_heap)\\n \\n window_start += 1\\n window_end += 1\\n # insert the new word at the end of the window\\n word_freq_in_window[nums[window_end]] += 1\\n heapq.heappush(window_heap,-1*nums[window_end])\\n\\n res.append(-1*window_heap[0])\\n\\n return res \\n\",\n \"memory\": \"38338\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n window = {}\\n heap = [-n for n in nums[:k]]\\n for n in heap:\\n window[-n] = window.get(-n, 0) + 1\\n \\n heapq.heapify(heap)\\n\\n res = []\\n left = 0\\n for right in range(k, len(nums)+1):\\n # make sure top of heap is always a number in the window\\n while heap and -heap[0] not in window:\\n heapq.heappop(heap)\\n\\n res.append(-heap[0])\\n\\n if right >= len(nums):\\n break\\n\\n heapq.heappush(heap, -nums[right])\\n window[nums[right]] = window.get(nums[right], 0) + 1\\n\\n window[nums[left]] -= 1\\n if window[nums[left]] <= 0:\\n del window[nums[left]]\\n\\n if nums[left] == -heap[0]:\\n heapq.heappop(heap)\\n\\n left += 1\\n\\n return res\\n \",\n \"memory\": \"38338\"\n },\n {\n \"code\": \"import heapq\\nfrom collections import defaultdict\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if len(nums) == 1:\\n return [nums[0]]\\n # assumptions will len(nums) >= k?\\n # will nums be valid inputs?\\n # ints, floats? \\n # range of these numbers?\\n # range of k?\\n\\n heap = [-nums[i] for i in range(k)]\\n heapq.heapify(heap)\\n \\n # first idea is just have a heap that keeps track of the max\\n # pop that max from the heap once it leaves\\n # problem its hard to pop the 2nd biggest item in \\n # keep track of nums to pop in a hashmap\\n\\n nums_to_pop = defaultdict(int) #{num: how many}\\n max_in_window = [-heap[0]]\\n # pop {-1: 1, -3: 1}\\n # heap [-1, -3, 1, 3, -5]\\n # output: 3, 3, 5, \\n # rn edge case if i == 1: solved\\n for i in range(1, len(nums) - k + 1):\\n nums_to_pop[-nums[i - 1]] += 1\\n heapq.heappush(heap, -nums[i + k - 1])\\n\\n while nums_to_pop[heap[0]] > 0:\\n nums_to_pop[heap[0]] -= 1\\n heapq.heappop(heap)\\n max_in_window.append(-heap[0])\\n\\n return max_in_window\\n\\n\\n\\n\\n\\n\\n \\n\\n\\n\",\n \"memory\": \"38536\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n max_heap = [-1 * x for x in nums[0:k]]\\n heapq.heapify(max_heap)\\n curr_counts = Counter(nums[0:k])\\n\\n\\n def clean_out_queue():\\n while max_heap and (-1 * max_heap[0] not in curr_counts or curr_counts[-1 * max_heap[0]] == 0):\\n heapq.heappop(max_heap)\\n\\n out = []\\n for i in range(k, len(nums)):\\n clean_out_queue()\\n out.append(max_heap[0] * -1)\\n\\n to_remove = nums[i - k]\\n curr_counts[to_remove] -= 1\\n\\n to_add = nums[i]\\n curr_counts[to_add] += 1\\n heapq.heappush(max_heap, -1 * to_add)\\n \\n\\n clean_out_queue()\\n out.append(max_heap[0] * -1)\\n \\n return out\\n\\n\\n \\n\\n\\n\",\n \"memory\": \"38536\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n heap = []\\n heapq.heapify(heap)\\n\\n curWindow = defaultdict(int)\\n\\n for i in range(k):\\n heapq.heappush(heap, -nums[i])\\n curWindow[nums[i]] += 1\\n \\n out = []\\n\\n i = k - 1\\n while True:\\n while True:\\n mn = heapq.heappop(heap)\\n if curWindow[-mn] != 0:\\n heapq.heappush(heap, mn)\\n out.append(-mn)\\n break\\n \\n if i == len(nums) - 1:\\n break\\n \\n i += 1\\n heapq.heappush(heap, -nums[i])\\n curWindow[nums[i]] += 1\\n curWindow[nums[i - k]] -= 1\\n \\n return out\\n \\n \\n\\n \\n\\n\\n\",\n \"memory\": \"38733\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n import heapq\\n res = []\\n maxHeap = []\\n # initalise window\\n for i in range(len(nums)):\\n if i < k-1:\\n heapq.heappush(maxHeap, (-nums[i], i))\\n else:\\n # if top of heap is less than the current or index is not valid remove\\n while maxHeap and (-maxHeap[0][0] < nums[i] or maxHeap[0][1]+k <= i ):\\n heapq.heappop(maxHeap)\\n heapq.heappush(maxHeap, (-nums[i], i))\\n res.append(-maxHeap[0][0])\\n return res\\n\",\n \"memory\": \"38733\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # need to maintain ordering -> heap\\n # need to remove based on index\\n # intialize window\\n curr = []\\n for i in range(k):\\n heapq.heappush(curr, -1 * nums[i])\\n\\n deleted = defaultdict(int)\\n res = [-1 * curr[0]]\\n for i in range(k, len(nums)):\\n heapq.heappush(curr, -1 * nums[i])\\n deleted[-1 * nums[i-k]] += 1\\n while curr[0] in deleted and deleted[curr[0]] > 0:\\n deleted[curr[0]] -= 1\\n heapq.heappop(curr)\\n res.append(-1 * curr[0])\\n return res\",\n \"memory\": \"38931\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # need to maintain ordering -> heap\\n # need to remove based on index\\n # intialize window\\n curr = []\\n for i in range(k):\\n heapq.heappush(curr, -1 * nums[i])\\n\\n deleted = defaultdict(int)\\n res = [-1 * curr[0]]\\n for i in range(k, len(nums)):\\n heapq.heappush(curr, -1 * nums[i])\\n deleted[-1 * nums[i-k]] += 1\\n while curr[0] in deleted and deleted[curr[0]] > 0:\\n deleted[curr[0]] -= 1\\n heapq.heappop(curr)\\n res.append(-1 * curr[0])\\n return res\",\n \"memory\": \"38931\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n track = []\\n cnt = defaultdict(int)\\n heap = []\\n ans = []\\n for i in range(len(nums)):\\n cnt[nums[i]] += 1\\n track.append(nums[i])\\n heapq.heappush(heap,-nums[i])\\n if i >= k:\\n last = track[0]\\n cnt[last] -= 1\\n track.pop(0)\\n if i >= k-1:\\n while len(heap) > 0 and cnt[-heap[0]] == 0:\\n heapq.heappop(heap)\\n ans.append(-heap[0])\\n return ans\",\n \"memory\": \"39128\"\n },\n {\n \"code\": \"class Solution:\\n import heapq\\n def removeOldElements(self, maxHeap, removed):\\n while len(maxHeap) > 0 and maxHeap[0] in removed and removed[maxHeap[0]] > 0:\\n removed[maxHeap[0]] -= 1 \\n heapq.heappop(maxHeap)\\n\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxHeap, removed = [], {}\\n sol = []\\n for i in range(0, k):\\n heapq.heappush(maxHeap, -nums[i])\\n\\n sol.append(-maxHeap[0])\\n\\n for i in range(k, len(nums)):\\n remove = -nums[i - k]\\n if remove in removed:\\n removed[remove] += 1\\n else:\\n removed[remove] = 1\\n\\n self.removeOldElements(maxHeap, removed)\\n heapq.heappush(maxHeap, -nums[i])\\n sol.append(-maxHeap[0])\\n return sol\\n \\n\\n\\n\",\n \"memory\": \"39128\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n i = 0\\n heap = []\\n res = []\\n m = {}\\n\\n while i < k:\\n heapq.heappush(heap, -1 * nums[i])\\n i += 1\\n\\n res.append(heap[0] * -1)\\n\\n while i < len(nums):\\n removeIdx = i - k\\n removeVal = nums[removeIdx]\\n nextVal = nums[i]\\n\\n if removeVal == heap[0]*-1:\\n heapq.heappop(heap)\\n\\n while heap and (heap[0]*-1) in m and m[(heap[0]*-1)] > 0:\\n popped = heapq.heappop(heap) * -1\\n m[popped] -= 1\\n\\n heapq.heappush(heap, nextVal * -1)\\n res.append(heap[0] * -1)\\n else:\\n if removeVal in m:\\n m[removeVal] += 1\\n else:\\n m[removeVal] = 1\\n heapq.heappush(heap, nextVal * -1)\\n res.append(heap[0] * -1)\\n\\n i += 1\\n\\n return res\\n\",\n \"memory\": \"39326\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n i = 0\\n heap = []\\n res = []\\n m = {}\\n\\n while i < k:\\n heapq.heappush(heap, -1 * nums[i])\\n i += 1\\n\\n res.append(heap[0] * -1)\\n\\n while i < len(nums):\\n removeIdx = i - k\\n removeVal = nums[removeIdx]\\n nextVal = nums[i]\\n\\n if removeVal == heap[0]*-1:\\n heapq.heappop(heap)\\n\\n while heap and (heap[0]*-1) in m and m[(heap[0]*-1)] > 0:\\n popped = heapq.heappop(heap) * -1\\n m[popped] -= 1\\n\\n heapq.heappush(heap, nextVal * -1)\\n res.append(heap[0] * -1)\\n else:\\n if removeVal in m:\\n m[removeVal] += 1\\n else:\\n m[removeVal] = 1\\n heapq.heappush(heap, nextVal * -1)\\n res.append(heap[0] * -1)\\n\\n i += 1\\n\\n return res\\n\",\n \"memory\": \"39326\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n heap = []\\n for i in range(k):\\n heapq.heappush(heap, -nums[i])\\n ans = [-heap[0]]\\n p = 0\\n removed = set()\\n counter = Counter(heap)\\n for i in range(k, len(nums)):\\n removed.add(-nums[p])\\n counter[-nums[p]] -= 1\\n\\n heapq.heappush(heap, -nums[i])\\n counter[-nums[i]] += 1\\n while heap[0] in removed and counter[heap[0]] == 0:\\n heapq.heappop(heap)\\n # heap[0] not in removed or in removed but counter[nums[p]] >= 1\\n ans.append(-heap[0])\\n p += 1\\n return ans\\n\",\n \"memory\": \"39523\"\n },\n {\n \"code\": \"import heapq as hq\\nfrom collections import defaultdict\\nclass Solution:\\n def maxSlidingWindow(self, a: List[int], k: int) -> List[int]:\\n n = len(a)\\n heap = []\\n d = defaultdict(int)\\n for i in range(k):\\n hq.heappush(heap, -1 * a[i])\\n d[a[i]] += 1\\n res = []\\n s, e = 0, k - 1\\n while e < n:\\n maxm = -1 * hq.heappop(heap)\\n while True:\\n if d[maxm] == 0:\\n maxm = -1 * hq.heappop(heap)\\n continue\\n break\\n res.append(maxm)\\n if a[s] != maxm:\\n hq.heappush(heap, -1 * maxm)\\n d[a[s]] -= 1\\n s += 1\\n e += 1\\n if e < n: \\n d[a[e]] += 1\\n hq.heappush(heap, -1 * a[e])\\n return res\\n\",\n \"memory\": \"39523\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n heap = []\\n for index, val in enumerate(nums[:k-1]):\\n heapq.heappush(heap, (-1*val, index))\\n result = []\\n for i in range(k-1, len(nums)):\\n if heap:\\n v_check, i_check = heapq.heappop(heap)\\n if nums[i] > v_check*-1:\\n while heap != []:\\n heapq.heappop(heap)\\n else:\\n heapq.heappush(heap, (v_check, i_check))\\n heapq.heappush(heap, (nums[i] * -1, i))\\n while True:\\n v, pop_i = heapq.heappop(heap)\\n v *= -1\\n if pop_i > i - k:\\n break\\n if pop_i > i - k + 1:\\n heapq.heappush(heap, (v * -1, pop_i))\\n result.append(v)\\n return result\\n \",\n \"memory\": \"39721\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # monotonic queue\\n from sortedcontainers import SortedList\\n pq = SortedList([(nums[i], i) for i in range(k)])\\n res = [pq[-1][0]]\\n for i in range(k, len(nums)):\\n pq.add((nums[i], i))\\n while i - pq[-1][1] >= k:\\n pq.pop()\\n res.append(pq[-1][0])\\n return res\",\n \"memory\": \"39721\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxes = []\\n maxHeap = []\\n for i in range(k):\\n heapq.heappush(maxHeap, (-nums[i], i))\\n maxes.append(-maxHeap[0][0])\\n \\n for i in range(k, len(nums)):\\n while maxHeap and -nums[i] < maxHeap[0][0]:\\n heapq.heappop(maxHeap)\\n heapq.heappush(maxHeap, (-nums[i], i))\\n while maxHeap[0][1] < i-k+1:\\n heapq.heappop(maxHeap)\\n maxes.append(-maxHeap[0][0])\\n return maxes\",\n \"memory\": \"39918\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n maxHeap = []\\n res = []\\n numOutOfFrame = defaultdict(int)\\n\\n if len(nums) < k:\\n return res\\n \\n for i in range(k):\\n heapq.heappush(maxHeap, -nums[i])\\n \\n res.append(-maxHeap[0])\\n \\n for i in range(k, len(nums)):\\n heapq.heappush(maxHeap, -nums[i])\\n numOutOfFrame[nums[i-k]] += 1\\n while numOutOfFrame[-maxHeap[0]] > 0:\\n val = -heapq.heappop(maxHeap)\\n numOutOfFrame[val] -= 1\\n res.append(-maxHeap[0])\\n \\n return res\\n\",\n \"memory\": \"39918\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ub = []\\n result = []\\n for i in range(k):\\n heapq.heappush(ub, -nums[i])\\n result.append(-ub[0]) \\n todo = [] # also a heap\\n for i in range(k, len(nums)):\\n # number to be removed\\n kick = nums[i-k]\\n new = nums[i]\\n if kick == -ub[0]:\\n heapq.heappop(ub)\\n else:\\n heapq.heappush(todo, -kick)\\n\\n\\n while len(todo) != 0:\\n if todo[0] == ub[0]:\\n heapq.heappop(ub)\\n heapq.heappop(todo)\\n else:\\n break\\n\\n\\n\\n heapq.heappush(ub, -new)\\n result.append(-ub[0])\\n return result\\n\",\n \"memory\": \"40116\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n ub = []\\n result = []\\n for i in range(k):\\n heapq.heappush(ub, -nums[i])\\n result.append(-ub[0]) \\n todo = [] # also a heap\\n for i in range(k, len(nums)):\\n # number to be removed\\n kick = nums[i-k]\\n new = nums[i]\\n if kick == -ub[0]:\\n heapq.heappop(ub)\\n else:\\n heapq.heappush(todo, -kick)\\n\\n while len(todo) != 0:\\n if todo[0] == ub[0]:\\n heapq.heappop(ub)\\n heapq.heappop(todo)\\n else:\\n break\\n\\n heapq.heappush(ub, -new)\\n result.append(-ub[0])\\n return result\\n\",\n \"memory\": \"40116\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # Heap to store the elements as (-value, index)\\n max_heap = []\\n result = []\\n \\n for i in range(len(nums)):\\n # Push the current element onto the heap (storing negative to simulate max-heap)\\n heapq.heappush(max_heap, (-nums[i], i))\\n \\n # If the index of the current element is greater than or equal to (k-1),\\n # we are at a valid window.\\n if i >= k - 1:\\n # Pop elements from the heap that are out of the current window\\n while max_heap[0][1] <= i - k:\\n heapq.heappop(max_heap)\\n \\n # The root of the heap is the largest element in the current window\\n result.append(-max_heap[0][0])\\n \\n return result\\n\",\n \"memory\": \"40313\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n \\\"\\\"\\\"\\n [1, 3, -1, -3, 5, 1, 2, 3]\\n\\n 1 : [1] []\\n 3 : [3,1] []\\n -1 : [3,1,-1] []\\n -3 : [3,1,-1,-3] [1]\\n 4 : [4,-1,-3] []\\n 5 : [5,4,-1,-3] [-1]\\n 1 : [5,4,1,-1,-3] [-1,-3]\\n 2 : [5,4,2,1,-1,-3] [4,-1,-3]\\n 3 : [3,2,1,-1,-3] [-1,-3]\\n \\\"\\\"\\\"\\n maxHeap = [-x for x in nums[:k]]\\n heapq.heapify(maxHeap)\\n tombstones = []\\n result = [-maxHeap[0]]\\n for i in range(k, len(nums)):\\n remove = nums[i - k]\\n if maxHeap[0] == -remove:\\n heapq.heappop(maxHeap)\\n while maxHeap and tombstones and maxHeap[0] == tombstones[0]:\\n heapq.heappop(maxHeap)\\n heapq.heappop(tombstones)\\n else:\\n heapq.heappush(tombstones, -remove)\\n heapq.heappush(maxHeap, -nums[i])\\n result.append(-maxHeap[0])\\n return result\",\n \"memory\": \"40313\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n n = len(nums)\\n results = []\\n heap = []\\n\\n for i in range(k):\\n heapq.heappush(heap, (-nums[i], i))\\n results.append(-heap[0][0])\\n\\n for i in range(0, n - k):\\n \\n new_digit = nums[i + k]\\n old_digit = nums[i]\\n\\n # remove invalid number\\n while heap and heap[0][1] <= i:\\n heapq.heappop(heap)\\n \\n # add new\\n heapq.heappush(heap, (-new_digit, i + k))\\n \\n # add result\\n results.append(-heap[0][0])\\n \\n return results\\n \\n\\n\",\n \"memory\": \"40511\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n if k == 1: return nums\\n rwindow = [(-val, i) for i, val in enumerate(nums[:k])]\\n heapq.heapify(rwindow)\\n res = [-rwindow[0][0]]\\n\\n for i in range(k, len(nums)):\\n while rwindow[0][1] <= i - k: heapq.heappop(rwindow)\\n heapq.heappush(rwindow, (-nums[i], i))\\n res.append(-rwindow[0][0])\\n\\n return res\\n\\n\",\n \"memory\": \"40511\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n heap = []\\n i = 0\\n ret = []\\n\\n while i < k - 1:\\n heapq.heappush(heap, (-nums[i], i))\\n i += 1\\n\\n while i < len(nums):\\n heapq.heappush(heap, (-nums[i], i))\\n while heap[0][1] < i - k + 1:\\n heapq.heappop(heap)\\n ret.append(heap[0][0] * -1)\\n i += 1\\n \\n return ret\",\n \"memory\": \"40708\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n # initialize a max heap\\n # initialize a map\\n # initialize left and right pointer starting at 0\\n # loop from 0 to len(nums):\\n # if l is larger than current maxIndex value: \\n # pop the top of the heap\\n # remove maxIndex value\\n # add each value into the maxheap\\n # if the max value changes: change maxIndex value to the current index\\n # when the window size = k:\\n # add the current top of heap to ansList\\n # increment l\\n # return ansList\\n\\n if k == 1:\\n return nums\\n\\n maxH = []\\n ans = []\\n\\n for i in range(k):\\n heapq.heappush(maxH, (-nums[i], i))\\n \\n ans.append(-maxH[0][0])\\n\\n l = 1\\n\\n for r in range(k, len(nums)):\\n \\n\\n while maxH[0][1] < l:\\n heapq.heappop(maxH)\\n\\n heapq.heappush(maxH, (-nums[r], r))\\n\\n ans.append(-maxH[0][0])\\n\\n l += 1\\n \\n return ans\",\n \"memory\": \"40708\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n myheap = []\\n remheap = []\\n def add_elem(self, val):\\n heapq.heappush(self.myheap, val)\\n def rem_elem(self, val):\\n heapq.heappush(self.remheap, val)\\n def peek_top(self):\\n if len(self.myheap) == 0:\\n return None\\n while len(self.remheap) > 0 and self.remheap[0] < self.myheap[0]:\\n heapq.heappop(self.remheap)\\n while len(self.myheap) > 0 and len(self.remheap) > 0 and self.myheap[0] == self.remheap[0]:\\n heapq.heappop(self.myheap)\\n heapq.heappop(self.remheap)\\n \\n if len(self.myheap) == 0:\\n return None\\n return self.myheap[0]\\n\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n self.myheap = []\\n self.remheap = []\\n for i in range(k):\\n self.add_elem(-nums[i])\\n ans = [-self.peek_top()]\\n for i in range(k, len(nums)):\\n self.add_elem(-nums[i])\\n self.rem_elem(-nums[i-k])\\n ans.append(-self.peek_top())\\n return ans\",\n \"memory\": \"40906\"\n },\n {\n \"code\": \"# class Solution:\\n# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n# # left = 0\\n# # right = k-1\\n\\n# # max_windows = []\\n# # while right < len(nums):\\n# # max_window = max(nums[left:right+1])\\n# # max_windows.append(max_window)\\n# # return max_windows\\n# # k*n\\n\\n# # instead of max, remove last element from heap and add newly added element\\n# # logK * n\\n\\nimport heapq\\n\\nclass Solution:\\n def maxSlidingWindow(self, nums, k):\\n heap = []\\n result = []\\n\\n for i in range(len(nums)):\\n # Push the negative value to simulate a max heap\\n heapq.heappush(heap, (-nums[i], i))\\n \\n # Remove elements outside the current window\\n while heap[0][1] <= i - k:\\n heapq.heappop(heap)\\n \\n # Append the maximum value to the result once the first window is formed\\n if i >= k - 1:\\n result.append(-heap[0][0])\\n \\n return result\\n\",\n \"memory\": \"40906\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n heap = []\\n for i in range(k):\\n heapq.heappush(heap, (-nums[i], i))\\n \\n result = [-heap[0][0]]\\n \\n for i in range(k, len(nums)):\\n heapq.heappush(heap, (-nums[i], i))\\n while heap[0][1]+k <= i:\\n heapq.heappop(heap)\\n \\n result.append(-heap[0][0])\\n \\n return result\\n\\n \\n return maxSum\\n\\n \",\n \"memory\": \"41103\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n h = []\\n for i in range(k - 1):\\n h.append((-nums[i], i))\\n heapify(h)\\n res = []\\n l, r = 0, k - 1\\n while r < len(nums):\\n heappush(h, (-nums[r], r))\\n while not l <= h[0][1] <= r:\\n heappop(h)\\n res.append(-h[0][0])\\n l += 1\\n r += 1\\n return res\\n \",\n \"memory\": \"41103\"\n },\n {\n \"code\": \"class Solution:\\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n result = []\\n max_heap = []\\n \\n for i in range(len(nums)):\\n heapq.heappush(max_heap, (-nums[i], i))\\n while max_heap[0][1] <= i - k:\\n heapq.heappop(max_heap)\\n if i >= k - 1:\\n result.append(-max_heap[0][0])\\n \\n return result\\n \",\n \"memory\": \"41301\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":127,"string":"127"}}},{"rowIdx":64,"cells":{"question_id":{"kind":"number","value":240,"string":"240"},"name":{"kind":"string","value":"search-a-2d-matrix-ii"},"content":{"kind":"string","value":"<p>Write an efficient algorithm that searches for a value <code>target</code> in an <code>m x n</code> integer matrix <code>matrix</code>. This matrix has the following properties:</p>\n\n<ul>\n\t<li>Integers in each row are sorted in ascending from left to right.</li>\n\t<li>Integers in each column are sorted in ascending from top to bottom.</li>\n</ul>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2020/11/24/searchgrid2.jpg\" style=\"width: 300px; height: 300px;\" />\n<pre>\n<strong>Input:</strong> matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5\n<strong>Output:</strong> true\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2020/11/24/searchgrid.jpg\" style=\"width: 300px; height: 300px;\" />\n<pre>\n<strong>Input:</strong> matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20\n<strong>Output:</strong> false\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>m == matrix.length</code></li>\n\t<li><code>n == matrix[i].length</code></li>\n\t<li><code>1 <= n, m <= 300</code></li>\n\t<li><code>-10<sup>9</sup> <= matrix[i][j] <= 10<sup>9</sup></code></li>\n\t<li>All the integers in each row are <strong>sorted</strong> in ascending order.</li>\n\t<li>All the integers in each column are <strong>sorted</strong> in ascending order.</li>\n\t<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":53.51569276013313,"string":"53.515693"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","binary-search","divide-and-conquer","matrix"],"string":"[\n \"array\",\n \"binary-search\",\n \"divide-and-conquer\",\n \"matrix\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"41\", 0.0196], [\"42\", 0.0196], [\"47\", 0.0391], [\"50\", 0.0196], [\"51\", 0.0196], [\"113\", 0.0196], [\"115\", 0.0196], [\"116\", 0.0391], [\"117\", 0.0391], [\"118\", 0.0782], [\"119\", 0.1369], [\"120\", 0.0978], [\"121\", 0.2346], [\"122\", 0.2151], [\"123\", 0.3129], [\"124\", 0.4497], [\"125\", 0.6648], [\"126\", 0.9386], [\"127\", 0.8799], [\"128\", 1.1928], [\"129\", 1.4275], [\"130\", 1.799], [\"131\", 1.9163], [\"132\", 2.8745], [\"133\", 3.5393], [\"134\", 3.9695], [\"135\", 4.3215], [\"136\", 4.517], [\"137\", 4.6734], [\"138\", 5.9249], [\"139\", 5.7685], [\"140\", 5.2014], [\"141\", 6.0422], [\"142\", 5.7098], [\"143\", 5.6707], [\"144\", 4.5366], [\"145\", 5.045], [\"146\", 4.5366], [\"147\", 3.9499], [\"148\", 2.5029], [\"149\", 2.4052], [\"150\", 2.2096]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"20500\", 0.0196], [\"21400\", 0.0196], [\"21500\", 0.0782], [\"21600\", 0.0196], [\"22400\", 0.0196], [\"22500\", 0.1369], [\"22600\", 0.176], [\"22700\", 0.7039], [\"22800\", 8.7994], [\"22900\", 49.2178], [\"23000\", 31.2671], [\"23100\", 2.9722]]}"},"rt_list":{"kind":"list like","value":[{"code":"\ndef searchMatrix(matrix: List[List[int]], target: int) -> bool:\n i = j = 0\n m = len(matrix)\n n = len(matrix[0])\n\n while i < m and matrix[i][j] <= target:\n if matrix[i][j] == target:\n return 'true'\n i += 1\n \n i -= 1\n while i >= 0:\n j = 0\n while j < n and matrix[i][j] <= target:\n if matrix[i][j] == target:\n return 'true'\n j += 1\n i -= 1\n \n return 'false'\n\nwith open('user.out', 'w') as f:\n inputs = list(map(loads, stdin))\n for matrix, target in zip(inputs[::2], inputs[1::2]):\n f.write(f\"{searchMatrix(matrix, target)}\\n\")\nexit(0)","runtime":"41"},{"code":"from typing import List\ndef searchMatrix(matrix: List[List[int]], target: int) -> bool:\n n = len(matrix)\n m = len(matrix[0])\n\n i = 0\n j = m - 1\n\n while (i < n and j >= 0):\n if matrix[i][j] == target:\n return \"true\"\n if matrix[i][j] > target:\n j -= 1\n else:\n i += 1\n \n return \"false\"\n\nwith open('user.out', 'w') as f:\n inputs = list(map(loads, stdin))\n for matrix, target in zip(inputs[::2], inputs[1::2]):\n f.write(f\"{searchMatrix(matrix, target)}\\n\")\nexit(0)","runtime":"42"},{"code":"\ndef searchMatrix(matrix: List[List[int]], target: int) -> bool:\n r = len(matrix)\n c = len(matrix[0])\n\n # we search rows\n for row in matrix:\n if row[0] <= target and row[-1] >= target:\n # bin search\n l = 0\n r = c\n\n while l < r:\n m = (r + l) // 2\n\n if row[m] == target:\n return 'true'\n \n if row[m] < target:\n l = m + 1\n \n if row[m] > target:\n r = m\n \n return 'false'\n\nwith open('user.out', 'w') as f:\n inputs = list(map(loads, stdin))\n for matrix, target in zip(inputs[::2], inputs[1::2]):\n f.write(f\"{searchMatrix(matrix, target)}\\n\")\nexit(0)","runtime":"47"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n m, n = len(matrix), len(matrix[0])\n \n for row in matrix:\n if row[0] <= target <= row[-1]:\n left, right = 0, n - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if row[mid] == target:\n return 'true'\n elif row[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return 'false'\n\nwith open(\"user.out\", \"w\") as f:\n inputs = map(loads, stdin)\n for nums in inputs:\n print(Solution().searchMatrix(nums, next(inputs)),file=f)\nexit(0)","runtime":"50"},{"code":"def searchMatrix(matrix: List[List[int]], target: int) -> bool:\n # same solution as Search a 2D Matrix I\n row_len = len(matrix)\n col_len = len(matrix[0])\n\n row, col = 0, col_len - 1\n\n while ((row < row_len) and (col >= 0)):\n curr = matrix[row][col]\n\n if curr == target:\n return 'true'\n\n if target > curr:\n row += 1\n else:\n col -= 1\n\n return 'false'\n\n\nwith open('user.out', 'w') as f:\n inputs = list(map(loads, stdin))\n for matrix, target in zip(inputs[::2], inputs[1::2]):\n f.write(f\"{searchMatrix(matrix, target)}\\n\")\nexit(0)","runtime":"51"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n if not matrix:\n return null\n row = len(matrix)\n col = len(matrix[0])\n i = 0\n j = col - 1\n while i < row and j >= 0:\n if matrix[i][j] == target:\n return True\n elif matrix[i][j] > target:\n j -= 1\n else:\n i += 1\n return False","runtime":"113"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n # O(n^2)..?\n return any([target in row for row in matrix])\n\n # def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n # num_rows = len(matrix)\n # # O(m)\n # for rn in range(num_rows):\n # row = matrix[rn]\n # # O(logn)\n # idx = bisect.bisect_left(row, target)\n # if idx < len(row) and row[idx] == target:\n # return True\n # return False","runtime":"115"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n row = len(matrix)\n col = len(matrix[0])\n\n for i in range(row):\n if matrix[i][0] <= target and matrix[i][-1] >= target:\n low = 0\n high = col\n \n while (low < high):\n mid = (low + high) // 2\n\n if matrix[i][mid] == target:\n return True\n elif matrix[i][mid] < target:\n low = mid + 1\n else:\n high = mid\n return False\n","runtime":"116"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n if not matrix or not matrix[0]:\n return None\n\n # Method 1: Greedy Stairway Approach\n rowindex, colindex = len(matrix) - 1, 0\n while rowindex >= 0 and colindex < len(matrix[0]):\n curval = matrix[rowindex][colindex]\n if curval == target:\n return True\n elif curval < target:\n colindex += 1\n else:\n rowindex -= 1\n return False\n\n # Method 2: Binary Search\n\n ","runtime":"117"},{"code":"# class BinarySearch:\n# def __init__(self, matrix):\n# self.matrix = matrix\n\n# def columnSearch(self, target) -> tuple:\n# low = 0\n# high = len(self.matrix)-1\n# while low <= high:\n# mid = (low + high) // 2\n# if self.matrix[mid][0] <= target and target <= self.matrix[mid][len(self.matrix[mid])-1]:\n# return (low, high)\n# elif self.matrix[mid][0] > target:\n# high = mid - 1\n# elif self.matrix[mid][len(self.matrix[mid])-1] < target:\n# low = mid + 1\n# return (-1, -1)\n\n# def rowSearch(self, target) -> bool:\n# for row in self.matrix:\n# low = 0\n# high = len(row)-1\n# while low <= high:\n# mid = (low + high) // 2\n# if row[mid] == target:\n# return True\n# elif row[mid] > target:\n# high = mid - 1\n# else:\n# low = mid + 1\n# return False\n\n# def trimDownRows(self, target) -> bool:\n# (row, column) = self.columnSearch(target)\n# if row == -1:\n# return False\n# self.matrix = self.matrix[row:column+1]\n# return self.rowSearch(target)\n\nclass BinarySearch:\n def __init__(self, matrix):\n self.matrix = matrix\n\n def searchElement(self, target):\n m = len(self.matrix)\n n = len(self.matrix[0])\n row = 0\n col = n-1\n while row < m and col >= 0:\n if self.matrix[row][col] == target:\n return True\n elif self.matrix[row][col] < target:\n row += 1\n else:\n col -= 1\n return False\n\n\nclass Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n # if len(matrix) == 1:\n # if len(matrix[0]) == 1:\n # if matrix[0][0] == target:\n # return True\n # elif matrix[0][0] != target:\n # return False\n return BinarySearch(matrix).searchElement(target)","runtime":"118"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n cols = len(matrix[0]) - 1\n h = cols\n for i in range(len(matrix)):\n l = 0\n while l <= h:\n m = (l + h) >> 1\n if matrix[i][m] == target:\n return True\n elif matrix[i][m] < target:\n l = m + 1\n else:\n h = m - 1\n h = h + 1 if h < cols else cols\n return False\n \n","runtime":"119"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n m, n = len(matrix), len(matrix[0])\n i, j = m - 1, 0\n while i >=0 and j <= n - 1:\n if target > matrix[i][j]:\n i, j = i, j + 1\n elif target < matrix[i][j]:\n i, j = i - 1, j\n else:\n return True\n return False \n\n def searchMatrix_binarySearch(self, matrix: List[List[int]], target: int) -> bool:\n m, n = len(matrix), len(matrix[0])\n for i in range(m):\n vec = matrix[i]\n low, high = 0, n - 1\n while low <= high:\n mid = (low + high) // 2\n if target < vec[mid]:\n high = mid - 1\n elif target > vec[mid]:\n low = mid + 1\n else:\n return True\n return False\n ","runtime":"120"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n row = 0\n col = len(matrix[0])-1\n\n while row < len(matrix) and col >= 0:\n if matrix[row][col] == target:\n return True\n elif matrix[row][col] < target:\n row += 1\n else:\n col -= 1\n return False ","runtime":"121"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n # an empty matrix obviously does not contain `target` (make this check\n # because we want to cache `width` for efficiency's sake)\n if len(matrix) == 0 or len(matrix[0]) == 0:\n return False\n\n # cache these, as they won't change.\n height = len(matrix)\n width = len(matrix[0])\n\n # start our \"pointer\" in the bottom-left\n row = height - 1\n col = 0\n\n while col < width and row >= 0:\n if matrix[row][col] > target:\n row -= 1\n elif matrix[row][col] < target:\n col += 1\n else: # found it\n return True\n \n return False","runtime":"122"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n n = len(matrix[0])\n high = n - 1\n for row in matrix:\n if row[0] > target:\n return False\n if row[high] < target:\n continue\n low = 0\n while low + 1 < high:\n middle = (low + high) // 2\n number = row[middle]\n if number == target:\n return True\n if number > target:\n high = middle - 1\n else:\n low = middle + 1\n if row[low] == target or row[high] == target:\n return True\n return False","runtime":"124"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n row = 0\n col = len(matrix[0]) - 1\n \n #如果从左上往右下：不管向下还是向右数字都是变大，不好判断\n #但是从右上往左下：向下数字变大向左数字变小\n while row < len(matrix) and col >= 0: \n if matrix[row][col] == target:\n return True\n if matrix[row][col] < target:\n row += 1\n else:\n col -= 1\n \n return False","runtime":"125"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n m = len(matrix)\n n = len(matrix[0])\n i, j = 0, n-1\n while i < m and j >= 0:\n if matrix[i][j] == target:\n return True\n if matrix[i][j] > target:\n j -= 1\n else: \n i += 1\n\n return False","runtime":"126"},{"code":"class Solution:\n def searchMatrix(self, a: List[List[int]], target: int) -> bool:\n m = len(a)\n n = len(a[0])\n row, col = 0, n-1\n while row < m and col >= 0:\n if a[row][col] == target:\n return True\n if a[row][col] < target:\n row += 1\n else:\n col -= 1\n return False","runtime":"127"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n for element in matrix:\n if target in element:\n return True","runtime":"128"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n m, n = len(matrix), len(matrix[0])\n col, row = 0, m-1\n while col < n and row >= 0:\n if matrix[row][col] > target:\n row -= 1\n elif matrix[row][col] < target:\n col += 1\n else:\n return True\n \n return False\n ","runtime":"129"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n n = len(matrix)\n m = len(matrix[0]) - 1\n high = m\n for i in range(n):\n low = 0\n while low <= high:\n mid = low + (high - low ) // 2\n if matrix[i][mid] == target:\n return True\n \n elif matrix[i][mid] < target:\n low = mid + 1\n\n else:\n high = mid - 1\n\n\n\n\n return False\n\n\n","runtime":"130"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n for i in matrix:\n if target in i:\n return True\n return False","runtime":"131"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n m, n = len(matrix), len(matrix[0])\n r, c = 0, n-1\n while r < m and c >= 0:\n if target > matrix[r][c]:\n r += 1\n elif target < matrix[r][c]:\n c -= 1\n else:\n return True\n return False","runtime":"131"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n if not matrix or not matrix[0]:\n return False\n\n m, n = len(matrix), len(matrix[0])\n r, c = 0, n - 1 \n\n while r < m and c >= 0:\n if matrix[r][c] == target:\n return True\n elif matrix[r][c] > target:\n c -= 1 \n else:\n r += 1 \n\n return False\n","runtime":"132"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n col = len(matrix[0]) - 1\n row = len(matrix) - 1\n\n for i in range(row+1):\n l = 0\n r = col\n while l <= r:\n m = (l+r) // 2\n if matrix[i][m] == target:\n return True\n elif matrix[i][m] < target:\n l = m+1\n else:\n r = m-1\n return False","runtime":"133"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n m, n = len(matrix), len(matrix[0])\n row, col = m - 1, 0\n\n while row >= 0 and col < n:\n curr = matrix[row][col]\n if curr == target:\n return True\n if curr > target:\n row -= 1\n else:\n col += 1\n return False","runtime":"133"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n for row in matrix:\n if target in row:\n return True\n return False\n ","runtime":"134"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n m,n=len(matrix),len(matrix[0])\n row,col=0,n-1\n while row<m and col>=0:\n if matrix[row][col] == target:\n return True\n elif matrix[row][col] > target:\n col-=1\n else:\n row+=1\n return False","runtime":"134"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n if not matrix or not matrix[0]:\n return False\n \n # Start from the top right corner\n row, col = 0, len(matrix[0]) - 1\n \n while row < len(matrix) and col >= 0:\n if matrix[row][col] == target:\n return True\n elif matrix[row][col] < target:\n row += 1 # Move down\n else:\n col -= 1 # Move left\n \n return False","runtime":"135"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n rows=len(matrix)\n col=len(matrix[0])\n rowindex=0\n colindex=col-1\n\n while rowindex<rows and colindex>=0:\n element=matrix[rowindex][colindex]\n if element==target:\n return 1\n elif element<target:\n rowindex+=1\n else:\n colindex-=1\n\n return 0\n ","runtime":"135"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n\n #Brute Force\n\n # for i in range(len(matrix)):\n # for j in range(len(matrix[0])):\n # if(matrix[i][j]==target):\n # return True\n # else:\n # return False\n\n #Better\n\n\n # for sub_matrix in matrix:\n # d=self.search(sub_matrix,target)\n # if(d==True):\n # return True\n # else:\n # return False\n\n #Optimal\n\n i=0\n j=len(matrix[0])-1\n while(i<len(matrix) and j>=0):\n if(target==matrix[i][j]):\n return True\n elif(target<matrix[i][j]):\n d=self.search(matrix[i],target)\n if(d==True):\n return True\n else:\n i+=1\n j-=1\n else:\n d=self.search_col(matrix,i,j,target)\n if(d==True):\n return True\n else:\n i+=1\n j-=1\n else:\n return False\n def search_col(self,matrix,i,j,target):\n low=i\n high=len(matrix)-1\n while(low<=high):\n mid=(low+high)//2\n if(matrix[mid][j]==target):\n return True\n elif(matrix[mid][j]<target):\n low=mid+1\n else:\n high=mid-1\n else:\n return False\n def search(self,nums,target):\n low=0\n high=len(nums)-1\n while(low<=high):\n mid=(low+high)//2\n if(nums[mid]==target):\n return True\n if(nums[mid]<target):\n low=mid+1\n else:\n high=mid-1\n return False","runtime":"136"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n r = 0\n c = len(matrix[0])-1\n\n while c >= 0 and r <= len(matrix)-1:\n if matrix[r][c] > target:\n c-=1\n elif matrix[r][c] < target:\n r+=1\n else:\n return True\n\n\n return False","runtime":"136"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n i = len(matrix)-1\n j = 0\n while i >= 0 and j < len(matrix[0]):\n ##print(f'i:{i}, j:{j}, num:{matrix[i][j]}')\n if target == matrix[i][j]:\n return True\n elif target > matrix[i][j]: ## skip column\n j +=1\n else:\n i -=1\n return False \n \n\n ","runtime":"137"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n for r in matrix:\n for c in r:\n if c == target:\n return True\n\n return False","runtime":"137"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n n = len(matrix)\n m = len(matrix[0])\n row = 0\n col = m - 1\n while row < n and col >= 0:\n if matrix[row][col] == target:\n return True\n elif matrix[row][col] < target:\n row += 1\n else:\n col -= 1\n return False\n ","runtime":"138"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n height = len(matrix)\n if height == 0:\n return False\n width = len(matrix[0])\n if width == 0:\n return False\n\n row = height - 1\n col = 0\n\n while col < width and row >= 0: #while cursor is not past width and not past height\n if matrix[row][col] > target:\n row -= 1\n elif matrix[row][col] < target:\n col += 1\n else:\n return True\n\n return False\n","runtime":"138"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n ROWS, COLS = len(matrix), len(matrix[0])\n\n def bs(start, vertical):\n lo = start\n hi = ROWS - 1 if vertical else COLS - 1\n\n while lo <= hi:\n mid = (hi + lo) // 2\n if vertical:\n if matrix[mid][start] < target:\n lo = mid + 1\n elif matrix[mid][start] > target:\n hi = mid -1\n else:\n return True\n else:\n if matrix[start][mid] < target:\n lo = mid + 1\n elif matrix[start][mid] > target:\n hi = mid -1\n else:\n return True\n return False\n \n for i in range(min(ROWS, COLS)):\n left = bs(i, True)\n right = bs(i, False)\n\n if left or right:\n return True\n return False","runtime":"139"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n m, n = len(matrix), len(matrix[0])\n row = 0\n col = n - 1\n while row < m and col >= 0:\n if matrix[row][col] == target:\n return True\n elif matrix[row][col] > target:\n col -= 1\n else:\n row += 1\n return False\n\n ","runtime":"139"},{"code":"class Solution:\n def searchMatrix(self, mat: List[List[int]], target: int) -> bool:\n \n m=len(mat)\n n=len(mat[0])\n \n for i in range(m):\n if mat[i][0]<=target and mat[i][-1]>=target:\n lo=0\n hi=n\n while (lo<=hi):\n mid=(lo+hi)//2\n \n if mat[i][mid]==target:\n return True\n elif mat[i][mid]<target:\n lo = mid + 1\n else:\n hi = mid - 1\n \n return False","runtime":"140"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n cols = len(matrix[0]) - 1\n right = cols\n for i in range(len(matrix)):\n left = 0\n while left <= right:\n middle = (left + right) // 2\n if matrix[i][middle] == target:\n return True\n elif matrix[i][middle] < target:\n left = middle + 1\n else:\n right = middle - 1\n right = right + 1 if right < cols else cols\n return False \n\n","runtime":"140"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n def binary_search(start, column):\n low = start\n high = n - 1 if column else m - 1\n while low <= high:\n mid = (low + high) // 2\n if column:\n if matrix[start][mid] < target:\n low = mid + 1\n elif matrix[start][mid] > target:\n high = mid - 1\n else:\n return True\n else:\n if matrix[mid][start] < target:\n low = mid + 1\n elif matrix[mid][start] > target:\n high = mid - 1\n else:\n return True\n return False\n\n if not matrix: return False\n m, n = len(matrix), len(matrix[0])\n for i in range(min(m, n)):\n col_found = binary_search(i, True)\n row_found = binary_search(i, False)\n if col_found or row_found:\n return True\n return False","runtime":"141"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n for i in matrix:\n if target in i:\n a = True\n break\n else:\n a = False\n \n return a\n ","runtime":"141"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n i, j = 0, len(matrix[0])-1\n while i < len(matrix) and j >= 0 :\n if matrix[i][j] == target :\n return True\n elif matrix[i][j] < target :\n i += 1\n else :\n j -= 1\n return False","runtime":"142"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n def binarySearch(area, left: int, right: int, target):\n if left > right:\n return False\n \n mid = abs(right + left) // 2\n \n if area[mid] == target:\n return True\n elif target > area[mid]:\n left = mid+1\n else:\n right = mid-1\n \n return binarySearch(area, left, right, target)\n for i in matrix:\n if binarySearch(i, 0, len(i) - 1, target):\n return True\n \n return False","runtime":"142"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n n=len(matrix)\n m=len(matrix[0])\n row=0\n col=m-1\n while(row<n and col>=0):\n if matrix[row][col]==target:\n return True\n elif matrix[row][col]>target:\n col-=1\n else:\n row+=1\n return False\n\n ","runtime":"143"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n for i in matrix:\n if target in i: return True\n return False\n ","runtime":"143"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n for row in matrix:\n l=0;r=len(row)-1\n while l<=r:\n m = (l+r)//2\n if row[m]==target:\n return True\n elif row[m] > target:\n r = m-1\n else:\n l = m+1\n return False ","runtime":"144"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n n = len(matrix)\n m = len(matrix[0])\n row = 0\n col = m - 1\n while(row < n and col >= 0):\n if(matrix[row][col] == target):\n return True\n elif (matrix[row][col] < target):\n row += 1\n else:\n col -= 1\n return False","runtime":"145"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n def binary_search(maxtrix, left, right, top, bottom, target):\n if left > right or top > bottom:\n return False\n\n mid = ((top + bottom) // 2, (left + right) // 2)\n\n cur = matrix[mid[0]][mid[1]] \n\n if cur == target:\n return True\n elif cur > target:\n return binary_search(matrix, left, mid[1] - 1, top, bottom, target) or binary_search(matrix, left, right, top, mid[0] - 1, target)\n else:\n return binary_search(matrix, mid[1] + 1, right, top, bottom, target) or binary_search(matrix, left, right, mid[0] + 1, bottom, target)\n\n return binary_search(matrix, 0, len(matrix[0]) - 1, 0, len(matrix) - 1, target)\n ","runtime":"145"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n \n def searchRange(left, up, right, down):\n if left > right or up > down:\n return False\n \n mid = (left + right) // 2\n \n row = up\n while row <= down and matrix[row][mid] <= target:\n if matrix[row][mid] == target:\n return True\n row += 1\n \n return searchRange(left, row, mid - 1, down) or searchRange(mid + 1, up, right, row - 1)\n \n return searchRange(0, 0, len(matrix[0]) - 1, len(matrix) - 1)","runtime":"146"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n # almost similar to the part1 we can try brute and better approach but that's \n # not optimal\n # one observation is that rows and cols are sorted so if we are standing at\n # 0,0 then it's right and bottom is sorted so we can't decide which side to \n # eliminate, simillarly if we are standing at the m,n then it's left and top\n # are decreasing so we can not decide which side to eliminate\n # so only coardinate left is 0,n and m,0 we can start any of this cell check\n # if cell value < target that means we can't get the target on that row because\n # it's already sorted to go to the next row and if the cell value is > target\n # then we can't move in that col because all the element in that col will be\n # higher since it's sorted so decrease the col\n\n ROWS = len(matrix)\n COLS = len(matrix[0])\n\n r = 0\n c = COLS - 1\n while r < ROWS and c >= 0:\n if matrix[r][c] == target:\n # we can also return the coordinate as well \n return True\n elif matrix[r][c] < target: # move to the next row\n r += 1\n else:\n c -= 1\n\n return False\n ","runtime":"147"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n i = 0\n if matrix[i][-1] < target:\n i += 1\n for j in range(0, len(matrix[0])):\n k = i\n while k < len(matrix) and matrix[k][j] <= target:\n if matrix[k][j] == target:\n return True\n else:\n k += 1\n return False","runtime":"147"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n height = len(matrix)\n if height == 0:\n return False\n width = len(matrix[0])\n if width == 0:\n return False\n\n row = height - 1\n col = 0\n\n while col < width and row >= 0: #while cursor is not past width and not past height\n if matrix[row][col] > target:\n row -= 1\n elif matrix[row][col] < target:\n col += 1\n else:\n return True\n\n return False\n","runtime":"148"},{"code":"import bisect\nclass Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n for row in matrix:\n ind = bisect.bisect_left(row, target)\n if ind < len(row) and row[ind] == target: return True\n return False","runtime":"148"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n n=len(matrix)\n m=len(matrix[0])\n left=0\n right=m-1\n while(left<n and right>=0):\n point=matrix[left][right]\n if point==target:\n return True\n elif target<point:\n right-=1\n else:\n left+=1\n return False\n ","runtime":"149"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n\n m = len(matrix)\n n = len(matrix[0])\n\n row = 0\n col = n - 1\n\n while row < m and col >= 0:\n curr = matrix[row][col]\n if target == curr:\n return True\n elif target > curr:\n row += 1\n elif target < curr:\n col -= 1\n \n return False\n ","runtime":"149"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n if not matrix or not matrix[0]:\n return False\n rows=len(matrix)\n cols=len(matrix[0])\n row,col=0,cols-1\n while row<rows and col>=0:\n if matrix[row][col]==target:\n return True\n elif matrix[row][col]>target:\n col-=1\n else:\n row+=1\n return False\n ","runtime":"150"}],"string":"[\n {\n \"code\": \"\\ndef searchMatrix(matrix: List[List[int]], target: int) -> bool:\\n i = j = 0\\n m = len(matrix)\\n n = len(matrix[0])\\n\\n while i < m and matrix[i][j] <= target:\\n if matrix[i][j] == target:\\n return 'true'\\n i += 1\\n \\n i -= 1\\n while i >= 0:\\n j = 0\\n while j < n and matrix[i][j] <= target:\\n if matrix[i][j] == target:\\n return 'true'\\n j += 1\\n i -= 1\\n \\n return 'false'\\n\\nwith open('user.out', 'w') as f:\\n inputs = list(map(loads, stdin))\\n for matrix, target in zip(inputs[::2], inputs[1::2]):\\n f.write(f\\\"{searchMatrix(matrix, target)}\\\\n\\\")\\nexit(0)\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"from typing import List\\ndef searchMatrix(matrix: List[List[int]], target: int) -> bool:\\n n = len(matrix)\\n m = len(matrix[0])\\n\\n i = 0\\n j = m - 1\\n\\n while (i < n and j >= 0):\\n if matrix[i][j] == target:\\n return \\\"true\\\"\\n if matrix[i][j] > target:\\n j -= 1\\n else:\\n i += 1\\n \\n return \\\"false\\\"\\n\\nwith open('user.out', 'w') as f:\\n inputs = list(map(loads, stdin))\\n for matrix, target in zip(inputs[::2], inputs[1::2]):\\n f.write(f\\\"{searchMatrix(matrix, target)}\\\\n\\\")\\nexit(0)\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"\\ndef searchMatrix(matrix: List[List[int]], target: int) -> bool:\\n r = len(matrix)\\n c = len(matrix[0])\\n\\n # we search rows\\n for row in matrix:\\n if row[0] <= target and row[-1] >= target:\\n # bin search\\n l = 0\\n r = c\\n\\n while l < r:\\n m = (r + l) // 2\\n\\n if row[m] == target:\\n return 'true'\\n \\n if row[m] < target:\\n l = m + 1\\n \\n if row[m] > target:\\n r = m\\n \\n return 'false'\\n\\nwith open('user.out', 'w') as f:\\n inputs = list(map(loads, stdin))\\n for matrix, target in zip(inputs[::2], inputs[1::2]):\\n f.write(f\\\"{searchMatrix(matrix, target)}\\\\n\\\")\\nexit(0)\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n m, n = len(matrix), len(matrix[0])\\n \\n for row in matrix:\\n if row[0] <= target <= row[-1]:\\n left, right = 0, n - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if row[mid] == target:\\n return 'true'\\n elif row[mid] < target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n return 'false'\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n inputs = map(loads, stdin)\\n for nums in inputs:\\n print(Solution().searchMatrix(nums, next(inputs)),file=f)\\nexit(0)\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"def searchMatrix(matrix: List[List[int]], target: int) -> bool:\\n # same solution as Search a 2D Matrix I\\n row_len = len(matrix)\\n col_len = len(matrix[0])\\n\\n row, col = 0, col_len - 1\\n\\n while ((row < row_len) and (col >= 0)):\\n curr = matrix[row][col]\\n\\n if curr == target:\\n return 'true'\\n\\n if target > curr:\\n row += 1\\n else:\\n col -= 1\\n\\n return 'false'\\n\\n\\nwith open('user.out', 'w') as f:\\n inputs = list(map(loads, stdin))\\n for matrix, target in zip(inputs[::2], inputs[1::2]):\\n f.write(f\\\"{searchMatrix(matrix, target)}\\\\n\\\")\\nexit(0)\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n if not matrix:\\n return null\\n row = len(matrix)\\n col = len(matrix[0])\\n i = 0\\n j = col - 1\\n while i < row and j >= 0:\\n if matrix[i][j] == target:\\n return True\\n elif matrix[i][j] > target:\\n j -= 1\\n else:\\n i += 1\\n return False\",\n \"runtime\": \"113\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n # O(n^2)..?\\n return any([target in row for row in matrix])\\n\\n # def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n # num_rows = len(matrix)\\n # # O(m)\\n # for rn in range(num_rows):\\n # row = matrix[rn]\\n # # O(logn)\\n # idx = bisect.bisect_left(row, target)\\n # if idx < len(row) and row[idx] == target:\\n # return True\\n # return False\",\n \"runtime\": \"115\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n row = len(matrix)\\n col = len(matrix[0])\\n\\n for i in range(row):\\n if matrix[i][0] <= target and matrix[i][-1] >= target:\\n low = 0\\n high = col\\n \\n while (low < high):\\n mid = (low + high) // 2\\n\\n if matrix[i][mid] == target:\\n return True\\n elif matrix[i][mid] < target:\\n low = mid + 1\\n else:\\n high = mid\\n return False\\n\",\n \"runtime\": \"116\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n if not matrix or not matrix[0]:\\n return None\\n\\n # Method 1: Greedy Stairway Approach\\n rowindex, colindex = len(matrix) - 1, 0\\n while rowindex >= 0 and colindex < len(matrix[0]):\\n curval = matrix[rowindex][colindex]\\n if curval == target:\\n return True\\n elif curval < target:\\n colindex += 1\\n else:\\n rowindex -= 1\\n return False\\n\\n # Method 2: Binary Search\\n\\n \",\n \"runtime\": \"117\"\n },\n {\n \"code\": \"# class BinarySearch:\\n# def __init__(self, matrix):\\n# self.matrix = matrix\\n\\n# def columnSearch(self, target) -> tuple:\\n# low = 0\\n# high = len(self.matrix)-1\\n# while low <= high:\\n# mid = (low + high) // 2\\n# if self.matrix[mid][0] <= target and target <= self.matrix[mid][len(self.matrix[mid])-1]:\\n# return (low, high)\\n# elif self.matrix[mid][0] > target:\\n# high = mid - 1\\n# elif self.matrix[mid][len(self.matrix[mid])-1] < target:\\n# low = mid + 1\\n# return (-1, -1)\\n\\n# def rowSearch(self, target) -> bool:\\n# for row in self.matrix:\\n# low = 0\\n# high = len(row)-1\\n# while low <= high:\\n# mid = (low + high) // 2\\n# if row[mid] == target:\\n# return True\\n# elif row[mid] > target:\\n# high = mid - 1\\n# else:\\n# low = mid + 1\\n# return False\\n\\n# def trimDownRows(self, target) -> bool:\\n# (row, column) = self.columnSearch(target)\\n# if row == -1:\\n# return False\\n# self.matrix = self.matrix[row:column+1]\\n# return self.rowSearch(target)\\n\\nclass BinarySearch:\\n def __init__(self, matrix):\\n self.matrix = matrix\\n\\n def searchElement(self, target):\\n m = len(self.matrix)\\n n = len(self.matrix[0])\\n row = 0\\n col = n-1\\n while row < m and col >= 0:\\n if self.matrix[row][col] == target:\\n return True\\n elif self.matrix[row][col] < target:\\n row += 1\\n else:\\n col -= 1\\n return False\\n\\n\\nclass Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n # if len(matrix) == 1:\\n # if len(matrix[0]) == 1:\\n # if matrix[0][0] == target:\\n # return True\\n # elif matrix[0][0] != target:\\n # return False\\n return BinarySearch(matrix).searchElement(target)\",\n \"runtime\": \"118\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n cols = len(matrix[0]) - 1\\n h = cols\\n for i in range(len(matrix)):\\n l = 0\\n while l <= h:\\n m = (l + h) >> 1\\n if matrix[i][m] == target:\\n return True\\n elif matrix[i][m] < target:\\n l = m + 1\\n else:\\n h = m - 1\\n h = h + 1 if h < cols else cols\\n return False\\n \\n\",\n \"runtime\": \"119\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n m, n = len(matrix), len(matrix[0])\\n i, j = m - 1, 0\\n while i >=0 and j <= n - 1:\\n if target > matrix[i][j]:\\n i, j = i, j + 1\\n elif target < matrix[i][j]:\\n i, j = i - 1, j\\n else:\\n return True\\n return False \\n\\n def searchMatrix_binarySearch(self, matrix: List[List[int]], target: int) -> bool:\\n m, n = len(matrix), len(matrix[0])\\n for i in range(m):\\n vec = matrix[i]\\n low, high = 0, n - 1\\n while low <= high:\\n mid = (low + high) // 2\\n if target < vec[mid]:\\n high = mid - 1\\n elif target > vec[mid]:\\n low = mid + 1\\n else:\\n return True\\n return False\\n \",\n \"runtime\": \"120\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n row = 0\\n col = len(matrix[0])-1\\n\\n while row < len(matrix) and col >= 0:\\n if matrix[row][col] == target:\\n return True\\n elif matrix[row][col] < target:\\n row += 1\\n else:\\n col -= 1\\n return False \",\n \"runtime\": \"121\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n # an empty matrix obviously does not contain `target` (make this check\\n # because we want to cache `width` for efficiency's sake)\\n if len(matrix) == 0 or len(matrix[0]) == 0:\\n return False\\n\\n # cache these, as they won't change.\\n height = len(matrix)\\n width = len(matrix[0])\\n\\n # start our \\\"pointer\\\" in the bottom-left\\n row = height - 1\\n col = 0\\n\\n while col < width and row >= 0:\\n if matrix[row][col] > target:\\n row -= 1\\n elif matrix[row][col] < target:\\n col += 1\\n else: # found it\\n return True\\n \\n return False\",\n \"runtime\": \"122\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n n = len(matrix[0])\\n high = n - 1\\n for row in matrix:\\n if row[0] > target:\\n return False\\n if row[high] < target:\\n continue\\n low = 0\\n while low + 1 < high:\\n middle = (low + high) // 2\\n number = row[middle]\\n if number == target:\\n return True\\n if number > target:\\n high = middle - 1\\n else:\\n low = middle + 1\\n if row[low] == target or row[high] == target:\\n return True\\n return False\",\n \"runtime\": \"124\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n row = 0\\n col = len(matrix[0]) - 1\\n \\n #如果从左上往右下：不管向下还是向右数字都是变大，不好判断\\n #但是从右上往左下：向下数字变大向左数字变小\\n while row < len(matrix) and col >= 0: \\n if matrix[row][col] == target:\\n return True\\n if matrix[row][col] < target:\\n row += 1\\n else:\\n col -= 1\\n \\n return False\",\n \"runtime\": \"125\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n m = len(matrix)\\n n = len(matrix[0])\\n i, j = 0, n-1\\n while i < m and j >= 0:\\n if matrix[i][j] == target:\\n return True\\n if matrix[i][j] > target:\\n j -= 1\\n else: \\n i += 1\\n\\n return False\",\n \"runtime\": \"126\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, a: List[List[int]], target: int) -> bool:\\n m = len(a)\\n n = len(a[0])\\n row, col = 0, n-1\\n while row < m and col >= 0:\\n if a[row][col] == target:\\n return True\\n if a[row][col] < target:\\n row += 1\\n else:\\n col -= 1\\n return False\",\n \"runtime\": \"127\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n for element in matrix:\\n if target in element:\\n return True\",\n \"runtime\": \"128\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n m, n = len(matrix), len(matrix[0])\\n col, row = 0, m-1\\n while col < n and row >= 0:\\n if matrix[row][col] > target:\\n row -= 1\\n elif matrix[row][col] < target:\\n col += 1\\n else:\\n return True\\n \\n return False\\n \",\n \"runtime\": \"129\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n n = len(matrix)\\n m = len(matrix[0]) - 1\\n high = m\\n for i in range(n):\\n low = 0\\n while low <= high:\\n mid = low + (high - low ) // 2\\n if matrix[i][mid] == target:\\n return True\\n \\n elif matrix[i][mid] < target:\\n low = mid + 1\\n\\n else:\\n high = mid - 1\\n\\n\\n\\n\\n return False\\n\\n\\n\",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n for i in matrix:\\n if target in i:\\n return True\\n return False\",\n \"runtime\": \"131\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n m, n = len(matrix), len(matrix[0])\\n r, c = 0, n-1\\n while r < m and c >= 0:\\n if target > matrix[r][c]:\\n r += 1\\n elif target < matrix[r][c]:\\n c -= 1\\n else:\\n return True\\n return False\",\n \"runtime\": \"131\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n if not matrix or not matrix[0]:\\n return False\\n\\n m, n = len(matrix), len(matrix[0])\\n r, c = 0, n - 1 \\n\\n while r < m and c >= 0:\\n if matrix[r][c] == target:\\n return True\\n elif matrix[r][c] > target:\\n c -= 1 \\n else:\\n r += 1 \\n\\n return False\\n\",\n \"runtime\": \"132\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n col = len(matrix[0]) - 1\\n row = len(matrix) - 1\\n\\n for i in range(row+1):\\n l = 0\\n r = col\\n while l <= r:\\n m = (l+r) // 2\\n if matrix[i][m] == target:\\n return True\\n elif matrix[i][m] < target:\\n l = m+1\\n else:\\n r = m-1\\n return False\",\n \"runtime\": \"133\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n m, n = len(matrix), len(matrix[0])\\n row, col = m - 1, 0\\n\\n while row >= 0 and col < n:\\n curr = matrix[row][col]\\n if curr == target:\\n return True\\n if curr > target:\\n row -= 1\\n else:\\n col += 1\\n return False\",\n \"runtime\": \"133\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n for row in matrix:\\n if target in row:\\n return True\\n return False\\n \",\n \"runtime\": \"134\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n m,n=len(matrix),len(matrix[0])\\n row,col=0,n-1\\n while row<m and col>=0:\\n if matrix[row][col] == target:\\n return True\\n elif matrix[row][col] > target:\\n col-=1\\n else:\\n row+=1\\n return False\",\n \"runtime\": \"134\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n if not matrix or not matrix[0]:\\n return False\\n \\n # Start from the top right corner\\n row, col = 0, len(matrix[0]) - 1\\n \\n while row < len(matrix) and col >= 0:\\n if matrix[row][col] == target:\\n return True\\n elif matrix[row][col] < target:\\n row += 1 # Move down\\n else:\\n col -= 1 # Move left\\n \\n return False\",\n \"runtime\": \"135\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n rows=len(matrix)\\n col=len(matrix[0])\\n rowindex=0\\n colindex=col-1\\n\\n while rowindex<rows and colindex>=0:\\n element=matrix[rowindex][colindex]\\n if element==target:\\n return 1\\n elif element<target:\\n rowindex+=1\\n else:\\n colindex-=1\\n\\n return 0\\n \",\n \"runtime\": \"135\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n\\n #Brute Force\\n\\n # for i in range(len(matrix)):\\n # for j in range(len(matrix[0])):\\n # if(matrix[i][j]==target):\\n # return True\\n # else:\\n # return False\\n\\n #Better\\n\\n\\n # for sub_matrix in matrix:\\n # d=self.search(sub_matrix,target)\\n # if(d==True):\\n # return True\\n # else:\\n # return False\\n\\n #Optimal\\n\\n i=0\\n j=len(matrix[0])-1\\n while(i<len(matrix) and j>=0):\\n if(target==matrix[i][j]):\\n return True\\n elif(target<matrix[i][j]):\\n d=self.search(matrix[i],target)\\n if(d==True):\\n return True\\n else:\\n i+=1\\n j-=1\\n else:\\n d=self.search_col(matrix,i,j,target)\\n if(d==True):\\n return True\\n else:\\n i+=1\\n j-=1\\n else:\\n return False\\n def search_col(self,matrix,i,j,target):\\n low=i\\n high=len(matrix)-1\\n while(low<=high):\\n mid=(low+high)//2\\n if(matrix[mid][j]==target):\\n return True\\n elif(matrix[mid][j]<target):\\n low=mid+1\\n else:\\n high=mid-1\\n else:\\n return False\\n def search(self,nums,target):\\n low=0\\n high=len(nums)-1\\n while(low<=high):\\n mid=(low+high)//2\\n if(nums[mid]==target):\\n return True\\n if(nums[mid]<target):\\n low=mid+1\\n else:\\n high=mid-1\\n return False\",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n r = 0\\n c = len(matrix[0])-1\\n\\n while c >= 0 and r <= len(matrix)-1:\\n if matrix[r][c] > target:\\n c-=1\\n elif matrix[r][c] < target:\\n r+=1\\n else:\\n return True\\n\\n\\n return False\",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n i = len(matrix)-1\\n j = 0\\n while i >= 0 and j < len(matrix[0]):\\n ##print(f'i:{i}, j:{j}, num:{matrix[i][j]}')\\n if target == matrix[i][j]:\\n return True\\n elif target > matrix[i][j]: ## skip column\\n j +=1\\n else:\\n i -=1\\n return False \\n \\n\\n \",\n \"runtime\": \"137\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n for r in matrix:\\n for c in r:\\n if c == target:\\n return True\\n\\n return False\",\n \"runtime\": \"137\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n n = len(matrix)\\n m = len(matrix[0])\\n row = 0\\n col = m - 1\\n while row < n and col >= 0:\\n if matrix[row][col] == target:\\n return True\\n elif matrix[row][col] < target:\\n row += 1\\n else:\\n col -= 1\\n return False\\n \",\n \"runtime\": \"138\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n height = len(matrix)\\n if height == 0:\\n return False\\n width = len(matrix[0])\\n if width == 0:\\n return False\\n\\n row = height - 1\\n col = 0\\n\\n while col < width and row >= 0: #while cursor is not past width and not past height\\n if matrix[row][col] > target:\\n row -= 1\\n elif matrix[row][col] < target:\\n col += 1\\n else:\\n return True\\n\\n return False\\n\",\n \"runtime\": \"138\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n ROWS, COLS = len(matrix), len(matrix[0])\\n\\n def bs(start, vertical):\\n lo = start\\n hi = ROWS - 1 if vertical else COLS - 1\\n\\n while lo <= hi:\\n mid = (hi + lo) // 2\\n if vertical:\\n if matrix[mid][start] < target:\\n lo = mid + 1\\n elif matrix[mid][start] > target:\\n hi = mid -1\\n else:\\n return True\\n else:\\n if matrix[start][mid] < target:\\n lo = mid + 1\\n elif matrix[start][mid] > target:\\n hi = mid -1\\n else:\\n return True\\n return False\\n \\n for i in range(min(ROWS, COLS)):\\n left = bs(i, True)\\n right = bs(i, False)\\n\\n if left or right:\\n return True\\n return False\",\n \"runtime\": \"139\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n m, n = len(matrix), len(matrix[0])\\n row = 0\\n col = n - 1\\n while row < m and col >= 0:\\n if matrix[row][col] == target:\\n return True\\n elif matrix[row][col] > target:\\n col -= 1\\n else:\\n row += 1\\n return False\\n\\n \",\n \"runtime\": \"139\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, mat: List[List[int]], target: int) -> bool:\\n \\n m=len(mat)\\n n=len(mat[0])\\n \\n for i in range(m):\\n if mat[i][0]<=target and mat[i][-1]>=target:\\n lo=0\\n hi=n\\n while (lo<=hi):\\n mid=(lo+hi)//2\\n \\n if mat[i][mid]==target:\\n return True\\n elif mat[i][mid]<target:\\n lo = mid + 1\\n else:\\n hi = mid - 1\\n \\n return False\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n cols = len(matrix[0]) - 1\\n right = cols\\n for i in range(len(matrix)):\\n left = 0\\n while left <= right:\\n middle = (left + right) // 2\\n if matrix[i][middle] == target:\\n return True\\n elif matrix[i][middle] < target:\\n left = middle + 1\\n else:\\n right = middle - 1\\n right = right + 1 if right < cols else cols\\n return False \\n\\n\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n def binary_search(start, column):\\n low = start\\n high = n - 1 if column else m - 1\\n while low <= high:\\n mid = (low + high) // 2\\n if column:\\n if matrix[start][mid] < target:\\n low = mid + 1\\n elif matrix[start][mid] > target:\\n high = mid - 1\\n else:\\n return True\\n else:\\n if matrix[mid][start] < target:\\n low = mid + 1\\n elif matrix[mid][start] > target:\\n high = mid - 1\\n else:\\n return True\\n return False\\n\\n if not matrix: return False\\n m, n = len(matrix), len(matrix[0])\\n for i in range(min(m, n)):\\n col_found = binary_search(i, True)\\n row_found = binary_search(i, False)\\n if col_found or row_found:\\n return True\\n return False\",\n \"runtime\": \"141\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n for i in matrix:\\n if target in i:\\n a = True\\n break\\n else:\\n a = False\\n \\n return a\\n \",\n \"runtime\": \"141\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n i, j = 0, len(matrix[0])-1\\n while i < len(matrix) and j >= 0 :\\n if matrix[i][j] == target :\\n return True\\n elif matrix[i][j] < target :\\n i += 1\\n else :\\n j -= 1\\n return False\",\n \"runtime\": \"142\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n def binarySearch(area, left: int, right: int, target):\\n if left > right:\\n return False\\n \\n mid = abs(right + left) // 2\\n \\n if area[mid] == target:\\n return True\\n elif target > area[mid]:\\n left = mid+1\\n else:\\n right = mid-1\\n \\n return binarySearch(area, left, right, target)\\n for i in matrix:\\n if binarySearch(i, 0, len(i) - 1, target):\\n return True\\n \\n return False\",\n \"runtime\": \"142\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n n=len(matrix)\\n m=len(matrix[0])\\n row=0\\n col=m-1\\n while(row<n and col>=0):\\n if matrix[row][col]==target:\\n return True\\n elif matrix[row][col]>target:\\n col-=1\\n else:\\n row+=1\\n return False\\n\\n \",\n \"runtime\": \"143\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n for i in matrix:\\n if target in i: return True\\n return False\\n \",\n \"runtime\": \"143\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n for row in matrix:\\n l=0;r=len(row)-1\\n while l<=r:\\n m = (l+r)//2\\n if row[m]==target:\\n return True\\n elif row[m] > target:\\n r = m-1\\n else:\\n l = m+1\\n return False \",\n \"runtime\": \"144\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n n = len(matrix)\\n m = len(matrix[0])\\n row = 0\\n col = m - 1\\n while(row < n and col >= 0):\\n if(matrix[row][col] == target):\\n return True\\n elif (matrix[row][col] < target):\\n row += 1\\n else:\\n col -= 1\\n return False\",\n \"runtime\": \"145\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n def binary_search(maxtrix, left, right, top, bottom, target):\\n if left > right or top > bottom:\\n return False\\n\\n mid = ((top + bottom) // 2, (left + right) // 2)\\n\\n cur = matrix[mid[0]][mid[1]] \\n\\n if cur == target:\\n return True\\n elif cur > target:\\n return binary_search(matrix, left, mid[1] - 1, top, bottom, target) or binary_search(matrix, left, right, top, mid[0] - 1, target)\\n else:\\n return binary_search(matrix, mid[1] + 1, right, top, bottom, target) or binary_search(matrix, left, right, mid[0] + 1, bottom, target)\\n\\n return binary_search(matrix, 0, len(matrix[0]) - 1, 0, len(matrix) - 1, target)\\n \",\n \"runtime\": \"145\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n \\n def searchRange(left, up, right, down):\\n if left > right or up > down:\\n return False\\n \\n mid = (left + right) // 2\\n \\n row = up\\n while row <= down and matrix[row][mid] <= target:\\n if matrix[row][mid] == target:\\n return True\\n row += 1\\n \\n return searchRange(left, row, mid - 1, down) or searchRange(mid + 1, up, right, row - 1)\\n \\n return searchRange(0, 0, len(matrix[0]) - 1, len(matrix) - 1)\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n # almost similar to the part1 we can try brute and better approach but that's \\n # not optimal\\n # one observation is that rows and cols are sorted so if we are standing at\\n # 0,0 then it's right and bottom is sorted so we can't decide which side to \\n # eliminate, simillarly if we are standing at the m,n then it's left and top\\n # are decreasing so we can not decide which side to eliminate\\n # so only coardinate left is 0,n and m,0 we can start any of this cell check\\n # if cell value < target that means we can't get the target on that row because\\n # it's already sorted to go to the next row and if the cell value is > target\\n # then we can't move in that col because all the element in that col will be\\n # higher since it's sorted so decrease the col\\n\\n ROWS = len(matrix)\\n COLS = len(matrix[0])\\n\\n r = 0\\n c = COLS - 1\\n while r < ROWS and c >= 0:\\n if matrix[r][c] == target:\\n # we can also return the coordinate as well \\n return True\\n elif matrix[r][c] < target: # move to the next row\\n r += 1\\n else:\\n c -= 1\\n\\n return False\\n \",\n \"runtime\": \"147\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n i = 0\\n if matrix[i][-1] < target:\\n i += 1\\n for j in range(0, len(matrix[0])):\\n k = i\\n while k < len(matrix) and matrix[k][j] <= target:\\n if matrix[k][j] == target:\\n return True\\n else:\\n k += 1\\n return False\",\n \"runtime\": \"147\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n height = len(matrix)\\n if height == 0:\\n return False\\n width = len(matrix[0])\\n if width == 0:\\n return False\\n\\n row = height - 1\\n col = 0\\n\\n while col < width and row >= 0: #while cursor is not past width and not past height\\n if matrix[row][col] > target:\\n row -= 1\\n elif matrix[row][col] < target:\\n col += 1\\n else:\\n return True\\n\\n return False\\n\",\n \"runtime\": \"148\"\n },\n {\n \"code\": \"import bisect\\nclass Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n for row in matrix:\\n ind = bisect.bisect_left(row, target)\\n if ind < len(row) and row[ind] == target: return True\\n return False\",\n \"runtime\": \"148\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n n=len(matrix)\\n m=len(matrix[0])\\n left=0\\n right=m-1\\n while(left<n and right>=0):\\n point=matrix[left][right]\\n if point==target:\\n return True\\n elif target<point:\\n right-=1\\n else:\\n left+=1\\n return False\\n \",\n \"runtime\": \"149\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n\\n m = len(matrix)\\n n = len(matrix[0])\\n\\n row = 0\\n col = n - 1\\n\\n while row < m and col >= 0:\\n curr = matrix[row][col]\\n if target == curr:\\n return True\\n elif target > curr:\\n row += 1\\n elif target < curr:\\n col -= 1\\n \\n return False\\n \",\n \"runtime\": \"149\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n if not matrix or not matrix[0]:\\n return False\\n rows=len(matrix)\\n cols=len(matrix[0])\\n row,col=0,cols-1\\n while row<rows and col>=0:\\n if matrix[row][col]==target:\\n return True\\n elif matrix[row][col]>target:\\n col-=1\\n else:\\n row+=1\\n return False\\n \",\n \"runtime\": \"150\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":57,"string":"57"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n m, n = len(matrix), len(matrix[0])\n \n for row in matrix:\n if row[0] <= target <= row[-1]:\n left, right = 0, n - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if row[mid] == target:\n return 'true'\n elif row[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return 'false'\n\nwith open(\"user.out\", \"w\") as f:\n inputs = map(loads, stdin)\n for nums in inputs:\n print(Solution().searchMatrix(nums, next(inputs)),file=f)\nexit(0)","memory":"20500"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n # remove out of range rows\n for i in range(len(matrix) - 1, -1, -1):\n if not (matrix[i][0] <= target <= matrix[i][-1]):\n del matrix[i]\n \n # remove out of range columns\n if matrix:\n for i in range(len(matrix[0]) - 1, -1, -1):\n if not (matrix[0][i] <= target <= matrix[-1][i]):\n for row in matrix:\n del row[i]\n\n if matrix:\n for row in matrix:\n for elem in row:\n if elem == target:\n return True\n \n return False\n ","memory":"21400"},{"code":"from typing import List\ndef searchMatrix(matrix: List[List[int]], target: int) -> bool:\n n = len(matrix)\n m = len(matrix[0])\n\n i = 0\n j = m - 1\n\n while (i < n and j >= 0):\n if matrix[i][j] == target:\n return \"true\"\n if matrix[i][j] > target:\n j -= 1\n else:\n i += 1\n \n return \"false\"\n\nwith open('user.out', 'w') as f:\n inputs = list(map(loads, stdin))\n for matrix, target in zip(inputs[::2], inputs[1::2]):\n f.write(f\"{searchMatrix(matrix, target)}\\n\")\nexit(0)","memory":"21500"},{"code":"\ndef searchMatrix(matrix: List[List[int]], target: int) -> bool:\n r = len(matrix)\n c = len(matrix[0])\n\n # we search rows\n for row in matrix:\n if row[0] <= target and row[-1] >= target:\n # bin search\n l = 0\n r = c\n\n while l < r:\n m = (r + l) // 2\n\n if row[m] == target:\n return 'true'\n \n if row[m] < target:\n l = m + 1\n \n if row[m] > target:\n r = m\n \n return 'false'\n\nwith open('user.out', 'w') as f:\n inputs = list(map(loads, stdin))\n for matrix, target in zip(inputs[::2], inputs[1::2]):\n f.write(f\"{searchMatrix(matrix, target)}\\n\")\nexit(0)","memory":"21600"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n # As the rows are sorted -> matrix[i][j] < matrix[i][j+1]\n # As the columns are sorted -> matrix[i][j] >matrix[i-1][j] \n \"\"\"\n So we start searching from BOTTOM_LEFT:\n if element found -> return TRUE\n if matrix[i][j] > target -> move UP.\n if matrix[i][j] < target -> move RIGHT.\n \"\"\"\n m, n = len(matrix), len(matrix[0])\n i = m - 1\n j = 0\n while i >= 0 and j < n:\n if matrix[i][j] == target:\n return True\n elif matrix[i][j] < target:\n j += 1\n else:\n i -= 1\n return False\n\n \n\n\n ","memory":"22400"},{"code":"class Solution:\n def binarySearch(self, matrix, target, start, vertical):\n lo = start\n hi = len(matrix[0]) - 1 if vertical else len(matrix) - 1\n\n while hi >= lo:\n mid = (lo + hi) // 2\n if vertical:\n if matrix[start][mid] < target:\n lo = mid + 1\n elif matrix[start][mid] > target:\n hi = mid - 1\n else:\n return True\n else:\n if matrix[mid][start] < target:\n lo = mid + 1\n elif matrix[mid][start] > target:\n hi = mid - 1\n else:\n return True\n return False\n\n def searchMatrix(self, matrix, target):\n if not matrix or not matrix[0]:\n return False\n\n shorterDim = min(len(matrix), len(matrix[0]))\n for i in range(shorterDim):\n if self.binarySearch(matrix, target, i, True) or self.binarySearch(matrix, target, i, False):\n return True\n return False\n","memory":"22500"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n if not matrix or not matrix[0]:\n return False\n\n m = len(matrix)\n n = len(matrix[0])\n if not (1<= m <= 300) or not (1 <= n <=300):\n return False \n\n row = 0\n col = n-1 \n\n while row < m and col >= 0:\n current_value = matrix[row][col]\n\n if current_value == target:\n return True \n elif current_value < target:\n row += 1\n else:\n col -= 1\n \n return False \n\n\n\n ","memory":"22600"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n row = 0\n col = len(matrix[0]) - 1\n while row <=len(matrix)-1 and col >=0:\n if matrix[row][col] == target:\n return True\n elif matrix[row][col] > target:\n col -= 1\n else:\n row += 1\n return False\n ","memory":"22600"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n for i in range(len(matrix)):\n start = 0\n end = len(matrix[i]) - 1\n while start <= end:\n mid = start + ((end - start)//2)\n \n if target > matrix[i][mid]:\n start = mid + 1\n elif target < matrix[i][mid]:\n end = mid - 1\n else:\n return True\n \n return False","memory":"22700"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n \n for i in range(len(matrix)):\n row=matrix[i]\n start=0\n end=len(row)-1\n if row[start]==target:\n return True\n if row[end]==target:\n return True\n if row[start]>target or row[end]<target:\n continue\n\n while start<=end:\n mid=start+(end-start)//2\n\n if row[mid]==target:\n return True\n elif row[mid]>target:\n end=mid-1\n else:\n start=mid+1\n \n return False","memory":"22700"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n def binary_search(start, column):\n low = start\n high = n - 1 if column else m - 1\n while low <= high:\n mid = (low + high) // 2\n if column:\n if matrix[start][mid] < target:\n low = mid + 1\n elif matrix[start][mid] > target:\n high = mid - 1\n else:\n return True\n else:\n if matrix[mid][start] < target:\n low = mid + 1\n elif matrix[mid][start] > target:\n high = mid - 1\n else:\n return True\n return False\n\n if not matrix: return False\n m, n = len(matrix), len(matrix[0])\n for i in range(min(m, n)):\n col_found = binary_search(i, True)\n row_found = binary_search(i, False)\n if col_found or row_found:\n return True\n return False","memory":"22800"},{"code":"class Solution:\n def searchMatrix(self, mat: List[List[int]], target: int) -> bool:\n \n m=len(mat)\n n=len(mat[0])\n \n for i in range(m):\n if mat[i][0]<=target and mat[i][-1]>=target:\n lo=0\n hi=n\n while (lo<=hi):\n mid=(lo+hi)//2\n \n if mat[i][mid]==target:\n return True\n elif mat[i][mid]<target:\n lo = mid + 1\n else:\n hi = mid - 1\n \n return False","memory":"22800"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n for row in matrix:\n n = len(row)\n low, high = 0, n-1\n\n while low<=high:\n mid = low + (high-low)//2\n\n if row[mid] == target:\n return True \n elif row[mid] < target:\n low = mid+1\n elif row[mid] > target:\n high = mid - 1\n return False","memory":"22900"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n\n #Brute Force\n\n # for i in range(len(matrix)):\n # for j in range(len(matrix[0])):\n # if(matrix[i][j]==target):\n # return True\n # else:\n # return False\n\n #Better\n\n\n # for sub_matrix in matrix:\n # d=self.search(sub_matrix,target)\n # if(d==True):\n # return True\n # else:\n # return False\n\n #Optimal\n\n i=0\n j=len(matrix[0])-1\n while(i<len(matrix) and j>=0):\n if(target==matrix[i][j]):\n return True\n elif(target<matrix[i][j]):\n d=self.search(matrix[i],target)\n if(d==True):\n return True\n else:\n i+=1\n j-=1\n else:\n d=self.search_col(matrix,i,j,target)\n if(d==True):\n return True\n else:\n i+=1\n j-=1\n else:\n return False\n def search_col(self,matrix,i,j,target):\n low=i\n high=len(matrix)-1\n while(low<=high):\n mid=(low+high)//2\n if(matrix[mid][j]==target):\n return True\n elif(matrix[mid][j]<target):\n low=mid+1\n else:\n high=mid-1\n else:\n return False\n def search(self,nums,target):\n low=0\n high=len(nums)-1\n while(low<=high):\n mid=(low+high)//2\n if(nums[mid]==target):\n return True\n if(nums[mid]<target):\n low=mid+1\n else:\n high=mid-1\n return False","memory":"22900"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n def binarySearch(area, left: int, right: int, target):\n if left > right:\n return False\n \n mid = abs(right + left) // 2\n \n if area[mid] == target:\n return True\n elif target > area[mid]:\n left = mid+1\n else:\n right = mid-1\n \n return binarySearch(area, left, right, target)\n for i in matrix:\n if binarySearch(i, 0, len(i) - 1, target):\n return True\n \n return False","memory":"23000"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n n=len(matrix)\n m=len(matrix[0])\n row=0\n col=m-1\n while(row<n and col>=0):\n if matrix[row][col]==target:\n return True\n elif matrix[row][col]>target:\n col-=1\n else:\n row+=1\n return False\n\n ","memory":"23000"},{"code":"class Solution:\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n # start with brute force approach -\n # say we're looking for 5: \n # 1. starting from 0, 0, go right as far as number < target\n # 2. then, go down as far as number < target\n # 3. our ans\n # Try another number - 13\n # 1. go to 11\n # 2. end at 12\n # 3. go left to 8, then down to 9\n # 4. go left to 6, then down to 13\n # binary search can speed up the intial process, but maybe not get us to solution\n # another idea - what if we use two pointers to start\n # max possible on top and side\n # then, go down/left depending on if greater/smaller/equal to target\n # ex: 5\n # 4 and 3\n # go down from 4 - 5 is there\n # ex: 13\n # 11 and 10\n # second pointer doesn't seem to contribute much\n # unless... maybe it gives us the row/col we need\n # and we can bin search to opitimize\n # fails with 16 \n # lets code the trickle down approach\n\n\n\n x, y = 0, 0\n if matrix[x][y] == target:\n return True\n # optimize with bin search later\n # iterate along first row until greatest < target (or == target)\n while matrix[x][y] < target and x < len(matrix) - 1:\n print(x, y)\n x += 1\n print(x, y)\n if matrix[x][y] == target:\n return True\n y += 1\n while True:\n if x < 0 or y >= len(matrix[0]):\n return False\n elif matrix[x][y] == target:\n return True\n elif matrix[x][y] > target:\n x -= 1\n elif matrix[x][y] < target:\n y += 1\n return False\n \n \n","memory":"23100"}],"string":"[\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n m, n = len(matrix), len(matrix[0])\\n \\n for row in matrix:\\n if row[0] <= target <= row[-1]:\\n left, right = 0, n - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if row[mid] == target:\\n return 'true'\\n elif row[mid] < target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n return 'false'\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n inputs = map(loads, stdin)\\n for nums in inputs:\\n print(Solution().searchMatrix(nums, next(inputs)),file=f)\\nexit(0)\",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n # remove out of range rows\\n for i in range(len(matrix) - 1, -1, -1):\\n if not (matrix[i][0] <= target <= matrix[i][-1]):\\n del matrix[i]\\n \\n # remove out of range columns\\n if matrix:\\n for i in range(len(matrix[0]) - 1, -1, -1):\\n if not (matrix[0][i] <= target <= matrix[-1][i]):\\n for row in matrix:\\n del row[i]\\n\\n if matrix:\\n for row in matrix:\\n for elem in row:\\n if elem == target:\\n return True\\n \\n return False\\n \",\n \"memory\": \"21400\"\n },\n {\n \"code\": \"from typing import List\\ndef searchMatrix(matrix: List[List[int]], target: int) -> bool:\\n n = len(matrix)\\n m = len(matrix[0])\\n\\n i = 0\\n j = m - 1\\n\\n while (i < n and j >= 0):\\n if matrix[i][j] == target:\\n return \\\"true\\\"\\n if matrix[i][j] > target:\\n j -= 1\\n else:\\n i += 1\\n \\n return \\\"false\\\"\\n\\nwith open('user.out', 'w') as f:\\n inputs = list(map(loads, stdin))\\n for matrix, target in zip(inputs[::2], inputs[1::2]):\\n f.write(f\\\"{searchMatrix(matrix, target)}\\\\n\\\")\\nexit(0)\",\n \"memory\": \"21500\"\n },\n {\n \"code\": \"\\ndef searchMatrix(matrix: List[List[int]], target: int) -> bool:\\n r = len(matrix)\\n c = len(matrix[0])\\n\\n # we search rows\\n for row in matrix:\\n if row[0] <= target and row[-1] >= target:\\n # bin search\\n l = 0\\n r = c\\n\\n while l < r:\\n m = (r + l) // 2\\n\\n if row[m] == target:\\n return 'true'\\n \\n if row[m] < target:\\n l = m + 1\\n \\n if row[m] > target:\\n r = m\\n \\n return 'false'\\n\\nwith open('user.out', 'w') as f:\\n inputs = list(map(loads, stdin))\\n for matrix, target in zip(inputs[::2], inputs[1::2]):\\n f.write(f\\\"{searchMatrix(matrix, target)}\\\\n\\\")\\nexit(0)\",\n \"memory\": \"21600\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n # As the rows are sorted -> matrix[i][j] < matrix[i][j+1]\\n # As the columns are sorted -> matrix[i][j] >matrix[i-1][j] \\n \\\"\\\"\\\"\\n So we start searching from BOTTOM_LEFT:\\n if element found -> return TRUE\\n if matrix[i][j] > target -> move UP.\\n if matrix[i][j] < target -> move RIGHT.\\n \\\"\\\"\\\"\\n m, n = len(matrix), len(matrix[0])\\n i = m - 1\\n j = 0\\n while i >= 0 and j < n:\\n if matrix[i][j] == target:\\n return True\\n elif matrix[i][j] < target:\\n j += 1\\n else:\\n i -= 1\\n return False\\n\\n \\n\\n\\n \",\n \"memory\": \"22400\"\n },\n {\n \"code\": \"class Solution:\\n def binarySearch(self, matrix, target, start, vertical):\\n lo = start\\n hi = len(matrix[0]) - 1 if vertical else len(matrix) - 1\\n\\n while hi >= lo:\\n mid = (lo + hi) // 2\\n if vertical:\\n if matrix[start][mid] < target:\\n lo = mid + 1\\n elif matrix[start][mid] > target:\\n hi = mid - 1\\n else:\\n return True\\n else:\\n if matrix[mid][start] < target:\\n lo = mid + 1\\n elif matrix[mid][start] > target:\\n hi = mid - 1\\n else:\\n return True\\n return False\\n\\n def searchMatrix(self, matrix, target):\\n if not matrix or not matrix[0]:\\n return False\\n\\n shorterDim = min(len(matrix), len(matrix[0]))\\n for i in range(shorterDim):\\n if self.binarySearch(matrix, target, i, True) or self.binarySearch(matrix, target, i, False):\\n return True\\n return False\\n\",\n \"memory\": \"22500\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n if not matrix or not matrix[0]:\\n return False\\n\\n m = len(matrix)\\n n = len(matrix[0])\\n if not (1<= m <= 300) or not (1 <= n <=300):\\n return False \\n\\n row = 0\\n col = n-1 \\n\\n while row < m and col >= 0:\\n current_value = matrix[row][col]\\n\\n if current_value == target:\\n return True \\n elif current_value < target:\\n row += 1\\n else:\\n col -= 1\\n \\n return False \\n\\n\\n\\n \",\n \"memory\": \"22600\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n row = 0\\n col = len(matrix[0]) - 1\\n while row <=len(matrix)-1 and col >=0:\\n if matrix[row][col] == target:\\n return True\\n elif matrix[row][col] > target:\\n col -= 1\\n else:\\n row += 1\\n return False\\n \",\n \"memory\": \"22600\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n for i in range(len(matrix)):\\n start = 0\\n end = len(matrix[i]) - 1\\n while start <= end:\\n mid = start + ((end - start)//2)\\n \\n if target > matrix[i][mid]:\\n start = mid + 1\\n elif target < matrix[i][mid]:\\n end = mid - 1\\n else:\\n return True\\n \\n return False\",\n \"memory\": \"22700\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n \\n for i in range(len(matrix)):\\n row=matrix[i]\\n start=0\\n end=len(row)-1\\n if row[start]==target:\\n return True\\n if row[end]==target:\\n return True\\n if row[start]>target or row[end]<target:\\n continue\\n\\n while start<=end:\\n mid=start+(end-start)//2\\n\\n if row[mid]==target:\\n return True\\n elif row[mid]>target:\\n end=mid-1\\n else:\\n start=mid+1\\n \\n return False\",\n \"memory\": \"22700\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n def binary_search(start, column):\\n low = start\\n high = n - 1 if column else m - 1\\n while low <= high:\\n mid = (low + high) // 2\\n if column:\\n if matrix[start][mid] < target:\\n low = mid + 1\\n elif matrix[start][mid] > target:\\n high = mid - 1\\n else:\\n return True\\n else:\\n if matrix[mid][start] < target:\\n low = mid + 1\\n elif matrix[mid][start] > target:\\n high = mid - 1\\n else:\\n return True\\n return False\\n\\n if not matrix: return False\\n m, n = len(matrix), len(matrix[0])\\n for i in range(min(m, n)):\\n col_found = binary_search(i, True)\\n row_found = binary_search(i, False)\\n if col_found or row_found:\\n return True\\n return False\",\n \"memory\": \"22800\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, mat: List[List[int]], target: int) -> bool:\\n \\n m=len(mat)\\n n=len(mat[0])\\n \\n for i in range(m):\\n if mat[i][0]<=target and mat[i][-1]>=target:\\n lo=0\\n hi=n\\n while (lo<=hi):\\n mid=(lo+hi)//2\\n \\n if mat[i][mid]==target:\\n return True\\n elif mat[i][mid]<target:\\n lo = mid + 1\\n else:\\n hi = mid - 1\\n \\n return False\",\n \"memory\": \"22800\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n for row in matrix:\\n n = len(row)\\n low, high = 0, n-1\\n\\n while low<=high:\\n mid = low + (high-low)//2\\n\\n if row[mid] == target:\\n return True \\n elif row[mid] < target:\\n low = mid+1\\n elif row[mid] > target:\\n high = mid - 1\\n return False\",\n \"memory\": \"22900\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n\\n #Brute Force\\n\\n # for i in range(len(matrix)):\\n # for j in range(len(matrix[0])):\\n # if(matrix[i][j]==target):\\n # return True\\n # else:\\n # return False\\n\\n #Better\\n\\n\\n # for sub_matrix in matrix:\\n # d=self.search(sub_matrix,target)\\n # if(d==True):\\n # return True\\n # else:\\n # return False\\n\\n #Optimal\\n\\n i=0\\n j=len(matrix[0])-1\\n while(i<len(matrix) and j>=0):\\n if(target==matrix[i][j]):\\n return True\\n elif(target<matrix[i][j]):\\n d=self.search(matrix[i],target)\\n if(d==True):\\n return True\\n else:\\n i+=1\\n j-=1\\n else:\\n d=self.search_col(matrix,i,j,target)\\n if(d==True):\\n return True\\n else:\\n i+=1\\n j-=1\\n else:\\n return False\\n def search_col(self,matrix,i,j,target):\\n low=i\\n high=len(matrix)-1\\n while(low<=high):\\n mid=(low+high)//2\\n if(matrix[mid][j]==target):\\n return True\\n elif(matrix[mid][j]<target):\\n low=mid+1\\n else:\\n high=mid-1\\n else:\\n return False\\n def search(self,nums,target):\\n low=0\\n high=len(nums)-1\\n while(low<=high):\\n mid=(low+high)//2\\n if(nums[mid]==target):\\n return True\\n if(nums[mid]<target):\\n low=mid+1\\n else:\\n high=mid-1\\n return False\",\n \"memory\": \"22900\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n def binarySearch(area, left: int, right: int, target):\\n if left > right:\\n return False\\n \\n mid = abs(right + left) // 2\\n \\n if area[mid] == target:\\n return True\\n elif target > area[mid]:\\n left = mid+1\\n else:\\n right = mid-1\\n \\n return binarySearch(area, left, right, target)\\n for i in matrix:\\n if binarySearch(i, 0, len(i) - 1, target):\\n return True\\n \\n return False\",\n \"memory\": \"23000\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n n=len(matrix)\\n m=len(matrix[0])\\n row=0\\n col=m-1\\n while(row<n and col>=0):\\n if matrix[row][col]==target:\\n return True\\n elif matrix[row][col]>target:\\n col-=1\\n else:\\n row+=1\\n return False\\n\\n \",\n \"memory\": \"23000\"\n },\n {\n \"code\": \"class Solution:\\n def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\\n # start with brute force approach -\\n # say we're looking for 5: \\n # 1. starting from 0, 0, go right as far as number < target\\n # 2. then, go down as far as number < target\\n # 3. our ans\\n # Try another number - 13\\n # 1. go to 11\\n # 2. end at 12\\n # 3. go left to 8, then down to 9\\n # 4. go left to 6, then down to 13\\n # binary search can speed up the intial process, but maybe not get us to solution\\n # another idea - what if we use two pointers to start\\n # max possible on top and side\\n # then, go down/left depending on if greater/smaller/equal to target\\n # ex: 5\\n # 4 and 3\\n # go down from 4 - 5 is there\\n # ex: 13\\n # 11 and 10\\n # second pointer doesn't seem to contribute much\\n # unless... maybe it gives us the row/col we need\\n # and we can bin search to opitimize\\n # fails with 16 \\n # lets code the trickle down approach\\n\\n\\n\\n x, y = 0, 0\\n if matrix[x][y] == target:\\n return True\\n # optimize with bin search later\\n # iterate along first row until greatest < target (or == target)\\n while matrix[x][y] < target and x < len(matrix) - 1:\\n print(x, y)\\n x += 1\\n print(x, y)\\n if matrix[x][y] == target:\\n return True\\n y += 1\\n while True:\\n if x < 0 or y >= len(matrix[0]):\\n return False\\n elif matrix[x][y] == target:\\n return True\\n elif matrix[x][y] > target:\\n x -= 1\\n elif matrix[x][y] < target:\\n y += 1\\n return False\\n \\n \\n\",\n \"memory\": \"23100\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":17,"string":"17"}}},{"rowIdx":65,"cells":{"question_id":{"kind":"number","value":241,"string":"241"},"name":{"kind":"string","value":"different-ways-to-add-parentheses"},"content":{"kind":"string","value":"<p>Given a string <code>expression</code> of numbers and operators, return <em>all possible results from computing all the different possible ways to group numbers and operators</em>. You may return the answer in <strong>any order</strong>.</p>\n\n<p>The test cases are generated such that the output values fit in a 32-bit integer and the number of different results does not exceed <code>10<sup>4</sup></code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> expression = "2-1-1"\n<strong>Output:</strong> [0,2]\n<strong>Explanation:</strong>\n((2-1)-1) = 0 \n(2-(1-1)) = 2\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> expression = "2*3-4*5"\n<strong>Output:</strong> [-34,-14,-10,-10,10]\n<strong>Explanation:</strong>\n(2*(3-(4*5))) = -34 \n((2*3)-(4*5)) = -14 \n((2*(3-4))*5) = -10 \n(2*((3-4)*5)) = -10 \n(((2*3)-4)*5) = 10\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= expression.length <= 20</code></li>\n\t<li><code>expression</code> consists of digits and the operator <code>'+'</code>, <code>'-'</code>, and <code>'*'</code>.</li>\n\t<li>All the integer values in the input expression are in the range <code>[0, 99]</code>.</li>\n</ul>\n"},"acRate":{"kind":"number","value":66.2845017881894,"string":"66.284502"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["math","string","dynamic-programming","recursion","memoization"],"string":"[\n \"math\",\n \"string\",\n \"dynamic-programming\",\n \"recursion\",\n \"memoization\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"18\", 0.1313], [\"21\", 0.3283], [\"22\", 0.394], [\"23\", 0.3283], [\"24\", 0.4596], [\"25\", 0.2626], [\"26\", 0.9192], [\"27\", 1.1819], [\"28\", 1.1819], [\"29\", 1.0506], [\"30\", 3.283], [\"31\", 3.7426], [\"32\", 2.8234], [\"33\", 3.8083], [\"34\", 4.9245], [\"35\", 5.5811], [\"36\", 6.6973], [\"37\", 4.9902], [\"38\", 6.566], [\"39\", 6.6973], [\"40\", 6.5003], [\"41\", 5.3841], [\"42\", 5.8437], [\"43\", 4.0709], [\"44\", 3.8739], [\"45\", 2.2981], [\"46\", 1.6415], [\"47\", 0.9849], [\"48\", 0.8536], [\"49\", 0.4596], [\"50\", 0.9849], [\"51\", 0.5253], [\"52\", 0.5253], [\"53\", 0.1313], [\"54\", 0.3283], [\"55\", 0.2626], [\"56\", 0.3283], [\"57\", 0.2626], [\"58\", 0.0657], [\"59\", 0.0657], [\"60\", 0.1313], [\"61\", 0.1313], [\"62\", 0.0657], [\"63\", 0.394], [\"64\", 0.2626], [\"65\", 0.3283], [\"66\", 0.6566], [\"67\", 0.3283], [\"68\", 0.4596], [\"69\", 0.4596], [\"70\", 0.5909], [\"71\", 0.394]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16300\", 0.1313], [\"16400\", 0.9849], [\"16500\", 8.2075], [\"16600\", 22.981], [\"16700\", 40.1182], [\"16800\", 19.501]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n\n @cache\n def dfs(expr):\n if len(expr) == 0:\n return []\n \n if expr.isnumeric():\n return [int(expr)]\n\n result = []\n for i, c in enumerate(expr):\n if c.isdigit():\n continue\n left_result = dfs(expr[:i])\n right_result = dfs(expr[i+1:])\n\n for lr in left_result:\n for rl in right_result:\n match c:\n case '+':\n result.append(lr + rl)\n case '-':\n result.append(lr - rl)\n case '*':\n result.append(lr * rl)\n\n return result\n \n return dfs(expression)\n","runtime":"18"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n\n num = 0\n expression_split = []\n for c in expression: \n if c == '*' or c == '+' or c == '-':\n expression_split.append(num)\n expression_split.append(c)\n num = 0\n else:\n num = num * 10 + int(c)\n expression_split.append(num)\n bounds_to_ans = {}\n \n def calc_computation(start: int, end: int) -> list[int]:\n if start == end:\n return [expression_split[start]]\n if (start, end) in bounds_to_ans:\n return bounds_to_ans[(start, end)]\n\n ans = []\n for i in range(start + 1, end + 1, 2):\n left = calc_computation(start, i-1)\n right = calc_computation(i + 1, end)\n\n for l in left:\n for r in right:\n if expression_split[i] == '*':\n ans.append(l * r)\n elif expression_split[i] == '-':\n ans.append(l - r)\n elif expression_split[i] == '+':\n ans.append(l + r)\n else:\n print(\"This shouldn't print\")\n bounds_to_ans[(start, end)] = ans\n return ans\n \n return calc_computation(0, len(expression_split) - 1)\n\n# 0. len()\n# [2, '-', 1, '-', 1]\n\n# [0,0] and [2, 4]\n\n# [2, 4] = [2, 2] and [4, 4]\n\n\n\n","runtime":"21"},{"code":"class Solution:\n # Time: O()\n # Space: O(), where n = len(expression)\n def diffWaysToCompute(self, expression: str) -> List[int]:\n \n n = len(expression)\n\n # Top-down + memoization\n cache = {}\n def dfs(i, j) -> List[int]:\n # Evaluate the expression in expression[i:j] for every possible combination of numbers\n if (i, j) in cache:\n return cache[(i,j)]\n if i == j - 1 or i == j - 2:\n return [int(expression[i:j])]\n res = []\n for k in range(i, j):\n if expression[k] in '+*-':\n res_left = dfs(i, k)\n res_right = dfs(k+1, j)\n for rl in res_left:\n for rr in res_right:\n if expression[k] == '-':\n res.append(rl - rr)\n elif expression[k] == '+':\n res.append(rl + rr)\n else:\n res.append(rl * rr)\n cache[(i, j)] = res\n return res\n \n return dfs(0, n)\n","runtime":"21"},{"code":"class Solution:\n MAX_EXPRESSION_LENGTH = 20\n MAX_NUMBER = 99\n\n def diffWaysToCompute(self, expression: str) -> List[int]:\n expression_length = len(expression)\n result_table = [[[] for _ in range(expression_length)] for _ in range(expression_length)]\n\n numbers, operators = self.parse_expression(expression)\n \n # Initialize base cases (single numbers)\n for i in range(len(numbers)):\n result_table[i][i] = [numbers[i]]\n \n # Fill the result table\n for subexpr_length in range(2, len(numbers) + 1):\n for start in range(len(numbers) - subexpr_length + 1):\n end = start + subexpr_length - 1\n \n for split in range(start, end):\n op = operators[split]\n left_results = result_table[start][split]\n right_results = result_table[split + 1][end]\n \n self.combine_results(left_results, right_results, op, result_table[start][end])\n \n return result_table[0][len(numbers) - 1]\n\n def parse_expression(self, expression: str) -> tuple[List[int], List[str]]:\n numbers = []\n operators = []\n current_number = 0\n for c in expression:\n if c.isdigit():\n current_number = current_number * 10 + int(c)\n else:\n numbers.append(current_number)\n current_number = 0\n operators.append(c)\n numbers.append(current_number)\n return numbers, operators\n\n def combine_results(self, left_results: List[int], right_results: List[int], op: str, combined_results: List[int]):\n for left_value in left_results:\n for right_value in right_results:\n result = self.compute_operation(left_value, right_value, op)\n combined_results.append(result)\n\n def compute_operation(self, left: int, right: int, op: str) -> int:\n if op == '+':\n return left + right\n elif op == '-':\n return left - right\n elif op == '*':\n return left * right\n else:\n raise ValueError(f\"Invalid operator: {op}\")\n\n\n\n\n#kartikdevsharmaa","runtime":"22"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n dp = {}\n sym = [\"*\", \"+\", \"-\"]\n def calc(op1, op2, sym):\n if sym == \"*\":\n return op1 * op2\n if sym == \"+\":\n return op1 + op2\n if sym == \"-\":\n return op1 - op2\n def dfs(expr):\n if expr.isnumeric():\n dp[expr] = int(expr)\n return [int(expr)]\n if expr in dp:\n return dp[expr]\n\n all_mid = []\n for i in range(len(expr)):\n ch = expr[i]\n if ch in sym:\n left = dfs(expr[:i])\n right = dfs(expr[i+1:])\n # apply calculation to get combined results\n mid = []\n for j in range(len(left)):\n for k in range(len(right)):\n mid.append(calc(left[j], right[k], ch))\n all_mid.extend(mid)\n dp[expr] = all_mid\n return all_mid\n return dfs(expression)\n \n\n\n\n \n\n","runtime":"22"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n exp = [int(i) for i in re.split('[+\\-*]', expression)]\n op = re.split('[0-9]+', expression)\n o = {'+': lambda x, y: x + y, '-': lambda x, y: x - y, '*': lambda x, y: x * y}\n n = len(op)\n\n memo = {}\n def dfs(i, j):\n if i > j:\n return [exp[i - 1]]\n if i == j:\n return [o[op[i]](exp[i - 1], exp[i])]\n if (i, j) in memo:\n return memo[(i, j)]\n res = []\n for k in range(i, j + 1):\n res += [o[op[k]](x, y) for x in dfs(i, k - 1) for y in dfs(k + 1, j)]\n memo[(i, j)] = res\n return res\n return dfs(1, n - 2)\n","runtime":"23"},{"code":"from typing import List\n\nclass Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n memo = {}\n return self.compute(expression, memo)\n\n def compute(self, exp: str, memo: dict) -> List[int]:\n if exp in memo:\n return memo[exp]\n\n computed = []\n \n for i, ch in enumerate(exp):\n if ch in \"-*+\":\n left_compute = exp[:i]\n right_compute = exp[i+1:]\n \n left_exp = self.compute(left_compute, memo)\n right_exp = self.compute(right_compute, memo)\n \n for e1 in left_exp:\n for e2 in right_exp:\n computed.append(self.calculate(e1, e2, ch))\n \n if not computed:\n return [int(exp)]\n memo[exp] = computed\n return computed\n\n def calculate(self, x: int, y: int, ch: str) -> int:\n if ch == \"+\":\n return x + y\n elif ch == \"-\":\n return x - y\n else:\n return x * y\n","runtime":"24"},{"code":"class Solution:\n MAX_EXPRESSION_LENGTH = 20\n MAX_NUMBER = 99\n\n def diffWaysToCompute(self, expression: str) -> List[int]:\n expression_length = len(expression)\n result_table = [[[] for _ in range(expression_length)] for _ in range(expression_length)]\n\n numbers, operators = self.parse_expression(expression)\n \n # Initialize base cases (single numbers)\n for i in range(len(numbers)):\n result_table[i][i] = [numbers[i]]\n \n # Fill the result table\n for subexpr_length in range(2, len(numbers) + 1):\n for start in range(len(numbers) - subexpr_length + 1):\n end = start + subexpr_length - 1\n \n for split in range(start, end):\n op = operators[split]\n left_results = result_table[start][split]\n right_results = result_table[split + 1][end]\n \n self.combine_results(left_results, right_results, op, result_table[start][end])\n \n return result_table[0][len(numbers) - 1]\n\n def parse_expression(self, expression: str) -> tuple[List[int], List[str]]:\n numbers = []\n operators = []\n current_number = 0\n for c in expression:\n if c.isdigit():\n current_number = current_number * 10 + int(c)\n else:\n numbers.append(current_number)\n current_number = 0\n operators.append(c)\n numbers.append(current_number)\n return numbers, operators\n\n def combine_results(self, left_results: List[int], right_results: List[int], op: str, combined_results: List[int]):\n for left_value in left_results:\n for right_value in right_results:\n result = self.compute_operation(left_value, right_value, op)\n combined_results.append(result)\n\n def compute_operation(self, left: int, right: int, op: str) -> int:\n if op == '+':\n return left + right\n elif op == '-':\n return left - right\n elif op == '*':\n return left * right\n else:\n raise ValueError(f\"Invalid operator: {op}\")\n\n\n\n\n#kartikdevsharmaa","runtime":"25"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n @lru_cache(None)\n def compute(expr: str) -> List[int]:\n if expr.isdigit() or (expr[0] == '-' and expr[1:].isdigit()): # Check if expr is a number\n return [int(expr)]\n\n result = []\n\n for i, char in enumerate(expr):\n if char in '+-*':\n left_results = compute(expr[:i])\n right_results = compute(expr[i + 1:])\n \n for left in left_results:\n for right in right_results:\n if char == '+':\n result.append(left + right)\n elif char == '-':\n result.append(left - right)\n elif char == '*':\n result.append(left * right)\n\n return result\n \n return compute(expression)","runtime":"26"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n def compute(left: List[int], right: List[int], op: str) -> List[int]:\n results = []\n for l in left:\n for r in right:\n if op == '+':\n results.append(l + r)\n elif op == '-':\n results.append(l - r)\n elif op == '*':\n results.append(l * r)\n return results\n\n if expression.isdigit():\n return [int(expression)]\n\n results = []\n for i, char in enumerate(expression):\n if char in '+-*':\n left_expr = expression[:i]\n right_expr = expression[i+1:]\n left_results = self.diffWaysToCompute(left_expr)\n right_results = self.diffWaysToCompute(right_expr)\n results.extend(compute(left_results, right_results, char))\n \n return results\n","runtime":"27"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n results=[]\n if len(expression)==0:\n return results\n if len(expression)==1:\n return [int(expression)]\n if len(expression)==2 and expression[0].isdigit():\n return [int(expression)]\n for i,current_char in enumerate(expression):\n if current_char.isdigit():\n continue\n left_results=self.diffWaysToCompute(expression[:i])\n right_results=self.diffWaysToCompute(expression[i+1:])\n for left_val in left_results:\n for right_val in right_results:\n if current_char == \"+\":\n results.append(left_val + right_val)\n elif current_char == \"-\":\n results.append(left_val - right_val)\n elif current_char == \"*\":\n results.append(left_val * right_val)\n\n return results\n\n ","runtime":"28"},{"code":"class Solution:\n def parse(self, exp):\n ans = []\n prev = 0\n for i in range(len(exp)):\n s = exp[i]\n if s in ('+', '-', '*'):\n ans.append(int(exp[prev:i]))\n ans.append(s)\n prev = i + 1\n ans.append(int(exp[prev:]))\n return ans\n\n def dp(self, i, j):\n key = (i, j)\n if key in self.cache:\n return self.cache[key]\n ans = []\n if i == j:\n ans.append(self.p[i])\n else:\n for k in range(i + 1, j, 2):\n left = self.dp(i, k - 1)\n right = self.dp(k + 1, j)\n op = self.p[k]\n for a in left:\n for b in right:\n if op == '+':\n ans.append(a + b)\n elif op == '-':\n ans.append(a - b)\n else:\n ans.append(a * b)\n self.cache[key] = ans\n return ans\n\n def diffWaysToCompute(self, expression: str) -> List[int]:\n self.p = self.parse(expression)\n self.cache = {}\n return self.dp(0, len(self.p) - 1)","runtime":"29"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n nums, ops = [], []\n i = 0\n while i < len(expression):\n if expression[i].isdigit():\n num = 0\n while i < len(expression) and expression[i].isdigit():\n num = num * 10 + int(expression[i])\n i += 1\n nums.append(num)\n else:\n ops.append(expression[i])\n i += 1\n\n n = len(nums)\n dp = [[[] for _ in range(n)] for _ in range(n)]\n\n for i in range(n):\n dp[i][i] = [nums[i]]\n\n for length in range(2, n + 1):\n for i in range(n - length + 1):\n j = i + length - 1\n dp[i][j] = []\n for k in range(i, j):\n left_results = dp[i][k]\n right_results = dp[k + 1][j]\n operator = ops[k]\n\n for left in left_results:\n for right in right_results:\n if operator == '+':\n dp[i][j].append(left + right)\n elif operator == '-':\n dp[i][j].append(left - right)\n else:\n dp[i][j].append(left * right)\n\n return dp[0][n - 1]","runtime":"30"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n exp = [int(i) for i in re.split('[+\\-*]', expression)]\n op = re.split('[0-9]+', expression)\n o = {'+': lambda x, y: x + y, '-': lambda x, y: x - y, '*': lambda x, y: x * y}\n n = len(op)\n\n memo = {}\n def dfs(i, j):\n if i > j:\n return [exp[i - 1]]\n if i == j:\n return [o[op[i]](exp[i - 1], exp[i])]\n if (i, j) in memo:\n return memo[(i, j)]\n res = []\n for k in range(i, j + 1):\n res += [o[op[k]](x, y) for x in dfs(i, k - 1) for y in dfs(k + 1, j)]\n memo[(i, j)] = res\n return res\n return dfs(1, n - 2)","runtime":"31"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n ops = {\n '+': lambda a, b: a + b,\n '-': lambda a, b: a - b,\n '*': lambda a, b: a * b\n }\n cache = {}\n \n def calc(expr):\n if expr in cache:\n return cache[expr]\n \n if '+' not in expr and\\\n '-' not in expr and\\\n '*' not in expr:\n return [int(expr)]\n \n res = []\n for i, c in enumerate(expr):\n if c in '+-*':\n left_expr = calc(expr[:i])\n right_expr = calc(expr[i+1:])\n \n for l in left_expr:\n for r in right_expr:\n res.append(ops[c](l, r))\n cache[expr] = res\n return res\n \n \n return calc(expression)","runtime":"31"},{"code":"class Solution:\n def __init__(self):\n self.map = {}\n\n def diffWaysToCompute(self, expression: str) -> List[int]:\n if expression in self.map:\n return self.map[expression]\n result = []\n\n for i in range(len(expression)):\n ch = expression[i]\n if ch in '*+-':\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i+1:])\n for l in left:\n for r in right:\n if ch == \"+\":\n result.append(l+r)\n elif ch== '-':\n result.append(l-r)\n elif ch== '*':\n result.append(l*r)\n if not result:\n result.append(int(expression))\n \n self.map[expression] = result\n print(self.map)\n\n return result\n\n ","runtime":"32"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n def helper(e):\n if e.isnumeric():\n return [int(e)]\n ans=[]\n for i in range(len(e)):\n if e[i] in \"+-*\":\n left = helper(e[:i])\n right = helper(e[i+1:])\n for l in left:\n for r in right:\n if e[i]==\"+\":\n ans.append(l+r)\n elif e[i]==\"-\":\n ans.append(l-r)\n elif e[i]==\"*\":\n ans.append(l*r)\n return ans\n return helper(expression)\n","runtime":"33"},{"code":"class Solution:\n @cache\n def diffWaysToCompute(self, expression: str) -> List[int]:\n operators = set(list(\"+-*\"))\n # dp = [[0] * len(expression) for _ in range(len(expression))]\n res = []\n if len(expression) <= 2:\n return [int(expression)]\n for i in range(len(expression)):\n if expression[i] in operators:\n l = expression[:i]\n r = expression[i + 1:]\n l_res, r_res = self.diffWaysToCompute(l), self.diffWaysToCompute(r)\n for m in l_res:\n for n in r_res:\n if expression[i] == \"+\":\n res.append(m + n)\n elif expression[i] == \"-\":\n res.append(m - n)\n else:\n res.append(m * n)\n return res","runtime":"34"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n \n memo = {}\n\n def helper(expr):\n if expr in memo:\n return memo[expr]\n\n if expr.isdigit():\n return [int(expr)]\n \n results = []\n for i,ch in enumerate(expr):\n if ch in '+-*':\n left = helper(expr[:i])\n right= helper(expr[i+1:])\n\n for l in left:\n for r in right:\n if ch == '+':\n results.append(l + r)\n elif ch == '-':\n results.append(l - r)\n elif ch == '*':\n results.append(l * r)\n memo[expr] = results\n return results\n\n return helper(expression) \n","runtime":"34"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n # Base case: If the expression is a number, return it as an integer\n if expression.isdigit():\n return [int(expression)]\n \n results = []\n \n # Iterate through the expression and look for operators\n for i, char in enumerate(expression):\n if char in \"+-*\":\n # Recursively solve the left and right sub-expressions\n left_results = self.diffWaysToCompute(expression[:i])\n right_results = self.diffWaysToCompute(expression[i+1:])\n \n # Combine the results from both sides\n for left in left_results:\n for right in right_results:\n if char == '+':\n results.append(left + right)\n elif char == '-':\n results.append(left - right)\n elif char == '*':\n results.append(left * right)\n \n return results\n","runtime":"35"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n\n def _recurse(exp):\n\n if exp.isnumeric():\n return [int(exp)]\n \n cur_ans = []\n\n for idx, char in enumerate(exp):\n if char == '*' or char == '+' or char == '-':\n left_str = exp[:idx]\n right_str = exp[idx+1:]\n left_ans = _recurse(left_str)\n right_ans = _recurse(right_str)\n\n for num1 in left_ans:\n for num2 in right_ans:\n if char == '*':\n cur_ans.append(num1*num2)\n if char == '+':\n cur_ans.append(num1+num2)\n if char == '-':\n cur_ans.append(num1-num2)\n \n return cur_ans\n \n return _recurse(expression)\n \n\n","runtime":"35"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n if not expression:\n return []\n \n if (len(expression) == 1) or (len(expression) == 2 and expression[0].isdigit()):\n return [int(expression)]\n \n res = []\n \n for i, ch in enumerate(expression):\n if ch.isdigit():\n continue\n \n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i+1:])\n \n for l in left:\n for r in right:\n if ch == '+':\n res.append(l+r)\n elif ch == '-':\n res.append(l-r)\n else:\n res.append(l*r)\n \n return res\n \n \n \n ","runtime":"36"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n def isdigit(a):\n if a in \"+-*\":\n return False\n else:\n return True\n result = []\n if len(expression) == 1:\n return [int(expression)]\n if len(expression) == 2 and isdigit(expression[0]):\n return [int(expression)]\n for i in range(len(expression)):\n if isdigit(expression[i]):\n continue\n leftResult = self.diffWaysToCompute(expression[:i])\n rightResult = self.diffWaysToCompute(expression[i + 1 :])\n for l in leftResult:\n for r in rightResult:\n if expression[i] == \"+\":\n result.append(l + r)\n elif expression[i] == \"-\":\n result.append(l - r)\n else:\n result.append(l * r) \n return result","runtime":"36"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n\n @cache\n def dfs(expr):\n if len(expr) == 0:\n return []\n \n if len(expr) == 1:\n return [int(expr)]\n \n if len(expr) == 2 and expr[0].isdigit():\n return [int(expr)]\n\n result = []\n for i, c in enumerate(expr):\n if c.isdigit():\n continue\n left_result = dfs(expr[:i])\n right_result = dfs(expr[i+1:])\n\n for lr in left_result:\n for rl in right_result:\n match c:\n case '+':\n result.append(lr + rl)\n case '-':\n result.append(lr - rl)\n case '*':\n result.append(lr * rl)\n\n return result\n \n return dfs(expression)\n","runtime":"37"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n dp = {}\n \n def operators(ops,a,b):\n if ops == '+':\n return a+b \n if ops == '*':\n return a*b\n if ops == '-':\n return a-b\n i = 0\n numbers = []\n while i <= len(expression)-1:\n if not expression[i].isdigit():\n numbers.append(expression[i])\n i += 1\n \n else:\n temp = ''\n while i <= len(expression)-1 and expression[i].isdigit():\n temp += expression[i]\n i += 1\n numbers.append(int(temp))\n \n \n def dfs(i,j):\n if i > j:\n return []\n if i == j:\n return [numbers[i]]\n if (i,j) in dp:\n return dp[(i,j)]\n dp[(i,j)] = []\n for k1 in range(i,j+1):\n if type(numbers[k1]) != str:\n continue \n left = dfs(i,k1-1)\n right = dfs(k1+1,j)\n for les in left:\n for res in right:\n dp[(i,j)].append(operators(numbers[k1],les,res))\n return dp[(i,j)]\n return dfs(0,len(numbers)-1)","runtime":"37"},{"code":"class Solution:\n def __init__(self):\n self.map = {}\n\n def diffWaysToCompute(self, expression: str) -> List[int]:\n # Step 1: Check if the result for the current expression is already computed\n if expression in self.map:\n return self.map[expression]\n\n result = []\n\n # Step 2: Traverse the expression to find operators (+, -, *)\n for i in range(len(expression)):\n ch = expression[i]\n\n # Step 3: If the character is an operator, split the expression into left and right parts\n if ch in '*+-':\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i + 1:])\n\n # Step 4: Combine the results from left and right sub-expressions\n for l in left:\n for r in right:\n if ch == '+':\n result.append(l + r) # Add the results\n elif ch == '-':\n result.append(l - r) # Subtract the results\n elif ch == '*':\n result.append(l * r) # Multiply the results\n\n # Step 5: Base case - If there were no operators, it means the expression is a single number\n if not result:\n result.append(int(expression)) # Convert string to integer\n\n # Step 6: Store the result in the map to avoid redundant computation\n self.map[expression] = result\n\n # Step 7: Return the final computed result\n return result\n\n ","runtime":"38"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n @lru_cache(None)\n def compute(expr: str) -> List[int]:\n if expr.isdigit() or (expr[0] == '-' and expr[1:].isdigit()): # Check if expr is a number\n return [int(expr)]\n\n result = []\n\n for i, char in enumerate(expr):\n if char in '+-*':\n left_results = compute(expr[:i])\n right_results = compute(expr[i + 1:])\n \n for left in left_results:\n for right in right_results:\n if char == '+':\n result.append(left + right)\n elif char == '-':\n result.append(left - right)\n elif char == '*':\n result.append(left * right)\n\n return result\n \n return compute(expression)","runtime":"38"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n # operating = []\n # num = \"\"\n # for i in expression:\n \n # if not i.isdigit():\n # operating.append(num)\n # operating.append(i)\n # num = \"\"\n # else:\n # num += i\n # operating.append(num)\n\n def compute(l, r, o):\n temp = []\n for i in range(len(l)):\n for j in range(len(r)):\n if o == '-':\n temp.append(l[i]-r[j])\n elif o == '+':\n temp.append(l[i]+r[j])\n elif o == '*':\n temp.append(l[i]*r[j])\n return temp\n\n @cache\n def dvd(e):\n if len(e) < 3: return [int(e)]\n \n res = []\n for i in range(len(e)):\n \n if not e[i].isdigit():\n left = dvd(e[:i])\n right = dvd(e[i+1:])\n temp = compute(left, right, e[i])\n res.extend(temp)\n return res\n return dvd(expression)\n ","runtime":"39"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n def rec(li):\n if li.isdigit():\n return [int(li)]\n \n result = []\n for index,i in enumerate(li):\n if i in [\"*\",\"+\",\"-\"]:\n left = rec(li[:index])\n right = rec(li[index+1:])\n\n for l in left:\n for r in right:\n if i==\"+\":\n result.append(l+r)\n if i==\"-\":\n result.append(l-r)\n if i == \"*\":\n result.append(l*r)\n\n return result\n \n return rec(expression)\n \n # @staticmethod\n # def helper(q):\n # f_no = q.popleft()\n # sign = q.popleft()\n # s_no = q.popleft()\n # if sign == \"+\":\n # ans = int(f_no) + int(s_no)\n # elif sign == \"-\":\n # ans = int(f_no) - int(s_no)\n # elif sign == \"*\":\n # ans = int(f_no) * int(s_no)\n # return str(ans)\n\n # def rec(q,result,memo):\n # if tuple(q) in memo:\n # return\n \n # if len(q)==3:\n # memo.add(tuple(q))\n # ans = helper(q)\n # result.add(ans)\n \n # for i in range(len(q)):\n # if q[i].isdigit() and i+2<len(q):\n # ans = helper(deque(q[i:i+3]))\n # new_q = q[:i]+ [ans]+q[i+1:]\n # rec(new_q,result, memo)\n\n # return memo\n\n # memo = {}\n # result = set()\n # return rec(list(expression),result, memo)","runtime":"39"},{"code":"from typing import List\n\nclass Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n def dfs(exp):\n res = []\n \n for i in range(len(exp)):\n c = exp[i]\n \n if c in '-+*':\n # Split the expression into left and right parts\n left_expr = exp[:i]\n right_expr = exp[i+1:]\n \n # Recursively compute results for left and right expressions\n left_results = dfs(left_expr)\n right_results = dfs(right_expr)\n \n # Compute results for current split based on operator\n for left in left_results:\n for right in right_results:\n if c == '+':\n res.append(left + right)\n elif c == '-':\n res.append(left - right)\n elif c == '*':\n res.append(left * right)\n \n # Base case: if no operators found, convert the expression to an integer\n if not res:\n res.append(int(exp))\n \n return res\n \n return dfs(expression)\n","runtime":"40"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n def compute(left, right, op):\n results = []\n for l in left:\n for r in right:\n if op == '+':\n results.append(l + r)\n elif op == '-':\n results.append(l - r)\n elif op == '*':\n results.append(l * r)\n return results\n\n if expression.isdigit():\n return [int(expression)]\n\n results = []\n for i, char in enumerate(expression):\n if char in ['+', '-', '*']:\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i+1:])\n results.extend(compute(left, right, char))\n\n return results","runtime":"41"},{"code":"class Solution:\n dic = {} # memoise each expression to the list of results\n\n def diffWaysToCompute(self, expression: str) -> List[int]:\n\n if expression in self.dic: # work has already been done before \n return self.dic[expression]\n \n if expression.isdigit():\n return [int(expression)]\n\n res_list = []\n for i, c in enumerate(expression):\n if c in ['+', '-', '*']:\n left_res = self.diffWaysToCompute(expression[:i])\n right_res = self.diffWaysToCompute(expression[i+1:])\n\n for left in left_res:\n for right in right_res:\n if c == \"+\":\n res = left + right\n elif c == \"-\":\n res = left - right\n else:\n res = left * right\n\n res_list.append(res)\n\n self.dic[expression] = res_list\n return res_list","runtime":"41"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n operators = [\"+\", \"-\", \"*\"]\n is_pure_int = True\n for ops in operators:\n if ops in expression:\n is_pure_int = False\n if is_pure_int: \n return [int(expression)]\n ans = []\n for i in range(len(expression)):\n c = expression[i]\n if c in [\"+\", \"-\", \"*\"]:\n for op1 in self.diffWaysToCompute(expression[:i]):\n for op2 in self.diffWaysToCompute(expression[i+1:]):\n if c == \"+\":\n ans.append(op1 + op2)\n elif c == \"-\":\n ans.append(op1 - op2)\n elif c == \"*\":\n ans.append(op1 * op2)\n return ans\n ","runtime":"42"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n # eventually to involve DP on the subsequence, the indices i,j saying start and end\n # first: convert expression to two lists: operands and operators\n i = 0\n operands = []\n operators = []\n num = \"\"\n for char in expression:\n if char.isdigit():\n num+=char\n else:\n operands.append(int(num))\n operators.append(char)\n num=\"\"\n operands.append(int(num))\n #operands = [int(d) for d in expression[::2]]\n #operators = expression[1::2]\n j=len(operands)\n table = dict()\n return recursive_solution(i,j,operands,operators,table)\n\ndef recursive_solution(i,j,operands,operators,table): #i:j operands are all integers\n if (i,j) in table:\n return table[(i,j)]\n if i+1==j:\n table[(i,j)]=[operands[i]]\n return table[(i,j)]\n all_outcomes = []\n for k in range(i+1,j):\n left_vals = recursive_solution(i,k,operands,operators,table)\n right_vals = recursive_solution(k,j,operands,operators,table)\n combined = [eval(str(lv)+operators[k-1]+str(rv)) for lv in left_vals for rv in right_vals]\n all_outcomes.extend(combined)\n table[(i,j)]=all_outcomes\n return table[(i,j)]\n #i,...,k-1 and k...j-1, between i+1 and j-1\n","runtime":"42"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n if not len(expression):\n return []\n\n if (len(expression) == 1 or len(expression) == 2) and expression.isdigit():\n return [int(expression)]\n \n res = []\n for i in range(len(expression)):\n if expression[i].isdigit():\n continue\n \n l = self.diffWaysToCompute(expression[:i])\n r = self.diffWaysToCompute(expression[i+1:])\n\n for a in l:\n for b in r:\n if expression[i] == '+':\n res.append(a+b)\n elif expression[i] == '-':\n res.append(a-b)\n elif expression[i] == '*':\n res.append(a*b)\n\n return res\n ","runtime":"43"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n exp = [int(i) for i in re.split('[+\\-*]', expression)]\n op = re.split('[0-9]+', expression)[1:-1]\n o = {'+': lambda x, y: x + y, '-': lambda x, y: x - y, '*': lambda x, y: x * y}\n n = len(op)\n\n memo = {}\n def dfs(i, j):\n if i > j:\n return [exp[i]]\n if i == j:\n return [o[op[i]](exp[i], exp[i + 1])]\n if (i, j) in memo:\n return memo[(i, j)]\n res = []\n for k in range(i, j + 1):\n res += [o[op[k]](x, y) for x in dfs(i, k - 1) for y in dfs(k + 1, j)]\n memo[(i, j)] = res\n return res\n return dfs(0, n - 1)","runtime":"44"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n exp = [int(i) for i in re.split('[+\\-*]', expression)]\n o = {'+': lambda x, y: x + y, '-': lambda x, y: x - y, '*': lambda x, y: x * y}\n op = [o[i] for i in re.split('[0-9]+', expression)[1:-1]]\n n = len(op)\n\n # memo = {}\n def dfs(i, j):\n if i > j:\n return [exp[i]]\n if i == j:\n return [op[i](exp[i], exp[i + 1])]\n # if (i, j) in memo:\n # return memo[(i, j)]\n res = []\n for k in range(i, j + 1):\n res += [op[k](x, y) for x in dfs(i, k - 1) for y in dfs(k + 1, j)]\n # memo[(i, j)] = res\n return res\n return dfs(0, n - 1)","runtime":"45"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n m = {}\n def dfs(expression):\n if not len(expression):\n return []\n \n if expression in m:\n return m[expression]\n\n if (len(expression) == 1 or len(expression) == 2) and expression.isdigit():\n m[expression] = [int(expression)]\n return [int(expression)]\n \n res = []\n for i in range(len(expression)):\n if expression[i].isdigit():\n continue\n \n l = self.diffWaysToCompute(expression[:i])\n r = self.diffWaysToCompute(expression[i+1:])\n\n for a in l:\n for b in r:\n if expression[i] == '+':\n res.append(a+b)\n elif expression[i] == '-':\n res.append(a-b)\n elif expression[i] == '*':\n res.append(a*b)\n\n m[expression] = res\n return res\n \n return dfs(expression)","runtime":"45"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n results = []\n\n # Base case: if the string is empty, return an empty list\n if len(expression) == 0:\n return results\n\n # Base case: if the string is a single character, treat it as a number and return it\n if len(expression) == 1:\n return [int(expression)]\n\n # If the string has only two characters and the first character is a digit, parse it as a number\n if len(expression) == 2 and expression[0].isdigit():\n return [int(expression)]\n\n # Recursive case: iterate through each character\n for i, current_char in enumerate(expression):\n\n # Skip if the current character is a digit\n if current_char.isdigit():\n continue\n\n # Split the expression into left and right parts\n left_results = self.diffWaysToCompute(expression[:i])\n right_results = self.diffWaysToCompute(expression[i + 1 :])\n\n # Combine results from left and right parts\n for left_value in left_results:\n for right_value in right_results:\n # Perform the operation based on the current character\n if current_char == \"+\":\n results.append(left_value + right_value)\n elif current_char == \"-\":\n results.append(left_value - right_value)\n elif current_char == \"*\":\n results.append(left_value * right_value)\n\n return results","runtime":"46"},{"code":"class Solution:\n # First though, using recurrsive\n def diffWaysToCompute(self, expression: str) -> List[int]:\n ex = []\n pre = \"\"\n ops = {\"+\", \"-\", \"*\"}\n for e in expression:\n if e not in ops:\n pre = pre + e\n else:\n ex.append(pre)\n ex.append(e)\n pre = \"\"\n if pre:\n ex.append(pre)\n\n def recurr(express):\n n = len(express)\n if n == 1:\n # print(n)\n return [int(express[0])]\n op_count = (n + 1) // 2\n result = []\n for i in range(2, n, 2):\n op = express[i - 1]\n val_1 = recurr(express[:i - 1]) \n val_2 = recurr(express[i:])\n for v1 in val_1:\n for v2 in val_2:\n if op == '+':\n result.append(v1 + v2)\n elif op == '-':\n result.append(v1 - v2)\n elif op == '*':\n result.append(v1 * v2)\n return result\n return recurr(ex)\n ","runtime":"46"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n if expression.isdigit():\n return[int(expression)]\n\n results = []\n\n for i, char in enumerate(expression):\n if char in '+-*':\n left_results = self.diffWaysToCompute(expression[:i])\n right_results = self.diffWaysToCompute(expression[i +1:])\n\n for left in left_results:\n for right in right_results:\n if char == '+':\n results.append(left + right)\n elif char == '-':\n results.append(left - right)\n elif char == '*':\n results.append(left * right)\n return results","runtime":"47"},{"code":"class Solution:\n def expressionToList(self, expression: str):\n result = []\n tmp=\"\"\n for ch in expression:\n print(ch, tmp, result)\n if ch not in ['+','-','*']:\n tmp+=ch\n else:\n result.append(int(tmp))\n result.append(ch)\n tmp=\"\"\n result.append(int(tmp))\n return result\n\n\n def diffWaysToCompute(self, expression: str) -> List[int]:\n expr_list = self.expressionToList(expression)\n def generate(left, right):\n if left == right:\n return [expr_list[left]]\n\n # if left > right:\n # return [None]\n\n ans = []\n for val in range(left+1, right, 2):\n # print(left, val, right)\n left_ans = generate(left, val-1)\n right_ans = generate(val+1, right)\n\n print(val, expr_list[val], left_ans, right_ans)\n for l in left_ans:\n for r in right_ans:\n print(expr_list[val], l, r)\n if expr_list[val]=='-':\n ans.append(l-r)\n elif expr_list[val]=='+':\n ans.append(l+r)\n else:\n ans.append(l*r)\n\n return ans\n\n return generate(0,len(expr_list)-1)\n","runtime":"48"},{"code":"class Solution: \n def diffWaysToCompute(self, expression: str) -> List[int]:\n memo,output = {}, []\n def calculate(s):\n if s in memo: return memo[s] \n if s.isdigit():\n return [int(s)]\n ret = []\n for idx in range(len(s)):\n if s[idx] in '+-*':\n l = calculate(s[:idx])\n r = calculate(s[idx+1:])\n for i in l:\n for j in r:\n ret.append(eval(str(i)+s[idx]+str(j)))\n\n memo[s] = ret\n return ret\n return calculate(expression)\n\n\n\n\n\n\n\n \n\n\n \n \n ","runtime":"49"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n # map = {}\n # if expression in map:\n # return map[expression]\n result = []\n for i in range(len(expression)):\n char = expression[i]\n if char in ['+', '-', '*']:\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i+1:])\n for l in left:\n for r in right:\n if char == \"+\":\n result.append(l + r)\n elif char == \"-\":\n result.append(l - r)\n elif char == \"*\":\n result.append(l * r)\n if len(result) == 0:\n result.append(eval(expression))\n # map[expression] = result\n return result\n\n ","runtime":"50"},{"code":"class Solution:\n def diffWaysToCompute(self, expression):\n return self._diffWaysToCompute(expression)\n\n operators = {\n '+': operator.add,\n '-': operator.sub,\n '*': operator.mul,\n }\n\n def _diffWaysToCompute(self, expression):\n if not expression:\n return []\n\n def compute_left_right(match):\n left = expression[:match.start()]\n right = expression[match.end():]\n op = self.operators[match[0]]\n return [op(x, y)\n for x in self._diffWaysToCompute(left)\n for y in self._diffWaysToCompute(right)]\n\n results = list(itertools.chain.from_iterable(\n compute_left_right(match) for match in re.finditer(r'[*+-]', expression)))\n\n return results if results else [int(expression)]\n","runtime":"51"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n # 2-1-1\n\n # Loop to find all ops for 2-1-1\n # First -\n # [2-1] and [1]\n # Loop 2-1\n # First -\n # [2] and [1]\n # Left = [1]\n # Loop [1]\n # Right = [1]\n # Compute results = [1-1] = [0] --> Extends to result []\n\n # Second -\n # [2] and [1-1]\n # Left = [2]\n # Right: Loop [1-1]\n # First -\n # [1] and [1]\n # Right = [0]\n # Compute results = [2-0] = [2] --> Extends\n \n\n def compute(left, right, op):\n results = []\n for l in left:\n for r in right:\n if op == \"+\":\n results.append(l + r)\n elif op == \"-\":\n results.append(l - r)\n elif op == \"*\":\n results.append(l * r)\n return results\n\n if expression.isdigit():\n return [int(expression)]\n\n results = []\n for i, char in enumerate(expression):\n if char in [\"+\", \"-\", \"*\"]:\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i+1:])\n results.extend(compute(left, right, char))\n\n return results","runtime":"52"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n rslt = []\n tokens = self.tokenize(expression)\n for tree in self.helper(tokens):\n rslt.append(tree.eval())\n return rslt\n \n def tokenize(self, expression):\n tokens = []\n i = 0\n while i < len(expression):\n token = \"\"\n while i < len(expression) and expression[i].isnumeric():\n token += expression[i]\n i += 1\n tokens.append(token)\n if i < len(expression):\n tokens.append(expression[i])\n i += 1\n return tokens\n\n def helper(self, expression):\n n = len(expression)\n if len(expression) == 1:\n return [ExprTree(\"lit\", int(expression[0]), None)]\n trees = []\n for i in range(int ((n - 1) / 2)):\n for left in self.diffWaysToCompute(expression[:2 * i + 1]):\n for right in self.diffWaysToCompute(expression[2 * i + 2:]):\n trees.append(ExprTree(expression[2 * i + 1], left, right))\n return trees\n \n\nclass ExprTree:\n def __init__(self, op, left, right):\n self.op = op\n self.left = left\n self.right = right\n\n def eval(self):\n if self.op == \"lit\":\n return self.left\n elif self.op == \"*\":\n return self.left * self.right\n elif self.op == \"+\":\n return self.left + self.right\n elif self.op == \"-\":\n return self.left - self.right","runtime":"53"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n computed=[]\n for i , ch in enumerate(expression):\n if ch in \"*-+\":\n left_compute=expression[:i]\n right_compute=expression[i+1:]\n\n left=self.diffWaysToCompute(left_compute)\n right=self.diffWaysToCompute(right_compute)\n\n for e1 in left:\n for e2 in right:\n computed.append(self.compute(e1,e2,ch))\n if not computed:return [int(expression)]\n return computed\n def compute(self,x,y,ch):\n if ch==\"+\":return x+y\n elif ch==\"-\": return x-y\n return x*y\n \n","runtime":"54"},{"code":"from typing import List\n\nclass Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n # Function to perform the arithmetic operation\n def compute(left, right, op):\n results = []\n for l in left:\n for r in right:\n results.append(eval(f\"{l}{op}{r}\"))\n return results\n\n # Base case: if the expression is a single number\n if expression.isdigit():\n return [int(expression)]\n\n results = []\n for i, char in enumerate(expression):\n if char in '+-*':\n # Split the expression at the current operator\n left_results = self.diffWaysToCompute(expression[:i])\n right_results = self.diffWaysToCompute(expression[i+1:])\n\n # Combine the results using the current operator\n results.extend(compute(left_results, right_results, char))\n\n return results\n\n# Example usage:\nsolution = Solution()\nprint(solution.diffWaysToCompute(\"2-1-1\")) # Output: [0, 2]\nprint(solution.diffWaysToCompute(\"2*3-4*5\")) # Output: [-34, -10, -14, -10, 10]","runtime":"55"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n map = {}\n if expression in map:\n return map[expression]\n result = []\n for i in range(len(expression)):\n char = expression[i]\n if char in ['+', '-', '*']:\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i+1:])\n for l in left:\n for r in right:\n if char == \"+\":\n result.append(l + r)\n elif char == \"-\":\n result.append(l - r)\n elif char == \"*\":\n result.append(l * r)\n if len(result) == 0:\n result.append(eval(expression))\n map[expression] = result\n return result\n\n ","runtime":"56"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n #計算 expression 新增括號後的的所有可能值\n \n ans = []\n\n def get_combination(expr):\n #檢查字串是否只包含數字\n if expr.isdigit():\n return [expr] \n\n temp=[]\n #這邊 i 代表走到第幾個數字\n for i , char in enumerate(expr):\n if char in \"+-*\":\n #將運算子的左右拆開\n l_exp = expr[:i]\n r_exp = expr[i+1:]\n\n #遞迴遍歷\n l_com = get_combination(l_exp)\n r_com = get_combination(r_exp)\n\n for left in l_com:\n for right in r_com:\n temp.append(f\"({left}{char}{right})\")\n return temp\n \n all_com = get_combination(expression)\n print(all_com)\n \n for i in range(0,len(all_com)):\n ans.append(eval(all_com[i]))\n\n print(ans)\n return list(ans)\n\n ","runtime":"57"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n ways = []\n for i, c in enumerate(expression):\n if c == \"+\" or c == \"-\" or c == \"*\":\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i + 1 :])\n for l in left:\n for r in right:\n if c == \"+\":\n ways.append(l + r)\n elif c == \"-\":\n ways.append(l - r)\n elif c == \"*\":\n ways.append(l * r)\n if not ways:\n ways.append(eval(expression))\n\n return ways","runtime":"58"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n\n if expression.isdigit():\n return [int(expression)]\n res = []\n for i, s in enumerate(expression):\n if s in \"+-*\":\n l = self.diffWaysToCompute(expression[:i])\n r = self.diffWaysToCompute(expression[i+1:])\n \n for ls in l:\n for rs in r:\n res.append(eval(str(ls) + s + str(rs)))\n \n return res\n \n \n\n\n","runtime":"59"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n result = []\n operators = [\"*\",\"+\",\"-\"]\n isNumber = True\n for op in operators:\n if op in expression:\n isNumber = False\n if isNumber:\n return [int(expression)]\n for i,c in enumerate(expression):\n if c in operators:\n res1 = self.diffWaysToCompute(expression[:i])\n res2 = self.diffWaysToCompute(expression[i + 1:])\n\n for r1 in res1:\n for r2 in res2:\n result.append(eval(str(r1) + c + str(r2)))\n return result\n\n ","runtime":"60"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n result = []\n operators = \"*-+\"\n isNumber = True\n for op in operators:\n if op in expression:\n isNumber = False\n if isNumber:\n return [int(expression)]\n for i,c in enumerate(expression):\n if c in operators:\n res1 = self.diffWaysToCompute(expression[:i])\n res2 = self.diffWaysToCompute(expression[i + 1:])\n for r1 in res1:\n for r2 in res2:\n result.append(eval(str(r1) + c + str(r2)))\n return result\n\n ","runtime":"61"},{"code":"class Solution:\n # First though, using recurrsive\n def diffWaysToCompute(self, expression: str) -> List[int]:\n \n ex = []\n pre = \"\"\n\n for e in expression:\n if e.isalnum():\n pre = pre + e\n else:\n ex.append(pre)\n ex.append(e)\n pre = \"\"\n if pre:\n ex.append(pre)\n def recurr(express):\n n = len(express)\n if n == 1:\n # print(n)\n return [express[0]]\n op_count = (n + 1) // 2\n result = []\n for i in range(2, n, 2):\n op = express[i - 1]\n val_1 = recurr(express[:i - 1]) \n val_2 = recurr(express[i:])\n for v1 in val_1:\n for v2 in val_2:\n result.append(str(eval(v1 + op + v2)))\n return result\n return [int(x) for x in recurr(ex)]\n ","runtime":"62"},{"code":"from typing import List\n\nclass Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n def compute(left, right, op):\n results = []\n for l in left:\n for r in right:\n results.append(eval(str(l) + op + str(r)))\n return results\n \n if expression.isdigit():\n return [int(expression)]\n \n results = []\n for index, value in enumerate(expression):\n if value in \"+-*\":\n left = self.diffWaysToCompute(expression[:index])\n right = self.diffWaysToCompute(expression[index + 1:])\n\n results.extend(compute(left, right, value))\n \n return results","runtime":"63"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n operators = set([\"+\", \"-\", \"*\"])\n output = []\n has_operator = False\n for i in range(len(expression)):\n char = expression[i]\n if char in operators:\n has_operator = True\n left = expression[:i]\n right = expression[i+1:]\n left_results = self.diffWaysToCompute(left)\n right_results = self.diffWaysToCompute(right)\n for left_result in left_results:\n for right_result in right_results:\n output.append(eval(str(left_result) + char + str(right_result)))\n if not has_operator:\n output.append(int(expression))\n return output\n\n\n ","runtime":"64"},{"code":"class Solution:\n def diffWaysToCompute(self, s: str) -> List[int]:\n return(f:=lambda s:[eval(f'{a}{c}{b}')for i,c in enumerate(s)if c in'+-*'for a in f(s[:i])for b in f(s[i+1:])]or[int(s)])(s)\n","runtime":"65"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n result = []\n operators = \"*-+\"\n isNumber = True\n for op in operators:\n if op in expression:\n isNumber = False\n if isNumber:\n return [int(expression)]\n for i,c in enumerate(expression):\n if c in operators:\n res1 = self.diffWaysToCompute(expression[:i])\n res2 = self.diffWaysToCompute(expression[i + 1:])\n for r1 in res1:\n for r2 in res2:\n result.append(eval(str(r1) + c + str(r2)))\n return result","runtime":"67"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n if expression.isdigit():\n return[int(expression)]\n \n results=[]\n for i, char in enumerate(expression):\n if char in \"+-*\":\n left=self.diffWaysToCompute(expression[:i])\n right=self.diffWaysToCompute(expression[i+1:])\n results.extend(eval(f\"{l}{char}{r}\") for l in left for r in right)\n\n return results\n","runtime":"68"},{"code":"class Solution:\n # First though, using recurrsive\n def diffWaysToCompute(self, expression: str) -> List[int]:\n ex = []\n pre = \"\"\n for e in expression:\n if e.isalnum():\n pre = pre + e\n else:\n ex.append(pre)\n ex.append(e)\n pre = \"\"\n if pre:\n ex.append(pre)\n def recurr(express):\n n = len(express)\n if n == 1:\n # print(n)\n return [express[0]]\n op_count = (n + 1) // 2\n result = []\n for i in range(2, n, 2):\n op = express[i - 1]\n val_1 = recurr(express[:i - 1]) \n val_2 = recurr(express[i:])\n for v1 in val_1:\n for v2 in val_2:\n result.append(str(eval(v1 + op + v2)))\n return result\n return [int(x) for x in recurr(ex)]\n ","runtime":"69"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n if expression.isdigit():\n return [int(expression)]\n \n results = []\n for i, char in enumerate(expression):\n if char in \"+-*\":\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i+1:])\n results.extend(eval(f\"{l}{char}{r}\") for l in left for r in right)\n \n return results","runtime":"70"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n res = []\n \n def exp(string):\n if string.isdigit():\n return [string]\n else:\n outp = []\n for i in range(len(string)-1):\n if string[i] == \"+\" or string[i] == '-' or string[i] =='*' or string[i] == '/':\n left = exp(string[:i])\n right = exp(string[i+1:])\n \n outp += [str(eval(x + string[i] + y)) for x in left for y in right]\n return outp\n return map(int, exp(expression))","runtime":"71"}],"string":"[\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n\\n @cache\\n def dfs(expr):\\n if len(expr) == 0:\\n return []\\n \\n if expr.isnumeric():\\n return [int(expr)]\\n\\n result = []\\n for i, c in enumerate(expr):\\n if c.isdigit():\\n continue\\n left_result = dfs(expr[:i])\\n right_result = dfs(expr[i+1:])\\n\\n for lr in left_result:\\n for rl in right_result:\\n match c:\\n case '+':\\n result.append(lr + rl)\\n case '-':\\n result.append(lr - rl)\\n case '*':\\n result.append(lr * rl)\\n\\n return result\\n \\n return dfs(expression)\\n\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n\\n num = 0\\n expression_split = []\\n for c in expression: \\n if c == '*' or c == '+' or c == '-':\\n expression_split.append(num)\\n expression_split.append(c)\\n num = 0\\n else:\\n num = num * 10 + int(c)\\n expression_split.append(num)\\n bounds_to_ans = {}\\n \\n def calc_computation(start: int, end: int) -> list[int]:\\n if start == end:\\n return [expression_split[start]]\\n if (start, end) in bounds_to_ans:\\n return bounds_to_ans[(start, end)]\\n\\n ans = []\\n for i in range(start + 1, end + 1, 2):\\n left = calc_computation(start, i-1)\\n right = calc_computation(i + 1, end)\\n\\n for l in left:\\n for r in right:\\n if expression_split[i] == '*':\\n ans.append(l * r)\\n elif expression_split[i] == '-':\\n ans.append(l - r)\\n elif expression_split[i] == '+':\\n ans.append(l + r)\\n else:\\n print(\\\"This shouldn't print\\\")\\n bounds_to_ans[(start, end)] = ans\\n return ans\\n \\n return calc_computation(0, len(expression_split) - 1)\\n\\n# 0. len()\\n# [2, '-', 1, '-', 1]\\n\\n# [0,0] and [2, 4]\\n\\n# [2, 4] = [2, 2] and [4, 4]\\n\\n\\n\\n\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n # Time: O()\\n # Space: O(), where n = len(expression)\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n \\n n = len(expression)\\n\\n # Top-down + memoization\\n cache = {}\\n def dfs(i, j) -> List[int]:\\n # Evaluate the expression in expression[i:j] for every possible combination of numbers\\n if (i, j) in cache:\\n return cache[(i,j)]\\n if i == j - 1 or i == j - 2:\\n return [int(expression[i:j])]\\n res = []\\n for k in range(i, j):\\n if expression[k] in '+*-':\\n res_left = dfs(i, k)\\n res_right = dfs(k+1, j)\\n for rl in res_left:\\n for rr in res_right:\\n if expression[k] == '-':\\n res.append(rl - rr)\\n elif expression[k] == '+':\\n res.append(rl + rr)\\n else:\\n res.append(rl * rr)\\n cache[(i, j)] = res\\n return res\\n \\n return dfs(0, n)\\n\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n MAX_EXPRESSION_LENGTH = 20\\n MAX_NUMBER = 99\\n\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n expression_length = len(expression)\\n result_table = [[[] for _ in range(expression_length)] for _ in range(expression_length)]\\n\\n numbers, operators = self.parse_expression(expression)\\n \\n # Initialize base cases (single numbers)\\n for i in range(len(numbers)):\\n result_table[i][i] = [numbers[i]]\\n \\n # Fill the result table\\n for subexpr_length in range(2, len(numbers) + 1):\\n for start in range(len(numbers) - subexpr_length + 1):\\n end = start + subexpr_length - 1\\n \\n for split in range(start, end):\\n op = operators[split]\\n left_results = result_table[start][split]\\n right_results = result_table[split + 1][end]\\n \\n self.combine_results(left_results, right_results, op, result_table[start][end])\\n \\n return result_table[0][len(numbers) - 1]\\n\\n def parse_expression(self, expression: str) -> tuple[List[int], List[str]]:\\n numbers = []\\n operators = []\\n current_number = 0\\n for c in expression:\\n if c.isdigit():\\n current_number = current_number * 10 + int(c)\\n else:\\n numbers.append(current_number)\\n current_number = 0\\n operators.append(c)\\n numbers.append(current_number)\\n return numbers, operators\\n\\n def combine_results(self, left_results: List[int], right_results: List[int], op: str, combined_results: List[int]):\\n for left_value in left_results:\\n for right_value in right_results:\\n result = self.compute_operation(left_value, right_value, op)\\n combined_results.append(result)\\n\\n def compute_operation(self, left: int, right: int, op: str) -> int:\\n if op == '+':\\n return left + right\\n elif op == '-':\\n return left - right\\n elif op == '*':\\n return left * right\\n else:\\n raise ValueError(f\\\"Invalid operator: {op}\\\")\\n\\n\\n\\n\\n#kartikdevsharmaa\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n dp = {}\\n sym = [\\\"*\\\", \\\"+\\\", \\\"-\\\"]\\n def calc(op1, op2, sym):\\n if sym == \\\"*\\\":\\n return op1 * op2\\n if sym == \\\"+\\\":\\n return op1 + op2\\n if sym == \\\"-\\\":\\n return op1 - op2\\n def dfs(expr):\\n if expr.isnumeric():\\n dp[expr] = int(expr)\\n return [int(expr)]\\n if expr in dp:\\n return dp[expr]\\n\\n all_mid = []\\n for i in range(len(expr)):\\n ch = expr[i]\\n if ch in sym:\\n left = dfs(expr[:i])\\n right = dfs(expr[i+1:])\\n # apply calculation to get combined results\\n mid = []\\n for j in range(len(left)):\\n for k in range(len(right)):\\n mid.append(calc(left[j], right[k], ch))\\n all_mid.extend(mid)\\n dp[expr] = all_mid\\n return all_mid\\n return dfs(expression)\\n \\n\\n\\n\\n \\n\\n\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n exp = [int(i) for i in re.split('[+\\\\-*]', expression)]\\n op = re.split('[0-9]+', expression)\\n o = {'+': lambda x, y: x + y, '-': lambda x, y: x - y, '*': lambda x, y: x * y}\\n n = len(op)\\n\\n memo = {}\\n def dfs(i, j):\\n if i > j:\\n return [exp[i - 1]]\\n if i == j:\\n return [o[op[i]](exp[i - 1], exp[i])]\\n if (i, j) in memo:\\n return memo[(i, j)]\\n res = []\\n for k in range(i, j + 1):\\n res += [o[op[k]](x, y) for x in dfs(i, k - 1) for y in dfs(k + 1, j)]\\n memo[(i, j)] = res\\n return res\\n return dfs(1, n - 2)\\n\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n memo = {}\\n return self.compute(expression, memo)\\n\\n def compute(self, exp: str, memo: dict) -> List[int]:\\n if exp in memo:\\n return memo[exp]\\n\\n computed = []\\n \\n for i, ch in enumerate(exp):\\n if ch in \\\"-*+\\\":\\n left_compute = exp[:i]\\n right_compute = exp[i+1:]\\n \\n left_exp = self.compute(left_compute, memo)\\n right_exp = self.compute(right_compute, memo)\\n \\n for e1 in left_exp:\\n for e2 in right_exp:\\n computed.append(self.calculate(e1, e2, ch))\\n \\n if not computed:\\n return [int(exp)]\\n memo[exp] = computed\\n return computed\\n\\n def calculate(self, x: int, y: int, ch: str) -> int:\\n if ch == \\\"+\\\":\\n return x + y\\n elif ch == \\\"-\\\":\\n return x - y\\n else:\\n return x * y\\n\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n MAX_EXPRESSION_LENGTH = 20\\n MAX_NUMBER = 99\\n\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n expression_length = len(expression)\\n result_table = [[[] for _ in range(expression_length)] for _ in range(expression_length)]\\n\\n numbers, operators = self.parse_expression(expression)\\n \\n # Initialize base cases (single numbers)\\n for i in range(len(numbers)):\\n result_table[i][i] = [numbers[i]]\\n \\n # Fill the result table\\n for subexpr_length in range(2, len(numbers) + 1):\\n for start in range(len(numbers) - subexpr_length + 1):\\n end = start + subexpr_length - 1\\n \\n for split in range(start, end):\\n op = operators[split]\\n left_results = result_table[start][split]\\n right_results = result_table[split + 1][end]\\n \\n self.combine_results(left_results, right_results, op, result_table[start][end])\\n \\n return result_table[0][len(numbers) - 1]\\n\\n def parse_expression(self, expression: str) -> tuple[List[int], List[str]]:\\n numbers = []\\n operators = []\\n current_number = 0\\n for c in expression:\\n if c.isdigit():\\n current_number = current_number * 10 + int(c)\\n else:\\n numbers.append(current_number)\\n current_number = 0\\n operators.append(c)\\n numbers.append(current_number)\\n return numbers, operators\\n\\n def combine_results(self, left_results: List[int], right_results: List[int], op: str, combined_results: List[int]):\\n for left_value in left_results:\\n for right_value in right_results:\\n result = self.compute_operation(left_value, right_value, op)\\n combined_results.append(result)\\n\\n def compute_operation(self, left: int, right: int, op: str) -> int:\\n if op == '+':\\n return left + right\\n elif op == '-':\\n return left - right\\n elif op == '*':\\n return left * right\\n else:\\n raise ValueError(f\\\"Invalid operator: {op}\\\")\\n\\n\\n\\n\\n#kartikdevsharmaa\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n @lru_cache(None)\\n def compute(expr: str) -> List[int]:\\n if expr.isdigit() or (expr[0] == '-' and expr[1:].isdigit()): # Check if expr is a number\\n return [int(expr)]\\n\\n result = []\\n\\n for i, char in enumerate(expr):\\n if char in '+-*':\\n left_results = compute(expr[:i])\\n right_results = compute(expr[i + 1:])\\n \\n for left in left_results:\\n for right in right_results:\\n if char == '+':\\n result.append(left + right)\\n elif char == '-':\\n result.append(left - right)\\n elif char == '*':\\n result.append(left * right)\\n\\n return result\\n \\n return compute(expression)\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n def compute(left: List[int], right: List[int], op: str) -> List[int]:\\n results = []\\n for l in left:\\n for r in right:\\n if op == '+':\\n results.append(l + r)\\n elif op == '-':\\n results.append(l - r)\\n elif op == '*':\\n results.append(l * r)\\n return results\\n\\n if expression.isdigit():\\n return [int(expression)]\\n\\n results = []\\n for i, char in enumerate(expression):\\n if char in '+-*':\\n left_expr = expression[:i]\\n right_expr = expression[i+1:]\\n left_results = self.diffWaysToCompute(left_expr)\\n right_results = self.diffWaysToCompute(right_expr)\\n results.extend(compute(left_results, right_results, char))\\n \\n return results\\n\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n results=[]\\n if len(expression)==0:\\n return results\\n if len(expression)==1:\\n return [int(expression)]\\n if len(expression)==2 and expression[0].isdigit():\\n return [int(expression)]\\n for i,current_char in enumerate(expression):\\n if current_char.isdigit():\\n continue\\n left_results=self.diffWaysToCompute(expression[:i])\\n right_results=self.diffWaysToCompute(expression[i+1:])\\n for left_val in left_results:\\n for right_val in right_results:\\n if current_char == \\\"+\\\":\\n results.append(left_val + right_val)\\n elif current_char == \\\"-\\\":\\n results.append(left_val - right_val)\\n elif current_char == \\\"*\\\":\\n results.append(left_val * right_val)\\n\\n return results\\n\\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def parse(self, exp):\\n ans = []\\n prev = 0\\n for i in range(len(exp)):\\n s = exp[i]\\n if s in ('+', '-', '*'):\\n ans.append(int(exp[prev:i]))\\n ans.append(s)\\n prev = i + 1\\n ans.append(int(exp[prev:]))\\n return ans\\n\\n def dp(self, i, j):\\n key = (i, j)\\n if key in self.cache:\\n return self.cache[key]\\n ans = []\\n if i == j:\\n ans.append(self.p[i])\\n else:\\n for k in range(i + 1, j, 2):\\n left = self.dp(i, k - 1)\\n right = self.dp(k + 1, j)\\n op = self.p[k]\\n for a in left:\\n for b in right:\\n if op == '+':\\n ans.append(a + b)\\n elif op == '-':\\n ans.append(a - b)\\n else:\\n ans.append(a * b)\\n self.cache[key] = ans\\n return ans\\n\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n self.p = self.parse(expression)\\n self.cache = {}\\n return self.dp(0, len(self.p) - 1)\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n nums, ops = [], []\\n i = 0\\n while i < len(expression):\\n if expression[i].isdigit():\\n num = 0\\n while i < len(expression) and expression[i].isdigit():\\n num = num * 10 + int(expression[i])\\n i += 1\\n nums.append(num)\\n else:\\n ops.append(expression[i])\\n i += 1\\n\\n n = len(nums)\\n dp = [[[] for _ in range(n)] for _ in range(n)]\\n\\n for i in range(n):\\n dp[i][i] = [nums[i]]\\n\\n for length in range(2, n + 1):\\n for i in range(n - length + 1):\\n j = i + length - 1\\n dp[i][j] = []\\n for k in range(i, j):\\n left_results = dp[i][k]\\n right_results = dp[k + 1][j]\\n operator = ops[k]\\n\\n for left in left_results:\\n for right in right_results:\\n if operator == '+':\\n dp[i][j].append(left + right)\\n elif operator == '-':\\n dp[i][j].append(left - right)\\n else:\\n dp[i][j].append(left * right)\\n\\n return dp[0][n - 1]\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n exp = [int(i) for i in re.split('[+\\\\-*]', expression)]\\n op = re.split('[0-9]+', expression)\\n o = {'+': lambda x, y: x + y, '-': lambda x, y: x - y, '*': lambda x, y: x * y}\\n n = len(op)\\n\\n memo = {}\\n def dfs(i, j):\\n if i > j:\\n return [exp[i - 1]]\\n if i == j:\\n return [o[op[i]](exp[i - 1], exp[i])]\\n if (i, j) in memo:\\n return memo[(i, j)]\\n res = []\\n for k in range(i, j + 1):\\n res += [o[op[k]](x, y) for x in dfs(i, k - 1) for y in dfs(k + 1, j)]\\n memo[(i, j)] = res\\n return res\\n return dfs(1, n - 2)\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n ops = {\\n '+': lambda a, b: a + b,\\n '-': lambda a, b: a - b,\\n '*': lambda a, b: a * b\\n }\\n cache = {}\\n \\n def calc(expr):\\n if expr in cache:\\n return cache[expr]\\n \\n if '+' not in expr and\\\\\\n '-' not in expr and\\\\\\n '*' not in expr:\\n return [int(expr)]\\n \\n res = []\\n for i, c in enumerate(expr):\\n if c in '+-*':\\n left_expr = calc(expr[:i])\\n right_expr = calc(expr[i+1:])\\n \\n for l in left_expr:\\n for r in right_expr:\\n res.append(ops[c](l, r))\\n cache[expr] = res\\n return res\\n \\n \\n return calc(expression)\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.map = {}\\n\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n if expression in self.map:\\n return self.map[expression]\\n result = []\\n\\n for i in range(len(expression)):\\n ch = expression[i]\\n if ch in '*+-':\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i+1:])\\n for l in left:\\n for r in right:\\n if ch == \\\"+\\\":\\n result.append(l+r)\\n elif ch== '-':\\n result.append(l-r)\\n elif ch== '*':\\n result.append(l*r)\\n if not result:\\n result.append(int(expression))\\n \\n self.map[expression] = result\\n print(self.map)\\n\\n return result\\n\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n def helper(e):\\n if e.isnumeric():\\n return [int(e)]\\n ans=[]\\n for i in range(len(e)):\\n if e[i] in \\\"+-*\\\":\\n left = helper(e[:i])\\n right = helper(e[i+1:])\\n for l in left:\\n for r in right:\\n if e[i]==\\\"+\\\":\\n ans.append(l+r)\\n elif e[i]==\\\"-\\\":\\n ans.append(l-r)\\n elif e[i]==\\\"*\\\":\\n ans.append(l*r)\\n return ans\\n return helper(expression)\\n\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n @cache\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n operators = set(list(\\\"+-*\\\"))\\n # dp = [[0] * len(expression) for _ in range(len(expression))]\\n res = []\\n if len(expression) <= 2:\\n return [int(expression)]\\n for i in range(len(expression)):\\n if expression[i] in operators:\\n l = expression[:i]\\n r = expression[i + 1:]\\n l_res, r_res = self.diffWaysToCompute(l), self.diffWaysToCompute(r)\\n for m in l_res:\\n for n in r_res:\\n if expression[i] == \\\"+\\\":\\n res.append(m + n)\\n elif expression[i] == \\\"-\\\":\\n res.append(m - n)\\n else:\\n res.append(m * n)\\n return res\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n \\n memo = {}\\n\\n def helper(expr):\\n if expr in memo:\\n return memo[expr]\\n\\n if expr.isdigit():\\n return [int(expr)]\\n \\n results = []\\n for i,ch in enumerate(expr):\\n if ch in '+-*':\\n left = helper(expr[:i])\\n right= helper(expr[i+1:])\\n\\n for l in left:\\n for r in right:\\n if ch == '+':\\n results.append(l + r)\\n elif ch == '-':\\n results.append(l - r)\\n elif ch == '*':\\n results.append(l * r)\\n memo[expr] = results\\n return results\\n\\n return helper(expression) \\n\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n # Base case: If the expression is a number, return it as an integer\\n if expression.isdigit():\\n return [int(expression)]\\n \\n results = []\\n \\n # Iterate through the expression and look for operators\\n for i, char in enumerate(expression):\\n if char in \\\"+-*\\\":\\n # Recursively solve the left and right sub-expressions\\n left_results = self.diffWaysToCompute(expression[:i])\\n right_results = self.diffWaysToCompute(expression[i+1:])\\n \\n # Combine the results from both sides\\n for left in left_results:\\n for right in right_results:\\n if char == '+':\\n results.append(left + right)\\n elif char == '-':\\n results.append(left - right)\\n elif char == '*':\\n results.append(left * right)\\n \\n return results\\n\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n\\n def _recurse(exp):\\n\\n if exp.isnumeric():\\n return [int(exp)]\\n \\n cur_ans = []\\n\\n for idx, char in enumerate(exp):\\n if char == '*' or char == '+' or char == '-':\\n left_str = exp[:idx]\\n right_str = exp[idx+1:]\\n left_ans = _recurse(left_str)\\n right_ans = _recurse(right_str)\\n\\n for num1 in left_ans:\\n for num2 in right_ans:\\n if char == '*':\\n cur_ans.append(num1*num2)\\n if char == '+':\\n cur_ans.append(num1+num2)\\n if char == '-':\\n cur_ans.append(num1-num2)\\n \\n return cur_ans\\n \\n return _recurse(expression)\\n \\n\\n\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n if not expression:\\n return []\\n \\n if (len(expression) == 1) or (len(expression) == 2 and expression[0].isdigit()):\\n return [int(expression)]\\n \\n res = []\\n \\n for i, ch in enumerate(expression):\\n if ch.isdigit():\\n continue\\n \\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i+1:])\\n \\n for l in left:\\n for r in right:\\n if ch == '+':\\n res.append(l+r)\\n elif ch == '-':\\n res.append(l-r)\\n else:\\n res.append(l*r)\\n \\n return res\\n \\n \\n \\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n def isdigit(a):\\n if a in \\\"+-*\\\":\\n return False\\n else:\\n return True\\n result = []\\n if len(expression) == 1:\\n return [int(expression)]\\n if len(expression) == 2 and isdigit(expression[0]):\\n return [int(expression)]\\n for i in range(len(expression)):\\n if isdigit(expression[i]):\\n continue\\n leftResult = self.diffWaysToCompute(expression[:i])\\n rightResult = self.diffWaysToCompute(expression[i + 1 :])\\n for l in leftResult:\\n for r in rightResult:\\n if expression[i] == \\\"+\\\":\\n result.append(l + r)\\n elif expression[i] == \\\"-\\\":\\n result.append(l - r)\\n else:\\n result.append(l * r) \\n return result\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n\\n @cache\\n def dfs(expr):\\n if len(expr) == 0:\\n return []\\n \\n if len(expr) == 1:\\n return [int(expr)]\\n \\n if len(expr) == 2 and expr[0].isdigit():\\n return [int(expr)]\\n\\n result = []\\n for i, c in enumerate(expr):\\n if c.isdigit():\\n continue\\n left_result = dfs(expr[:i])\\n right_result = dfs(expr[i+1:])\\n\\n for lr in left_result:\\n for rl in right_result:\\n match c:\\n case '+':\\n result.append(lr + rl)\\n case '-':\\n result.append(lr - rl)\\n case '*':\\n result.append(lr * rl)\\n\\n return result\\n \\n return dfs(expression)\\n\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n dp = {}\\n \\n def operators(ops,a,b):\\n if ops == '+':\\n return a+b \\n if ops == '*':\\n return a*b\\n if ops == '-':\\n return a-b\\n i = 0\\n numbers = []\\n while i <= len(expression)-1:\\n if not expression[i].isdigit():\\n numbers.append(expression[i])\\n i += 1\\n \\n else:\\n temp = ''\\n while i <= len(expression)-1 and expression[i].isdigit():\\n temp += expression[i]\\n i += 1\\n numbers.append(int(temp))\\n \\n \\n def dfs(i,j):\\n if i > j:\\n return []\\n if i == j:\\n return [numbers[i]]\\n if (i,j) in dp:\\n return dp[(i,j)]\\n dp[(i,j)] = []\\n for k1 in range(i,j+1):\\n if type(numbers[k1]) != str:\\n continue \\n left = dfs(i,k1-1)\\n right = dfs(k1+1,j)\\n for les in left:\\n for res in right:\\n dp[(i,j)].append(operators(numbers[k1],les,res))\\n return dp[(i,j)]\\n return dfs(0,len(numbers)-1)\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.map = {}\\n\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n # Step 1: Check if the result for the current expression is already computed\\n if expression in self.map:\\n return self.map[expression]\\n\\n result = []\\n\\n # Step 2: Traverse the expression to find operators (+, -, *)\\n for i in range(len(expression)):\\n ch = expression[i]\\n\\n # Step 3: If the character is an operator, split the expression into left and right parts\\n if ch in '*+-':\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i + 1:])\\n\\n # Step 4: Combine the results from left and right sub-expressions\\n for l in left:\\n for r in right:\\n if ch == '+':\\n result.append(l + r) # Add the results\\n elif ch == '-':\\n result.append(l - r) # Subtract the results\\n elif ch == '*':\\n result.append(l * r) # Multiply the results\\n\\n # Step 5: Base case - If there were no operators, it means the expression is a single number\\n if not result:\\n result.append(int(expression)) # Convert string to integer\\n\\n # Step 6: Store the result in the map to avoid redundant computation\\n self.map[expression] = result\\n\\n # Step 7: Return the final computed result\\n return result\\n\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n @lru_cache(None)\\n def compute(expr: str) -> List[int]:\\n if expr.isdigit() or (expr[0] == '-' and expr[1:].isdigit()): # Check if expr is a number\\n return [int(expr)]\\n\\n result = []\\n\\n for i, char in enumerate(expr):\\n if char in '+-*':\\n left_results = compute(expr[:i])\\n right_results = compute(expr[i + 1:])\\n \\n for left in left_results:\\n for right in right_results:\\n if char == '+':\\n result.append(left + right)\\n elif char == '-':\\n result.append(left - right)\\n elif char == '*':\\n result.append(left * right)\\n\\n return result\\n \\n return compute(expression)\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n # operating = []\\n # num = \\\"\\\"\\n # for i in expression:\\n \\n # if not i.isdigit():\\n # operating.append(num)\\n # operating.append(i)\\n # num = \\\"\\\"\\n # else:\\n # num += i\\n # operating.append(num)\\n\\n def compute(l, r, o):\\n temp = []\\n for i in range(len(l)):\\n for j in range(len(r)):\\n if o == '-':\\n temp.append(l[i]-r[j])\\n elif o == '+':\\n temp.append(l[i]+r[j])\\n elif o == '*':\\n temp.append(l[i]*r[j])\\n return temp\\n\\n @cache\\n def dvd(e):\\n if len(e) < 3: return [int(e)]\\n \\n res = []\\n for i in range(len(e)):\\n \\n if not e[i].isdigit():\\n left = dvd(e[:i])\\n right = dvd(e[i+1:])\\n temp = compute(left, right, e[i])\\n res.extend(temp)\\n return res\\n return dvd(expression)\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n def rec(li):\\n if li.isdigit():\\n return [int(li)]\\n \\n result = []\\n for index,i in enumerate(li):\\n if i in [\\\"*\\\",\\\"+\\\",\\\"-\\\"]:\\n left = rec(li[:index])\\n right = rec(li[index+1:])\\n\\n for l in left:\\n for r in right:\\n if i==\\\"+\\\":\\n result.append(l+r)\\n if i==\\\"-\\\":\\n result.append(l-r)\\n if i == \\\"*\\\":\\n result.append(l*r)\\n\\n return result\\n \\n return rec(expression)\\n \\n # @staticmethod\\n # def helper(q):\\n # f_no = q.popleft()\\n # sign = q.popleft()\\n # s_no = q.popleft()\\n # if sign == \\\"+\\\":\\n # ans = int(f_no) + int(s_no)\\n # elif sign == \\\"-\\\":\\n # ans = int(f_no) - int(s_no)\\n # elif sign == \\\"*\\\":\\n # ans = int(f_no) * int(s_no)\\n # return str(ans)\\n\\n # def rec(q,result,memo):\\n # if tuple(q) in memo:\\n # return\\n \\n # if len(q)==3:\\n # memo.add(tuple(q))\\n # ans = helper(q)\\n # result.add(ans)\\n \\n # for i in range(len(q)):\\n # if q[i].isdigit() and i+2<len(q):\\n # ans = helper(deque(q[i:i+3]))\\n # new_q = q[:i]+ [ans]+q[i+1:]\\n # rec(new_q,result, memo)\\n\\n # return memo\\n\\n # memo = {}\\n # result = set()\\n # return rec(list(expression),result, memo)\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n def dfs(exp):\\n res = []\\n \\n for i in range(len(exp)):\\n c = exp[i]\\n \\n if c in '-+*':\\n # Split the expression into left and right parts\\n left_expr = exp[:i]\\n right_expr = exp[i+1:]\\n \\n # Recursively compute results for left and right expressions\\n left_results = dfs(left_expr)\\n right_results = dfs(right_expr)\\n \\n # Compute results for current split based on operator\\n for left in left_results:\\n for right in right_results:\\n if c == '+':\\n res.append(left + right)\\n elif c == '-':\\n res.append(left - right)\\n elif c == '*':\\n res.append(left * right)\\n \\n # Base case: if no operators found, convert the expression to an integer\\n if not res:\\n res.append(int(exp))\\n \\n return res\\n \\n return dfs(expression)\\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n def compute(left, right, op):\\n results = []\\n for l in left:\\n for r in right:\\n if op == '+':\\n results.append(l + r)\\n elif op == '-':\\n results.append(l - r)\\n elif op == '*':\\n results.append(l * r)\\n return results\\n\\n if expression.isdigit():\\n return [int(expression)]\\n\\n results = []\\n for i, char in enumerate(expression):\\n if char in ['+', '-', '*']:\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i+1:])\\n results.extend(compute(left, right, char))\\n\\n return results\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n dic = {} # memoise each expression to the list of results\\n\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n\\n if expression in self.dic: # work has already been done before \\n return self.dic[expression]\\n \\n if expression.isdigit():\\n return [int(expression)]\\n\\n res_list = []\\n for i, c in enumerate(expression):\\n if c in ['+', '-', '*']:\\n left_res = self.diffWaysToCompute(expression[:i])\\n right_res = self.diffWaysToCompute(expression[i+1:])\\n\\n for left in left_res:\\n for right in right_res:\\n if c == \\\"+\\\":\\n res = left + right\\n elif c == \\\"-\\\":\\n res = left - right\\n else:\\n res = left * right\\n\\n res_list.append(res)\\n\\n self.dic[expression] = res_list\\n return res_list\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n operators = [\\\"+\\\", \\\"-\\\", \\\"*\\\"]\\n is_pure_int = True\\n for ops in operators:\\n if ops in expression:\\n is_pure_int = False\\n if is_pure_int: \\n return [int(expression)]\\n ans = []\\n for i in range(len(expression)):\\n c = expression[i]\\n if c in [\\\"+\\\", \\\"-\\\", \\\"*\\\"]:\\n for op1 in self.diffWaysToCompute(expression[:i]):\\n for op2 in self.diffWaysToCompute(expression[i+1:]):\\n if c == \\\"+\\\":\\n ans.append(op1 + op2)\\n elif c == \\\"-\\\":\\n ans.append(op1 - op2)\\n elif c == \\\"*\\\":\\n ans.append(op1 * op2)\\n return ans\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n # eventually to involve DP on the subsequence, the indices i,j saying start and end\\n # first: convert expression to two lists: operands and operators\\n i = 0\\n operands = []\\n operators = []\\n num = \\\"\\\"\\n for char in expression:\\n if char.isdigit():\\n num+=char\\n else:\\n operands.append(int(num))\\n operators.append(char)\\n num=\\\"\\\"\\n operands.append(int(num))\\n #operands = [int(d) for d in expression[::2]]\\n #operators = expression[1::2]\\n j=len(operands)\\n table = dict()\\n return recursive_solution(i,j,operands,operators,table)\\n\\ndef recursive_solution(i,j,operands,operators,table): #i:j operands are all integers\\n if (i,j) in table:\\n return table[(i,j)]\\n if i+1==j:\\n table[(i,j)]=[operands[i]]\\n return table[(i,j)]\\n all_outcomes = []\\n for k in range(i+1,j):\\n left_vals = recursive_solution(i,k,operands,operators,table)\\n right_vals = recursive_solution(k,j,operands,operators,table)\\n combined = [eval(str(lv)+operators[k-1]+str(rv)) for lv in left_vals for rv in right_vals]\\n all_outcomes.extend(combined)\\n table[(i,j)]=all_outcomes\\n return table[(i,j)]\\n #i,...,k-1 and k...j-1, between i+1 and j-1\\n\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n if not len(expression):\\n return []\\n\\n if (len(expression) == 1 or len(expression) == 2) and expression.isdigit():\\n return [int(expression)]\\n \\n res = []\\n for i in range(len(expression)):\\n if expression[i].isdigit():\\n continue\\n \\n l = self.diffWaysToCompute(expression[:i])\\n r = self.diffWaysToCompute(expression[i+1:])\\n\\n for a in l:\\n for b in r:\\n if expression[i] == '+':\\n res.append(a+b)\\n elif expression[i] == '-':\\n res.append(a-b)\\n elif expression[i] == '*':\\n res.append(a*b)\\n\\n return res\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n exp = [int(i) for i in re.split('[+\\\\-*]', expression)]\\n op = re.split('[0-9]+', expression)[1:-1]\\n o = {'+': lambda x, y: x + y, '-': lambda x, y: x - y, '*': lambda x, y: x * y}\\n n = len(op)\\n\\n memo = {}\\n def dfs(i, j):\\n if i > j:\\n return [exp[i]]\\n if i == j:\\n return [o[op[i]](exp[i], exp[i + 1])]\\n if (i, j) in memo:\\n return memo[(i, j)]\\n res = []\\n for k in range(i, j + 1):\\n res += [o[op[k]](x, y) for x in dfs(i, k - 1) for y in dfs(k + 1, j)]\\n memo[(i, j)] = res\\n return res\\n return dfs(0, n - 1)\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n exp = [int(i) for i in re.split('[+\\\\-*]', expression)]\\n o = {'+': lambda x, y: x + y, '-': lambda x, y: x - y, '*': lambda x, y: x * y}\\n op = [o[i] for i in re.split('[0-9]+', expression)[1:-1]]\\n n = len(op)\\n\\n # memo = {}\\n def dfs(i, j):\\n if i > j:\\n return [exp[i]]\\n if i == j:\\n return [op[i](exp[i], exp[i + 1])]\\n # if (i, j) in memo:\\n # return memo[(i, j)]\\n res = []\\n for k in range(i, j + 1):\\n res += [op[k](x, y) for x in dfs(i, k - 1) for y in dfs(k + 1, j)]\\n # memo[(i, j)] = res\\n return res\\n return dfs(0, n - 1)\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n m = {}\\n def dfs(expression):\\n if not len(expression):\\n return []\\n \\n if expression in m:\\n return m[expression]\\n\\n if (len(expression) == 1 or len(expression) == 2) and expression.isdigit():\\n m[expression] = [int(expression)]\\n return [int(expression)]\\n \\n res = []\\n for i in range(len(expression)):\\n if expression[i].isdigit():\\n continue\\n \\n l = self.diffWaysToCompute(expression[:i])\\n r = self.diffWaysToCompute(expression[i+1:])\\n\\n for a in l:\\n for b in r:\\n if expression[i] == '+':\\n res.append(a+b)\\n elif expression[i] == '-':\\n res.append(a-b)\\n elif expression[i] == '*':\\n res.append(a*b)\\n\\n m[expression] = res\\n return res\\n \\n return dfs(expression)\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n results = []\\n\\n # Base case: if the string is empty, return an empty list\\n if len(expression) == 0:\\n return results\\n\\n # Base case: if the string is a single character, treat it as a number and return it\\n if len(expression) == 1:\\n return [int(expression)]\\n\\n # If the string has only two characters and the first character is a digit, parse it as a number\\n if len(expression) == 2 and expression[0].isdigit():\\n return [int(expression)]\\n\\n # Recursive case: iterate through each character\\n for i, current_char in enumerate(expression):\\n\\n # Skip if the current character is a digit\\n if current_char.isdigit():\\n continue\\n\\n # Split the expression into left and right parts\\n left_results = self.diffWaysToCompute(expression[:i])\\n right_results = self.diffWaysToCompute(expression[i + 1 :])\\n\\n # Combine results from left and right parts\\n for left_value in left_results:\\n for right_value in right_results:\\n # Perform the operation based on the current character\\n if current_char == \\\"+\\\":\\n results.append(left_value + right_value)\\n elif current_char == \\\"-\\\":\\n results.append(left_value - right_value)\\n elif current_char == \\\"*\\\":\\n results.append(left_value * right_value)\\n\\n return results\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n # First though, using recurrsive\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n ex = []\\n pre = \\\"\\\"\\n ops = {\\\"+\\\", \\\"-\\\", \\\"*\\\"}\\n for e in expression:\\n if e not in ops:\\n pre = pre + e\\n else:\\n ex.append(pre)\\n ex.append(e)\\n pre = \\\"\\\"\\n if pre:\\n ex.append(pre)\\n\\n def recurr(express):\\n n = len(express)\\n if n == 1:\\n # print(n)\\n return [int(express[0])]\\n op_count = (n + 1) // 2\\n result = []\\n for i in range(2, n, 2):\\n op = express[i - 1]\\n val_1 = recurr(express[:i - 1]) \\n val_2 = recurr(express[i:])\\n for v1 in val_1:\\n for v2 in val_2:\\n if op == '+':\\n result.append(v1 + v2)\\n elif op == '-':\\n result.append(v1 - v2)\\n elif op == '*':\\n result.append(v1 * v2)\\n return result\\n return recurr(ex)\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n if expression.isdigit():\\n return[int(expression)]\\n\\n results = []\\n\\n for i, char in enumerate(expression):\\n if char in '+-*':\\n left_results = self.diffWaysToCompute(expression[:i])\\n right_results = self.diffWaysToCompute(expression[i +1:])\\n\\n for left in left_results:\\n for right in right_results:\\n if char == '+':\\n results.append(left + right)\\n elif char == '-':\\n results.append(left - right)\\n elif char == '*':\\n results.append(left * right)\\n return results\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def expressionToList(self, expression: str):\\n result = []\\n tmp=\\\"\\\"\\n for ch in expression:\\n print(ch, tmp, result)\\n if ch not in ['+','-','*']:\\n tmp+=ch\\n else:\\n result.append(int(tmp))\\n result.append(ch)\\n tmp=\\\"\\\"\\n result.append(int(tmp))\\n return result\\n\\n\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n expr_list = self.expressionToList(expression)\\n def generate(left, right):\\n if left == right:\\n return [expr_list[left]]\\n\\n # if left > right:\\n # return [None]\\n\\n ans = []\\n for val in range(left+1, right, 2):\\n # print(left, val, right)\\n left_ans = generate(left, val-1)\\n right_ans = generate(val+1, right)\\n\\n print(val, expr_list[val], left_ans, right_ans)\\n for l in left_ans:\\n for r in right_ans:\\n print(expr_list[val], l, r)\\n if expr_list[val]=='-':\\n ans.append(l-r)\\n elif expr_list[val]=='+':\\n ans.append(l+r)\\n else:\\n ans.append(l*r)\\n\\n return ans\\n\\n return generate(0,len(expr_list)-1)\\n\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution: \\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n memo,output = {}, []\\n def calculate(s):\\n if s in memo: return memo[s] \\n if s.isdigit():\\n return [int(s)]\\n ret = []\\n for idx in range(len(s)):\\n if s[idx] in '+-*':\\n l = calculate(s[:idx])\\n r = calculate(s[idx+1:])\\n for i in l:\\n for j in r:\\n ret.append(eval(str(i)+s[idx]+str(j)))\\n\\n memo[s] = ret\\n return ret\\n return calculate(expression)\\n\\n\\n\\n\\n\\n\\n\\n \\n\\n\\n \\n \\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n # map = {}\\n # if expression in map:\\n # return map[expression]\\n result = []\\n for i in range(len(expression)):\\n char = expression[i]\\n if char in ['+', '-', '*']:\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i+1:])\\n for l in left:\\n for r in right:\\n if char == \\\"+\\\":\\n result.append(l + r)\\n elif char == \\\"-\\\":\\n result.append(l - r)\\n elif char == \\\"*\\\":\\n result.append(l * r)\\n if len(result) == 0:\\n result.append(eval(expression))\\n # map[expression] = result\\n return result\\n\\n \",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression):\\n return self._diffWaysToCompute(expression)\\n\\n operators = {\\n '+': operator.add,\\n '-': operator.sub,\\n '*': operator.mul,\\n }\\n\\n def _diffWaysToCompute(self, expression):\\n if not expression:\\n return []\\n\\n def compute_left_right(match):\\n left = expression[:match.start()]\\n right = expression[match.end():]\\n op = self.operators[match[0]]\\n return [op(x, y)\\n for x in self._diffWaysToCompute(left)\\n for y in self._diffWaysToCompute(right)]\\n\\n results = list(itertools.chain.from_iterable(\\n compute_left_right(match) for match in re.finditer(r'[*+-]', expression)))\\n\\n return results if results else [int(expression)]\\n\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n # 2-1-1\\n\\n # Loop to find all ops for 2-1-1\\n # First -\\n # [2-1] and [1]\\n # Loop 2-1\\n # First -\\n # [2] and [1]\\n # Left = [1]\\n # Loop [1]\\n # Right = [1]\\n # Compute results = [1-1] = [0] --> Extends to result []\\n\\n # Second -\\n # [2] and [1-1]\\n # Left = [2]\\n # Right: Loop [1-1]\\n # First -\\n # [1] and [1]\\n # Right = [0]\\n # Compute results = [2-0] = [2] --> Extends\\n \\n\\n def compute(left, right, op):\\n results = []\\n for l in left:\\n for r in right:\\n if op == \\\"+\\\":\\n results.append(l + r)\\n elif op == \\\"-\\\":\\n results.append(l - r)\\n elif op == \\\"*\\\":\\n results.append(l * r)\\n return results\\n\\n if expression.isdigit():\\n return [int(expression)]\\n\\n results = []\\n for i, char in enumerate(expression):\\n if char in [\\\"+\\\", \\\"-\\\", \\\"*\\\"]:\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i+1:])\\n results.extend(compute(left, right, char))\\n\\n return results\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n rslt = []\\n tokens = self.tokenize(expression)\\n for tree in self.helper(tokens):\\n rslt.append(tree.eval())\\n return rslt\\n \\n def tokenize(self, expression):\\n tokens = []\\n i = 0\\n while i < len(expression):\\n token = \\\"\\\"\\n while i < len(expression) and expression[i].isnumeric():\\n token += expression[i]\\n i += 1\\n tokens.append(token)\\n if i < len(expression):\\n tokens.append(expression[i])\\n i += 1\\n return tokens\\n\\n def helper(self, expression):\\n n = len(expression)\\n if len(expression) == 1:\\n return [ExprTree(\\\"lit\\\", int(expression[0]), None)]\\n trees = []\\n for i in range(int ((n - 1) / 2)):\\n for left in self.diffWaysToCompute(expression[:2 * i + 1]):\\n for right in self.diffWaysToCompute(expression[2 * i + 2:]):\\n trees.append(ExprTree(expression[2 * i + 1], left, right))\\n return trees\\n \\n\\nclass ExprTree:\\n def __init__(self, op, left, right):\\n self.op = op\\n self.left = left\\n self.right = right\\n\\n def eval(self):\\n if self.op == \\\"lit\\\":\\n return self.left\\n elif self.op == \\\"*\\\":\\n return self.left * self.right\\n elif self.op == \\\"+\\\":\\n return self.left + self.right\\n elif self.op == \\\"-\\\":\\n return self.left - self.right\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n computed=[]\\n for i , ch in enumerate(expression):\\n if ch in \\\"*-+\\\":\\n left_compute=expression[:i]\\n right_compute=expression[i+1:]\\n\\n left=self.diffWaysToCompute(left_compute)\\n right=self.diffWaysToCompute(right_compute)\\n\\n for e1 in left:\\n for e2 in right:\\n computed.append(self.compute(e1,e2,ch))\\n if not computed:return [int(expression)]\\n return computed\\n def compute(self,x,y,ch):\\n if ch==\\\"+\\\":return x+y\\n elif ch==\\\"-\\\": return x-y\\n return x*y\\n \\n\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n # Function to perform the arithmetic operation\\n def compute(left, right, op):\\n results = []\\n for l in left:\\n for r in right:\\n results.append(eval(f\\\"{l}{op}{r}\\\"))\\n return results\\n\\n # Base case: if the expression is a single number\\n if expression.isdigit():\\n return [int(expression)]\\n\\n results = []\\n for i, char in enumerate(expression):\\n if char in '+-*':\\n # Split the expression at the current operator\\n left_results = self.diffWaysToCompute(expression[:i])\\n right_results = self.diffWaysToCompute(expression[i+1:])\\n\\n # Combine the results using the current operator\\n results.extend(compute(left_results, right_results, char))\\n\\n return results\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.diffWaysToCompute(\\\"2-1-1\\\")) # Output: [0, 2]\\nprint(solution.diffWaysToCompute(\\\"2*3-4*5\\\")) # Output: [-34, -10, -14, -10, 10]\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n map = {}\\n if expression in map:\\n return map[expression]\\n result = []\\n for i in range(len(expression)):\\n char = expression[i]\\n if char in ['+', '-', '*']:\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i+1:])\\n for l in left:\\n for r in right:\\n if char == \\\"+\\\":\\n result.append(l + r)\\n elif char == \\\"-\\\":\\n result.append(l - r)\\n elif char == \\\"*\\\":\\n result.append(l * r)\\n if len(result) == 0:\\n result.append(eval(expression))\\n map[expression] = result\\n return result\\n\\n \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n #計算 expression 新增括號後的的所有可能值\\n \\n ans = []\\n\\n def get_combination(expr):\\n #檢查字串是否只包含數字\\n if expr.isdigit():\\n return [expr] \\n\\n temp=[]\\n #這邊 i 代表走到第幾個數字\\n for i , char in enumerate(expr):\\n if char in \\\"+-*\\\":\\n #將運算子的左右拆開\\n l_exp = expr[:i]\\n r_exp = expr[i+1:]\\n\\n #遞迴遍歷\\n l_com = get_combination(l_exp)\\n r_com = get_combination(r_exp)\\n\\n for left in l_com:\\n for right in r_com:\\n temp.append(f\\\"({left}{char}{right})\\\")\\n return temp\\n \\n all_com = get_combination(expression)\\n print(all_com)\\n \\n for i in range(0,len(all_com)):\\n ans.append(eval(all_com[i]))\\n\\n print(ans)\\n return list(ans)\\n\\n \",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n ways = []\\n for i, c in enumerate(expression):\\n if c == \\\"+\\\" or c == \\\"-\\\" or c == \\\"*\\\":\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i + 1 :])\\n for l in left:\\n for r in right:\\n if c == \\\"+\\\":\\n ways.append(l + r)\\n elif c == \\\"-\\\":\\n ways.append(l - r)\\n elif c == \\\"*\\\":\\n ways.append(l * r)\\n if not ways:\\n ways.append(eval(expression))\\n\\n return ways\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n\\n if expression.isdigit():\\n return [int(expression)]\\n res = []\\n for i, s in enumerate(expression):\\n if s in \\\"+-*\\\":\\n l = self.diffWaysToCompute(expression[:i])\\n r = self.diffWaysToCompute(expression[i+1:])\\n \\n for ls in l:\\n for rs in r:\\n res.append(eval(str(ls) + s + str(rs)))\\n \\n return res\\n \\n \\n\\n\\n\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n result = []\\n operators = [\\\"*\\\",\\\"+\\\",\\\"-\\\"]\\n isNumber = True\\n for op in operators:\\n if op in expression:\\n isNumber = False\\n if isNumber:\\n return [int(expression)]\\n for i,c in enumerate(expression):\\n if c in operators:\\n res1 = self.diffWaysToCompute(expression[:i])\\n res2 = self.diffWaysToCompute(expression[i + 1:])\\n\\n for r1 in res1:\\n for r2 in res2:\\n result.append(eval(str(r1) + c + str(r2)))\\n return result\\n\\n \",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n result = []\\n operators = \\\"*-+\\\"\\n isNumber = True\\n for op in operators:\\n if op in expression:\\n isNumber = False\\n if isNumber:\\n return [int(expression)]\\n for i,c in enumerate(expression):\\n if c in operators:\\n res1 = self.diffWaysToCompute(expression[:i])\\n res2 = self.diffWaysToCompute(expression[i + 1:])\\n for r1 in res1:\\n for r2 in res2:\\n result.append(eval(str(r1) + c + str(r2)))\\n return result\\n\\n \",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n # First though, using recurrsive\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n \\n ex = []\\n pre = \\\"\\\"\\n\\n for e in expression:\\n if e.isalnum():\\n pre = pre + e\\n else:\\n ex.append(pre)\\n ex.append(e)\\n pre = \\\"\\\"\\n if pre:\\n ex.append(pre)\\n def recurr(express):\\n n = len(express)\\n if n == 1:\\n # print(n)\\n return [express[0]]\\n op_count = (n + 1) // 2\\n result = []\\n for i in range(2, n, 2):\\n op = express[i - 1]\\n val_1 = recurr(express[:i - 1]) \\n val_2 = recurr(express[i:])\\n for v1 in val_1:\\n for v2 in val_2:\\n result.append(str(eval(v1 + op + v2)))\\n return result\\n return [int(x) for x in recurr(ex)]\\n \",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n def compute(left, right, op):\\n results = []\\n for l in left:\\n for r in right:\\n results.append(eval(str(l) + op + str(r)))\\n return results\\n \\n if expression.isdigit():\\n return [int(expression)]\\n \\n results = []\\n for index, value in enumerate(expression):\\n if value in \\\"+-*\\\":\\n left = self.diffWaysToCompute(expression[:index])\\n right = self.diffWaysToCompute(expression[index + 1:])\\n\\n results.extend(compute(left, right, value))\\n \\n return results\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n operators = set([\\\"+\\\", \\\"-\\\", \\\"*\\\"])\\n output = []\\n has_operator = False\\n for i in range(len(expression)):\\n char = expression[i]\\n if char in operators:\\n has_operator = True\\n left = expression[:i]\\n right = expression[i+1:]\\n left_results = self.diffWaysToCompute(left)\\n right_results = self.diffWaysToCompute(right)\\n for left_result in left_results:\\n for right_result in right_results:\\n output.append(eval(str(left_result) + char + str(right_result)))\\n if not has_operator:\\n output.append(int(expression))\\n return output\\n\\n\\n \",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, s: str) -> List[int]:\\n return(f:=lambda s:[eval(f'{a}{c}{b}')for i,c in enumerate(s)if c in'+-*'for a in f(s[:i])for b in f(s[i+1:])]or[int(s)])(s)\\n\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n result = []\\n operators = \\\"*-+\\\"\\n isNumber = True\\n for op in operators:\\n if op in expression:\\n isNumber = False\\n if isNumber:\\n return [int(expression)]\\n for i,c in enumerate(expression):\\n if c in operators:\\n res1 = self.diffWaysToCompute(expression[:i])\\n res2 = self.diffWaysToCompute(expression[i + 1:])\\n for r1 in res1:\\n for r2 in res2:\\n result.append(eval(str(r1) + c + str(r2)))\\n return result\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n if expression.isdigit():\\n return[int(expression)]\\n \\n results=[]\\n for i, char in enumerate(expression):\\n if char in \\\"+-*\\\":\\n left=self.diffWaysToCompute(expression[:i])\\n right=self.diffWaysToCompute(expression[i+1:])\\n results.extend(eval(f\\\"{l}{char}{r}\\\") for l in left for r in right)\\n\\n return results\\n\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n # First though, using recurrsive\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n ex = []\\n pre = \\\"\\\"\\n for e in expression:\\n if e.isalnum():\\n pre = pre + e\\n else:\\n ex.append(pre)\\n ex.append(e)\\n pre = \\\"\\\"\\n if pre:\\n ex.append(pre)\\n def recurr(express):\\n n = len(express)\\n if n == 1:\\n # print(n)\\n return [express[0]]\\n op_count = (n + 1) // 2\\n result = []\\n for i in range(2, n, 2):\\n op = express[i - 1]\\n val_1 = recurr(express[:i - 1]) \\n val_2 = recurr(express[i:])\\n for v1 in val_1:\\n for v2 in val_2:\\n result.append(str(eval(v1 + op + v2)))\\n return result\\n return [int(x) for x in recurr(ex)]\\n \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n if expression.isdigit():\\n return [int(expression)]\\n \\n results = []\\n for i, char in enumerate(expression):\\n if char in \\\"+-*\\\":\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i+1:])\\n results.extend(eval(f\\\"{l}{char}{r}\\\") for l in left for r in right)\\n \\n return results\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n res = []\\n \\n def exp(string):\\n if string.isdigit():\\n return [string]\\n else:\\n outp = []\\n for i in range(len(string)-1):\\n if string[i] == \\\"+\\\" or string[i] == '-' or string[i] =='*' or string[i] == '/':\\n left = exp(string[:i])\\n right = exp(string[i+1:])\\n \\n outp += [str(eval(x + string[i] + y)) for x in left for y in right]\\n return outp\\n return map(int, exp(expression))\",\n \"runtime\": \"71\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":64,"string":"64"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def recurse(self, expr) -> list[int]:\n try:\n return [int(expr)]\n except:\n results = []\n for op in range(len(expr)):\n if expr[op] in '+-*':\n left_side = self.recurse(expr[:op])\n right_side = self.recurse(expr[op+1:])\n for left in left_side:\n for right in right_side:\n if expr[op] == '+':\n results.append(left + right)\n elif expr[op] == '-':\n results.append(left - right)\n elif expr[op] == '*':\n results.append(left * right)\n return results\n\n\n def diffWaysToCompute(self, expression: str) -> List[int]:\n return self.recurse(expression)","memory":"16300"},{"code":"from typing import List\nimport re\nclass Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n def compute(expression: str) -> List[int]:\n res = []\n for i, char in enumerate(expression):\n if char in \"+-*\":\n lr = compute(expression[:i])\n rr = compute(expression[i+1:])\n for l in lr:\n for r in rr:\n if char == '+':\n res.append(l + r)\n elif char == '-':\n res.append(l - r)\n elif char == '*':\n res.append(l * r)\n \n if not res:\n res.append(int(expression))\n \n return res\n return compute(expression)\n ","memory":"16400"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n \n def helper(expr):\n result = []\n for i, char in enumerate(expr):\n if char in \"+-*\":\n left = helper(expr[:i])\n right = helper(expr[i+1:])\n \n for l in left:\n for r in right:\n if char == '+':\n result.append(l + r)\n elif char == '-':\n result.append(l - r)\n else:\n result.append(l * r)\n \n if not result:\n result.append(int(expr))\n \n return result\n \n return helper(expression)\n","memory":"16500"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n def backtrack(expr):\n result = []\n if len(expr) == 0: return result\n if len(expr) == 1: return [int(expr)]\n if len(expr) == 2 and expr[0].isdigit():\n return [int(expr)]\n \n for i, char in enumerate(expr):\n if char.isdigit(): continue\n left = backtrack(expr[ : i])\n right = backtrack(expr[i + 1 :])\n for val1 in left:\n for val2 in right:\n if char == \"+\":\n result.append(val1 + val2)\n elif char == \"-\":\n result.append(val1 - val2)\n else:\n result.append(val1 * val2)\n return result\n \n return backtrack(expression)\n\n ","memory":"16500"},{"code":"class Solution:\n def __init__(self):\n self.map = {}\n\n def diffWaysToCompute(self, expression: str) -> List[int]:\n # Step 1: Check if the result for the current expression is already computed\n if expression in self.map:\n return self.map[expression]\n\n result = []\n\n # Step 2: Traverse the expression to find operators (+, -, *)\n for i in range(len(expression)):\n ch = expression[i]\n\n # Step 3: If the character is an operator, split the expression into left and right parts\n if ch in '*+-':\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i + 1:])\n\n # Step 4: Combine the results from left and right sub-expressions\n for l in left:\n for r in right:\n if ch == '+':\n result.append(l + r) # Add the results\n elif ch == '-':\n result.append(l - r) # Subtract the results\n elif ch == '*':\n result.append(l * r) # Multiply the results\n\n # Step 5: Base case - If there were no operators, it means the expression is a single number\n if not result:\n result.append(int(expression)) # Convert string to integer\n\n # Step 6: Store the result in the map to avoid redundant computation\n self.map[expression] = result\n\n # Step 7: Return the final computed result\n return result\n\n ","memory":"16600"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n # 2-1-1\n\n # Loop to find all ops for 2-1-1\n # First -\n # [2-1] and [1]\n # Loop 2-1\n # First -\n # [2] and [1]\n # Left = [1]\n # Loop [1]\n # Right = [1]\n # Compute results = [1-1] = [0] --> Extends to result []\n\n # Second -\n # [2] and [1-1]\n # Left = [2]\n # Right: Loop [1-1]\n # First -\n # [1] and [1]\n # Right = [0]\n # Compute results = [2-0] = [2] --> Extends\n \n\n def compute(left, right, op):\n results = []\n for l in left:\n for r in right:\n if op == \"+\":\n results.append(l + r)\n elif op == \"-\":\n results.append(l - r)\n elif op == \"*\":\n results.append(l * r)\n return results\n\n if expression.isdigit():\n return [int(expression)]\n\n results = []\n for i, char in enumerate(expression):\n if char in [\"+\", \"-\", \"*\"]:\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i+1:])\n results.extend(compute(left, right, char))\n\n return results","memory":"16600"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n def compute(left, right, op):\n results = []\n for l in left:\n for r in right:\n if op == '+':\n results.append(l + r)\n elif op == '-':\n results.append(l - r)\n elif op == '*':\n results.append(l * r)\n return results\n\n if expression.isdigit():\n return [int(expression)]\n\n results = []\n for i, char in enumerate(expression):\n if char in ['+', '-', '*']:\n left = self.diffWaysToCompute(expression[:i])\n right = self.diffWaysToCompute(expression[i+1:])\n results.extend(compute(left, right, char))\n\n return results","memory":"16700"},{"code":"class Solution:\n dic = {} # memoise each expression to the list of results\n\n def diffWaysToCompute(self, expression: str) -> List[int]:\n\n if expression in self.dic: # work has already been done before \n return self.dic[expression]\n \n if expression.isdigit():\n return [int(expression)]\n\n res_list = []\n for i, c in enumerate(expression):\n if c in ['+', '-', '*']:\n left_res = self.diffWaysToCompute(expression[:i])\n right_res = self.diffWaysToCompute(expression[i+1:])\n\n for left in left_res:\n for right in right_res:\n if c == \"+\":\n res = left + right\n elif c == \"-\":\n res = left - right\n else:\n res = left * right\n\n res_list.append(res)\n\n self.dic[expression] = res_list\n return res_list","memory":"16700"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n #計算 expression 新增括號後的的所有可能值\n \n ans = []\n\n def get_combination(expr):\n #檢查字串是否只包含數字\n if expr.isdigit():\n return [expr] \n\n temp=[]\n #這邊 i 代表走到第幾個數字\n for i , char in enumerate(expr):\n if char in \"+-*\":\n #將運算子的左右拆開\n l_exp = expr[:i]\n r_exp = expr[i+1:]\n\n #遞迴遍歷\n l_com = get_combination(l_exp)\n r_com = get_combination(r_exp)\n\n for left in l_com:\n for right in r_com:\n temp.append(f\"({left}{char}{right})\")\n return temp\n \n all_com = get_combination(expression)\n print(all_com)\n \n for i in range(0,len(all_com)):\n ans.append(eval(all_com[i]))\n\n print(ans)\n return list(ans)\n\n ","memory":"16800"},{"code":"class Solution:\n def diffWaysToCompute(self, expression: str) -> List[int]:\n op = ['*','+','-']\n def fun(s):\n count = sum([op[i] in s for i in range(3)])\n if count==0:\n return [int(s)]\n ans = []\n for i in range(len(s)):\n if s[i] in op:\n left = fun(s[:i])\n right = fun(s[i+1:])\n for j in left:\n for k in right:\n ans.append(eval(str(j) + s[i] + str(k)))\n return ans\n return fun(expression)\n \n ","memory":"16800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def recurse(self, expr) -> list[int]:\\n try:\\n return [int(expr)]\\n except:\\n results = []\\n for op in range(len(expr)):\\n if expr[op] in '+-*':\\n left_side = self.recurse(expr[:op])\\n right_side = self.recurse(expr[op+1:])\\n for left in left_side:\\n for right in right_side:\\n if expr[op] == '+':\\n results.append(left + right)\\n elif expr[op] == '-':\\n results.append(left - right)\\n elif expr[op] == '*':\\n results.append(left * right)\\n return results\\n\\n\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n return self.recurse(expression)\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"from typing import List\\nimport re\\nclass Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n def compute(expression: str) -> List[int]:\\n res = []\\n for i, char in enumerate(expression):\\n if char in \\\"+-*\\\":\\n lr = compute(expression[:i])\\n rr = compute(expression[i+1:])\\n for l in lr:\\n for r in rr:\\n if char == '+':\\n res.append(l + r)\\n elif char == '-':\\n res.append(l - r)\\n elif char == '*':\\n res.append(l * r)\\n \\n if not res:\\n res.append(int(expression))\\n \\n return res\\n return compute(expression)\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n \\n def helper(expr):\\n result = []\\n for i, char in enumerate(expr):\\n if char in \\\"+-*\\\":\\n left = helper(expr[:i])\\n right = helper(expr[i+1:])\\n \\n for l in left:\\n for r in right:\\n if char == '+':\\n result.append(l + r)\\n elif char == '-':\\n result.append(l - r)\\n else:\\n result.append(l * r)\\n \\n if not result:\\n result.append(int(expr))\\n \\n return result\\n \\n return helper(expression)\\n\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n def backtrack(expr):\\n result = []\\n if len(expr) == 0: return result\\n if len(expr) == 1: return [int(expr)]\\n if len(expr) == 2 and expr[0].isdigit():\\n return [int(expr)]\\n \\n for i, char in enumerate(expr):\\n if char.isdigit(): continue\\n left = backtrack(expr[ : i])\\n right = backtrack(expr[i + 1 :])\\n for val1 in left:\\n for val2 in right:\\n if char == \\\"+\\\":\\n result.append(val1 + val2)\\n elif char == \\\"-\\\":\\n result.append(val1 - val2)\\n else:\\n result.append(val1 * val2)\\n return result\\n \\n return backtrack(expression)\\n\\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.map = {}\\n\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n # Step 1: Check if the result for the current expression is already computed\\n if expression in self.map:\\n return self.map[expression]\\n\\n result = []\\n\\n # Step 2: Traverse the expression to find operators (+, -, *)\\n for i in range(len(expression)):\\n ch = expression[i]\\n\\n # Step 3: If the character is an operator, split the expression into left and right parts\\n if ch in '*+-':\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i + 1:])\\n\\n # Step 4: Combine the results from left and right sub-expressions\\n for l in left:\\n for r in right:\\n if ch == '+':\\n result.append(l + r) # Add the results\\n elif ch == '-':\\n result.append(l - r) # Subtract the results\\n elif ch == '*':\\n result.append(l * r) # Multiply the results\\n\\n # Step 5: Base case - If there were no operators, it means the expression is a single number\\n if not result:\\n result.append(int(expression)) # Convert string to integer\\n\\n # Step 6: Store the result in the map to avoid redundant computation\\n self.map[expression] = result\\n\\n # Step 7: Return the final computed result\\n return result\\n\\n \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n # 2-1-1\\n\\n # Loop to find all ops for 2-1-1\\n # First -\\n # [2-1] and [1]\\n # Loop 2-1\\n # First -\\n # [2] and [1]\\n # Left = [1]\\n # Loop [1]\\n # Right = [1]\\n # Compute results = [1-1] = [0] --> Extends to result []\\n\\n # Second -\\n # [2] and [1-1]\\n # Left = [2]\\n # Right: Loop [1-1]\\n # First -\\n # [1] and [1]\\n # Right = [0]\\n # Compute results = [2-0] = [2] --> Extends\\n \\n\\n def compute(left, right, op):\\n results = []\\n for l in left:\\n for r in right:\\n if op == \\\"+\\\":\\n results.append(l + r)\\n elif op == \\\"-\\\":\\n results.append(l - r)\\n elif op == \\\"*\\\":\\n results.append(l * r)\\n return results\\n\\n if expression.isdigit():\\n return [int(expression)]\\n\\n results = []\\n for i, char in enumerate(expression):\\n if char in [\\\"+\\\", \\\"-\\\", \\\"*\\\"]:\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i+1:])\\n results.extend(compute(left, right, char))\\n\\n return results\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n def compute(left, right, op):\\n results = []\\n for l in left:\\n for r in right:\\n if op == '+':\\n results.append(l + r)\\n elif op == '-':\\n results.append(l - r)\\n elif op == '*':\\n results.append(l * r)\\n return results\\n\\n if expression.isdigit():\\n return [int(expression)]\\n\\n results = []\\n for i, char in enumerate(expression):\\n if char in ['+', '-', '*']:\\n left = self.diffWaysToCompute(expression[:i])\\n right = self.diffWaysToCompute(expression[i+1:])\\n results.extend(compute(left, right, char))\\n\\n return results\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n dic = {} # memoise each expression to the list of results\\n\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n\\n if expression in self.dic: # work has already been done before \\n return self.dic[expression]\\n \\n if expression.isdigit():\\n return [int(expression)]\\n\\n res_list = []\\n for i, c in enumerate(expression):\\n if c in ['+', '-', '*']:\\n left_res = self.diffWaysToCompute(expression[:i])\\n right_res = self.diffWaysToCompute(expression[i+1:])\\n\\n for left in left_res:\\n for right in right_res:\\n if c == \\\"+\\\":\\n res = left + right\\n elif c == \\\"-\\\":\\n res = left - right\\n else:\\n res = left * right\\n\\n res_list.append(res)\\n\\n self.dic[expression] = res_list\\n return res_list\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n #計算 expression 新增括號後的的所有可能值\\n \\n ans = []\\n\\n def get_combination(expr):\\n #檢查字串是否只包含數字\\n if expr.isdigit():\\n return [expr] \\n\\n temp=[]\\n #這邊 i 代表走到第幾個數字\\n for i , char in enumerate(expr):\\n if char in \\\"+-*\\\":\\n #將運算子的左右拆開\\n l_exp = expr[:i]\\n r_exp = expr[i+1:]\\n\\n #遞迴遍歷\\n l_com = get_combination(l_exp)\\n r_com = get_combination(r_exp)\\n\\n for left in l_com:\\n for right in r_com:\\n temp.append(f\\\"({left}{char}{right})\\\")\\n return temp\\n \\n all_com = get_combination(expression)\\n print(all_com)\\n \\n for i in range(0,len(all_com)):\\n ans.append(eval(all_com[i]))\\n\\n print(ans)\\n return list(ans)\\n\\n \",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def diffWaysToCompute(self, expression: str) -> List[int]:\\n op = ['*','+','-']\\n def fun(s):\\n count = sum([op[i] in s for i in range(3)])\\n if count==0:\\n return [int(s)]\\n ans = []\\n for i in range(len(s)):\\n if s[i] in op:\\n left = fun(s[:i])\\n right = fun(s[i+1:])\\n for j in left:\\n for k in right:\\n ans.append(eval(str(j) + s[i] + str(k)))\\n return ans\\n return fun(expression)\\n \\n \",\n \"memory\": \"16800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":10,"string":"10"}}},{"rowIdx":66,"cells":{"question_id":{"kind":"number","value":242,"string":"242"},"name":{"kind":"string","value":"valid-anagram"},"content":{"kind":"string","value":"<p>Given two strings <code>s</code> and <code>t</code>, return <code>true</code> if <code>t</code> is an <span data-keyword=\"anagram\">anagram</span> of <code>s</code>, and <code>false</code> otherwise.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">s = "anagram", t = "nagaram"</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">true</span></p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">s = "rat", t = "car"</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">false</span></p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= s.length, t.length <= 5 * 10<sup>4</sup></code></li>\n\t<li><code>s</code> and <code>t</code> consist of lowercase English letters.</li>\n</ul>\n\n<p> </p>\n<p><strong>Follow up:</strong> What if the inputs contain Unicode characters? How would you adapt your solution to such a case?</p>\n"},"acRate":{"kind":"number","value":65.31158706186258,"string":"65.311587"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["hash-table","string","sorting"],"string":"[\n \"hash-table\",\n \"string\",\n \"sorting\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"20\", 0.0016], [\"22\", 0.0078], [\"23\", 0.011], [\"24\", 0.0078], [\"25\", 0.0188], [\"26\", 0.0627], [\"27\", 0.0627], [\"28\", 0.0909], [\"29\", 0.094], [\"30\", 0.1928], [\"31\", 0.2335], [\"32\", 0.4185], [\"33\", 0.4357], [\"34\", 0.5329], [\"35\", 0.7994], [\"36\", 1.1395], [\"37\", 1.1505], [\"38\", 1.4953], [\"39\", 1.8433], [\"40\", 2.5533], [\"41\", 2.6192], [\"42\", 2.848], [\"43\", 3.5001], [\"44\", 4.033], [\"45\", 4.1693], [\"46\", 4.3998], [\"47\", 5.4217], [\"48\", 5.3136], [\"49\", 5.0173], [\"50\", 5.2665], [\"51\", 5.8214], [\"52\", 5.3136], [\"53\", 4.6208], [\"54\", 4.5157], [\"55\", 4.3339], [\"56\", 3.8261], [\"57\", 3.1442], [\"58\", 2.5549], [\"59\", 2.1583], [\"60\", 1.6944], [\"61\", 1.2884], [\"62\", 0.9201], [\"63\", 0.6379], [\"64\", 0.4013]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15900\", 0.0016], [\"16100\", 0.0016], [\"16300\", 0.0031], [\"16400\", 0.0031], [\"16500\", 0.0282], [\"16600\", 0.0376], [\"16700\", 0.4154], [\"16800\", 8.1804], [\"16900\", 44.9741], [\"17000\", 18.5646], [\"17100\", 0.7633], [\"17200\", 1.8699], [\"17300\", 6.3857], [\"17400\", 13.3059]]}"},"rt_list":{"kind":"list like","value":[{"code":"from collections import Counter\n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n s_count = Counter(s)\n t_count = Counter(t)\n\n for i,j in s_count.items():\n if t_count.get(i, -1) != j:\n return False\n return True\n \n ","runtime":"20"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)","runtime":"22"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)\n ","runtime":"22"},{"code":"from collections import Counter\n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)","runtime":"23"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if set(s) != set(t):\n return False\n if len(s) != len(t):\n return False\n for i in list(set(s)):\n if s.count(i) != t.count(i):\n return False\n return True","runtime":"24"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)\n","runtime":"25"},{"code":"from collections import Counter\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n checkone = Counter(s)\n checktwo = Counter(t)\n if checkone == checktwo:\n return True\n return False\n\n\n\n ","runtime":"26"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n check1=Counter(s)\n check2=Counter(t)\n\n return check1==check2\n ","runtime":"26"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n for i in set(s):\n if s.count(i) != t.count(i):\n return False\n return True\n ","runtime":"27"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)","runtime":"27"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)","runtime":"28"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n s_map = Counter(s)\n t_map = Counter(t)\n\n if s_map == t_map:\n return True\n\n return False\n ","runtime":"29"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n # use Counter hashtable to do this\n memo1 = Counter(s)\n memo2 = Counter(t)\n\n if len(memo1) != len(memo2):\n return False\n for ch, num in memo1.items():\n if ch not in memo2:\n return False\n if memo2[ch] != num:\n return False\n return True\n\n ","runtime":"29"},{"code":"class Solution:\n def isAnagram(self, s, t):\n st = \"abcdefghijklmnopqrstuvwxyz\"\n return all([s.count(c)==t.count(c) for c in st])","runtime":"30"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)\n","runtime":"30"},{"code":"from collections import Counter\n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n\n # s = anagram a - 3, n - 1, g - 1, r - 1, m - 1\n # t = nagaram a - 3, n - 1, g - 1, r - 1, m - 1. -> True\n # rat rat\n # car rac. -> False\n\n s_counter = Counter(s)\n t_counter = Counter(t) \n\n return s_counter == t_counter","runtime":"31"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n res = defaultdict(int)\n\n for c in t:\n res[c] += 1\n for c in s:\n res[c] -= 1\n for v in res.values():\n if v != 0:\n return False\n return True \n ","runtime":"31"},{"code":"from collections import Counter\n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)","runtime":"32"},{"code":"from collections import Counter\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)\n ","runtime":"32"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n \n for si in set(s):\n if s.count(si) != t.count(si):\n return False\n \n return True","runtime":"33"},{"code":"from collections import Counter\n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n return Counter(s) == Counter(t)\n","runtime":"33"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n d = dict()\n for l in s:\n if l in d:\n d[l] += 1\n else:\n d[l] = 1\n for l in t:\n if l in d:\n d[l] -= 1\n else:\n return False\n return all(l == 0 for l in d.values())","runtime":"34"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)","runtime":"34"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n\n alph = [0]*26\n for i in range(len(s)):\n alph[ord(s[i])-ord('a')] += 1\n alph[ord(t[i])-ord('a')] -= 1\n\n for i in alph:\n if i != 0:\n return False\n return True\n\n","runtime":"35"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n s_count = {}\n t_count = {}\n for val in s:\n s_count[val] = s_count.get(val,0) + 1\n for val in t:\n t_count[val] = t_count.get(val,0) + 1\n if s_count == t_count:\n return True\n\n return False\n \n # if sorted(s) == sorted(t):\n # return True\n # else:\n # return False","runtime":"35"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n\n from collections import Counter\n\n if len(s) != len(t):\n return False\n\n s1 = dict(Counter(s))\n t1 = dict(Counter(t))\n for key in s1:\n if key not in t1:\n return False\n elif s1[key] != t1[key]:\n return False\n return True\n ","runtime":"36"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n count = defaultdict(int)\n \n # Count the frequency of characters in string s\n for x in s:\n count[x] += 1\n \n # Decrement the frequency of characters in string t\n for x in t:\n count[x] -= 1\n \n # Check if any character has non-zero frequency\n for val in count.values():\n if val != 0:\n return False\n \n return True","runtime":"36"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t): return False\n count = defaultdict(int)\n for c in s:\n count[c] += 1\n for c in t:\n count[c] -= 1\n for v in count.values():\n if v != 0: return False\n return True\n","runtime":"37"},{"code":"from collections import Counter\n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n inter = Counter(s) - Counter(t)\n return len(inter) == 0","runtime":"37"},{"code":"from collections import Counter\n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)","runtime":"38"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(t)!= len(s): \n return False\n ds,dt={},{}\n for a in s:\n ds[a]=ds.get(a,0)+1\n for a in t:\n dt[a]=dt.get(a,0)+1\n \n for a in dt:\n if a not in ds:\n return False\n elif ds[a]!=dt[a]:\n return False\n return True\n \n ","runtime":"38"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n a={}\n b={}\n for word in s:\n a[word]=a.get(word,0)+1\n for word1 in t:\n b[word1]=b.get(word1,0)+1\n return a==b","runtime":"39"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n # # Hash Map\n\n # if len(s) != len(t):\n # return False\n # else:\n # dict_ = defaultdict(int)\n # for i in s:\n # dict_[i] += 1\n\n # for j in t:\n # dict_[j] -= 1\n\n # for i in dict_.values():\n # if i != 0:\n # return False\n \n # return True\n\n\n # sorted\n\n # return sorted(s) == sorted(t)\n\n return Counter(s) == Counter(t)","runtime":"39"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n # # Hash Map\n\n if len(s) != len(t):\n return False\n else:\n dict_ = defaultdict(int)\n for i in s:\n dict_[i] += 1\n\n for j in t:\n dict_[j] -= 1\n\n for i in dict_.values():\n if i != 0:\n return False\n \n return True\n\n\n # sorted\n\n # return sorted(s) == sorted(t)","runtime":"40"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n # # Hash Map\n\n # if len(s) != len(t):\n # return False\n # else:\n # dict_ = defaultdict(int)\n # for i in s:\n # dict_[i] += 1\n\n # for j in t:\n # dict_[j] -= 1\n\n # for i in dict_.values():\n # if i != 0:\n # return False\n \n # return True\n\n\n # sorted\n\n # return sorted(s) == sorted(t)\n\n return Counter(s) == Counter(t)","runtime":"40"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n s_letters = {}\n t_letters = {}\n for i in s:\n s_letters[i] = s_letters.get(i, 0) + 1\n \n for j in t:\n t_letters[j] = t_letters.get(j, 0) + 1\n \n if s_letters == t_letters:\n return True\n return False","runtime":"41"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n s_letters = {}\n t_letters = {}\n for i in s:\n s_letters[i] = s_letters.get(i, 0) + 1\n \n for j in t:\n t_letters[j] = t_letters.get(j, 0) + 1\n \n if s_letters == t_letters:\n return True\n return False","runtime":"41"},{"code":"from collections import Counter\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)\n ","runtime":"42"},{"code":"\nfrom collections import Counter\n\nclass Solution:\n # simplest solution\n def isAnagram(self, s: str, t: str) -> bool:\n return sorted(s) == sorted(t)\n \n \"\"\"\n # with import solution\n def isAnagram(self, s: str, t: str) -> bool:\n # just count occurences of each letter in the string \n # and compare if the counts are equal\n s_count = Counter(s)\n t_count = Counter(t)\n\n return s_count == t_count\n \"\"\"","runtime":"42"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n \n count = {}\n for char in s:\n count[char] = count.get(char,0) + 1\n \n for char in t:\n if char not in count:\n return False\n count[char] -= 1\n if count[char] < 0:\n return False\n\n return True","runtime":"43"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n freq = {}\n for letter in s:\n if letter not in freq:\n freq[letter] = 1\n else:\n freq[letter] += 1\n for letter in t:\n if letter not in freq:\n return False\n freq[letter] -= 1\n for letter in freq:\n if freq[letter] != 0:\n return False\n return True\n ","runtime":"43"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n counter1= Counter(s)\n counter2 = Counter(t)\n if counter1==counter2:\n return True\n return False","runtime":"44"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n count = defaultdict(int)\n\n for x in s:\n count[x] += 1\n for x in t:\n count[x] -= 1\n\n for val in count.values():\n if val != 0:\n return False\n \n return True","runtime":"44"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n\n first_string = Counter(s)\n second_string = Counter(t)\n\n return first_string == second_string\n \n ","runtime":"45"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n letters = 26 * [0]\n for char in s:\n letters[ord(char) - 97] += 1\n \n for char in t:\n val = letters[ord(char) - 97]\n if val == 0:\n return False\n letters[ord(char) - 97] -= 1\n \n return letters == 26 * [0]","runtime":"46"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n # Step 1: Check if lengths are different\n if len(s) != len(t):\n return False\n \n # Step 2: Create an array to count the frequency of each character\n count = [0] * 26 # There are 26 letters in the alphabet\n \n # Step 3: Count characters in both strings\n for i in range(len(s)):\n count[ord(s[i]) - ord('a')] += 1 # Increase count for s\n count[ord(t[i]) - ord('a')] -= 1 # Decrease count for t\n \n # Step 4: Check if all counts are zero\n for c in count:\n if c != 0:\n return False\n \n return True\n","runtime":"46"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n s_count = {}\n for char in s:\n s_count[char] = s_count.get(char,0) + 1\n \n t_count = {}\n for char in t:\n t_count[char] = t_count.get(char,0) + 1\n\n return s_count == t_count\n \n ","runtime":"47"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n hashmap={}\n if len(s)!=len(t):\n return False\n for i in s:\n if i in hashmap:\n hashmap[i]+=1\n else:\n hashmap[i]=1\n for i in t:\n if i not in hashmap:\n return False\n elif hashmap[i]==1:\n del hashmap[i]\n else:\n hashmap[i]-=1\n if not hashmap:\n return True\n ","runtime":"47"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n hashMap = [0] * 26\n for i in s:\n hashMap[ord(i) - ord('a')] += 1\n \n for i in t:\n hashMap[ord(i) - ord('a')] -= 1\n\n for val in hashMap:\n if val != 0:\n return False\n return True","runtime":"48"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n countS, countT = {}, {}\n\n for i in range(len(s)):\n countS[s[i]] = 1 + countS.get(s[i], 0)\n countT[t[i]] = 1 + countT.get(t[i], 0)\n\n for c in countS:\n if countS[c] != countT.get(c,0):\n return False\n return True","runtime":"48"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n char_count = [0 for _ in range(26)]\n for c in s:\n char_count[ord(c)-ord('a')] += 1\n \n for c in t:\n char_count[ord(c)-ord('a')] -= 1\n\n for num in char_count:\n if num != 0:\n return False\n return True\n\n ","runtime":"49"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if (len(s) == len(t)) and ((s != t) or (len(s)==1)): \n if sorted(list(s)) == sorted(list(t)):\n return True\n return False\n ","runtime":"49"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n str_set = set(s)\n t_set = set(t)\n if len(s) != len(t):\n return False\n sc = Counter(s)\n tc = Counter(t)\n if sc != tc:\n return False\n if t_set.issubset(str_set):\n return True\n return False\n ","runtime":"50"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n sort_s = sorted(s)\n sort_t = sorted(t)\n \n if sort_s == sort_t:\n return True\n else:\n return False\n\n","runtime":"50"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return sorted(s) == sorted(t)","runtime":"51"},{"code":"from collections import defaultdict\n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n s1 = defaultdict(int)\n t1 = defaultdict(int)\n for i in range(len(s)):\n s1[s[i]] += 1\n\n for i in range(len(t)):\n t1[t[i]] += 1\n for k, v in s1.items():\n if k not in t1:\n return False\n elif k in t1:\n if v != t1[k]:\n return False\n del t1[k]\n if len(t1) == 0:\n return True\n \n return False","runtime":"51"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n ts = ''.join(sorted(s))\n tt = ''.join(sorted(t))\n\n return ts == tt","runtime":"52"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n dp=[0]*26\n\n for x in s:\n dp[ord(x)-ord('a')]+=1\n for x in t:\n dp[ord(x)-ord('a')]-=1\n for x in dp:\n if x != 0:\n return False\n return True\n","runtime":"52"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n def sortString(phrase):\n arr = [ch for ch in phrase]\n arr.sort()\n return ''.join(arr)\n s = sortString(s)\n t = sortString(t)\n return s == t","runtime":"53"},{"code":"from dataclasses import dataclass\nfrom typing import List\n\n@dataclass\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return Counter(s) == Counter(t)\n def get_char_idx(self, c: str) -> bool:\n return ord(c) - ord(\"a\")\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n charcnt = [0] * 26\n length = len(s)\n for i in range(length):\n charcnt[self.get_char_idx(s[i])] += 1\n charcnt[self.get_char_idx(t[i])] -= 1\n\n return all(x == 0 for x in charcnt)\n","runtime":"53"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n sd = {}\n td = {}\n for i in range(len(s)):\n if s[i] not in sd:\n sd[s[i]] = 0\n if t[i] not in td:\n td[t[i]] = 0\n sd[s[i]] += 1\n td[t[i]] += 1\n return td == sd\n # if len(s) != len(t):\n # return False\n # sa = [0]*26\n # ta = [0]*26\n # for i in range(len(s)):\n # sa[ord(s[i])-ord('a')] += 1\n # ta[ord(t[i])-ord('a')] += 1\n # return sa==ta","runtime":"54"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n s_dict = [0] * 26\n if len(s) != len(t):\n return False\n for i in range(len(s)):\n s_dict[ord(s[i]) - ord(\"a\")] += 1\n s_dict[ord(t[i]) - ord(\"a\")] -= 1\n return s_dict == [0] * 26\n ","runtime":"54"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if sorted(list(s))==sorted(list(t)):\n return True\n else:\n return False","runtime":"55"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if sorted(s)==sorted(t):\n return True\n else:\n return False","runtime":"55"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n # hash = {}\n # for char in s:\n # if char in hash:\n # hash[char] += 1\n # else:\n # hash[char] = 1\n # for char in t:\n # if char in hash:\n # if hash[char] == 1:\n # del hash[char]\n # else:\n # hash[char] -= 1\n # else:\n # return False\n # if len(hash) == 0:\n # return True\n # return False\n if len(s) != len(t):\n return False\n hash = {}\n for i in range(len(s)):\n if s[i] in hash:\n if hash[s[i]] == -1:\n del hash[s[i]]\n else:\n hash[s[i]] += 1\n else: \n hash[s[i]] = 1\n if t[i] in hash:\n if hash[t[i]] == 1:\n del hash[t[i]]\n else:\n hash[t[i]] -= 1\n else: \n hash[t[i]] = -1 \n if len(hash) == 0:\n return True\n return False\n\n","runtime":"56"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n dict_value = {}\n\n for letter in s:\n if letter not in dict_value:\n dict_value[letter] = 1\n else:\n dict_value[letter] += 1\n \n \n for letter in t:\n if letter not in dict_value:\n return False\n else:\n dict_value[letter] -= 1\n\n for value in dict_value.values():\n if value != 0:\n return False\n\n return True\n \n\n \n ","runtime":"56"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return sorted(s) == sorted(t)\n ","runtime":"57"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n sorted_s = sorted(s)\n sorted_t = sorted(t)\n return sorted_s == sorted_t","runtime":"57"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n \n mapp1,mapp2={},{} \n\n for i in s: \n mapp1.update({i : mapp1.get(i,0)+1})\n for i in t: \n mapp2.update({i : mapp2.get(i,0)+1})\n \n return mapp1 == mapp2 ","runtime":"58"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return sorted(s) == sorted(t)","runtime":"58"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return sorted(s) == sorted(t)","runtime":"59"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n sorted_s=sorted(s)\n sorted_t=sorted(t)\n return sorted_s==sorted_t","runtime":"59"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n dict_s = {}\n dict_t = {}\n\n len_s = len(s)\n len_t = len(t)\n\n if len_t != len_s:\n return False\n\n for i in range(len_s):\n \n if s[i] in dict_s:\n dict_s[s[i]] += 1\n \n if s[i] not in dict_s:\n dict_s[s[i]] = 1\n\n if t[i] in dict_t:\n dict_t[t[i]] += 1\n \n if t[i] not in dict_t:\n dict_t[t[i]] = 1\n \n if dict_s == dict_t:\n return True\n return False\n","runtime":"60"},{"code":"def sortStr(str):\n return ''.join(sorted(str))\n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return sortStr(s) == sortStr(t)\n","runtime":"60"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n # If the string lengths don't match, we can straight away reject\n if len(s) != len(t):\n return False\n\n # Create a hash table (dictionary in Python)\n hash_table = {}\n\n # Fill the hash table with s data\n for letter in s:\n if letter in hash_table:\n hash_table[letter] += 1\n else:\n hash_table[letter] = 1\n\n # Now start removing elements from the hash table using t data\n # If the hash table is empty at the end, then the strings are anagrams\n for letter in t:\n if letter in hash_table:\n if hash_table[letter] > 1:\n hash_table[letter] -= 1\n else:\n del hash_table[letter]\n else:\n return False\n\n return len(hash_table) == 0\n","runtime":"61"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(t)==len(s):\n def di(li):\n i=0\n d=dict()\n while i<len(li):\n if li[i] not in d:\n d[li[i]]=1\n i+=1\n else:\n d[li[i]]+=1\n i+=1\n return d\n if sorted(di(s).items())==sorted(di(t).items()):\n return True\n else:\n return False\n return False\n \n ","runtime":"61"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n \n s1 = sorted(s)\n t1 = sorted(t)\n if len(s1) != len(t1):\n return False\n for i in range(len(s1)):\n if s1[i] != t1[i]:\n return False\n return True","runtime":"62"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n char_count = collections.defaultdict(int)\n\n for i in range(len(s)):\n char_count[s[i]] += 1\n # print(\"char_count\" + str(char_count))\n\n for j in range(len(t)):\n if t[j] not in char_count:\n return False\n char_count[t[j]] -= 1\n \n for char in char_count:\n if char_count[char] != 0:\n return False\n \n return True\n","runtime":"62"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n d1 = dict()\n d2 = dict()\n for i in range(len(s)):\n if s[i] not in d1.keys():\n d1[s[i]] = 1\n else:\n d1[s[i]] += 1\n\n if t[i] not in d2.keys():\n d2[t[i]] = 1\n else:\n d2[t[i]] += 1\n return d1 == d2\n","runtime":"63"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n # # Method 1\n # s = Counter(s)\n # t = Counter(t)\n # return s == t\n\n # # Method 2\n # d = {}\n\n # for i in s:\n # if i not in d:\n # d[i] = 0\n # d[i] += 1\n \n # for j in t:\n # if j in d:\n # d[j] -= 1\n # else:\n # return False\n \n # for value in d.values():\n # if value != 0:\n # return False\n # return True\n\n # Method 3\n s = sorted(s)\n t = sorted(t)\n return s == t\n ","runtime":"63"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n # Hash Map\n\n if len(s) != len(t):\n return False\n else:\n dict_ = {}\n dict_2 = {}\n for i in range(len(s)):\n if s[i] in dict_:\n dict_[s[i]] += 1\n else:\n dict_[s[i]] = 1\n\n for j in range(len(t)):\n if t[j] in dict_2:\n dict_2[t[j]] += 1\n else:\n dict_2[t[j]] = 1\n\n if dict_ == dict_2:\n return True\n else:\n return False","runtime":"64"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n #brute force building a counter\n s_counter = {}\n #build s counter\n for i in s:\n current = s_counter.get(i,0)\n s_counter.update({i:current+1})\n #make sure every value of t in s\n for x in t:\n curr_total = s_counter.get(x,0)\n if curr_total <= 0:\n return False\n s_counter.update({x:curr_total-1})\n #make sure there aren't leftovers in s\n for j in s_counter:\n if s_counter.get(j) != 0:\n return False\n \n return True\n","runtime":"64"}],"string":"[\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n s_count = Counter(s)\\n t_count = Counter(t)\\n\\n for i,j in s_count.items():\\n if t_count.get(i, -1) != j:\\n return False\\n return True\\n \\n \",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\\n \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if set(s) != set(t):\\n return False\\n if len(s) != len(t):\\n return False\\n for i in list(set(s)):\\n if s.count(i) != t.count(i):\\n return False\\n return True\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\\n\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n checkone = Counter(s)\\n checktwo = Counter(t)\\n if checkone == checktwo:\\n return True\\n return False\\n\\n\\n\\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n check1=Counter(s)\\n check2=Counter(t)\\n\\n return check1==check2\\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n for i in set(s):\\n if s.count(i) != t.count(i):\\n return False\\n return True\\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n s_map = Counter(s)\\n t_map = Counter(t)\\n\\n if s_map == t_map:\\n return True\\n\\n return False\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n # use Counter hashtable to do this\\n memo1 = Counter(s)\\n memo2 = Counter(t)\\n\\n if len(memo1) != len(memo2):\\n return False\\n for ch, num in memo1.items():\\n if ch not in memo2:\\n return False\\n if memo2[ch] != num:\\n return False\\n return True\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s, t):\\n st = \\\"abcdefghijklmnopqrstuvwxyz\\\"\\n return all([s.count(c)==t.count(c) for c in st])\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\\n\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n\\n # s = anagram a - 3, n - 1, g - 1, r - 1, m - 1\\n # t = nagaram a - 3, n - 1, g - 1, r - 1, m - 1. -> True\\n # rat rat\\n # car rac. -> False\\n\\n s_counter = Counter(s)\\n t_counter = Counter(t) \\n\\n return s_counter == t_counter\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n res = defaultdict(int)\\n\\n for c in t:\\n res[c] += 1\\n for c in s:\\n res[c] -= 1\\n for v in res.values():\\n if v != 0:\\n return False\\n return True \\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n \\n for si in set(s):\\n if s.count(si) != t.count(si):\\n return False\\n \\n return True\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n return Counter(s) == Counter(t)\\n\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n d = dict()\\n for l in s:\\n if l in d:\\n d[l] += 1\\n else:\\n d[l] = 1\\n for l in t:\\n if l in d:\\n d[l] -= 1\\n else:\\n return False\\n return all(l == 0 for l in d.values())\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n\\n alph = [0]*26\\n for i in range(len(s)):\\n alph[ord(s[i])-ord('a')] += 1\\n alph[ord(t[i])-ord('a')] -= 1\\n\\n for i in alph:\\n if i != 0:\\n return False\\n return True\\n\\n\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n s_count = {}\\n t_count = {}\\n for val in s:\\n s_count[val] = s_count.get(val,0) + 1\\n for val in t:\\n t_count[val] = t_count.get(val,0) + 1\\n if s_count == t_count:\\n return True\\n\\n return False\\n \\n # if sorted(s) == sorted(t):\\n # return True\\n # else:\\n # return False\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n\\n from collections import Counter\\n\\n if len(s) != len(t):\\n return False\\n\\n s1 = dict(Counter(s))\\n t1 = dict(Counter(t))\\n for key in s1:\\n if key not in t1:\\n return False\\n elif s1[key] != t1[key]:\\n return False\\n return True\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n count = defaultdict(int)\\n \\n # Count the frequency of characters in string s\\n for x in s:\\n count[x] += 1\\n \\n # Decrement the frequency of characters in string t\\n for x in t:\\n count[x] -= 1\\n \\n # Check if any character has non-zero frequency\\n for val in count.values():\\n if val != 0:\\n return False\\n \\n return True\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t): return False\\n count = defaultdict(int)\\n for c in s:\\n count[c] += 1\\n for c in t:\\n count[c] -= 1\\n for v in count.values():\\n if v != 0: return False\\n return True\\n\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n inter = Counter(s) - Counter(t)\\n return len(inter) == 0\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(t)!= len(s): \\n return False\\n ds,dt={},{}\\n for a in s:\\n ds[a]=ds.get(a,0)+1\\n for a in t:\\n dt[a]=dt.get(a,0)+1\\n \\n for a in dt:\\n if a not in ds:\\n return False\\n elif ds[a]!=dt[a]:\\n return False\\n return True\\n \\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n a={}\\n b={}\\n for word in s:\\n a[word]=a.get(word,0)+1\\n for word1 in t:\\n b[word1]=b.get(word1,0)+1\\n return a==b\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n # # Hash Map\\n\\n # if len(s) != len(t):\\n # return False\\n # else:\\n # dict_ = defaultdict(int)\\n # for i in s:\\n # dict_[i] += 1\\n\\n # for j in t:\\n # dict_[j] -= 1\\n\\n # for i in dict_.values():\\n # if i != 0:\\n # return False\\n \\n # return True\\n\\n\\n # sorted\\n\\n # return sorted(s) == sorted(t)\\n\\n return Counter(s) == Counter(t)\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n # # Hash Map\\n\\n if len(s) != len(t):\\n return False\\n else:\\n dict_ = defaultdict(int)\\n for i in s:\\n dict_[i] += 1\\n\\n for j in t:\\n dict_[j] -= 1\\n\\n for i in dict_.values():\\n if i != 0:\\n return False\\n \\n return True\\n\\n\\n # sorted\\n\\n # return sorted(s) == sorted(t)\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n # # Hash Map\\n\\n # if len(s) != len(t):\\n # return False\\n # else:\\n # dict_ = defaultdict(int)\\n # for i in s:\\n # dict_[i] += 1\\n\\n # for j in t:\\n # dict_[j] -= 1\\n\\n # for i in dict_.values():\\n # if i != 0:\\n # return False\\n \\n # return True\\n\\n\\n # sorted\\n\\n # return sorted(s) == sorted(t)\\n\\n return Counter(s) == Counter(t)\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n s_letters = {}\\n t_letters = {}\\n for i in s:\\n s_letters[i] = s_letters.get(i, 0) + 1\\n \\n for j in t:\\n t_letters[j] = t_letters.get(j, 0) + 1\\n \\n if s_letters == t_letters:\\n return True\\n return False\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n s_letters = {}\\n t_letters = {}\\n for i in s:\\n s_letters[i] = s_letters.get(i, 0) + 1\\n \\n for j in t:\\n t_letters[j] = t_letters.get(j, 0) + 1\\n \\n if s_letters == t_letters:\\n return True\\n return False\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"\\nfrom collections import Counter\\n\\nclass Solution:\\n # simplest solution\\n def isAnagram(self, s: str, t: str) -> bool:\\n return sorted(s) == sorted(t)\\n \\n \\\"\\\"\\\"\\n # with import solution\\n def isAnagram(self, s: str, t: str) -> bool:\\n # just count occurences of each letter in the string \\n # and compare if the counts are equal\\n s_count = Counter(s)\\n t_count = Counter(t)\\n\\n return s_count == t_count\\n \\\"\\\"\\\"\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n \\n count = {}\\n for char in s:\\n count[char] = count.get(char,0) + 1\\n \\n for char in t:\\n if char not in count:\\n return False\\n count[char] -= 1\\n if count[char] < 0:\\n return False\\n\\n return True\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n freq = {}\\n for letter in s:\\n if letter not in freq:\\n freq[letter] = 1\\n else:\\n freq[letter] += 1\\n for letter in t:\\n if letter not in freq:\\n return False\\n freq[letter] -= 1\\n for letter in freq:\\n if freq[letter] != 0:\\n return False\\n return True\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n counter1= Counter(s)\\n counter2 = Counter(t)\\n if counter1==counter2:\\n return True\\n return False\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n count = defaultdict(int)\\n\\n for x in s:\\n count[x] += 1\\n for x in t:\\n count[x] -= 1\\n\\n for val in count.values():\\n if val != 0:\\n return False\\n \\n return True\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n\\n first_string = Counter(s)\\n second_string = Counter(t)\\n\\n return first_string == second_string\\n \\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n letters = 26 * [0]\\n for char in s:\\n letters[ord(char) - 97] += 1\\n \\n for char in t:\\n val = letters[ord(char) - 97]\\n if val == 0:\\n return False\\n letters[ord(char) - 97] -= 1\\n \\n return letters == 26 * [0]\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n # Step 1: Check if lengths are different\\n if len(s) != len(t):\\n return False\\n \\n # Step 2: Create an array to count the frequency of each character\\n count = [0] * 26 # There are 26 letters in the alphabet\\n \\n # Step 3: Count characters in both strings\\n for i in range(len(s)):\\n count[ord(s[i]) - ord('a')] += 1 # Increase count for s\\n count[ord(t[i]) - ord('a')] -= 1 # Decrease count for t\\n \\n # Step 4: Check if all counts are zero\\n for c in count:\\n if c != 0:\\n return False\\n \\n return True\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n s_count = {}\\n for char in s:\\n s_count[char] = s_count.get(char,0) + 1\\n \\n t_count = {}\\n for char in t:\\n t_count[char] = t_count.get(char,0) + 1\\n\\n return s_count == t_count\\n \\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n hashmap={}\\n if len(s)!=len(t):\\n return False\\n for i in s:\\n if i in hashmap:\\n hashmap[i]+=1\\n else:\\n hashmap[i]=1\\n for i in t:\\n if i not in hashmap:\\n return False\\n elif hashmap[i]==1:\\n del hashmap[i]\\n else:\\n hashmap[i]-=1\\n if not hashmap:\\n return True\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n hashMap = [0] * 26\\n for i in s:\\n hashMap[ord(i) - ord('a')] += 1\\n \\n for i in t:\\n hashMap[ord(i) - ord('a')] -= 1\\n\\n for val in hashMap:\\n if val != 0:\\n return False\\n return True\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n countS, countT = {}, {}\\n\\n for i in range(len(s)):\\n countS[s[i]] = 1 + countS.get(s[i], 0)\\n countT[t[i]] = 1 + countT.get(t[i], 0)\\n\\n for c in countS:\\n if countS[c] != countT.get(c,0):\\n return False\\n return True\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n char_count = [0 for _ in range(26)]\\n for c in s:\\n char_count[ord(c)-ord('a')] += 1\\n \\n for c in t:\\n char_count[ord(c)-ord('a')] -= 1\\n\\n for num in char_count:\\n if num != 0:\\n return False\\n return True\\n\\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if (len(s) == len(t)) and ((s != t) or (len(s)==1)): \\n if sorted(list(s)) == sorted(list(t)):\\n return True\\n return False\\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n str_set = set(s)\\n t_set = set(t)\\n if len(s) != len(t):\\n return False\\n sc = Counter(s)\\n tc = Counter(t)\\n if sc != tc:\\n return False\\n if t_set.issubset(str_set):\\n return True\\n return False\\n \",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n sort_s = sorted(s)\\n sort_t = sorted(t)\\n \\n if sort_s == sort_t:\\n return True\\n else:\\n return False\\n\\n\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return sorted(s) == sorted(t)\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n s1 = defaultdict(int)\\n t1 = defaultdict(int)\\n for i in range(len(s)):\\n s1[s[i]] += 1\\n\\n for i in range(len(t)):\\n t1[t[i]] += 1\\n for k, v in s1.items():\\n if k not in t1:\\n return False\\n elif k in t1:\\n if v != t1[k]:\\n return False\\n del t1[k]\\n if len(t1) == 0:\\n return True\\n \\n return False\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n ts = ''.join(sorted(s))\\n tt = ''.join(sorted(t))\\n\\n return ts == tt\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n dp=[0]*26\\n\\n for x in s:\\n dp[ord(x)-ord('a')]+=1\\n for x in t:\\n dp[ord(x)-ord('a')]-=1\\n for x in dp:\\n if x != 0:\\n return False\\n return True\\n\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n def sortString(phrase):\\n arr = [ch for ch in phrase]\\n arr.sort()\\n return ''.join(arr)\\n s = sortString(s)\\n t = sortString(t)\\n return s == t\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"from dataclasses import dataclass\\nfrom typing import List\\n\\n@dataclass\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return Counter(s) == Counter(t)\\n def get_char_idx(self, c: str) -> bool:\\n return ord(c) - ord(\\\"a\\\")\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n charcnt = [0] * 26\\n length = len(s)\\n for i in range(length):\\n charcnt[self.get_char_idx(s[i])] += 1\\n charcnt[self.get_char_idx(t[i])] -= 1\\n\\n return all(x == 0 for x in charcnt)\\n\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n sd = {}\\n td = {}\\n for i in range(len(s)):\\n if s[i] not in sd:\\n sd[s[i]] = 0\\n if t[i] not in td:\\n td[t[i]] = 0\\n sd[s[i]] += 1\\n td[t[i]] += 1\\n return td == sd\\n # if len(s) != len(t):\\n # return False\\n # sa = [0]*26\\n # ta = [0]*26\\n # for i in range(len(s)):\\n # sa[ord(s[i])-ord('a')] += 1\\n # ta[ord(t[i])-ord('a')] += 1\\n # return sa==ta\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n s_dict = [0] * 26\\n if len(s) != len(t):\\n return False\\n for i in range(len(s)):\\n s_dict[ord(s[i]) - ord(\\\"a\\\")] += 1\\n s_dict[ord(t[i]) - ord(\\\"a\\\")] -= 1\\n return s_dict == [0] * 26\\n \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if sorted(list(s))==sorted(list(t)):\\n return True\\n else:\\n return False\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if sorted(s)==sorted(t):\\n return True\\n else:\\n return False\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n # hash = {}\\n # for char in s:\\n # if char in hash:\\n # hash[char] += 1\\n # else:\\n # hash[char] = 1\\n # for char in t:\\n # if char in hash:\\n # if hash[char] == 1:\\n # del hash[char]\\n # else:\\n # hash[char] -= 1\\n # else:\\n # return False\\n # if len(hash) == 0:\\n # return True\\n # return False\\n if len(s) != len(t):\\n return False\\n hash = {}\\n for i in range(len(s)):\\n if s[i] in hash:\\n if hash[s[i]] == -1:\\n del hash[s[i]]\\n else:\\n hash[s[i]] += 1\\n else: \\n hash[s[i]] = 1\\n if t[i] in hash:\\n if hash[t[i]] == 1:\\n del hash[t[i]]\\n else:\\n hash[t[i]] -= 1\\n else: \\n hash[t[i]] = -1 \\n if len(hash) == 0:\\n return True\\n return False\\n\\n\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n dict_value = {}\\n\\n for letter in s:\\n if letter not in dict_value:\\n dict_value[letter] = 1\\n else:\\n dict_value[letter] += 1\\n \\n \\n for letter in t:\\n if letter not in dict_value:\\n return False\\n else:\\n dict_value[letter] -= 1\\n\\n for value in dict_value.values():\\n if value != 0:\\n return False\\n\\n return True\\n \\n\\n \\n \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return sorted(s) == sorted(t)\\n \",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n sorted_s = sorted(s)\\n sorted_t = sorted(t)\\n return sorted_s == sorted_t\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n \\n mapp1,mapp2={},{} \\n\\n for i in s: \\n mapp1.update({i : mapp1.get(i,0)+1})\\n for i in t: \\n mapp2.update({i : mapp2.get(i,0)+1})\\n \\n return mapp1 == mapp2 \",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return sorted(s) == sorted(t)\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return sorted(s) == sorted(t)\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n sorted_s=sorted(s)\\n sorted_t=sorted(t)\\n return sorted_s==sorted_t\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n dict_s = {}\\n dict_t = {}\\n\\n len_s = len(s)\\n len_t = len(t)\\n\\n if len_t != len_s:\\n return False\\n\\n for i in range(len_s):\\n \\n if s[i] in dict_s:\\n dict_s[s[i]] += 1\\n \\n if s[i] not in dict_s:\\n dict_s[s[i]] = 1\\n\\n if t[i] in dict_t:\\n dict_t[t[i]] += 1\\n \\n if t[i] not in dict_t:\\n dict_t[t[i]] = 1\\n \\n if dict_s == dict_t:\\n return True\\n return False\\n\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"def sortStr(str):\\n return ''.join(sorted(str))\\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return sortStr(s) == sortStr(t)\\n\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n # If the string lengths don't match, we can straight away reject\\n if len(s) != len(t):\\n return False\\n\\n # Create a hash table (dictionary in Python)\\n hash_table = {}\\n\\n # Fill the hash table with s data\\n for letter in s:\\n if letter in hash_table:\\n hash_table[letter] += 1\\n else:\\n hash_table[letter] = 1\\n\\n # Now start removing elements from the hash table using t data\\n # If the hash table is empty at the end, then the strings are anagrams\\n for letter in t:\\n if letter in hash_table:\\n if hash_table[letter] > 1:\\n hash_table[letter] -= 1\\n else:\\n del hash_table[letter]\\n else:\\n return False\\n\\n return len(hash_table) == 0\\n\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(t)==len(s):\\n def di(li):\\n i=0\\n d=dict()\\n while i<len(li):\\n if li[i] not in d:\\n d[li[i]]=1\\n i+=1\\n else:\\n d[li[i]]+=1\\n i+=1\\n return d\\n if sorted(di(s).items())==sorted(di(t).items()):\\n return True\\n else:\\n return False\\n return False\\n \\n \",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n \\n s1 = sorted(s)\\n t1 = sorted(t)\\n if len(s1) != len(t1):\\n return False\\n for i in range(len(s1)):\\n if s1[i] != t1[i]:\\n return False\\n return True\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n char_count = collections.defaultdict(int)\\n\\n for i in range(len(s)):\\n char_count[s[i]] += 1\\n # print(\\\"char_count\\\" + str(char_count))\\n\\n for j in range(len(t)):\\n if t[j] not in char_count:\\n return False\\n char_count[t[j]] -= 1\\n \\n for char in char_count:\\n if char_count[char] != 0:\\n return False\\n \\n return True\\n\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n d1 = dict()\\n d2 = dict()\\n for i in range(len(s)):\\n if s[i] not in d1.keys():\\n d1[s[i]] = 1\\n else:\\n d1[s[i]] += 1\\n\\n if t[i] not in d2.keys():\\n d2[t[i]] = 1\\n else:\\n d2[t[i]] += 1\\n return d1 == d2\\n\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n # # Method 1\\n # s = Counter(s)\\n # t = Counter(t)\\n # return s == t\\n\\n # # Method 2\\n # d = {}\\n\\n # for i in s:\\n # if i not in d:\\n # d[i] = 0\\n # d[i] += 1\\n \\n # for j in t:\\n # if j in d:\\n # d[j] -= 1\\n # else:\\n # return False\\n \\n # for value in d.values():\\n # if value != 0:\\n # return False\\n # return True\\n\\n # Method 3\\n s = sorted(s)\\n t = sorted(t)\\n return s == t\\n \",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n # Hash Map\\n\\n if len(s) != len(t):\\n return False\\n else:\\n dict_ = {}\\n dict_2 = {}\\n for i in range(len(s)):\\n if s[i] in dict_:\\n dict_[s[i]] += 1\\n else:\\n dict_[s[i]] = 1\\n\\n for j in range(len(t)):\\n if t[j] in dict_2:\\n dict_2[t[j]] += 1\\n else:\\n dict_2[t[j]] = 1\\n\\n if dict_ == dict_2:\\n return True\\n else:\\n return False\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n #brute force building a counter\\n s_counter = {}\\n #build s counter\\n for i in s:\\n current = s_counter.get(i,0)\\n s_counter.update({i:current+1})\\n #make sure every value of t in s\\n for x in t:\\n curr_total = s_counter.get(x,0)\\n if curr_total <= 0:\\n return False\\n s_counter.update({x:curr_total-1})\\n #make sure there aren't leftovers in s\\n for j in s_counter:\\n if s_counter.get(j) != 0:\\n return False\\n \\n return True\\n\",\n \"runtime\": \"64\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":82,"string":"82"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n \n count = defaultdict(int)\n\n for x in s:\n count[x] += 1\n\n for x in t:\n count[x] -= 1\n\n for val in count.values():\n if val != 0:\n return False\n \n return True","memory":"15900"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n map=dict()\n for i in s:\n if i in map:\n map[i]+=1\n else:\n map[i]=1\n for i in t:\n if i in map:\n map[i]-=1\n else:\n return False\n res=list(map.values())\n return res.count(0)==len(res)","memory":"16100"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n cnt1 = {}\n cnt2 = {}\n for ss in s:\n if ss in cnt1:\n cnt1[ss]+=1\n else:\n cnt1[ss]=1\n \n for ss in t:\n if ss in cnt2:\n cnt2[ss]+=1\n else:\n cnt2[ss]=1\n \n if len(cnt1)!=len(cnt2):\n return False\n \n for ss in s:\n if ss not in t:\n return False\n if cnt1[ss]!=cnt2[ss]:\n return False\n return True","memory":"16300"},{"code":"from collections import Counter\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n \n sCounter = Counter(s)\n tCounter = Counter(t)\n\n for key, value in sCounter.items():\n if value != tCounter[key]:\n return False\n return True","memory":"16400"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n\n delta = dict()\n for i in range(len(s)):\n if s[i] not in delta:\n delta[s[i]] = 0\n if t[i] not in delta:\n delta[t[i]] = 0\n delta[s[i]] += 1\n delta[t[i]] -= 1\n \n for key in delta.keys():\n if delta[key] != 0:\n return False\n return True","memory":"16500"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n hash_map = {}\n if len(s) != len(t):\n return False\n for c in s:\n if c not in hash_map:\n hash_map[c] = 1\n else:\n hash_map[c] += 1\n \n for c in t:\n if c not in hash_map:\n return False\n if hash_map[c] == 0:\n return False\n hash_map[c] -= 1\n return True","memory":"16600"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n \n count = {}\n for char in s:\n count[char] = count.get(char,0) + 1\n \n for char in t:\n if char not in count:\n return False\n count[char] -= 1\n if count[char] < 0:\n return False\n\n return True","memory":"16700"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n\n # Put them both into dictionaries, check if they're equal\n s_map = {}\n for ch in s:\n if ch not in s_map.keys():\n s_map[ch] = 1\n else: \n s_map[ch] += 1\n\n t_map = {}\n \n for ch in t:\n if ch not in t_map.keys():\n t_map[ch] = 1\n else: \n t_map[ch] += 1\n \n\n return s_map == t_map","memory":"16700"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n mem = {}\n for char in s:\n if char in mem:\n mem[char] += 1\n else:\n mem[char] = 1\n for char in t:\n if char in mem:\n mem[char] -= 1\n if mem[char] == 0:\n del mem[char]\n else:\n return False\n return not mem","memory":"16800"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n s_count = [0 for i in range(26)] \n t_count = [0 for i in range(26)]\n\n for c in s:\n s_count[ord(c) - ord('a')] += 1\n for c in t: \n t_count[ord(c) - ord('a')] += 1\n \n return s_count == t_count","memory":"16800"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n dicts = {}\n dictt = {}\n\n if len(s) != len(t):\n return False\n\n for i in range(len(s)):\n dicts[s[i]] = 1 + dicts.get(s[i],0)\n\n dictt[t[i]] = 1 + dictt.get(t[i],0)\n\n return dicts == dictt\n\n","memory":"16900"},{"code":"class Solution:\n def isAnagram(self, s, t):\n # TODO: Write your code here\n if len(s)!=len(t):\n return False\n\n freq_map={}\n for i in range (len(s)):\n if s[i] in freq_map:\n freq_map[s[i]]+=1\n else:\n freq_map[s[i]]=1\n if t[i] in freq_map:\n freq_map[t[i]]-=1\n else:\n freq_map[t[i]]=-1\n for char in freq_map:\n if freq_map[char]!=0:\n return False\n return True \n","memory":"16900"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n s_count = Counter(s)\n for c in t:\n if s_count[c] <= 0:\n return False\n else:\n s_count[c] -= 1\n \n for k, v in s_count.items():\n if v != 0:\n return False\n return True","memory":"17000"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n import collections\n\n s_dict = collections.Counter(s)\n t_dict = collections.Counter(t)\n\n if len(s) != len(t):\n return False\n\n for key, value in s_dict.items():\n if not key in t_dict.keys():\n return False\n else:\n if value != t_dict[key]:\n return False\n return True\n\n \n\n ","memory":"17000"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n # s_count = Counter(s)\n # t_count = Counter(t)\n # for char, count in s_count.items():\n # for char, count in t_count.items():\n # if t_count[char] == s_count[char]:\n # return True\n \n # return False\n return Counter(s) == Counter(t)\n ","memory":"17100"},{"code":"from collections import Counter \nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n if len(s)!=len(t):\n return False\n s_dict=Counter(s)\n t_dict=Counter(t)\n return s_dict==t_dict\n\n ","memory":"17100"},{"code":"def sortStr(str):\n return ''.join(sorted(str))\n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return sortStr(s) == sortStr(t)\n","memory":"17200"},{"code":"# def sortStr(str):\n# return ''.join(sorted(str))\n\n# Nlogn complexity\n# class Solution:\n# def isAnagram(self, s: str, t: str) -> bool:\n# return sortStr(s) == sortStr(t)\n\n\n# Runtime complexity = O(n)\n# Space complexity = O(n)\ndef occurence(s: str):\n occurenceDict = {}\n arr = list(s)\n for i in arr:\n if (i in occurenceDict):\n occurenceDict[i] = occurenceDict[i] + 1\n else:\n occurenceDict[i] = 1\n return occurenceDict \n\nclass Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n dict1 = occurence(s)\n dict2 = occurence(t)\n\n return dict1 == dict2\n","memory":"17200"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return sorted(s)==sorted(t)\n ","memory":"17300"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n return sorted(s) == sorted(t)","memory":"17300"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n a,b=list(s),list(t)\n a.sort()\n b.sort()\n if a==b:\n return True\n return False","memory":"17400"},{"code":"class Solution:\n def isAnagram(self, s: str, t: str) -> bool:\n a,b=list(s),list(t)\n a.sort()\n b.sort()\n if a==b:\n return True\n return False","memory":"17400"}],"string":"[\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n \\n count = defaultdict(int)\\n\\n for x in s:\\n count[x] += 1\\n\\n for x in t:\\n count[x] -= 1\\n\\n for val in count.values():\\n if val != 0:\\n return False\\n \\n return True\",\n \"memory\": \"15900\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n map=dict()\\n for i in s:\\n if i in map:\\n map[i]+=1\\n else:\\n map[i]=1\\n for i in t:\\n if i in map:\\n map[i]-=1\\n else:\\n return False\\n res=list(map.values())\\n return res.count(0)==len(res)\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n cnt1 = {}\\n cnt2 = {}\\n for ss in s:\\n if ss in cnt1:\\n cnt1[ss]+=1\\n else:\\n cnt1[ss]=1\\n \\n for ss in t:\\n if ss in cnt2:\\n cnt2[ss]+=1\\n else:\\n cnt2[ss]=1\\n \\n if len(cnt1)!=len(cnt2):\\n return False\\n \\n for ss in s:\\n if ss not in t:\\n return False\\n if cnt1[ss]!=cnt2[ss]:\\n return False\\n return True\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n \\n sCounter = Counter(s)\\n tCounter = Counter(t)\\n\\n for key, value in sCounter.items():\\n if value != tCounter[key]:\\n return False\\n return True\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n\\n delta = dict()\\n for i in range(len(s)):\\n if s[i] not in delta:\\n delta[s[i]] = 0\\n if t[i] not in delta:\\n delta[t[i]] = 0\\n delta[s[i]] += 1\\n delta[t[i]] -= 1\\n \\n for key in delta.keys():\\n if delta[key] != 0:\\n return False\\n return True\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n hash_map = {}\\n if len(s) != len(t):\\n return False\\n for c in s:\\n if c not in hash_map:\\n hash_map[c] = 1\\n else:\\n hash_map[c] += 1\\n \\n for c in t:\\n if c not in hash_map:\\n return False\\n if hash_map[c] == 0:\\n return False\\n hash_map[c] -= 1\\n return True\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n \\n count = {}\\n for char in s:\\n count[char] = count.get(char,0) + 1\\n \\n for char in t:\\n if char not in count:\\n return False\\n count[char] -= 1\\n if count[char] < 0:\\n return False\\n\\n return True\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n\\n # Put them both into dictionaries, check if they're equal\\n s_map = {}\\n for ch in s:\\n if ch not in s_map.keys():\\n s_map[ch] = 1\\n else: \\n s_map[ch] += 1\\n\\n t_map = {}\\n \\n for ch in t:\\n if ch not in t_map.keys():\\n t_map[ch] = 1\\n else: \\n t_map[ch] += 1\\n \\n\\n return s_map == t_map\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n mem = {}\\n for char in s:\\n if char in mem:\\n mem[char] += 1\\n else:\\n mem[char] = 1\\n for char in t:\\n if char in mem:\\n mem[char] -= 1\\n if mem[char] == 0:\\n del mem[char]\\n else:\\n return False\\n return not mem\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n s_count = [0 for i in range(26)] \\n t_count = [0 for i in range(26)]\\n\\n for c in s:\\n s_count[ord(c) - ord('a')] += 1\\n for c in t: \\n t_count[ord(c) - ord('a')] += 1\\n \\n return s_count == t_count\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n dicts = {}\\n dictt = {}\\n\\n if len(s) != len(t):\\n return False\\n\\n for i in range(len(s)):\\n dicts[s[i]] = 1 + dicts.get(s[i],0)\\n\\n dictt[t[i]] = 1 + dictt.get(t[i],0)\\n\\n return dicts == dictt\\n\\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s, t):\\n # TODO: Write your code here\\n if len(s)!=len(t):\\n return False\\n\\n freq_map={}\\n for i in range (len(s)):\\n if s[i] in freq_map:\\n freq_map[s[i]]+=1\\n else:\\n freq_map[s[i]]=1\\n if t[i] in freq_map:\\n freq_map[t[i]]-=1\\n else:\\n freq_map[t[i]]=-1\\n for char in freq_map:\\n if freq_map[char]!=0:\\n return False\\n return True \\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n s_count = Counter(s)\\n for c in t:\\n if s_count[c] <= 0:\\n return False\\n else:\\n s_count[c] -= 1\\n \\n for k, v in s_count.items():\\n if v != 0:\\n return False\\n return True\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n import collections\\n\\n s_dict = collections.Counter(s)\\n t_dict = collections.Counter(t)\\n\\n if len(s) != len(t):\\n return False\\n\\n for key, value in s_dict.items():\\n if not key in t_dict.keys():\\n return False\\n else:\\n if value != t_dict[key]:\\n return False\\n return True\\n\\n \\n\\n \",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n # s_count = Counter(s)\\n # t_count = Counter(t)\\n # for char, count in s_count.items():\\n # for char, count in t_count.items():\\n # if t_count[char] == s_count[char]:\\n # return True\\n \\n # return False\\n return Counter(s) == Counter(t)\\n \",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"from collections import Counter \\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n if len(s)!=len(t):\\n return False\\n s_dict=Counter(s)\\n t_dict=Counter(t)\\n return s_dict==t_dict\\n\\n \",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"def sortStr(str):\\n return ''.join(sorted(str))\\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return sortStr(s) == sortStr(t)\\n\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"# def sortStr(str):\\n# return ''.join(sorted(str))\\n\\n# Nlogn complexity\\n# class Solution:\\n# def isAnagram(self, s: str, t: str) -> bool:\\n# return sortStr(s) == sortStr(t)\\n\\n\\n# Runtime complexity = O(n)\\n# Space complexity = O(n)\\ndef occurence(s: str):\\n occurenceDict = {}\\n arr = list(s)\\n for i in arr:\\n if (i in occurenceDict):\\n occurenceDict[i] = occurenceDict[i] + 1\\n else:\\n occurenceDict[i] = 1\\n return occurenceDict \\n\\nclass Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n dict1 = occurence(s)\\n dict2 = occurence(t)\\n\\n return dict1 == dict2\\n\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return sorted(s)==sorted(t)\\n \",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n return sorted(s) == sorted(t)\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n a,b=list(s),list(t)\\n a.sort()\\n b.sort()\\n if a==b:\\n return True\\n return False\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def isAnagram(self, s: str, t: str) -> bool:\\n a,b=list(s),list(t)\\n a.sort()\\n b.sort()\\n if a==b:\\n return True\\n return False\",\n \"memory\": \"17400\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":22,"string":"22"}}},{"rowIdx":67,"cells":{"question_id":{"kind":"number","value":31,"string":"31"},"name":{"kind":"string","value":"next-permutation"},"content":{"kind":"string","value":"<p>A <strong>permutation</strong> of an array of integers is an arrangement of its members into a sequence or linear order.</p>\n\n<ul>\n\t<li>For example, for <code>arr = [1,2,3]</code>, the following are all the permutations of <code>arr</code>: <code>[1,2,3], [1,3,2], [2, 1, 3], [2, 3, 1], [3,1,2], [3,2,1]</code>.</li>\n</ul>\n\n<p>The <strong>next permutation</strong> of an array of integers is the next lexicographically greater permutation of its integer. More formally, if all the permutations of the array are sorted in one container according to their lexicographical order, then the <strong>next permutation</strong> of that array is the permutation that follows it in the sorted container. If such arrangement is not possible, the array must be rearranged as the lowest possible order (i.e., sorted in ascending order).</p>\n\n<ul>\n\t<li>For example, the next permutation of <code>arr = [1,2,3]</code> is <code>[1,3,2]</code>.</li>\n\t<li>Similarly, the next permutation of <code>arr = [2,3,1]</code> is <code>[3,1,2]</code>.</li>\n\t<li>While the next permutation of <code>arr = [3,2,1]</code> is <code>[1,2,3]</code> because <code>[3,2,1]</code> does not have a lexicographical larger rearrangement.</li>\n</ul>\n\n<p>Given an array of integers <code>nums</code>, <em>find the next permutation of</em> <code>nums</code>.</p>\n\n<p>The replacement must be <strong><a href=\"http://en.wikipedia.org/wiki/In-place_algorithm\" target=\"_blank\">in place</a></strong> and use only constant extra memory.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [1,2,3]\n<strong>Output:</strong> [1,3,2]\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [3,2,1]\n<strong>Output:</strong> [1,2,3]\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [1,1,5]\n<strong>Output:</strong> [1,5,1]\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 100</code></li>\n\t<li><code>0 <= nums[i] <= 100</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":41.07568825572439,"string":"41.075688"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","two-pointers"],"string":"[\n \"array\",\n \"two-pointers\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"22\", 0.0073], [\"23\", 0.0073], [\"24\", 0.0219], [\"25\", 0.0439], [\"26\", 0.1756], [\"27\", 0.1756], [\"28\", 0.1609], [\"29\", 0.2268], [\"30\", 0.7388], [\"31\", 0.5999], [\"32\", 0.929], [\"33\", 1.3021], [\"34\", 2.6408], [\"35\", 2.0263], [\"36\", 2.2531], [\"37\", 3.6138], [\"38\", 5.5743], [\"39\", 4.6086], [\"40\", 4.6452], [\"41\", 6.9349], [\"42\", 8.632], [\"43\", 6.218], [\"44\", 5.9766], [\"45\", 7.981], [\"46\", 7.9517], [\"47\", 5.7864], [\"48\", 4.6233], [\"49\", 4.8354], [\"50\", 3.8332]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16000\", 0.0073], [\"16100\", 0.0219], [\"16200\", 0.117], [\"16300\", 3.6138], [\"16400\", 22.2677], [\"16500\", 40.3731]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n length = len(nums) \n pivot = -1\n for i in range(length - 2, -1, -1):\n if nums[i] < nums[i + 1]:\n pivot = i\n break\n if pivot != -1:\n for j in range(length - 1, pivot, -1):\n if nums[j] > nums[pivot]:\n nums[pivot], nums[j] = nums[j], nums[pivot]\n break\n nums[pivot + 1:] = reversed(nums[pivot + 1:])","runtime":"22"},{"code":"from typing import List\n\n\ndef get_smaller_num_index_from_right(num: int, end_index: int, nums: list[int]) -> int | None:\n current_index = end_index\n while current_index >= 0:\n if nums[current_index] < num:\n return current_index\n current_index -= 1\n\n return None\n\n\ndef get_left_index_to_switch(nums: list[int]) -> int | None:\n index = len(nums) - 1\n while index > 0:\n if nums[index - 1] < nums[index]:\n return index - 1\n index -= 1\n return None\n\n\ndef get_right_index_to_switch(nums: list[int], smaller_num: int) -> int:\n index = len(nums) - 1\n while nums[index] <= smaller_num:\n index -= 1\n\n return index\n\n\ndef get_indexes_to_switch(nums: list[int]) -> tuple[int, int] | None:\n left_index_to_switch = get_left_index_to_switch(nums)\n if left_index_to_switch is None:\n return None\n return left_index_to_switch, get_right_index_to_switch(nums, nums[left_index_to_switch])\n\n\ndef reverse(start_index: int, end_index: int, nums: list[int]) -> None:\n while start_index < end_index:\n nums[start_index], nums[end_index] = nums[end_index], nums[start_index]\n start_index += 1\n end_index -= 1\n\n\nclass Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n if len(nums) <= 1:\n return\n\n indexes_to_switch = get_indexes_to_switch(nums)\n if indexes_to_switch is None:\n reverse(0, len(nums) - 1, nums)\n else:\n nums[indexes_to_switch[0]], nums[indexes_to_switch[1]] = \\\n nums[indexes_to_switch[1]], nums[indexes_to_switch[0]]\n reverse(indexes_to_switch[0] + 1, len(nums) - 1, nums)\n","runtime":"23"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n n = len(nums)\n l = n - 1\n while l > 0 and nums[l - 1] >= nums[l]:\n l -= 1\n if l == 0:\n nums.reverse()\n return\n\n min_index = l\n l -= 1\n for i in range(l + 1, n):\n if nums[i] > nums[l] and nums[i] <= nums[min_index]:\n min_index = i\n # print(min_index)\n # swap l and min_index\n temp = nums[min_index]\n nums[min_index] = nums[l]\n nums[l] = temp\n\n # sort l+1..n-1\n l = l + 1\n r = n - 1\n while l <= r:\n temp = nums[l]\n nums[l] = nums[r]\n nums[r] = temp\n r -= 1\n l += 1\n \n\n\n","runtime":"24"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n is_max = True\n\n current = nums[0]\n for num in nums:\n if num > current:\n is_max = False\n break\n current = num\n\n if is_max:\n nums.reverse()\n return nums\n\n target = -1\n for idx in range(len(nums) - 1, 0, -1):\n if nums[idx] > nums[idx - 1]:\n target = idx - 1\n break\n\n next_greater_idx = target\n idx = target + 1\n while idx < len(nums):\n if nums[idx] <= nums[target]:\n next_greater_idx = idx - 1\n break\n idx += 1\n\n if next_greater_idx == target:\n next_greater_idx = len(nums) - 1\n\n nums[target], nums[next_greater_idx] = nums[next_greater_idx], nums[target]\n\n left = target + 1\n right = len(nums) - 1\n\n while left < right:\n nums[left], nums[right] = nums[right], nums[left]\n left += 1\n right -= 1\n\n return nums\n","runtime":"25"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n # i such that nums[i] < nums[i+1] else reverse\n # j such that nums[j] < nums[i]\n # reverse nums[i+1:] \n i = len(nums) - 2\n while i > -1:\n if nums[i] < nums[i+1]:\n break\n i -= 1\n else:\n nums.reverse()\n return \n \n j = len(nums) - 1\n\n while j > -1:\n if nums[j] > nums[i]:\n break\n j -=1\n \n nums[i], nums[j] = nums[j], nums[i]\n nums[i+1:] = nums[i+1:][::-1]\n","runtime":"26"},{"code":"class Solution:\n def nextPermutation(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: void Do not return anything, modify nums in-place instead.\n \"\"\"\n i = len(nums) - 2\n while i >= 0 and nums[i] >= nums[i+1]:\n i -= 1\n\n #i is smaller element i+1 is peak\n if i >= 0:\n j = len(nums) - 1\n while nums[j] <= nums[i]:\n j -= 1\n nums[i], nums[j] = nums[j], nums[i]\n #reverse instead of sort because we know right side is descending\n self.reverse(nums, i + 1)\n\n def reverse(self, nums, start):\n i, j = start, len(nums) - 1\n while i < j:\n nums[i], nums[j] = nums[j], nums[i]\n i += 1\n j -= 1\n\n \n ","runtime":"27"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n i = len(nums) - 2\n while i >= 0 and nums[i+1] <= nums[i]:\n i-=1\n if i >= 0:\n j = len(nums) - 1\n while nums[j] <= nums[i]:\n j-=1\n nums[i], nums[j] = nums[j], nums[i]\n self.reverse(nums, i + 1)\n\n def reverse(self, nums, start):\n i, j = start, len(nums) - 1 \n while i < j:\n nums[i], nums[j] = nums[j], nums[i]\n i+=1\n j-=1","runtime":"28"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n n = len(nums)\n if n <= 1:\n return\n\n k = n - 2\n # Step 1: Find the largest index k such that nums[k] < nums[k + 1]\n while k >= 0 and nums[k] >= nums[k + 1]:\n k -= 1\n \n if k >= 0:\n # Step 2: Find the largest index l greater than k such that nums[k] < nums[l]\n l = n - 1\n while nums[k] >= nums[l]:\n l -= 1\n\n # Step 3: Swap the values of nums[k] and nums[l]\n nums[k], nums[l] = nums[l], nums[k]\n\n # Step 4: Reverse the sequence from sequence k + 1 to end\n nums[k + 1:] = reversed(nums[k + 1:])\n \n return nums\n\n","runtime":"29"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n # Solution 1 - \n # Time - \n # Space -\n\n # https://www.youtube.com/watch?v=6qXO72FkqwM - To understand\n # https://www.youtube.com/watch?v=JRgIqugFhTo - For code\n\n pivot = -1\n\n for i in range(len(nums) - 1, 0, -1):\n if nums[i - 1] < nums[i]:\n pivot = i - 1\n break\n\n\n if pivot < 0: # Means the number is in Descending order; Already highest permutation possible\n nums.reverse()\n return\n\n swap = len(nums) - 1\n\n while nums[swap] <= nums[pivot]:\n swap -= 1\n\n nums[swap], nums[pivot] = nums[pivot], nums[swap]\n # print(pivot, nums[pivot + 1:])\n nums[pivot + 1:] = reversed(nums[pivot + 1:])\n\n return\n\n # 0. 1. 2\n # nums = [1, 3, 2]\n # pivot = 1\n # swap = 2\n\n # 0. 1. 2\n # nums = [3, 2, 1]\n # pivot = -1\n # reverse it\n\n # 0. 1. 2\n # nums = [1, 5, 1]\n # pivot = 1\n # swap = 2\n\n\n # NOTE: very good example. \n #. 0.1 2 3 4\n # nums = [ 1 2 3 5 4 ]\n # pivot = 2\n # swap = 4\n\n # res = [1 2 4 3 5]","runtime":"29"},{"code":"class Solution:\n \n def swapWithMin(self, nums, startIndex, endIndex):\n for i in range(endIndex, startIndex, -1):\n if nums[i] > nums[startIndex]:\n nums[startIndex], nums[i] = nums[i], nums[startIndex]\n break\n \n \n def reverseArray(self, nums, startIndex, endIndex):\n while(startIndex <= endIndex):\n nums[startIndex], nums[endIndex] = nums[endIndex], nums[startIndex]\n startIndex+=1\n endIndex-=1\n \n \n \n \n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n n = len(nums)\n i = n-2\n isLoopBroke = 0\n while(i >= 0):\n if(nums[i] >= nums[i+1]):\n print(i)\n i-=1\n else:\n self.swapWithMin(nums, i, n-1)\n self.reverseArray(nums, i+1, n-1)\n break\n \n \n if i == -1:\n self.reverseArray(nums, 0, n-1)","runtime":"30"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n n=len(nums)\n b=-1\n for i in range(n-2,-1,-1):\n if nums[i]<nums[i+1]:\n b=i\n break\n if b==-1:\n nums.sort()\n for i in range(n-1,-1,-1):\n if nums[i]>nums[b]:\n nums[i],nums[b]=nums[b],nums[i]\n break\n if b+1!=n-1:\n l=nums[b+1:]\n l.sort()\n nums[b+1:]=l[:]\n \n\n \n ","runtime":"30"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n \n \n def reverse(start,end):\n \n while start<=end:\n \n nums[start],nums[end]=nums[end],nums[start]\n start+=1\n end-=1\n \n \n for idx in range(len(nums)-1,0,-1):\n \n \n if (nums[idx]>nums[idx-1]):\n pivot= idx-1\n \n end=len(nums)-1\n while nums[end]<=nums[pivot]:\n end-=1\n nums[end],nums[pivot]=nums[pivot],nums[end]\n # print(nums)\n reverse(pivot+1,len(nums)-1)\n break\n \n else:\n reverse(0,len(nums)-1)\n \n ","runtime":"31"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n n = len(nums) # size of the array.\n A=nums\n # Step 1: Find the break point:\n ind = -1 # break point\n for i in range(n-2, -1, -1):\n if A[i] < A[i + 1]:\n # index i is the break point\n ind = i\n break\n\n # If break point does not exist:\n if ind == -1:\n # reverse the whole array:\n A.reverse()\n return A\n\n # Step 2: Find the next greater element\n # and swap it with arr[ind]:\n for i in range(n - 1, ind, -1):\n if A[i] > A[ind]:\n A[i], A[ind] = A[ind], A[i]\n break\n\n # Step 3: reverse the right half:\n A[ind+1:] = reversed(A[ind+1:])\n\n return A\n","runtime":"32"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n # start from end and find first number lower than prev\n end = len(nums) - 1\n last = nums[end]\n while end >= 0:\n num = nums[end]\n if num < last:\n last = num\n break\n else:\n last = num\n end -= 1\n\n # start from end and find first number greater than prev\n right = len(nums) - 1\n while right >= 0:\n num = nums[right]\n if num > last:\n break\n right -= 1\n\n print(nums)\n # swap\n temp = nums[right]\n nums[right] = last\n nums[end] = temp\n\n print(nums)\n\n # sort asc by swapping\n start = end + 1\n end = len(nums) - 1\n while start < end:\n temp = nums[start]\n nums[start] = nums[end]\n nums[end] = temp\n\n start += 1\n end -= 1\n return None","runtime":"32"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n idx=-1\n for i in range(len(nums)-2,-1,-1):\n if nums[i]<nums[i+1]:\n idx=i\n break\n if idx == -1 :\n return nums.reverse()\n\n for i in range(len(nums)-1,idx,-1):\n if nums[i]>nums[idx]:\n nums[i] , nums[idx] = nums[idx],nums[i]\n break\n\n nums[idx+1:] = reversed(nums[idx+1:])\n \n return nums \n","runtime":"33"},{"code":"from bisect import bisect_right\n\nclass Solution:\n \n def pickNextNumber(self, arr, target):\n arr.sort()\n index = bisect_right(arr, target)\n return arr[index]\n \n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n \n remaining = []\n \n minTillNow = 10**10\n for i in range(len(nums) - 1, 0, -1):\n if nums[i] > nums[i-1]:\n remaining = nums[i:]\n swap = self.pickNextNumber(remaining, nums[i-1])\n break\n \n if remaining:\n remaining.remove(swap)\n temp = nums[i-1] \n nums[i-1] = swap\n remaining.append(temp)\n remaining.sort()\n\n for j in range(i, len(nums)):\n nums[j] = remaining[j-i]\n\n else:\n \n nums.sort()","runtime":"33"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n if len(nums) == 1:\n return nums\n change = 0\n for i in range(len(nums)-2,-1,-1):\n if nums[i] < nums[i+1]:\n change = i\n break\n \n pter = len(nums)-1\n while pter > change:\n if nums[pter] > nums[change]:\n break\n pter-=1\n # print(change, pter)\n\n if pter != change:\n nums[change], nums[pter] = nums[pter], nums[change]\n else:\n nums[change], nums[-1] = nums[-1], nums[change]\n\n i = change+1\n j = len(nums)-1\n # print(nums)\n while i <= j:\n if nums[i] > nums[j]:\n nums[i], nums[j] = nums[j], nums[i]\n i+=1\n else:\n j-=1","runtime":"34"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n 1 2 5 6 4 3\n \"\"\"\n\n def reverse(i, j):\n while i < j:\n nums[i], nums[j] = nums[j], nums[i]\n i += 1\n j -= 1\n \n # if descending, reverse\n i = len(nums) - 2\n while i >= 0 and nums[i] >= nums[i + 1] :\n i -= 1\n\n if i >= 0:\n j = len(nums) - 1\n while j >=0 and nums[j] <= nums[i]:\n j -= 1\n nums[i], nums[j] = nums[j], nums[i]\n reverse(i + 1, len(nums) - 1)","runtime":"34"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n if len(nums) <= 1:\n return\n \n i = len(nums) - 2\n while i >= 0 and nums[i] >= nums[i + 1]:\n i -= 1\n \n if i >= 0:\n j = bisect_left(nums, -nums[i], lo=i + 1, key=lambda x: -x) - 1\n nums[i], nums[j] = nums[j], nums[i]\n \n l = i + 1\n r = len(nums) - 1\n while l < r:\n nums[l], nums[r] = nums[r], nums[l]\n l += 1\n r -= 1\n \n \n ","runtime":"35"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n if len(nums) <=1:\n return\n\n def reverse(n):\n left, right = n,len(nums)-1\n\n while left<right:\n nums[left], nums[right] = nums[right], nums[left]\n left +=1\n right -=1\n\n def swap_with_larger_right(j):\n max_val_index = j\n max_val = 101\n\n for i in range(j, len(nums)):\n if nums[i] > nums[j] and nums[i]<= max_val:\n max_val = nums[i]\n max_val_index = i\n nums[j], nums[max_val_index] = nums[max_val_index], nums[j]\n\n for i in range(len(nums)-1, 0, -1):\n if nums[i-1] < nums[i]:\n swap_with_larger_right(i-1)\n reverse(i)\n return\n\n reverse(0)\n\n \n ","runtime":"35"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n n=len(nums)\n j=-1\n for i in range(n-2,-1,-1):\n if nums[i]<nums[i+1]:\n j=i\n break\n if j==-1:\n reverse(0,n-1,nums)\n return \n else:\n for k in range(n-1,-1,-1):\n if nums[k]>nums[j]:\n nums[j],nums[k]=nums[k],nums[j]\n reverse(j+1,n-1,nums)\n return \ndef reverse(start,end,nums):\n while start<=end:\n nums[start],nums[end]=nums[end],nums[start]\n start+=1\n end-=1\n \n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n ","runtime":"36"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n if len(nums) == 1:\n return nums\n change = 0\n for i in range(len(nums)-2,-1,-1):\n if nums[i] < nums[i+1]:\n change = i\n break\n \n pter = len(nums)-1\n while pter > change:\n if nums[pter] > nums[change]:\n break\n pter-=1\n # print(change, pter)\n\n if pter != change:\n nums[change], nums[pter] = nums[pter], nums[change]\n else:\n nums[change], nums[-1] = nums[-1], nums[change]\n\n i = change+1\n j = len(nums)-1\n # print(nums)\n while i <= j:\n if nums[i] > nums[j]:\n nums[i], nums[j] = nums[j], nums[i]\n i+=1\n else:\n j-=1\n # print(i,j,nums)","runtime":"36"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n i = j = len(nums) - 1\n while i > 0 and nums[i-1] >= nums[i]:\n i -= 1\n if i == 0:\n return nums.reverse()\n k = i - 1\n while nums[k] >= nums[j]:\n j -= 1\n nums[k], nums[j] = nums[j], nums[k]\n l = k + 1\n r = len(nums) - 1\n while l < r:\n nums[l], nums[r] = nums[r], nums[l]\n r -= 1\n l += 1\n return nums\n\n \n\n \n ","runtime":"37"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n n = len(nums)\n i = n - 2\n while i >= 0 and nums[i] >= nums[i + 1]:\n i -= 1\n \n if i >= 0:\n j = n - 1\n while nums[j] <= nums[i]:\n j -= 1\n nums[i], nums[j] = nums[j], nums[i]\n \n left, right = i + 1, n - 1\n while left < right:\n nums[left], nums[right] = nums[right], nums[left]\n left += 1\n right -= 1\n","runtime":"37"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n \n # 12345 66\n # 1234656\n\n # 135 8762\n # 136 2578\n\n # 8876\n # 6788\n pt = -1\n for i in range(len(nums)-1,0,-1):\n if nums[i] > nums[i-1]:\n pt = i - 1\n break\n if pt != -1:\n target = nums[pt]\n for i in range(len(nums)-1,pt,-1):\n if nums[i] > nums[pt]:\n nums[i],nums[pt] = nums[pt],nums[i]\n break\n self.reverse(nums, pt+1)\n def reverse(self, nums, start):\n i, j = start, len(nums) - 1\n while i < j:\n self.swap(nums, i, j)\n i += 1\n j -= 1\n\n def swap(self, nums, i, j):\n temp = nums[i]\n nums[i] = nums[j]\n nums[j] = temp ","runtime":"38"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n i = len(nums) -2\n #Find DIP \n while i >=0 and nums[i] >= nums[i+1]:\n i -= 1\n \n if i == -1:\n left = 0 \n right = len(nums) - 1\n while left < right: \n nums[left], nums[right] = nums[right], nums[left]\n left += 1\n right -=1 \n return \n #Find smallest element larger than DIP\n j = len(nums) - 1\n while nums[j] <= nums[i]:\n j -= 1\n nums[i], nums[j] = nums[j], nums[i]\n #Reverse numbers after pivot\n left = i + 1 \n right = len(nums) - 1\n while left < right: \n nums[left], nums[right] = nums[right], nums[left]\n left += 1\n right -= 1\n","runtime":"38"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n #1,2,3,4,1\n #1,2,4,1,3\n # switch least significant that can go up, sort all after that\n if len(nums) == 1:\n return nums\n curIdx = len(nums) - 2\n while curIdx >= 0 and nums[curIdx + 1] <= nums[curIdx]:\n curIdx -= 1\n toSwap = curIdx + 1\n if curIdx != -1:\n while toSwap < len(nums) and nums[toSwap] > nums[curIdx]:\n toSwap += 1\n toSwap -= 1\n nums[toSwap], nums[curIdx] = nums[curIdx], nums[toSwap]\n nums[curIdx+1:] = sorted(nums[curIdx+1:])","runtime":"39"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n # find the decreasingIndex of nums from right to left\n decreasingIndex:int = len(nums) - 2\n # if we can't find one reverse nums and thats it\n while decreasingIndex > - 1:\n if nums[decreasingIndex] < nums[decreasingIndex + 1]:\n break\n decreasingIndex -= 1\n\n if decreasingIndex == -1:\n nums.reverse()\n return\n # Find the number larger than decreasing Index from right to left (it has to exist)\n largerIndex:int = len(nums) - 1\n while largerIndex > - 1:\n if nums[largerIndex] > nums[decreasingIndex]:\n break\n largerIndex -= 1\n\n # swap decreasingIndex and largest Index\n self.swap(nums, decreasingIndex, largerIndex)\n # reverse from decreasingIndex + 1\n self.reverse(nums, decreasingIndex + 1, len(nums) - 1)\n\n \n def swap(self, nums: List[int], left:int, right:int):\n leftVal:int = nums[left]\n rightVal:int = nums[right]\n nums[left] = rightVal\n nums[right] = leftVal\n \n def reverse(self, nums: List[int], left:int, right:int):\n while left < right:\n self.swap(nums, left, right)\n left += 1\n right -= 1","runtime":"39"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n i=j=len(nums)-1\n while i > 0 and nums[i-1] >= nums[i]:\n i -= 1\n if i==0:\n nums.reverse()\n return\n k = i-1\n while nums[j] <= nums[k]:\n j -= 1\n nums[j],nums[k] = nums[k],nums[j]\n l,r = k+1,len(nums)-1\n while l < r:\n nums[l],nums[r] = nums[r],nums[l]\n l += 1\n r -= 1\n ","runtime":"40"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Find the longest non-increasing suffix.\n Point before it being is your pivot\n From that suffix, find the minimum that's greater than your pivot\n Swap your pivot with it\n Reverse the suffix\n \"\"\"\n i = len(nums) - 1\n while i > 0:\n if nums[i] > nums[i - 1]:\n pivot = i - 1\n j = i\n while j < len(nums) and nums[j] > nums[pivot]:\n j += 1\n j -= 1\n nums[pivot], nums[j] = nums[j], nums[pivot]\n nums[pivot + 1:] = nums[pivot + 1:][::-1]\n return\n else:\n i -= 1\n nums.reverse()\n ","runtime":"40"},{"code":"class Solution:\n\n\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n n = len(nums)\n\n # First i smaller than next\n i = n -2\n while i >= 0 and nums[i] >= nums[i + 1]:\n i -= 1\n\n\n # if it's in sorted order\n if i < 0:\n nums[0:] = reversed(nums)\n return\n\n j = n-1\n while nums[j] <= nums[i]:\n j -= 1\n \n nums[i], nums[j] = nums[j], nums[i]\n\n # reverse the last ones as well\n nums[i+1:] = reversed(nums[i+1:]) \n\n\n","runtime":"41"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n def swap(fromIndex:int, toIndex:int):\n fromVal:int = nums[fromIndex]\n toVal:int = nums[toIndex]\n nums[fromIndex] = toVal\n nums[toIndex] = fromVal\n \n def reverse(left:int, right:int):\n while left < right:\n swap(left, right)\n left += 1\n right -= 1\n\n decreasingIndex:int = len(nums) - 2\n while decreasingIndex > -1:\n if nums[decreasingIndex] < nums[decreasingIndex + 1]:\n break\n decreasingIndex -= 1\n \n if decreasingIndex == -1:\n nums.sort()\n return\n \n largerIndex:int = len(nums) - 1\n\n while largerIndex > -1:\n if nums[largerIndex] > nums[decreasingIndex]:\n break\n largerIndex -= 1\n \n swap(largerIndex, decreasingIndex)\n reverse(decreasingIndex + 1, len(nums) - 1)","runtime":"41"},{"code":"\nclass Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n length = len(nums)\n\n i = length - 2\n while i >= 0 and nums[i] >= nums[ i+1 ]:\n i -= 1\n\n if i >= 0:\n j = length - 1\n while nums[j] <= nums[i]:\n j -= 1\n nums[i], nums[j] = nums[j], nums[i]\n \n nums[i + 1:] = reversed(nums[i + 1:])\n","runtime":"42"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n \n if len(nums) <= 1:\n return\n\n def get_valued_index_from_right(value: int) -> int:\n idx = len(nums) - 1\n while nums[idx] <= value and idx > 0:\n idx -= 1\n return idx\n \n def verse_form_index(idx: int):\n iterations = (len(nums) - idx) // 2\n for i in range(iterations):\n first = nums[idx + i]\n last = nums[len(nums) - 1 -i]\n nums[idx + i] = last\n nums[len(nums) - 1 -i] = first\n\n # loop from n-1 to 0\n # search for smaller than i\n\n # get pivot\n i = len(nums) - 1\n while nums[i - 1] >= nums[i] and i > 0:\n i -= 1\n\n # handle the case of the initial state\n if i <= 0:\n verse_form_index(i)\n return\n\n idx = get_valued_index_from_right(nums[i - 1])\n\n first = nums[i - 1]\n to_swap = nums[idx]\n nums[i - 1] = to_swap\n nums[idx] = first\n\n verse_form_index(i)\n\n \"\"\"\n\n 1 2 3 4\n 1 2 4 3\n\n 1 3 2 4\n 1 3 4 2\n 1 4 2 3\n 1 4 3 2\n\n 1 5 4 3 2\n\n 2 1 3 4 5\n 2 5 4 3 1\n\n \"\"\"","runtime":"42"},{"code":"class Solution:\n def swap(self, nums, i, j):\n temp = nums[i]\n nums[i] = nums[j]\n nums[j] = temp\n def reverse(self, nums, i, j):\n while i < j:\n self.swap(nums, i, j)\n i += 1\n j -= 1\n \n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n i = len(nums) - 2\n while i >= 0 and nums[i] >= nums[i + 1]:\n i -= 1\n if i >= 0:\n j = len(nums) - 1\n while nums[j] <= nums[i]:\n j -= 1\n self.swap(nums, i, j)\n self.reverse(nums, i+1, len(nums) - 1)\n\n return nums","runtime":"43"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n i = len(nums) - 2\n while i>=0 and nums[i] >= nums[i+1]:\n i-=1\n if i >= 0:\n j = len(nums) - 1\n while nums[j] <= nums[i]:\n j-=1\n nums[i], nums[j] = nums[j], nums[i]\n def reverse(start):\n right = len(nums) - 1\n while start < right:\n nums[start], nums[right] = nums[right], nums[start]\n start+=1\n right-=1\n reverse(i+1)","runtime":"43"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n i=len(nums)-2\n while i>=0 and nums[i]>=nums[i+1]:\n i-=1\n if i==-1:\n nums.reverse()\n return\n j=len(nums)-1\n while nums[j]<=nums[i]:\n j-=1\n nums[i],nums[j]=nums[j],nums[i]\n nums[i+1:]=reversed(nums[i+1:])\n\n","runtime":"44"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n N = len(nums)\n greatest = nums[-1]\n found = False\n for i in reversed(range(N - 1)):\n if greatest > nums[i]:\n smallestGreater = None\n for j in range(i + 1, N):\n if nums[j] > nums[i]:\n if smallestGreater is None or nums[j] < nums[smallestGreater]:\n smallestGreater = j\n tmp = nums[smallestGreater]\n nums[smallestGreater] = nums[i]\n nums[i] = tmp\n\n nums[i + 1:] = list(sorted(nums[i + 1:]))\n\n found = True\n break\n greatest = max(greatest, nums[i])\n \n if not found:\n nums.sort()","runtime":"44"},{"code":"class Solution:\n def rev(self, nums, i, j):\n nums[i+1:j+1] = nums[i+1:j+1][::-1]\n # print(\"nums1 \", nums)\n return nums\n\n def swap_eles(self, nums, i, j):\n t = nums[i]\n nums[i] = nums[j]\n nums[j] = t\n # print(\"nums2 \", nums)\n return nums\n \n def find_sec_max(self, nums, i, j, ele):\n max_ele = 999\n ind = -1\n for k in range(i, j):\n if ele < nums[k] <= max_ele:\n max_ele = nums[k]\n ind = k\n # print(\"ind, i \", ind, i-1)\n nums = self.swap_eles(nums, i-1, ind)\n # print(\"after swap \", nums)\n return nums\n\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n max_ele = -1\n diff_ele = None\n for i in range(len(nums)-1, -1, -1):\n if nums[i] >= max_ele:\n max_ele = nums[i]\n else:\n diff_ele = nums[i]\n break\n # print(\"i \", i)\n if diff_ele is None:\n # print(\"inside if\")\n nums[:] = sorted(nums)\n else:\n # print(\"inside else\")\n nums = self.find_sec_max(nums, i+1, len(nums), nums[i])\n # print(\"nums1 \", nums)\n nums = self.rev(nums, i, len(nums)-1)\n # print(\"nums2 \", nums)\n \n # print(\"nums \", nums)","runtime":"45"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n #finding pivot\n pivot=0\n n=len(nums)\n for i in range(n-1,0,-1):\n if nums[i-1]<nums[i]:\n pivot=i\n break\n #if in maximum decending order\n if pivot==0:\n return nums.reverse()\n\n #finding successor in case pivot found\n pivot_index=pivot-1\n successor=n-1\n while nums[successor]<=nums[pivot_index]:\n successor-=1\n \n #swapping pivot with just next larger element\n nums[pivot_index],nums[successor]=nums[successor],nums[pivot_index]\n\n #reverse rest of the element to ascending \n nums[pivot:]=reversed(nums[pivot:])\n\n ","runtime":"45"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n for idx in range(len(nums)-2, -1, -1):\n if nums[idx] >= nums[idx + 1]: continue\n \n replacement_idx = idx + 1\n for tmp in range(idx+2, len(nums)):\n if nums[tmp] > nums[idx] and nums[tmp] < nums[replacement_idx]:\n replacement_idx = tmp\n nums[idx], nums[replacement_idx] = nums[replacement_idx], nums[idx]\n\n nums[idx+1: ] = sorted(nums[idx+1:])\n\n return\n else:\n nums.sort()","runtime":"46"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n n = len(nums)\n i = n - 1\n\n # Find non-increasing sucessor\n while i > 0 and nums[i] <= nums[i-1]:\n i -= 1\n if i == 0:\n nums.reverse()\n return \n j = n - 1\n while j > 0 and nums[j] <= nums[i-1]:\n j -= 1\n\n nums[i-1], nums[j] = nums[j], nums[i-1]\n nums[i:] = nums[n-1:i-1:-1]\n\n ","runtime":"46"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n ind=-1\n n=len(nums)\n for i in range(n-2,-1,-1):\n if nums[i]<nums[i+1]:\n ind=i\n break\n if ind==-1:\n return nums.reverse()\n for i in range(n-1,ind,-1):\n if nums[i]>nums[ind]:\n nums[i],nums[ind]=nums[ind],nums[i]\n break\n nums[ind+1:]=reversed(nums[ind+1:])","runtime":"47"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n #1,2,3,4,1\n #1,2,4,1,3\n # switch least significant that can go up, sort all after that\n if len(nums) == 1:\n return nums\n curIdx = len(nums) - 2\n while curIdx >= 0 and nums[curIdx + 1] <= nums[curIdx]:\n curIdx -= 1\n toSwap = curIdx + 1\n if curIdx != -1:\n while toSwap < len(nums) and nums[toSwap] > nums[curIdx]:\n toSwap += 1\n toSwap -= 1\n nums[toSwap], nums[curIdx] = nums[curIdx], nums[toSwap]\n nums[curIdx+1:] = reversed(nums[curIdx+1:])","runtime":"47"},{"code":"class Solution:\n def nextPermutation(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: void Do not return anything, modify nums in-place instead.\n \"\"\"\n i = len(nums) - 2\n while i >= 0 and nums[i + 1] <= nums[i]:\n i -= 1\n if i >= 0:\n j = len(nums) - 1\n while nums[j] <= nums[i]:\n j -= 1\n self.swap(nums, i, j)\n self.reverse(nums, i + 1)\n\n def reverse(self, nums, start):\n i, j = start, len(nums) - 1\n while i < j:\n self.swap(nums, i, j)\n i += 1\n j -= 1\n\n def swap(self, nums, i, j):\n temp = nums[i]\n nums[i] = nums[j]\n nums[j] = temp","runtime":"48"},{"code":"class Solution:\n def nextPermutation(self, nums: list[int]) -> None:\n \"\"\"Do not return anything, modify nums in-place instead.\"\"\"\n i = len(nums) - 2\n while i >= 0 and nums[i] >= nums[i + 1]:\n i -= 1\n\n if i >= 0:\n j = len(nums) - 1\n while nums[j] <= nums[i]:\n j -= 1\n self.swap(nums, i, j)\n self.reverse(nums, i + 1)\n\n def reverse(self, nums, start):\n i, j = start, len(nums) - 1\n while i < j:\n self.swap(nums, i, j)\n i += 1\n j -= 1\n\n def swap(self, nums, i, j):\n tmp = nums[i]\n nums[i] = nums[j]\n nums[j] = tmp\n\n\n# [3,5,6,1,2,4]\n","runtime":"48"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n if len(nums) == 1:\n return nums\n change = 0\n for i in range(len(nums)-2,-1,-1):\n if nums[i] < nums[i+1]:\n change = i\n break\n \n pter = len(nums)-1\n while pter > change:\n if nums[pter] > nums[change]:\n break\n pter-=1\n # print(change, pter)\n\n if pter != change:\n nums[change], nums[pter] = nums[pter], nums[change]\n else:\n nums[change], nums[-1] = nums[-1], nums[change]\n\n i = change+1\n j = len(nums)-1\n # print(nums)\n while i <= j:\n if nums[i] > nums[j]:\n nums[i], nums[j] = nums[j], nums[i]\n i+=1\n else:\n j-=1\n # print(i,j,nums)\n ","runtime":"49"},{"code":"class Solution:\n def rev(self, nums, i, j):\n nums[i+1:j+1] = nums[i+1:j+1][::-1]\n # print(\"nums1 \", nums)\n return nums\n\n def swap_eles(self, nums, i, j):\n t = nums[i]\n nums[i] = nums[j]\n nums[j] = t\n # print(\"nums2 \", nums)\n return nums\n \n def find_sec_max(self, nums, i, j, ele):\n max_ele = 999\n ind = -1\n for k in range(i, j):\n if ele < nums[k] <= max_ele:\n max_ele = nums[k]\n ind = k\n print(\"ind, i \", ind, i-1)\n nums = self.swap_eles(nums, i-1, ind)\n print(\"after swap \", nums)\n return nums\n\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n max_ele = -1\n diff_ele = None\n for i in range(len(nums)-1, -1, -1):\n if nums[i] >= max_ele:\n max_ele = nums[i]\n else:\n diff_ele = nums[i]\n break\n print(\"i \", i)\n if diff_ele is None:\n print(\"inside if\")\n nums[:] = sorted(nums)\n else:\n print(\"inside else\")\n nums = self.find_sec_max(nums, i+1, len(nums), nums[i])\n print(\"nums1 \", nums)\n nums = self.rev(nums, i, len(nums)-1)\n print(\"nums2 \", nums)\n \n print(\"nums \", nums)","runtime":"49"}],"string":"[\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n length = len(nums) \\n pivot = -1\\n for i in range(length - 2, -1, -1):\\n if nums[i] < nums[i + 1]:\\n pivot = i\\n break\\n if pivot != -1:\\n for j in range(length - 1, pivot, -1):\\n if nums[j] > nums[pivot]:\\n nums[pivot], nums[j] = nums[j], nums[pivot]\\n break\\n nums[pivot + 1:] = reversed(nums[pivot + 1:])\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"from typing import List\\n\\n\\ndef get_smaller_num_index_from_right(num: int, end_index: int, nums: list[int]) -> int | None:\\n current_index = end_index\\n while current_index >= 0:\\n if nums[current_index] < num:\\n return current_index\\n current_index -= 1\\n\\n return None\\n\\n\\ndef get_left_index_to_switch(nums: list[int]) -> int | None:\\n index = len(nums) - 1\\n while index > 0:\\n if nums[index - 1] < nums[index]:\\n return index - 1\\n index -= 1\\n return None\\n\\n\\ndef get_right_index_to_switch(nums: list[int], smaller_num: int) -> int:\\n index = len(nums) - 1\\n while nums[index] <= smaller_num:\\n index -= 1\\n\\n return index\\n\\n\\ndef get_indexes_to_switch(nums: list[int]) -> tuple[int, int] | None:\\n left_index_to_switch = get_left_index_to_switch(nums)\\n if left_index_to_switch is None:\\n return None\\n return left_index_to_switch, get_right_index_to_switch(nums, nums[left_index_to_switch])\\n\\n\\ndef reverse(start_index: int, end_index: int, nums: list[int]) -> None:\\n while start_index < end_index:\\n nums[start_index], nums[end_index] = nums[end_index], nums[start_index]\\n start_index += 1\\n end_index -= 1\\n\\n\\nclass Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n if len(nums) <= 1:\\n return\\n\\n indexes_to_switch = get_indexes_to_switch(nums)\\n if indexes_to_switch is None:\\n reverse(0, len(nums) - 1, nums)\\n else:\\n nums[indexes_to_switch[0]], nums[indexes_to_switch[1]] = \\\\\\n nums[indexes_to_switch[1]], nums[indexes_to_switch[0]]\\n reverse(indexes_to_switch[0] + 1, len(nums) - 1, nums)\\n\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n n = len(nums)\\n l = n - 1\\n while l > 0 and nums[l - 1] >= nums[l]:\\n l -= 1\\n if l == 0:\\n nums.reverse()\\n return\\n\\n min_index = l\\n l -= 1\\n for i in range(l + 1, n):\\n if nums[i] > nums[l] and nums[i] <= nums[min_index]:\\n min_index = i\\n # print(min_index)\\n # swap l and min_index\\n temp = nums[min_index]\\n nums[min_index] = nums[l]\\n nums[l] = temp\\n\\n # sort l+1..n-1\\n l = l + 1\\n r = n - 1\\n while l <= r:\\n temp = nums[l]\\n nums[l] = nums[r]\\n nums[r] = temp\\n r -= 1\\n l += 1\\n \\n\\n\\n\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n is_max = True\\n\\n current = nums[0]\\n for num in nums:\\n if num > current:\\n is_max = False\\n break\\n current = num\\n\\n if is_max:\\n nums.reverse()\\n return nums\\n\\n target = -1\\n for idx in range(len(nums) - 1, 0, -1):\\n if nums[idx] > nums[idx - 1]:\\n target = idx - 1\\n break\\n\\n next_greater_idx = target\\n idx = target + 1\\n while idx < len(nums):\\n if nums[idx] <= nums[target]:\\n next_greater_idx = idx - 1\\n break\\n idx += 1\\n\\n if next_greater_idx == target:\\n next_greater_idx = len(nums) - 1\\n\\n nums[target], nums[next_greater_idx] = nums[next_greater_idx], nums[target]\\n\\n left = target + 1\\n right = len(nums) - 1\\n\\n while left < right:\\n nums[left], nums[right] = nums[right], nums[left]\\n left += 1\\n right -= 1\\n\\n return nums\\n\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n # i such that nums[i] < nums[i+1] else reverse\\n # j such that nums[j] < nums[i]\\n # reverse nums[i+1:] \\n i = len(nums) - 2\\n while i > -1:\\n if nums[i] < nums[i+1]:\\n break\\n i -= 1\\n else:\\n nums.reverse()\\n return \\n \\n j = len(nums) - 1\\n\\n while j > -1:\\n if nums[j] > nums[i]:\\n break\\n j -=1\\n \\n nums[i], nums[j] = nums[j], nums[i]\\n nums[i+1:] = nums[i+1:][::-1]\\n\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: void Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n i = len(nums) - 2\\n while i >= 0 and nums[i] >= nums[i+1]:\\n i -= 1\\n\\n #i is smaller element i+1 is peak\\n if i >= 0:\\n j = len(nums) - 1\\n while nums[j] <= nums[i]:\\n j -= 1\\n nums[i], nums[j] = nums[j], nums[i]\\n #reverse instead of sort because we know right side is descending\\n self.reverse(nums, i + 1)\\n\\n def reverse(self, nums, start):\\n i, j = start, len(nums) - 1\\n while i < j:\\n nums[i], nums[j] = nums[j], nums[i]\\n i += 1\\n j -= 1\\n\\n \\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n i = len(nums) - 2\\n while i >= 0 and nums[i+1] <= nums[i]:\\n i-=1\\n if i >= 0:\\n j = len(nums) - 1\\n while nums[j] <= nums[i]:\\n j-=1\\n nums[i], nums[j] = nums[j], nums[i]\\n self.reverse(nums, i + 1)\\n\\n def reverse(self, nums, start):\\n i, j = start, len(nums) - 1 \\n while i < j:\\n nums[i], nums[j] = nums[j], nums[i]\\n i+=1\\n j-=1\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n n = len(nums)\\n if n <= 1:\\n return\\n\\n k = n - 2\\n # Step 1: Find the largest index k such that nums[k] < nums[k + 1]\\n while k >= 0 and nums[k] >= nums[k + 1]:\\n k -= 1\\n \\n if k >= 0:\\n # Step 2: Find the largest index l greater than k such that nums[k] < nums[l]\\n l = n - 1\\n while nums[k] >= nums[l]:\\n l -= 1\\n\\n # Step 3: Swap the values of nums[k] and nums[l]\\n nums[k], nums[l] = nums[l], nums[k]\\n\\n # Step 4: Reverse the sequence from sequence k + 1 to end\\n nums[k + 1:] = reversed(nums[k + 1:])\\n \\n return nums\\n\\n\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n # Solution 1 - \\n # Time - \\n # Space -\\n\\n # https://www.youtube.com/watch?v=6qXO72FkqwM - To understand\\n # https://www.youtube.com/watch?v=JRgIqugFhTo - For code\\n\\n pivot = -1\\n\\n for i in range(len(nums) - 1, 0, -1):\\n if nums[i - 1] < nums[i]:\\n pivot = i - 1\\n break\\n\\n\\n if pivot < 0: # Means the number is in Descending order; Already highest permutation possible\\n nums.reverse()\\n return\\n\\n swap = len(nums) - 1\\n\\n while nums[swap] <= nums[pivot]:\\n swap -= 1\\n\\n nums[swap], nums[pivot] = nums[pivot], nums[swap]\\n # print(pivot, nums[pivot + 1:])\\n nums[pivot + 1:] = reversed(nums[pivot + 1:])\\n\\n return\\n\\n # 0. 1. 2\\n # nums = [1, 3, 2]\\n # pivot = 1\\n # swap = 2\\n\\n # 0. 1. 2\\n # nums = [3, 2, 1]\\n # pivot = -1\\n # reverse it\\n\\n # 0. 1. 2\\n # nums = [1, 5, 1]\\n # pivot = 1\\n # swap = 2\\n\\n\\n # NOTE: very good example. \\n #. 0.1 2 3 4\\n # nums = [ 1 2 3 5 4 ]\\n # pivot = 2\\n # swap = 4\\n\\n # res = [1 2 4 3 5]\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n \\n def swapWithMin(self, nums, startIndex, endIndex):\\n for i in range(endIndex, startIndex, -1):\\n if nums[i] > nums[startIndex]:\\n nums[startIndex], nums[i] = nums[i], nums[startIndex]\\n break\\n \\n \\n def reverseArray(self, nums, startIndex, endIndex):\\n while(startIndex <= endIndex):\\n nums[startIndex], nums[endIndex] = nums[endIndex], nums[startIndex]\\n startIndex+=1\\n endIndex-=1\\n \\n \\n \\n \\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n n = len(nums)\\n i = n-2\\n isLoopBroke = 0\\n while(i >= 0):\\n if(nums[i] >= nums[i+1]):\\n print(i)\\n i-=1\\n else:\\n self.swapWithMin(nums, i, n-1)\\n self.reverseArray(nums, i+1, n-1)\\n break\\n \\n \\n if i == -1:\\n self.reverseArray(nums, 0, n-1)\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n n=len(nums)\\n b=-1\\n for i in range(n-2,-1,-1):\\n if nums[i]<nums[i+1]:\\n b=i\\n break\\n if b==-1:\\n nums.sort()\\n for i in range(n-1,-1,-1):\\n if nums[i]>nums[b]:\\n nums[i],nums[b]=nums[b],nums[i]\\n break\\n if b+1!=n-1:\\n l=nums[b+1:]\\n l.sort()\\n nums[b+1:]=l[:]\\n \\n\\n \\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n \\n \\n def reverse(start,end):\\n \\n while start<=end:\\n \\n nums[start],nums[end]=nums[end],nums[start]\\n start+=1\\n end-=1\\n \\n \\n for idx in range(len(nums)-1,0,-1):\\n \\n \\n if (nums[idx]>nums[idx-1]):\\n pivot= idx-1\\n \\n end=len(nums)-1\\n while nums[end]<=nums[pivot]:\\n end-=1\\n nums[end],nums[pivot]=nums[pivot],nums[end]\\n # print(nums)\\n reverse(pivot+1,len(nums)-1)\\n break\\n \\n else:\\n reverse(0,len(nums)-1)\\n \\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n n = len(nums) # size of the array.\\n A=nums\\n # Step 1: Find the break point:\\n ind = -1 # break point\\n for i in range(n-2, -1, -1):\\n if A[i] < A[i + 1]:\\n # index i is the break point\\n ind = i\\n break\\n\\n # If break point does not exist:\\n if ind == -1:\\n # reverse the whole array:\\n A.reverse()\\n return A\\n\\n # Step 2: Find the next greater element\\n # and swap it with arr[ind]:\\n for i in range(n - 1, ind, -1):\\n if A[i] > A[ind]:\\n A[i], A[ind] = A[ind], A[i]\\n break\\n\\n # Step 3: reverse the right half:\\n A[ind+1:] = reversed(A[ind+1:])\\n\\n return A\\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n # start from end and find first number lower than prev\\n end = len(nums) - 1\\n last = nums[end]\\n while end >= 0:\\n num = nums[end]\\n if num < last:\\n last = num\\n break\\n else:\\n last = num\\n end -= 1\\n\\n # start from end and find first number greater than prev\\n right = len(nums) - 1\\n while right >= 0:\\n num = nums[right]\\n if num > last:\\n break\\n right -= 1\\n\\n print(nums)\\n # swap\\n temp = nums[right]\\n nums[right] = last\\n nums[end] = temp\\n\\n print(nums)\\n\\n # sort asc by swapping\\n start = end + 1\\n end = len(nums) - 1\\n while start < end:\\n temp = nums[start]\\n nums[start] = nums[end]\\n nums[end] = temp\\n\\n start += 1\\n end -= 1\\n return None\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n idx=-1\\n for i in range(len(nums)-2,-1,-1):\\n if nums[i]<nums[i+1]:\\n idx=i\\n break\\n if idx == -1 :\\n return nums.reverse()\\n\\n for i in range(len(nums)-1,idx,-1):\\n if nums[i]>nums[idx]:\\n nums[i] , nums[idx] = nums[idx],nums[i]\\n break\\n\\n nums[idx+1:] = reversed(nums[idx+1:])\\n \\n return nums \\n\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"from bisect import bisect_right\\n\\nclass Solution:\\n \\n def pickNextNumber(self, arr, target):\\n arr.sort()\\n index = bisect_right(arr, target)\\n return arr[index]\\n \\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n \\n remaining = []\\n \\n minTillNow = 10**10\\n for i in range(len(nums) - 1, 0, -1):\\n if nums[i] > nums[i-1]:\\n remaining = nums[i:]\\n swap = self.pickNextNumber(remaining, nums[i-1])\\n break\\n \\n if remaining:\\n remaining.remove(swap)\\n temp = nums[i-1] \\n nums[i-1] = swap\\n remaining.append(temp)\\n remaining.sort()\\n\\n for j in range(i, len(nums)):\\n nums[j] = remaining[j-i]\\n\\n else:\\n \\n nums.sort()\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n if len(nums) == 1:\\n return nums\\n change = 0\\n for i in range(len(nums)-2,-1,-1):\\n if nums[i] < nums[i+1]:\\n change = i\\n break\\n \\n pter = len(nums)-1\\n while pter > change:\\n if nums[pter] > nums[change]:\\n break\\n pter-=1\\n # print(change, pter)\\n\\n if pter != change:\\n nums[change], nums[pter] = nums[pter], nums[change]\\n else:\\n nums[change], nums[-1] = nums[-1], nums[change]\\n\\n i = change+1\\n j = len(nums)-1\\n # print(nums)\\n while i <= j:\\n if nums[i] > nums[j]:\\n nums[i], nums[j] = nums[j], nums[i]\\n i+=1\\n else:\\n j-=1\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n 1 2 5 6 4 3\\n \\\"\\\"\\\"\\n\\n def reverse(i, j):\\n while i < j:\\n nums[i], nums[j] = nums[j], nums[i]\\n i += 1\\n j -= 1\\n \\n # if descending, reverse\\n i = len(nums) - 2\\n while i >= 0 and nums[i] >= nums[i + 1] :\\n i -= 1\\n\\n if i >= 0:\\n j = len(nums) - 1\\n while j >=0 and nums[j] <= nums[i]:\\n j -= 1\\n nums[i], nums[j] = nums[j], nums[i]\\n reverse(i + 1, len(nums) - 1)\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n if len(nums) <= 1:\\n return\\n \\n i = len(nums) - 2\\n while i >= 0 and nums[i] >= nums[i + 1]:\\n i -= 1\\n \\n if i >= 0:\\n j = bisect_left(nums, -nums[i], lo=i + 1, key=lambda x: -x) - 1\\n nums[i], nums[j] = nums[j], nums[i]\\n \\n l = i + 1\\n r = len(nums) - 1\\n while l < r:\\n nums[l], nums[r] = nums[r], nums[l]\\n l += 1\\n r -= 1\\n \\n \\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n if len(nums) <=1:\\n return\\n\\n def reverse(n):\\n left, right = n,len(nums)-1\\n\\n while left<right:\\n nums[left], nums[right] = nums[right], nums[left]\\n left +=1\\n right -=1\\n\\n def swap_with_larger_right(j):\\n max_val_index = j\\n max_val = 101\\n\\n for i in range(j, len(nums)):\\n if nums[i] > nums[j] and nums[i]<= max_val:\\n max_val = nums[i]\\n max_val_index = i\\n nums[j], nums[max_val_index] = nums[max_val_index], nums[j]\\n\\n for i in range(len(nums)-1, 0, -1):\\n if nums[i-1] < nums[i]:\\n swap_with_larger_right(i-1)\\n reverse(i)\\n return\\n\\n reverse(0)\\n\\n \\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n n=len(nums)\\n j=-1\\n for i in range(n-2,-1,-1):\\n if nums[i]<nums[i+1]:\\n j=i\\n break\\n if j==-1:\\n reverse(0,n-1,nums)\\n return \\n else:\\n for k in range(n-1,-1,-1):\\n if nums[k]>nums[j]:\\n nums[j],nums[k]=nums[k],nums[j]\\n reverse(j+1,n-1,nums)\\n return \\ndef reverse(start,end,nums):\\n while start<=end:\\n nums[start],nums[end]=nums[end],nums[start]\\n start+=1\\n end-=1\\n \\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n if len(nums) == 1:\\n return nums\\n change = 0\\n for i in range(len(nums)-2,-1,-1):\\n if nums[i] < nums[i+1]:\\n change = i\\n break\\n \\n pter = len(nums)-1\\n while pter > change:\\n if nums[pter] > nums[change]:\\n break\\n pter-=1\\n # print(change, pter)\\n\\n if pter != change:\\n nums[change], nums[pter] = nums[pter], nums[change]\\n else:\\n nums[change], nums[-1] = nums[-1], nums[change]\\n\\n i = change+1\\n j = len(nums)-1\\n # print(nums)\\n while i <= j:\\n if nums[i] > nums[j]:\\n nums[i], nums[j] = nums[j], nums[i]\\n i+=1\\n else:\\n j-=1\\n # print(i,j,nums)\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n i = j = len(nums) - 1\\n while i > 0 and nums[i-1] >= nums[i]:\\n i -= 1\\n if i == 0:\\n return nums.reverse()\\n k = i - 1\\n while nums[k] >= nums[j]:\\n j -= 1\\n nums[k], nums[j] = nums[j], nums[k]\\n l = k + 1\\n r = len(nums) - 1\\n while l < r:\\n nums[l], nums[r] = nums[r], nums[l]\\n r -= 1\\n l += 1\\n return nums\\n\\n \\n\\n \\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n n = len(nums)\\n i = n - 2\\n while i >= 0 and nums[i] >= nums[i + 1]:\\n i -= 1\\n \\n if i >= 0:\\n j = n - 1\\n while nums[j] <= nums[i]:\\n j -= 1\\n nums[i], nums[j] = nums[j], nums[i]\\n \\n left, right = i + 1, n - 1\\n while left < right:\\n nums[left], nums[right] = nums[right], nums[left]\\n left += 1\\n right -= 1\\n\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n \\n # 12345 66\\n # 1234656\\n\\n # 135 8762\\n # 136 2578\\n\\n # 8876\\n # 6788\\n pt = -1\\n for i in range(len(nums)-1,0,-1):\\n if nums[i] > nums[i-1]:\\n pt = i - 1\\n break\\n if pt != -1:\\n target = nums[pt]\\n for i in range(len(nums)-1,pt,-1):\\n if nums[i] > nums[pt]:\\n nums[i],nums[pt] = nums[pt],nums[i]\\n break\\n self.reverse(nums, pt+1)\\n def reverse(self, nums, start):\\n i, j = start, len(nums) - 1\\n while i < j:\\n self.swap(nums, i, j)\\n i += 1\\n j -= 1\\n\\n def swap(self, nums, i, j):\\n temp = nums[i]\\n nums[i] = nums[j]\\n nums[j] = temp \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n i = len(nums) -2\\n #Find DIP \\n while i >=0 and nums[i] >= nums[i+1]:\\n i -= 1\\n \\n if i == -1:\\n left = 0 \\n right = len(nums) - 1\\n while left < right: \\n nums[left], nums[right] = nums[right], nums[left]\\n left += 1\\n right -=1 \\n return \\n #Find smallest element larger than DIP\\n j = len(nums) - 1\\n while nums[j] <= nums[i]:\\n j -= 1\\n nums[i], nums[j] = nums[j], nums[i]\\n #Reverse numbers after pivot\\n left = i + 1 \\n right = len(nums) - 1\\n while left < right: \\n nums[left], nums[right] = nums[right], nums[left]\\n left += 1\\n right -= 1\\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n #1,2,3,4,1\\n #1,2,4,1,3\\n # switch least significant that can go up, sort all after that\\n if len(nums) == 1:\\n return nums\\n curIdx = len(nums) - 2\\n while curIdx >= 0 and nums[curIdx + 1] <= nums[curIdx]:\\n curIdx -= 1\\n toSwap = curIdx + 1\\n if curIdx != -1:\\n while toSwap < len(nums) and nums[toSwap] > nums[curIdx]:\\n toSwap += 1\\n toSwap -= 1\\n nums[toSwap], nums[curIdx] = nums[curIdx], nums[toSwap]\\n nums[curIdx+1:] = sorted(nums[curIdx+1:])\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n # find the decreasingIndex of nums from right to left\\n decreasingIndex:int = len(nums) - 2\\n # if we can't find one reverse nums and thats it\\n while decreasingIndex > - 1:\\n if nums[decreasingIndex] < nums[decreasingIndex + 1]:\\n break\\n decreasingIndex -= 1\\n\\n if decreasingIndex == -1:\\n nums.reverse()\\n return\\n # Find the number larger than decreasing Index from right to left (it has to exist)\\n largerIndex:int = len(nums) - 1\\n while largerIndex > - 1:\\n if nums[largerIndex] > nums[decreasingIndex]:\\n break\\n largerIndex -= 1\\n\\n # swap decreasingIndex and largest Index\\n self.swap(nums, decreasingIndex, largerIndex)\\n # reverse from decreasingIndex + 1\\n self.reverse(nums, decreasingIndex + 1, len(nums) - 1)\\n\\n \\n def swap(self, nums: List[int], left:int, right:int):\\n leftVal:int = nums[left]\\n rightVal:int = nums[right]\\n nums[left] = rightVal\\n nums[right] = leftVal\\n \\n def reverse(self, nums: List[int], left:int, right:int):\\n while left < right:\\n self.swap(nums, left, right)\\n left += 1\\n right -= 1\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n i=j=len(nums)-1\\n while i > 0 and nums[i-1] >= nums[i]:\\n i -= 1\\n if i==0:\\n nums.reverse()\\n return\\n k = i-1\\n while nums[j] <= nums[k]:\\n j -= 1\\n nums[j],nums[k] = nums[k],nums[j]\\n l,r = k+1,len(nums)-1\\n while l < r:\\n nums[l],nums[r] = nums[r],nums[l]\\n l += 1\\n r -= 1\\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Find the longest non-increasing suffix.\\n Point before it being is your pivot\\n From that suffix, find the minimum that's greater than your pivot\\n Swap your pivot with it\\n Reverse the suffix\\n \\\"\\\"\\\"\\n i = len(nums) - 1\\n while i > 0:\\n if nums[i] > nums[i - 1]:\\n pivot = i - 1\\n j = i\\n while j < len(nums) and nums[j] > nums[pivot]:\\n j += 1\\n j -= 1\\n nums[pivot], nums[j] = nums[j], nums[pivot]\\n nums[pivot + 1:] = nums[pivot + 1:][::-1]\\n return\\n else:\\n i -= 1\\n nums.reverse()\\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n\\n\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n n = len(nums)\\n\\n # First i smaller than next\\n i = n -2\\n while i >= 0 and nums[i] >= nums[i + 1]:\\n i -= 1\\n\\n\\n # if it's in sorted order\\n if i < 0:\\n nums[0:] = reversed(nums)\\n return\\n\\n j = n-1\\n while nums[j] <= nums[i]:\\n j -= 1\\n \\n nums[i], nums[j] = nums[j], nums[i]\\n\\n # reverse the last ones as well\\n nums[i+1:] = reversed(nums[i+1:]) \\n\\n\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n def swap(fromIndex:int, toIndex:int):\\n fromVal:int = nums[fromIndex]\\n toVal:int = nums[toIndex]\\n nums[fromIndex] = toVal\\n nums[toIndex] = fromVal\\n \\n def reverse(left:int, right:int):\\n while left < right:\\n swap(left, right)\\n left += 1\\n right -= 1\\n\\n decreasingIndex:int = len(nums) - 2\\n while decreasingIndex > -1:\\n if nums[decreasingIndex] < nums[decreasingIndex + 1]:\\n break\\n decreasingIndex -= 1\\n \\n if decreasingIndex == -1:\\n nums.sort()\\n return\\n \\n largerIndex:int = len(nums) - 1\\n\\n while largerIndex > -1:\\n if nums[largerIndex] > nums[decreasingIndex]:\\n break\\n largerIndex -= 1\\n \\n swap(largerIndex, decreasingIndex)\\n reverse(decreasingIndex + 1, len(nums) - 1)\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n length = len(nums)\\n\\n i = length - 2\\n while i >= 0 and nums[i] >= nums[ i+1 ]:\\n i -= 1\\n\\n if i >= 0:\\n j = length - 1\\n while nums[j] <= nums[i]:\\n j -= 1\\n nums[i], nums[j] = nums[j], nums[i]\\n \\n nums[i + 1:] = reversed(nums[i + 1:])\\n\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n \\n if len(nums) <= 1:\\n return\\n\\n def get_valued_index_from_right(value: int) -> int:\\n idx = len(nums) - 1\\n while nums[idx] <= value and idx > 0:\\n idx -= 1\\n return idx\\n \\n def verse_form_index(idx: int):\\n iterations = (len(nums) - idx) // 2\\n for i in range(iterations):\\n first = nums[idx + i]\\n last = nums[len(nums) - 1 -i]\\n nums[idx + i] = last\\n nums[len(nums) - 1 -i] = first\\n\\n # loop from n-1 to 0\\n # search for smaller than i\\n\\n # get pivot\\n i = len(nums) - 1\\n while nums[i - 1] >= nums[i] and i > 0:\\n i -= 1\\n\\n # handle the case of the initial state\\n if i <= 0:\\n verse_form_index(i)\\n return\\n\\n idx = get_valued_index_from_right(nums[i - 1])\\n\\n first = nums[i - 1]\\n to_swap = nums[idx]\\n nums[i - 1] = to_swap\\n nums[idx] = first\\n\\n verse_form_index(i)\\n\\n \\\"\\\"\\\"\\n\\n 1 2 3 4\\n 1 2 4 3\\n\\n 1 3 2 4\\n 1 3 4 2\\n 1 4 2 3\\n 1 4 3 2\\n\\n 1 5 4 3 2\\n\\n 2 1 3 4 5\\n 2 5 4 3 1\\n\\n \\\"\\\"\\\"\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def swap(self, nums, i, j):\\n temp = nums[i]\\n nums[i] = nums[j]\\n nums[j] = temp\\n def reverse(self, nums, i, j):\\n while i < j:\\n self.swap(nums, i, j)\\n i += 1\\n j -= 1\\n \\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n i = len(nums) - 2\\n while i >= 0 and nums[i] >= nums[i + 1]:\\n i -= 1\\n if i >= 0:\\n j = len(nums) - 1\\n while nums[j] <= nums[i]:\\n j -= 1\\n self.swap(nums, i, j)\\n self.reverse(nums, i+1, len(nums) - 1)\\n\\n return nums\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n i = len(nums) - 2\\n while i>=0 and nums[i] >= nums[i+1]:\\n i-=1\\n if i >= 0:\\n j = len(nums) - 1\\n while nums[j] <= nums[i]:\\n j-=1\\n nums[i], nums[j] = nums[j], nums[i]\\n def reverse(start):\\n right = len(nums) - 1\\n while start < right:\\n nums[start], nums[right] = nums[right], nums[start]\\n start+=1\\n right-=1\\n reverse(i+1)\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n i=len(nums)-2\\n while i>=0 and nums[i]>=nums[i+1]:\\n i-=1\\n if i==-1:\\n nums.reverse()\\n return\\n j=len(nums)-1\\n while nums[j]<=nums[i]:\\n j-=1\\n nums[i],nums[j]=nums[j],nums[i]\\n nums[i+1:]=reversed(nums[i+1:])\\n\\n\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n N = len(nums)\\n greatest = nums[-1]\\n found = False\\n for i in reversed(range(N - 1)):\\n if greatest > nums[i]:\\n smallestGreater = None\\n for j in range(i + 1, N):\\n if nums[j] > nums[i]:\\n if smallestGreater is None or nums[j] < nums[smallestGreater]:\\n smallestGreater = j\\n tmp = nums[smallestGreater]\\n nums[smallestGreater] = nums[i]\\n nums[i] = tmp\\n\\n nums[i + 1:] = list(sorted(nums[i + 1:]))\\n\\n found = True\\n break\\n greatest = max(greatest, nums[i])\\n \\n if not found:\\n nums.sort()\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def rev(self, nums, i, j):\\n nums[i+1:j+1] = nums[i+1:j+1][::-1]\\n # print(\\\"nums1 \\\", nums)\\n return nums\\n\\n def swap_eles(self, nums, i, j):\\n t = nums[i]\\n nums[i] = nums[j]\\n nums[j] = t\\n # print(\\\"nums2 \\\", nums)\\n return nums\\n \\n def find_sec_max(self, nums, i, j, ele):\\n max_ele = 999\\n ind = -1\\n for k in range(i, j):\\n if ele < nums[k] <= max_ele:\\n max_ele = nums[k]\\n ind = k\\n # print(\\\"ind, i \\\", ind, i-1)\\n nums = self.swap_eles(nums, i-1, ind)\\n # print(\\\"after swap \\\", nums)\\n return nums\\n\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n max_ele = -1\\n diff_ele = None\\n for i in range(len(nums)-1, -1, -1):\\n if nums[i] >= max_ele:\\n max_ele = nums[i]\\n else:\\n diff_ele = nums[i]\\n break\\n # print(\\\"i \\\", i)\\n if diff_ele is None:\\n # print(\\\"inside if\\\")\\n nums[:] = sorted(nums)\\n else:\\n # print(\\\"inside else\\\")\\n nums = self.find_sec_max(nums, i+1, len(nums), nums[i])\\n # print(\\\"nums1 \\\", nums)\\n nums = self.rev(nums, i, len(nums)-1)\\n # print(\\\"nums2 \\\", nums)\\n \\n # print(\\\"nums \\\", nums)\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n #finding pivot\\n pivot=0\\n n=len(nums)\\n for i in range(n-1,0,-1):\\n if nums[i-1]<nums[i]:\\n pivot=i\\n break\\n #if in maximum decending order\\n if pivot==0:\\n return nums.reverse()\\n\\n #finding successor in case pivot found\\n pivot_index=pivot-1\\n successor=n-1\\n while nums[successor]<=nums[pivot_index]:\\n successor-=1\\n \\n #swapping pivot with just next larger element\\n nums[pivot_index],nums[successor]=nums[successor],nums[pivot_index]\\n\\n #reverse rest of the element to ascending \\n nums[pivot:]=reversed(nums[pivot:])\\n\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n for idx in range(len(nums)-2, -1, -1):\\n if nums[idx] >= nums[idx + 1]: continue\\n \\n replacement_idx = idx + 1\\n for tmp in range(idx+2, len(nums)):\\n if nums[tmp] > nums[idx] and nums[tmp] < nums[replacement_idx]:\\n replacement_idx = tmp\\n nums[idx], nums[replacement_idx] = nums[replacement_idx], nums[idx]\\n\\n nums[idx+1: ] = sorted(nums[idx+1:])\\n\\n return\\n else:\\n nums.sort()\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n n = len(nums)\\n i = n - 1\\n\\n # Find non-increasing sucessor\\n while i > 0 and nums[i] <= nums[i-1]:\\n i -= 1\\n if i == 0:\\n nums.reverse()\\n return \\n j = n - 1\\n while j > 0 and nums[j] <= nums[i-1]:\\n j -= 1\\n\\n nums[i-1], nums[j] = nums[j], nums[i-1]\\n nums[i:] = nums[n-1:i-1:-1]\\n\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n ind=-1\\n n=len(nums)\\n for i in range(n-2,-1,-1):\\n if nums[i]<nums[i+1]:\\n ind=i\\n break\\n if ind==-1:\\n return nums.reverse()\\n for i in range(n-1,ind,-1):\\n if nums[i]>nums[ind]:\\n nums[i],nums[ind]=nums[ind],nums[i]\\n break\\n nums[ind+1:]=reversed(nums[ind+1:])\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n #1,2,3,4,1\\n #1,2,4,1,3\\n # switch least significant that can go up, sort all after that\\n if len(nums) == 1:\\n return nums\\n curIdx = len(nums) - 2\\n while curIdx >= 0 and nums[curIdx + 1] <= nums[curIdx]:\\n curIdx -= 1\\n toSwap = curIdx + 1\\n if curIdx != -1:\\n while toSwap < len(nums) and nums[toSwap] > nums[curIdx]:\\n toSwap += 1\\n toSwap -= 1\\n nums[toSwap], nums[curIdx] = nums[curIdx], nums[toSwap]\\n nums[curIdx+1:] = reversed(nums[curIdx+1:])\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: void Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n i = len(nums) - 2\\n while i >= 0 and nums[i + 1] <= nums[i]:\\n i -= 1\\n if i >= 0:\\n j = len(nums) - 1\\n while nums[j] <= nums[i]:\\n j -= 1\\n self.swap(nums, i, j)\\n self.reverse(nums, i + 1)\\n\\n def reverse(self, nums, start):\\n i, j = start, len(nums) - 1\\n while i < j:\\n self.swap(nums, i, j)\\n i += 1\\n j -= 1\\n\\n def swap(self, nums, i, j):\\n temp = nums[i]\\n nums[i] = nums[j]\\n nums[j] = temp\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: list[int]) -> None:\\n \\\"\\\"\\\"Do not return anything, modify nums in-place instead.\\\"\\\"\\\"\\n i = len(nums) - 2\\n while i >= 0 and nums[i] >= nums[i + 1]:\\n i -= 1\\n\\n if i >= 0:\\n j = len(nums) - 1\\n while nums[j] <= nums[i]:\\n j -= 1\\n self.swap(nums, i, j)\\n self.reverse(nums, i + 1)\\n\\n def reverse(self, nums, start):\\n i, j = start, len(nums) - 1\\n while i < j:\\n self.swap(nums, i, j)\\n i += 1\\n j -= 1\\n\\n def swap(self, nums, i, j):\\n tmp = nums[i]\\n nums[i] = nums[j]\\n nums[j] = tmp\\n\\n\\n# [3,5,6,1,2,4]\\n\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n if len(nums) == 1:\\n return nums\\n change = 0\\n for i in range(len(nums)-2,-1,-1):\\n if nums[i] < nums[i+1]:\\n change = i\\n break\\n \\n pter = len(nums)-1\\n while pter > change:\\n if nums[pter] > nums[change]:\\n break\\n pter-=1\\n # print(change, pter)\\n\\n if pter != change:\\n nums[change], nums[pter] = nums[pter], nums[change]\\n else:\\n nums[change], nums[-1] = nums[-1], nums[change]\\n\\n i = change+1\\n j = len(nums)-1\\n # print(nums)\\n while i <= j:\\n if nums[i] > nums[j]:\\n nums[i], nums[j] = nums[j], nums[i]\\n i+=1\\n else:\\n j-=1\\n # print(i,j,nums)\\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def rev(self, nums, i, j):\\n nums[i+1:j+1] = nums[i+1:j+1][::-1]\\n # print(\\\"nums1 \\\", nums)\\n return nums\\n\\n def swap_eles(self, nums, i, j):\\n t = nums[i]\\n nums[i] = nums[j]\\n nums[j] = t\\n # print(\\\"nums2 \\\", nums)\\n return nums\\n \\n def find_sec_max(self, nums, i, j, ele):\\n max_ele = 999\\n ind = -1\\n for k in range(i, j):\\n if ele < nums[k] <= max_ele:\\n max_ele = nums[k]\\n ind = k\\n print(\\\"ind, i \\\", ind, i-1)\\n nums = self.swap_eles(nums, i-1, ind)\\n print(\\\"after swap \\\", nums)\\n return nums\\n\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n max_ele = -1\\n diff_ele = None\\n for i in range(len(nums)-1, -1, -1):\\n if nums[i] >= max_ele:\\n max_ele = nums[i]\\n else:\\n diff_ele = nums[i]\\n break\\n print(\\\"i \\\", i)\\n if diff_ele is None:\\n print(\\\"inside if\\\")\\n nums[:] = sorted(nums)\\n else:\\n print(\\\"inside else\\\")\\n nums = self.find_sec_max(nums, i+1, len(nums), nums[i])\\n print(\\\"nums1 \\\", nums)\\n nums = self.rev(nums, i, len(nums)-1)\\n print(\\\"nums2 \\\", nums)\\n \\n print(\\\"nums \\\", nums)\",\n \"runtime\": \"49\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":48,"string":"48"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n elem=-1\n for i in range(len(nums)-2,-1,-1):\n if nums[i]<nums[i+1]:\n elem=i\n break\n if elem!=-1:\n elem2=-1\n minElem=float(\"inf\")\n for j in range(elem+1,len(nums)):\n if nums[j]>nums[elem] and nums[j]<=minElem:\n minElem=min(minElem,nums[j])\n elem2=j\n \n if elem!=-1 and elem2!=-1:\n temp=nums[elem]\n nums[elem]=nums[elem2]\n nums[elem2]=temp\n \n h=len(nums)-1\n l=elem+1\n #swap coz till elem is in descending order anyways\n while l<h:\n temp=nums[l]\n nums[l]=nums[h]\n nums[h]=temp\n l+=1\n h-=1\n \n\n","memory":"16000"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n pivot = None\n\n for i in range(len(nums) -1, 0, -1):\n if nums[i]> nums[i-1]:\n pivot = i-1\n break\n else:\n return nums.reverse()\n swap = len(nums)-1\n while nums[swap] <= nums[pivot]:\n swap -=1\n\n nums[pivot], nums[swap] = nums[swap], nums[pivot]\n nums[pivot + 1:] = reversed(nums[pivot + 1:])\n return","memory":"16100"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n # Step 1: Find the pivot\n i = len(nums) - 2\n while i >= 0 and nums[i] >= nums[i + 1]:\n i -= 1\n \n if i >= 0: # If a pivot is found\n # Step 2: Find the successor to swap with the pivot\n j = len(nums) - 1\n while nums[j] <= nums[i]:\n j -= 1\n \n # Step 3: Swap the pivot with the successor\n nums[i], nums[j] = nums[j], nums[i]\n \n # Step 4: Reverse the suffix\n nums[i + 1:] = reversed(nums[i + 1:])\n ","memory":"16200"},{"code":"class Solution:\n def nextPermutation(self, nums: list[int]) -> None:\n \"\"\"Do not return anything, modify nums in-place instead.\"\"\"\n i = len(nums) - 2\n while i >= 0 and nums[i] >= nums[i + 1]:\n i -= 1\n\n if i >= 0:\n j = len(nums) - 1\n while nums[j] <= nums[i]:\n j -= 1\n self.swap(nums, i, j)\n self.reverse(nums, i + 1)\n\n def reverse(self, nums, start):\n i, j = start, len(nums) - 1\n while i < j:\n self.swap(nums, i, j)\n i += 1\n j -= 1\n\n def swap(self, nums, i, j):\n tmp = nums[i]\n nums[i] = nums[j]\n nums[j] = tmp\n\n\n# [3,5,6,1,2,4]\n","memory":"16300"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n # Find the first index where num is in decreasing order from right\n\n # Find the second index where is smallest on the right side of i and greater than nums[i]\n \n i = len(nums) - 2\n while i >= 0 and nums[i] >= nums[i+1]:\n i-=1\n if i >= 0:\n j = len(nums) - 1 \n while nums[j] <= nums[i]:\n j-=1\n nums[j], nums[i] = nums[i], nums[j]\n def reverse(start):\n left = start\n right = len(nums) - 1\n while left < right:\n nums[left], nums[right] = nums[right], nums[left]\n left+=1\n right-=1\n reverse(i+1)","memory":"16300"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n per={}\n lis=nums[:]\n bp=-1\n mini=len(nums)-1\n for i in range(len(nums)-1,0,-1):\n if(nums[i]>nums[i-1]):\n bp=i-1\n break\n if(bp==-1):\n nums.reverse()\n return\n for i in range(len(nums)-1,bp,-1):\n if(nums[i]>nums[bp]):\n print(nums[bp],nums[i])\n nums[bp],nums[i]=nums[i],nums[bp]\n break\n\n\n nums[bp+1:]=reversed(nums[bp+1:])\n return\n\n \n ","memory":"16400"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n # [2,3,1,5,4,2]\n # [2,3,2,5,4,1]\n # [2,3,2,1,4,5]\n\n # algorithm\n # iterate reversely, stop at the num that stops increasing, index = p\n # iterate reversely, find the num that's greater than the previous num\n # swap these numbers\n # reverse everything after p\n\n p = len(nums) - 2\n while p >= 0 and nums[p] >= nums[p + 1]:\n p -= 1\n if p == -1:\n nums = nums.reverse()\n return nums\n\n i = len(nums) - 1\n while i >= 0 and nums[i] <= nums[p]:\n i -= 1\n\n nums[p], nums[i] = nums[i], nums[p]\n\n nums[p + 1: ] = nums[p + 1: ][::-1]\n\n return nums","memory":"16400"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n \n pivot = -1\n n = len(nums)\n for i in range(n - 2, -1, -1):\n if nums[i] < nums[i + 1]:\n pivot = i\n break\n if pivot == -1:\n nums = nums.reverse()\n else:\n # Find element that is next greater than nums[pivot]\n i = n - 1\n for i in range(n - 1, pivot, -1):\n if nums[i] > nums[pivot]:\n break\n \n # Swap\n temp = nums[pivot]\n nums[pivot] = nums[i]\n nums[i] = temp\n\n # Reverse array from [pivot + 1:]\n for j in range(0, (n - 1 - pivot) // 2):\n temp = nums[pivot + 1 + j]\n nums[pivot + 1 + j] = nums[n - 1 - j]\n nums[n - 1 - j] = temp\n \n","memory":"16500"},{"code":"class Solution:\n def nextPermutation(self, nums: List[int]) -> None:\n \"\"\"\n Do not return anything, modify nums in-place instead.\n \"\"\"\n # try to find the idx where nums[i] < nums[i + 1]\n n = len(nums)\n idx = -1\n for i in range(n-2, -1, -1):\n if nums[i] < nums[i + 1] :\n idx = i\n break\n if idx == -1:\n return nums.reverse()\n # swap with the lowest\n for i in range(n-1, idx, -1):\n if nums[i] > nums[idx]:\n nums[i], nums[idx] = nums[idx], nums[i]\n break\n # sort the remaining part\n nums[idx + 1:] = reversed(nums[idx + 1:])\n \n \n ","memory":"16500"}],"string":"[\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n elem=-1\\n for i in range(len(nums)-2,-1,-1):\\n if nums[i]<nums[i+1]:\\n elem=i\\n break\\n if elem!=-1:\\n elem2=-1\\n minElem=float(\\\"inf\\\")\\n for j in range(elem+1,len(nums)):\\n if nums[j]>nums[elem] and nums[j]<=minElem:\\n minElem=min(minElem,nums[j])\\n elem2=j\\n \\n if elem!=-1 and elem2!=-1:\\n temp=nums[elem]\\n nums[elem]=nums[elem2]\\n nums[elem2]=temp\\n \\n h=len(nums)-1\\n l=elem+1\\n #swap coz till elem is in descending order anyways\\n while l<h:\\n temp=nums[l]\\n nums[l]=nums[h]\\n nums[h]=temp\\n l+=1\\n h-=1\\n \\n\\n\",\n \"memory\": \"16000\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n pivot = None\\n\\n for i in range(len(nums) -1, 0, -1):\\n if nums[i]> nums[i-1]:\\n pivot = i-1\\n break\\n else:\\n return nums.reverse()\\n swap = len(nums)-1\\n while nums[swap] <= nums[pivot]:\\n swap -=1\\n\\n nums[pivot], nums[swap] = nums[swap], nums[pivot]\\n nums[pivot + 1:] = reversed(nums[pivot + 1:])\\n return\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n # Step 1: Find the pivot\\n i = len(nums) - 2\\n while i >= 0 and nums[i] >= nums[i + 1]:\\n i -= 1\\n \\n if i >= 0: # If a pivot is found\\n # Step 2: Find the successor to swap with the pivot\\n j = len(nums) - 1\\n while nums[j] <= nums[i]:\\n j -= 1\\n \\n # Step 3: Swap the pivot with the successor\\n nums[i], nums[j] = nums[j], nums[i]\\n \\n # Step 4: Reverse the suffix\\n nums[i + 1:] = reversed(nums[i + 1:])\\n \",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: list[int]) -> None:\\n \\\"\\\"\\\"Do not return anything, modify nums in-place instead.\\\"\\\"\\\"\\n i = len(nums) - 2\\n while i >= 0 and nums[i] >= nums[i + 1]:\\n i -= 1\\n\\n if i >= 0:\\n j = len(nums) - 1\\n while nums[j] <= nums[i]:\\n j -= 1\\n self.swap(nums, i, j)\\n self.reverse(nums, i + 1)\\n\\n def reverse(self, nums, start):\\n i, j = start, len(nums) - 1\\n while i < j:\\n self.swap(nums, i, j)\\n i += 1\\n j -= 1\\n\\n def swap(self, nums, i, j):\\n tmp = nums[i]\\n nums[i] = nums[j]\\n nums[j] = tmp\\n\\n\\n# [3,5,6,1,2,4]\\n\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n # Find the first index where num is in decreasing order from right\\n\\n # Find the second index where is smallest on the right side of i and greater than nums[i]\\n \\n i = len(nums) - 2\\n while i >= 0 and nums[i] >= nums[i+1]:\\n i-=1\\n if i >= 0:\\n j = len(nums) - 1 \\n while nums[j] <= nums[i]:\\n j-=1\\n nums[j], nums[i] = nums[i], nums[j]\\n def reverse(start):\\n left = start\\n right = len(nums) - 1\\n while left < right:\\n nums[left], nums[right] = nums[right], nums[left]\\n left+=1\\n right-=1\\n reverse(i+1)\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n per={}\\n lis=nums[:]\\n bp=-1\\n mini=len(nums)-1\\n for i in range(len(nums)-1,0,-1):\\n if(nums[i]>nums[i-1]):\\n bp=i-1\\n break\\n if(bp==-1):\\n nums.reverse()\\n return\\n for i in range(len(nums)-1,bp,-1):\\n if(nums[i]>nums[bp]):\\n print(nums[bp],nums[i])\\n nums[bp],nums[i]=nums[i],nums[bp]\\n break\\n\\n\\n nums[bp+1:]=reversed(nums[bp+1:])\\n return\\n\\n \\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n # [2,3,1,5,4,2]\\n # [2,3,2,5,4,1]\\n # [2,3,2,1,4,5]\\n\\n # algorithm\\n # iterate reversely, stop at the num that stops increasing, index = p\\n # iterate reversely, find the num that's greater than the previous num\\n # swap these numbers\\n # reverse everything after p\\n\\n p = len(nums) - 2\\n while p >= 0 and nums[p] >= nums[p + 1]:\\n p -= 1\\n if p == -1:\\n nums = nums.reverse()\\n return nums\\n\\n i = len(nums) - 1\\n while i >= 0 and nums[i] <= nums[p]:\\n i -= 1\\n\\n nums[p], nums[i] = nums[i], nums[p]\\n\\n nums[p + 1: ] = nums[p + 1: ][::-1]\\n\\n return nums\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n \\n pivot = -1\\n n = len(nums)\\n for i in range(n - 2, -1, -1):\\n if nums[i] < nums[i + 1]:\\n pivot = i\\n break\\n if pivot == -1:\\n nums = nums.reverse()\\n else:\\n # Find element that is next greater than nums[pivot]\\n i = n - 1\\n for i in range(n - 1, pivot, -1):\\n if nums[i] > nums[pivot]:\\n break\\n \\n # Swap\\n temp = nums[pivot]\\n nums[pivot] = nums[i]\\n nums[i] = temp\\n\\n # Reverse array from [pivot + 1:]\\n for j in range(0, (n - 1 - pivot) // 2):\\n temp = nums[pivot + 1 + j]\\n nums[pivot + 1 + j] = nums[n - 1 - j]\\n nums[n - 1 - j] = temp\\n \\n\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def nextPermutation(self, nums: List[int]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify nums in-place instead.\\n \\\"\\\"\\\"\\n # try to find the idx where nums[i] < nums[i + 1]\\n n = len(nums)\\n idx = -1\\n for i in range(n-2, -1, -1):\\n if nums[i] < nums[i + 1] :\\n idx = i\\n break\\n if idx == -1:\\n return nums.reverse()\\n # swap with the lowest\\n for i in range(n-1, idx, -1):\\n if nums[i] > nums[idx]:\\n nums[i], nums[idx] = nums[idx], nums[i]\\n break\\n # sort the remaining part\\n nums[idx + 1:] = reversed(nums[idx + 1:])\\n \\n \\n \",\n \"memory\": \"16500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":9,"string":"9"}}},{"rowIdx":68,"cells":{"question_id":{"kind":"number","value":32,"string":"32"},"name":{"kind":"string","value":"longest-valid-parentheses"},"content":{"kind":"string","value":"<p>Given a string containing just the characters <code>'('</code> and <code>')'</code>, return <em>the length of the longest valid (well-formed) parentheses </em><span data-keyword=\"substring-nonempty\"><em>substring</em></span>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> s = "(()"\n<strong>Output:</strong> 2\n<strong>Explanation:</strong> The longest valid parentheses substring is "()".\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> s = ")()())"\n<strong>Output:</strong> 4\n<strong>Explanation:</strong> The longest valid parentheses substring is "()()".\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> s = ""\n<strong>Output:</strong> 0\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>0 <= s.length <= 3 * 10<sup>4</sup></code></li>\n\t<li><code>s[i]</code> is <code>'('</code>, or <code>')'</code>.</li>\n</ul>\n"},"acRate":{"kind":"number","value":34.76212680200797,"string":"34.762127"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["string","dynamic-programming","stack"],"string":"[\n \"string\",\n \"dynamic-programming\",\n \"stack\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"22\", 0.0183], [\"24\", 0.0915], [\"25\", 0.0549], [\"26\", 0.1464], [\"27\", 0.2562], [\"28\", 0.366], [\"29\", 0.4392], [\"30\", 0.6953], [\"31\", 0.9332], [\"32\", 1.2626], [\"33\", 1.2077], [\"34\", 1.5737], [\"35\", 3.5865], [\"36\", 3.7328], [\"37\", 3.5499], [\"38\", 4.2086], [\"39\", 5.9103], [\"40\", 5.764], [\"41\", 5.8371], [\"42\", 5.3614], [\"43\", 6.9167], [\"44\", 7.0997], [\"45\", 4.9405], [\"46\", 5.0503], [\"47\", 4.7941], [\"48\", 4.3184], [\"49\", 3.4401], [\"50\", 3.4035], [\"51\", 2.0311], [\"52\", 1.6834], [\"53\", 1.0796], [\"54\", 0.9698], [\"55\", 0.6587], [\"56\", 0.677], [\"57\", 0.3843], [\"58\", 0.4575], [\"59\", 0.2196], [\"60\", 0.2196], [\"61\", 0.2196], [\"62\", 0.2196], [\"63\", 0.0915], [\"64\", 0.0915], [\"65\", 0.1647], [\"66\", 0.1281], [\"67\", 0.0915], [\"68\", 0.0183], [\"69\", 0.0366], [\"70\", 0.0366], [\"71\", 0.0915], [\"72\", 0.0549], [\"73\", 0.0915], [\"74\", 0.0549], [\"75\", 0.0732], [\"77\", 0.0549], [\"78\", 0.0732], [\"79\", 0.0366]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16300\", 0.0915], [\"16400\", 1.3358], [\"16500\", 6.6972], [\"16600\", 9.1308], [\"16700\", 6.9716], [\"16800\", 2.6532], [\"16900\", 1.5188], [\"17000\", 2.1958], [\"17100\", 10.6496], [\"17200\", 20.9149], [\"17300\", 21.9396], [\"17400\", 6.1482], [\"17500\", 0.9881], [\"17600\", 0.4941], [\"17700\", 0.2379], [\"17800\", 0.183], [\"17900\", 0.2928], [\"18000\", 0.7136], [\"18100\", 0.6404], [\"18200\", 1.1345]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n max_len = 0\n \n for i, char in enumerate(s):\n if char == '(':\n stack.append(i)\n else:\n stack.pop()\n if not stack:\n stack.append(i)\n else:\n max_len = max(max_len, i - stack[-1])\n \n return max_len\n","runtime":"22"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n # given a string containing ( and )\n # return length of the longest valid parentheses\n # valid substring problem\n # longest = keep searching -> dfs?\n # valid means maintaining conditions -> dfs\n # sliding window + dfs?\n # contratins 10^4\n\n \n # states = substring with valid parenthesis\n\n # if we had a closing one without a open one the state is invalid\n # if we had more open substrings we can keep building\n \n # create open parent stack\n # l, r = 0,0\n # loop through string s by r\n # if stack and current parent is closing:\n # decrement closing paren\n # if not stack:\n # res = max(res, len(substring))\n # if not stack and current parent is closing:\n # shift l to right + 1\n # if opening paren:\n # add stack\n\n stack = []\n stack.append(-1)\n res = 0\n for i in range(len(s)):\n # print(\"b\", stack)\n if s[i] == \"(\":\n # index of starting paren\n stack.append(i)\n else:\n # remove matching parenthesis\n stack.pop()\n # no more starting paren\n if not stack:\n # shift to new substring start\n stack.append(i)\n # valid parenthesis is i - open parenthesis index in stack\n else:\n res = max(res, i - stack[-1])\n # print(\"a\", stack)\n return res\n\n # store position of last open parenthesis in stack using index\n # burned valid parenthesis in stack by popping from the top\n\n\n return res\n \n\n ","runtime":"24"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n n = len(s)\n stack = []\n for i, c in enumerate(s):\n if c == \"(\":\n stack.append(i)\n elif c == \")\":\n if stack and s[stack[-1]] == \"(\":\n stack.pop()\n else:\n stack.append(i)\n stack = [-1] + stack + [n]\n return max(b - a - 1 for a, b in zip(stack, stack[1:]))","runtime":"25"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n s2 = ')' + s\n # dp[i] := the length of the longest valid parentheses in the substring\n # s2[1..i]\n dp = [0] * len(s2)\n\n for i in range(1, len(s2)):\n if s2[i] == ')' and s2[i - dp[i - 1] - 1] == '(':\n dp[i] = dp[i - 1] + dp[i - dp[i - 1] - 2] + 2\n\n return max(dp)","runtime":"26"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n max_len = 0\n stack = [-1]\n for i, x in enumerate(s):\n if x == \"(\":\n stack.append(i)\n else:\n stack.pop()\n if stack:\n max_len = max( max_len, i - stack[-1])\n else:\n stack.append(i)\n return max_len","runtime":"27"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1] # Initialize with -1 to handle edge cases\n max_length = 0\n\n for i in range(len(s)):\n if s[i] == '(':\n stack.append(i)\n else: # s[i] == ')'\n stack.pop()\n if not stack:\n stack.append(i)\n else:\n max_length = max(max_length, i - stack[-1])\n\n return max_length","runtime":"28"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n # i'm going to use a stack, whenever we close a paraenthesis if its valid we increment\n # we set best to max(best, current count)\n # if we close and there's nothing to close... then we reset the count\n best = 0\n count = 0\n stack: List[int] = []\n for el in s:\n if el == \"(\":\n stack.append(count)\n count = 0\n elif el == \")\":\n if stack:\n count += 2 + stack.pop()\n best = max(best, count)\n else:\n count = 0\n else:\n raise RuntimeError(\"Oops...\")\n\n return best","runtime":"29"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n max_len = 0\n\n for i, each_s in enumerate(s):\n if each_s == '(':\n stack.append(i)\n else:\n top_ele = stack.pop()\n if len(stack) == 0:\n stack.append(i)\n else:\n max_len = max(max_len, (i - stack[-1]))\n \n return max_len\n","runtime":"29"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n \n maxi = 0\n stack = [-1]\n \n for i in range(len(s)) :\n if s[i] == \"(\" : stack.append(i)\n else :\n stack.pop()\n if len(stack) == 0 : stack.append(i)\n else : maxi = max(maxi, i - stack[-1])\n \n return maxi","runtime":"30"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n max_length = 0\n stack = [-1] # Initialize stack with -1 to handle base cases\n \n for i, char in enumerate(s):\n if char == '(':\n stack.append(i) # Push the index onto the stack\n else:\n stack.pop() # Pop the last '(' index\n if not stack:\n # If stack is empty, push current index as a base for the next valid substring\n stack.append(i)\n else:\n # Calculate the length of the current valid substring\n max_length = max(max_length, i - stack[-1])\n \n return max_length","runtime":"30"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n # Initialize a stack with -1\n stack = [-1]\n # Handles empty string edge case\n\n # Initialize the max length to 0\n max_length = 0\n\n # The goal here is to keep track of the index of the last opening parantheses\n # This way, we can calculate the length of the substring\n\n # Iterate through the string\n for i in range(len(s)):\n\n # If the character is an opening parantheses, push the index to the stack\n if s[i] == '(':\n stack.append(i)\n\n # If the character is a closing parantheses\n else:\n\n # Pop the top element from the stack\n stack.pop()\n\n # If the stack is empty, push the index to the stack\n if len(stack) == 0:\n stack.append(i)\n\n # Update the max length\n else:\n max_length = max(max_length, i - stack[-1])\n\n return max_length ","runtime":"31"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n max_len = 0\n\n for i in range(len(s)):\n if s[i] == \"(\":\n stack.append(i)\n else:\n stack.pop()\n if len(stack) == 0:\n stack.append(i)\n else:\n max_len = max(max_len, i - stack[-1])\n \n return max_len\n ","runtime":"32"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n res = 0\n st = [-1]\n for i,c in enumerate(s):\n if c == '(':\n st.append(i)\n else:\n st.pop()\n if not st:\n st.append(i)\n else:\n res = max(res, i-st[-1])\n return res\n \n ","runtime":"32"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n l = r = 0\n ans = 0\n N = len(s)\n for c in s:\n if c == '(':\n l += 1\n else:\n r += 1\n if r > l:\n l = r = 0\n elif r == l:\n ans = max(ans, r+l)\n r = l = 0\n for c in s[::-1]:\n if c == ')':\n r += 1\n else:\n l += 1\n if l > r:\n l = r = 0\n elif r == l:\n ans = max(ans, r+l)\n return ans\n \n\n \n\n\n\n \n ","runtime":"33"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n max_len = 0\n\n for i, c in enumerate(s):\n if c == '(':\n stack.append(i)\n else:\n stack.pop()\n if not stack:\n stack.append(i)\n else:\n max_len = max(max_len, i - stack[-1])\n return max_len","runtime":"33"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n max_len = 0\n\n for i in range(len(s)):\n if s[i] == \"(\":\n stack.append(i)\n else:\n stack.pop()\n if len(stack) == 0:\n stack.append(i)\n else:\n max_len = max(max_len, i - stack[-1])\n \n return max_len","runtime":"34"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = []\n l = ['0'] * len(s)\n\n for ind, i in enumerate(s):\n if i == '(':\n stack.append(ind)\n else:\n if stack:\n l[stack.pop()] = '1'\n l[ind] = '1'\n\n return max(len(i) for i in ''.join(l).split('0'))","runtime":"34"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n answer = 0\n for i in range(len(s)):\n if s[i] == '(':\n stack.append(i)\n else:\n stack.pop()\n # Could not find a '(' to match\n # This index becomes the new start of any valid string from behinde\n if len(stack) == 0:\n stack.append(i)\n else:\n # ex: (()\n # The popped element would be 1, we know 2 matches with 1 which is valid\n # 0 is the topped element in the stack and it's not matched, so 2-0 would be the length\n answer = max(answer, i - stack[-1])\n\n return answer\n\n ","runtime":"35"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stk = [-1]\n ans = 0\n\n for i in range(len(s)):\n if s[i] == ')' and stk[-1] != -1 and s[stk[-1]] == '(':\n stk.pop()\n ans = max(ans, i - stk[-1])\n else:\n stk.append(i)\n \n return ans","runtime":"35"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n st = [-1]\n res = 0\n for i in range(len(s)):\n if s[i]=='(':\n st.append(i)\n else:\n st.pop()\n if len(st)==0:\n st.append(i)\n else:\n res = max(res, i-st[-1])\n # print(st)\n return res","runtime":"36"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n # base case to handle the case when we find a valid substring starting from the first character\n stack = [-1]\n longest = 0\n \n for i, char in enumerate(s):\n if char == '(':\n stack.append(i)\n else:\n stack.pop()\n # If stack is empty, push the current index\n if not stack:\n stack.append(i) \n else:\n # all the valid pair from stack[-1] to i has been poped\n longest = max(longest, i - stack[-1])\n \n return longest","runtime":"36"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n st = [-1]\n res = 0\n for i, v in enumerate(s):\n if v == '(':\n st.append(i)\n else:\n st.pop()\n if not st:\n st.append(i)\n else:\n res = max(res, i-st[-1])\n return res\n ","runtime":"37"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int: # O(n) time and space\n res, stack = 0, [-1]\n for i in range(len(s)):\n if s[i] == \"(\": stack.append(i)\n else: # )\n stack.pop()\n if not stack: stack.append(i)\n else: res = max(res, i - stack[-1]) \n return res","runtime":"38"},{"code":"\ndef check(str):\n left=0\n right=0\n ans=0\n for i in str:\n if(i=='('):\n left+=1\n else:\n right+=1\n if(right>left):\n left=right=0\n elif(right==left):\n ans=max(ans,left*2)\n left=right=0\n for i in range(len(str)-1,-1,-1):\n if(str[i]=='('):\n left+=1\n else:\n right+=1\n if(left>right):\n left=right=0\n elif(left==right):\n ans=max(ans,left*2)\n return ans\nclass Solution:\n def longestValidParentheses(self, str):\n # code here\n return check(str)","runtime":"38"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n max_len = 0\n\n for i in range(len(s)):\n if s[i] == '(':\n stack.append(i)\n else:\n stack.pop()\n if len(stack) == 0:\n stack.append(i)\n else:\n max_len = max(max_len, i - stack[-1])\n\n return max_len\n","runtime":"39"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n \n openCount, closeCount = 0, 0\n res = 0\n for c in s:\n if c == \"(\":\n openCount += 1\n else:\n closeCount += 1\n if openCount == closeCount:\n res = max(res, openCount + closeCount)\n if closeCount > openCount:\n openCount, closeCount = 0, 0\n openCount, closeCount = 0, 0\n for c in s[::-1]:\n if c == \"(\":\n openCount += 1\n else:\n closeCount += 1\n if closeCount == openCount:\n res = max(res, openCount + closeCount)\n if closeCount < openCount:\n openCount, closeCount = 0, 0\n \n return res\n","runtime":"39"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n l_count = 0\n r_count = 0\n max_len = 0\n\n i = 0\n # l -> r\n while i < len(s):\n if s[i] == \"(\":\n l_count += 1\n else:\n r_count += 1\n\n if l_count == r_count:\n max_len = max(max_len, l_count + r_count)\n elif r_count > l_count:\n l_count = 0\n r_count = 0\n i += 1\n \n i = len(s) - 1\n l_count = 0\n r_count = 0\n\n # r->l\n while i >= 0:\n if s[i] == \"(\":\n l_count += 1\n else: \n r_count += 1\n \n if l_count == r_count:\n max_len = max(max_len, l_count + r_count)\n elif l_count > r_count:\n l_count = 0\n r_count = 0\n i -= 1\n \n return max_len","runtime":"40"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n m = 0\n stack = [-1]\n for i in range(len(s)):\n if s[i]=='(':\n stack.append(i)\n else:\n stack.pop()\n if not stack:\n stack.append(i)\n else:\n m = max(m,i-stack[-1])\n return m\n ","runtime":"40"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n left, right, maxlength = 0, 0, 0\n for i in range(len(s)):\n if s[i] == \"(\":\n left += 1\n else:\n right += 1\n if left == right:\n maxlength = max(maxlength, 2 * right)\n elif right > left:\n left = right = 0\n left = right = 0\n for i in range(len(s) - 1, -1, -1):\n if s[i] == \"(\":\n left += 1\n else:\n right += 1\n if left == right:\n maxlength = max(maxlength, 2 * left)\n elif left > right:\n left = right = 0\n return maxlength","runtime":"41"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n n = len(s)\n if n < 2:\n return 0\n dp = [0] * n\n for i in range(1, n):\n if s[i] == ')':\n if s[i - 1] == '(':\n dp[i] = 2 + (dp[i - 2] if i > 1 else 0)\n else:\n j = i - dp[i - 1] - 1\n if j >= 0 and s[j] == '(':\n dp[i] = 2 + dp[i - 1] + dp[j - 1]\n return max(dp)\n\n ","runtime":"41"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n n = len(s)\n f = [0] * (n + 1)\n for i, c in enumerate(s, 1):\n if c == \")\":\n if i > 1 and s[i - 2] == \"(\":\n f[i] = f[i - 2] + 2\n else:\n j = i - f[i - 1] - 1\n if j and s[j - 1] == \"(\":\n f[i] = f[i - 1] + 2 + f[j - 1]\n return max(f)","runtime":"42"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n st = []\n ans = 0\n curr = 0\n for i in range(0,len(s)):\n if s[i]=='(':\n st.append(i)\n elif s[i]==')':\n if len(st)>0 and s[st[-1]] == '(':\n st.pop()\n else:\n st.append(i)\n end = len(s)\n for i in range(len(st)-1,-1,-1):\n ans = max(ans,end - st[i] -1)\n end = st[i]\n return max(ans,end)","runtime":"42"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n left = right = 0\n ans = 0\n\n # scan from left to right\n for c in s:\n if c == '(':\n left += 1\n else:\n right += 1\n\n if left == right:\n ans = max(ans, 2 * right)\n elif right > left:\n left = right = 0\n\n left = right = 0\n # scan from right to left\n for c in reversed(s):\n if c == '(':\n left += 1\n else:\n right += 1\n\n if left == right:\n ans = max(ans, 2 * left)\n elif left > right:\n left = right = 0\n\n return ans","runtime":"43"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n\n leading_brac = 0\n open_brac_indices = []\n mask = [0] * len(s)\n for index, brac in enumerate(s):\n if brac == '(':\n leading_brac += 1\n open_brac_indices.append(index)\n elif brac == ')':\n if leading_brac == 0:\n pass\n elif leading_brac > 0:\n leading_brac -= 1\n open_brac_index = open_brac_indices.pop()\n mask[open_brac_index] = 1\n mask[index] = 1\n\n\n\n if ')' not in s:\n return 0\n\n count = 0\n all_lengths = []\n\n for i in mask:\n if i==1:\n count += 1\n else:\n all_lengths.append(count)\n count = 0\n all_lengths.append(count)\n\n return max(all_lengths)\n\n ","runtime":"43"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack=[-1]\n max_len=0\n for i in range(len(s)):\n if s[i] == \"(\":\n stack.append(i)\n else:\n stack.pop()\n if len(stack) ==0:\n stack.append(i)\n else:\n max_len=max(max_len,i-stack[-1])\n return max_len\n ","runtime":"44"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n s2 = ')' + s\n # dp[i] := the length of the longest valid parentheses in the substring\n # s2[1..i]\n dp = [0] * len(s2)\n\n for i in range(1, len(s2)):\n if s2[i] == ')' and s2[i - dp[i - 1] - 1] == '(':\n dp[i] = dp[i - 1] + dp[i - dp[i - 1] - 2] + 2\n\n return max(dp)\n ","runtime":"44"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n max_len = 0\n\n for i in range(len(s)):\n if s[i] == \"(\":\n stack.append(i)\n else:\n stack.pop()\n if len(stack) == 0:\n stack.append(i)\n else:\n max_len = max(max_len, i - stack[-1])\n \n return max_len","runtime":"45"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n max_length = 0\n stck=[-1]\n print(stck)\n for i in range(len(s)):\n if s[i] == '(':\n stck.append(i)\n else:\n stck.pop()\n if not stck:\n stck.append(i)\n else:\n max_length=max(max_length, i-stck[-1])\n return max_length\n ","runtime":"45"},{"code":"\nclass Solution:\n def longestValidParentheses(self, s: str) -> int:\n n=len(s)\n stack=[-1]\n maxi=0\n\n for i in range(len(s)):\n ch=s[i]\n if ch==\"(\":\n stack.append(i)\n else:\n stack.pop()\n if len(stack)==0:\n stack.append(i)\n else:\n maxi=max(maxi,i-stack[-1])\n \n return maxi","runtime":"46"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = []\n dp = [-1] * len(s)\n res = 0\n for i in range(len(s)):\n if s[i] == \")\":\n if stack:\n ind = stack.pop()\n dp[ind] = i\n else:\n stack.append(i)\n \n i = 0\n res = 0\n count = 0\n while i < len(dp):\n if dp[i] == -1:\n res = max(res, count)\n count = 0\n i += 1\n else:\n count += dp[i] - i + 1\n i = dp[i] + 1\n return max(res, count)","runtime":"46"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n n = len(s)\n f = [0] * (n + 1)\n for i, c in enumerate(s, 1):\n if c == \")\":\n if i > 1 and s[i - 2] == \"(\":\n f[i] = f[i - 2] + 2\n else:\n j = i - f[i - 1] - 1\n if j and s[j - 1] == \"(\":\n f[i] = f[i - 1] + 2 + f[j - 1]\n return max(f)","runtime":"47"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n v = [0] * (len(s) + 1)\n m = 0\n for i in range(len(s)-2, -1, -1):\n d = v[i+1]\n if s[i] == '(' and (i + d + 1) < len(s) and s[i+d+ 1] == ')':\n v[i] = 2 + d + v[i + d + 2]\n m = max(v[i], m)\n return m\n\n\n","runtime":"47"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n L=len(s)\n if L<2: return 0\n max1=0\n l=0\n r=0\n i=0\n while i<L:\n if s[i]=='(': l+=1\n if s[i]==')': r+=1\n if l==r:\n if max1<l+r:\n max1=l+r\n if r>l:\n l=0\n r=0\n i+=1\n l=0\n r=0\n i=L-1\n while i>=0:\n if s[i]=='(': l+=1\n if s[i]==')': r+=1\n if l==r:\n if max1<l+r:\n max1=l+r\n if r<l:\n l=0\n r=0\n i-=1\n return max1\n\n ","runtime":"48"},{"code":"class Solution:\n # (num of open, num of closed successfully)\n def longestValidParentheses(self, s: str) -> int:\n stack = []\n for c in s:\n if c == '(':\n if not stack:\n stack.append((1, 0))\n else:\n num_open = 0\n if stack[-1][1] == 0:\n num_open = stack.pop()[0]\n stack.append((num_open + 1, 0))\n elif stack:\n if stack[-1][0] <= 0:\n stack.append((-1,-1))\n else:\n tmp = stack.pop()\n stack.append((tmp[0] - 1, tmp[1] + 1))\n num_close = 0\n while stack and stack[-1][0] == 0:\n num_close += stack.pop()[1]\n tmp = stack.pop() if stack and stack[-1][0]!=-1 else (0, 0)\n stack.append((tmp[0], tmp[1]+num_close))\n return (max(stack, key=lambda pair: pair[1])[1])*2 if stack else 0","runtime":"48"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n if len(s) == 0:\n return 0\n\n left = 0\n right = 0\n # True means it can connect with next \n lens = []\n curr_len = 0 \n for i, ch in enumerate(s):\n if ch == \"(\":\n left += 1\n else:\n right += 1\n # check if there is anything to pop and check if it can connect to prev\n \n if left > 0 or (len(lens) > 0 and lens[-1][1] > 0):\n \n left -= 1\n right -= 1\n if len(lens) > 0:\n prev, prev_left, prev_right = lens.pop()\n if prev_left > 0 and prev_right == 0 and left == -1: # merge to prev chunk\n lens.append((prev + 2, prev_left - 1, prev_right))\n left = 0\n else: #unable to merge to previous chunk \n lens.append((prev, prev_left, prev_right))\n lens.append((2, left, right))\n left = 0\n\n else: \n lens.append((2, left, right))\n left = 0\n\n while len(lens) > 1:\n curr, curr_left, curr_right = lens.pop()\n prev, prev_left, prev_right = lens.pop()\n if curr_left == 0 and prev_right == 0:\n lens.append((curr + prev, prev_left, curr_right))\n else: # unable to merge \n lens.append((prev, prev_left, prev_right))\n lens.append((curr, curr_left, curr_right))\n break\n else: # nothing to pop on left for now, seq ends with more right.\n if len(lens) > 0:\n prev, prev_left, prev_right = lens.pop()\n lens.append((prev, prev_left, prev_right+1))\n right = 0\n\n if len(lens) == 0:\n return 0\n return max([num for num, left, right in lens])\n\n","runtime":"49"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n max_len = 0\n\n for i in range(len(s)):\n if s[i] == \"(\":\n stack.append(i)\n else:\n stack.pop()\n if len(stack) == 0:\n stack.append(i)\n else:\n max_len = max(max_len, i - stack[-1])\n \n return max_len","runtime":"49"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n if len(s) == 0:\n return 0\n left = 0\n right = 0\n maximum = 0\n for i in range(0,len(s)):\n if s[i] == '(':\n left += 1\n else:\n right += 1\n if left == right:\n maximum = max(maximum,left*2)\n elif right > left:\n left = 0\n right = 0\n left = 0\n right = 0\n for i in range(len(s)-1,-1,-1):\n if s[i] == '(':\n left += 1\n else:\n right += 1\n if left == right:\n maximum = max(maximum,left*2)\n elif left > right:\n left = 0\n right = 0\n return maximum","runtime":"50"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n # dp[i]: end in s[i], how faraway to the left makes the substring valid\n dp = [0]*(len(s))\n res = 0\n for i in range(1, len(s)):\n if s[i] == \")\":\n pre = i - dp[i - 1] - 1\n if pre >= 0 and s[pre] == \"(\":\n dp[i] = dp[i - 1] + 2 + (dp[pre - 1] if pre > 0 else 0)\n res = max(res, dp[i])\n return res\n","runtime":"50"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n maxans = 0\n dp = [0] * len(s)\n for i in range(1, len(s)):\n if s[i] == \")\":\n if s[i - 1] == \"(\":\n dp[i] = (dp[i - 2] if i >= 2 else 0) + 2\n elif i - dp[i - 1] > 0 and s[i - dp[i - 1] - 1] == \"(\":\n dp[i] = (\n dp[i - 1]\n + (dp[i - dp[i - 1] - 2] if i - dp[i - 1] >= 2 else 0)\n + 2\n )\n maxans = max(maxans, dp[i])\n return maxans","runtime":"51"},{"code":"class Solution:\n # (num of open, num of closed successfully)\n def longestValidParentheses(self, s: str) -> int:\n stack = []\n for c in s:\n if c == '(':\n num_open = 0\n if stack and stack[-1][1] == 0:\n num_open = stack.pop()[0]\n stack.append((num_open + 1, 0))\n elif stack and stack[-1][0] <= 0:\n stack.append((-1,-1))\n elif stack:\n # close current\n tmp = stack.pop()\n stack.append((tmp[0] - 1, tmp[1] + 1))\n\n # sum of all consecutive close\n num_close = 0\n while stack and stack[-1][0] == 0:\n num_close += stack.pop()[1]\n tmp = stack.pop() if stack and stack[-1][0] != -1 else (0, 0)\n stack.append((tmp[0], tmp[1]+num_close))\n return (max(stack, key=lambda pair: pair[1])[1])*2 if stack else 0","runtime":"51"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n # Time: O(n)\n # Space: O(n)\n\n stack = [-1]\n res = 0\n for i, ch in enumerate(s):\n if ch == '(':\n stack.append(i)\n else:\n stack.pop()\n if not stack:\n stack.append(i)\n else:\n res = max(res, i-stack[-1])\n return res","runtime":"54"},{"code":"\nclass Solution:\n def longestValidParentheses(self, s: str) -> int:\n\n if s.find('()')==-1 :\n return 0\n\n print('s0='+s)\n\n brackets = [-1]\n max_ = 0\n\n for i, el in enumerate(s):\n print('i0='+str(i))\n if el == '(':\n brackets.append(i)\n else:\n brackets.pop()\n if not brackets:\n brackets.append(i)\n else:\n #print('i1='+str(i))\n #print('brackets[-1]='+str(brackets[-1]))\n max_ = max(max_, i - brackets[-1])\n\n\n return max_\n","runtime":"55"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = []\n dp = [-1] * len(s)\n res = 0\n for i in range(len(s)):\n if s[i] == \")\":\n if stack:\n ind = stack.pop()\n dp[ind] = i\n else:\n stack.append(i)\n \n i = 0\n res = 0\n count = 0\n while i < len(dp):\n if dp[i] == -1:\n res = max(res, count)\n count = 0\n i += 1\n else:\n count += dp[i] - i + 1\n i = dp[i] + 1\n return max(res, count)","runtime":"56"},{"code":"class Solution:\n # the idea is similar to find the longest sub array of sum to 0 with sliding window\n # We keep the balance score and mono stack of the non zero balance\n # when balance is negative, reset\n def longestValidParentheses(self, s: str) -> int:\n score = 0\n stack = [[-1, 0]]\n res = 0\n for i, c in enumerate(s):\n if c == '(':\n score += 1\n else:\n score -= 1\n if score < 0:\n # invalid state, will start from here\n score = 0\n stack.clear()\n stack.append([i, 0])\n else: \n while stack and stack[-1][1] > score:\n stack.pop()\n \n # now the last position in stack has the same score\n # in between it is valid\n if score == stack[-1][1]:\n res = max(res, i - stack[-1][0])\n else:\n stack.append([i, score])\n # print(stack)\n return res\n\n def longestValidParentheses_(self, s: str) -> int:\n # the idea is to match the sting and keep the state\n # The trick here is that we keep the immediate right valid length at '(' in the stack\n # And clear the stack when the state is invalid\n # ((())()((\n # e.g. above we keep the valid length to previous '('\n # add a dummy node to store the score\n stack = []\n stack.append(['#', 0])\n res = 0\n\n for c in s:\n if c == '(':\n stack.append(['(', 0])\n else:\n if stack[-1][0] == '(':\n p, l = stack.pop()\n # score of the complete range\n l += 2\n stack[-1][1] += l\n res = max(res, stack[-1][1])\n else:\n # start of new exploration\n del stack[1:]\n # res = max(res, stack[0][1])\n # clear the count\n stack[0][1] = 0\n # print(stack)\n return res","runtime":"57"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n n = len(s)\n cache = dict()\n i = 0\n while i < n-1:\n if s[i] == '(' and s[i+1] == ')':\n cache[i] = i+1\n i += 2\n else:\n i += 1\n max_len = 2 if cache else 0\n\n \n has_changed = True\n while has_changed:\n # print(cache)\n has_changed = False\n for i in list(cache.keys()):\n j = cache.get(i)\n # print(f'i={i} j={j}')\n if j is None:\n continue\n\n # case XY\n nj = cache.get(j+1)\n if nj:\n del cache[j+1]\n max_len = max(max_len, nj-i + 1)\n cache[i] = nj\n has_changed = True\n # print(f'case XY add i={i} j={nj}; delete {j+1}')\n # print(cache)\n else:\n # case (X)\n if 0 < i and j < n-1:\n if s[i-1] == '(' and s[j+1] == ')':\n del cache[i]\n max_len = max(max_len, j-i + 3)\n cache[i-1] = j+1\n has_changed = True\n # print(f'case (X) add i={i-1} j={j+1}; delete {i}')\n\n return max_len\n \n","runtime":"58"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n self.memo=[-1]*len(s)\n res = 0\n for p in range(len(s)):\n res = max(res, self.dp(s,p))\n return res\n \n def dp(self, s, p):\n if p<=0:\n return 0\n if self.memo[p]!=-1:\n return self.memo[p]\n if s[p]==\"(\":\n res=0\n elif s[p]==\")\":\n if s[p-1]==\"(\":\n res = self.dp(s,p-2)+2\n elif s[p-1]==\")\":\n if p-self.dp(s,p-1)-1>=0 and s[p-self.dp(s,p-1)-1]==\"(\":\n res=self.dp(s,p-self.dp(s,p-1)-2)+self.dp(s,p-1)+2\n else:\n res=0\n self.memo[p]=res\n return res\n","runtime":"58"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n self.memo=[-1]*len(s)\n res = 0\n for p in range(len(s)):\n res = max(res, self.dp(s,p))\n return res\n \n def dp(self, s, p):\n if p<=0:\n return 0\n if self.memo[p]!=-1:\n return self.memo[p]\n res = 0\n if s[p]==\")\":\n if s[p-1]==\"(\":\n res = self.dp(s,p-2)+2\n elif s[p-1]==\")\":\n if p-self.dp(s,p-1)-1>=0 and s[p-self.dp(s,p-1)-1]==\"(\":\n res=self.dp(s,p-self.dp(s,p-1)-2)+self.dp(s,p-1)+2\n self.memo[p]=res\n return res\n","runtime":"59"},{"code":"from collections import defaultdict\n\n\nclass Solution:\n def longestValidParentheses(self, s: str) -> int:\n latest_current_state = defaultdict(lambda: -1)\n current_level = 0\n max_length = 0\n for idx, c in enumerate(s):\n if c == '(':\n current_level += 1\n latest_current_state[current_level] = idx\n else:\n current_level -= 1\n if current_level >= 0:\n max_length = max(max_length,idx - latest_current_state[current_level])\n else:\n current_level = 0\n latest_current_state[current_level] = idx\n print(current_level)\n return max_length\n \n ","runtime":"60"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n self.memo=[-1]*len(s)\n res = 0\n for p in range(len(s)):\n res = max(res, self.dp(s,p))\n return res\n \n def dp(self, s, p):\n if p<=0:\n return 0\n if self.memo[p]!=-1:\n return self.memo[p]\n res = 0\n if s[p]==\")\":\n if s[p-1]==\"(\":\n res = self.dp(s,p-2)+2\n elif s[p-1]==\")\":\n if p-self.dp(s,p-1)-1>=0 and s[p-self.dp(s,p-1)-1]==\"(\":\n res=self.dp(s,p-self.dp(s,p-1)-2)+self.dp(s,p-1)+2\n self.memo[p]=res\n return res\n","runtime":"61"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n cores = []\n\n i = 0\n while i < (len(s)-1):\n if s[i]=='(' and s[i+1]==')':\n cores.append([i,i+1])\n i+=2\n else:\n i+=1\n\n if len(cores) == 0:\n return 0\n\n i = 0\n while i < len(cores):\n while True:\n left, right = cores[i][0]-1, cores[i][1]+1\n if left >= 0 and right < len(s) and s[left] == \"(\" and s[right] == \")\":\n cores[i][0]-=1\n cores[i][1]+=1\n else:\n break\n\n yes = False\n while i >= 0:\n if (i+1)<len(cores) and cores[i][1] == cores[i+1][0]:\n cores[i][1] = cores[i+1][1]\n del cores[i+1] \n\n if i > 0 and (cores[i-1][1]+1) == cores[i][0]:\n cores[i][0] = cores[i-1][0]\n del cores[i-1]\n i -= 1\n yes = True\n else:\n break\n\n if not yes:\n i+=1\n \n return max([m[1]-m[0]+1 for m in cores])","runtime":"62"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack=[]\n list1=list(s)\n for i in range(len(s)):\n if(len(stack)==0):stack.append([s[i],i])\n elif(stack[-1][0]==\"(\" and s[i]==\")\"):\n list1[stack[-1][1]]=True\n list1[i]=True\n stack.pop()\n else:stack.append([s[i],i])\n ctr,max1=0,0\n for i in list1:\n if i==True:\n ctr+=1\n max1=max(max1,ctr)\n else:ctr=0\n return max1\n\n ","runtime":"62"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n prev_left = []\n curr_len, max_len = 0, 0\n for c in s:\n if c == '(':\n prev_left.append(curr_len)\n curr_len = 0\n elif len(prev_left) == 0:\n curr_len = 0\n else:\n curr_len += prev_left[-1] + 2\n max_len = max(curr_len, max_len)\n prev_left = prev_left[:-1]\n return max_len\n","runtime":"63"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n res = []\n left = right = 0\n left_cnt = right_cnt = 0\n cur_length = 0\n stack = []\n while left < len(s) and right < len(s):\n c = s[right]\n if c == '(':\n stack.append(right)\n left_cnt += 1\n else:\n if left_cnt:\n res.append((stack.pop(), right))\n left_cnt -= 1\n else:\n left = right + 1\n left_cnt = right_cnt = 0\n right += 1\n if not res:\n return 0\n \n res.sort()\n print(res)\n ans = [res[0]]\n\n for i in range(1, len(res)):\n left, right = res[i][0], res[i][1]\n prev_left, prev_right = ans[-1][0], ans[-1][1]\n if left < prev_left and right > prev_right:\n ans[-1] = (left, right)\n elif left >= prev_left and right <= prev_right:\n continue\n else:\n if prev_right + 1 == left:\n ans[-1] = (prev_left, right)\n else:\n ans.append((left, right))\n print(ans)\n max_length = max([right - left + 1 for left, right in ans])\n return max_length\n \n \n ","runtime":"64"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n n = len(s)\n cache = dict()\n max_len = 0\n for i in range(n-1):\n if s[i] == '(' and s[i+1] == ')':\n max_len = 2\n cache[i] = i+1\n \n has_changed = True\n while has_changed:\n # print(cache)\n has_changed = False\n for i in list(cache.keys()):\n j = cache.get(i)\n # print(f'i={i} j={j}')\n if j is None:\n continue\n\n # case XY\n nj = cache.get(j+1)\n if nj:\n del cache[j+1]\n max_len = max(max_len, nj-i + 1)\n cache[i] = nj\n has_changed = True\n # print(f'case XY add i={i} j={nj}; delete {j+1}')\n # print(cache)\n else:\n # case (X)\n if 0 < i and j < n-1:\n if s[i-1] == '(' and s[j+1] == ')':\n del cache[i]\n max_len = max(max_len, j-i + 3)\n cache[i-1] = j+1\n has_changed = True\n # print(f'case (X) add i={i-1} j={j+1}; delete {i}')\n\n return max_len\n \n","runtime":"65"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n memo = {}\n def dfs(i):\n if i >= len(s):\n return 0\n if i in memo:\n return memo[i]\n memo[i] = 0\n if s[i] == '(':\n if i + 1 < len(s) and s[i + 1] == ')':\n memo[i] = dfs(i + 2) + 2\n elif i + dfs(i + 1) + 1 < len(s) and s[i + dfs(i + 1) + 1] == ')':\n memo[i] = dfs(i + 1) + 2 + dfs(i + dfs(i + 1) + 2)\n return memo[i]\n\n for i in range(len(s)):\n dfs(i)\n return max(memo.values()) if memo else 0","runtime":"66"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n n = len(s)\n cache = dict()\n i = 0\n \n while i < n-1:\n if s[i] == '(' and s[i+1] == ')':\n cache[i] = i+1\n i += 2\n else:\n i += 1\n max_len = 2 if cache else 0\n\n \n has_changed = True\n while has_changed:\n # print(cache)\n has_changed = False\n for i in list(cache.keys()):\n j = cache.get(i)\n # print(f'i={i} j={j}')\n if j is None:\n continue\n\n # case XY\n nj = cache.get(j+1)\n if nj:\n del cache[j+1]\n # max_len = max(max_len, nj-i + 1)\n cache[i] = nj\n has_changed = True\n # print(f'case XY add i={i} j={nj}; delete {j+1}')\n # print(cache)\n else:\n # case (X)\n if 0 < i and j < n-1:\n if s[i-1] == '(' and s[j+1] == ')':\n del cache[i]\n # max_len = max(max_len, j-i + 3)\n cache[i-1] = j+1\n has_changed = True\n # print(f'case (X) add i={i-1} j={j+1}; delete {i}')\n\n for i, j in cache.items():\n max_len = max(max_len, j - i + 1)\n return max_len\n \n","runtime":"67"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n temp = [i for i in s]\n for i in range(len(temp)): \n if temp[i] == \"(\" : \n continue \n else : \n for j in range(i-1,-1,-1): \n if temp[j] == \"(\" :\n temp[j] = 1 \n temp[i] = 1 \n break\n temp_res = 0 \n res = 0 \n for i in range(len(temp)) : \n if temp[i] == 1 :\n temp_res +=1 \n else : \n if res < temp_res : \n res = temp_res \n temp_res = 0 \n if res < temp_res : \n res = temp_res\n return res\n ","runtime":"68"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n longestLength = 0\n l = 0\n opened = 0\n closed = 0\n length = 0\n for i in s:\n print(opened, closed)\n length += 1\n if i == \"(\":\n opened += 1\n else:\n closed += 1\n if opened == closed:\n longestLength = max(longestLength, length)\n if closed > opened:\n opened = 0\n closed = 0\n length = 0\n opened = 0\n closed = 0\n length = 0\n for i in s[::-1]:\n length += 1\n if i == \")\":\n closed += 1\n else:\n opened += 1\n if opened == closed:\n longestLength = max(longestLength, length)\n if opened > closed:\n opened = 0\n closed = 0\n length = 0\n return longestLength\n ","runtime":"69"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = []\n result = []\n\n for elem in s:\n if len(stack) > 0 and stack[-1] == '(' and elem == ')':\n stack.pop()\n\n i = len(result) - 1\n\n while i >= 0 and result[i] == 1:\n i -= 1\n\n result[i] = 1\n result.pop()\n result.extend([1, 1])\n else:\n stack.append(elem)\n result.append(0)\n\n current = 0\n longest = 0\n\n for i in range(len(result)):\n if result[i] == 1:\n current += 1\n else:\n current = 0\n\n if current > longest and current > 0:\n longest = current\n\n return longest","runtime":"70"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n\n # Memoization table to store intermediate results\n memo = [-1] * len(s)\n\n def dp(i: int) -> int:\n # Base case: if we're out of bounds, no valid parentheses\n if i >= len(s):\n return 0\n \n # If we've already solved this subproblem, return the result\n if memo[i] != -1:\n return memo[i]\n \n # Initialize current result to 0\n res = 0\n\n # Case 1: '(' followed by a matching ')'\n if i + 1 < len(s) and s[i] == '(' and s[i + 1] == ')':\n res = 2 + dp(i + 2)\n\n # Case 2: '(' followed by a matching ')' at a further index\n elif i + 1 < len(s) and s[i] == '(':\n close_index = i + dp(i + 1) + 1\n if close_index < len(s) and s[close_index] == ')':\n res = 2 + dp(i + 1) + dp(close_index + 1)\n \n # Store the result in memo\n memo[i] = res\n return res\n\n # We need to check every index, as the longest valid parentheses can start anywhere\n max_len = 0\n for i in range(len(s)):\n max_len = max(max_len, dp(i))\n\n return max_len\n","runtime":"71"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n \n class Node:\n def __init__(self):\n self.parent = None\n self.children = []\n self.start = None\n self.end = None\n \n def __repr__(self):\n return f\"({self.start}, {self.end}, {self.parent})\"\n\n active_intervals = []\n complete_intervals = []\n for i, c in enumerate(s):\n if c == '(':\n node = Node()\n node.start = i\n if len(active_intervals) > 0:\n node.parent = active_intervals[-1]\n active_intervals[-1].children.append(node)\n active_intervals.append(node)\n elif len(active_intervals) > 0:\n latest_node = active_intervals.pop()\n latest_node.end = i\n complete_intervals.append(latest_node)\n top_level_intervals = [node for node in complete_intervals if node.parent is None or node.parent.end is None]\n # print(active_intervals)\n # print(complete_intervals)\n # print(top_level_intervals)\n\n max_len = 0\n if len(top_level_intervals) == 0:\n return max_len\n\n first = top_level_intervals[0]\n substr_start = first.start\n substr_end = first.end\n for node in top_level_intervals[1:]:\n if substr_end + 1 == node.start:\n substr_end = node.end\n else:\n substr_len = substr_end - substr_start + 1\n if substr_len > max_len:\n max_len = substr_len\n\n substr_start = node.start\n substr_end = node.end\n \n substr_len = substr_end - substr_start + 1\n if substr_len > max_len:\n max_len = substr_len\n\n return max_len","runtime":"72"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n list_s = list(s.strip())\n i = 0\n temp_count, res = 0,0\n while i < len(list_s):\n temp = list_s[i]\n if temp == ')':\n if list_s[i-1] == '(' and i != 0: \n list_s[i-1:i+1]= '2'\n i-=1\n elif i > 0:\n j = i\n while j > 0 and list_s[j] != '|':\n j-=1\n if list_s[j] == '(':\n list_s[i] = '2'\n list_s.pop(j)\n i-=1\n break \n else:\n list_s[i]='|'\n else:\n list_s.pop(i)\n else:\n i+=1\n\n for s in list_s:\n if s == '2':\n temp_count +=2\n res = max(res, temp_count)\n else:\n temp_count=0\n return res\n\n ","runtime":"73"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n import re\n p = re.compile('\\(b*\\)') \n s_prev = s\n s = s.replace('()', 'b')\n\n while s_prev != s:\n s_prev = s\n searches = set(p.findall(s))\n for search in searches:\n s = s.replace(search, 'b'*(len(search) - 1))\n \n len_ = max_len = 0\n for ch in s:\n if ch == 'b':\n len_ += 2\n else:\n max_len = max(max_len, len_)\n len_ = 0\n \n max_len = max(max_len, len_)\n return max_len","runtime":"74"},{"code":"\nclass Solution:\n def longestValidParentheses(self, s: str) -> int:\n\n if s.find('()')==-1 :\n return 0\n\n print('s0='+s)\n\n brackets = [-1]\n max_ = 0\n\n for i, el in enumerate(s):\n print('i0='+str(i))\n if el == '(':\n brackets.append(i)\n else:\n brackets.pop()\n if not brackets:\n brackets.append(i)\n else:\n print('i1='+str(i))\n print('brackets[-1]='+str(brackets[-1]))\n max_ = max(max_, i - brackets[-1])\n\n\n return max_\n","runtime":"75"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n hash = {}\n prev = -1\n\n queue = []\n finalarr = [-1 for _ in range(len(s))]\n for i,c in enumerate(s):\n if c==\"(\":\n queue.insert(0,i)\n else:\n if len(queue) > 0:\n idx=queue.pop(0)\n finalarr[idx] = 1\n finalarr[i] = 1\n else:\n finalarr[i] = -1\n \n curr = 0\n ans = 0\n for i in finalarr:\n if i==-1:\n curr = 0\n else:\n curr+=1\n \n if curr > ans:\n ans = curr\n return ans\n","runtime":"77"},{"code":"from collections import deque \n\nclass Solution:\n def longestValidParentheses(self, s: str) -> int:\n \n \n st = deque()\n lst = []\n \n for i,e in enumerate(s):\n #print(\"st\", st)\n if not st:\n st.append( (i+1,e) )\n else:\n indx, val = st[-1]\n if val == '(' and e == ')':\n st.pop()\n else:\n st.append( (i+1,e) )\n idnx = 0\n print(\"St\", st)\n maxval = 0\n lst = []\n while st:\n i,e = st.popleft()\n lst.append(i)\n print(\"lst\", lst)\n \n if lst:\n prev = lst[0]\n for e in lst[1:]:\n print(\"e\", e, \"prev\",prev, \"(e-prev)-1\", (e-prev)-1)\n maxval = max(maxval,(e-prev)-1 )\n prev = e\n if len(lst) == 1:\n maxval = max( lst[-1]-1, len(s)-lst[-1] )\n else:\n maxval = max( maxval, len(s)-lst[-1] )\n maxval = max( maxval, lst[0]-1 )\n\n \n return len(s) if not lst else maxval \n ","runtime":"78"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n l, r, output = 0,0,0\n for right_ptr, cur in enumerate(s):\n if(cur == \"(\"):\n l += 1\n else:\n if(l > r):\n r += 1\n else:\n l = 0\n r = 0\n if(l == r):\n output = max(r*2, output)\n \n l, r = 0,0\n for right_pt, cur in enumerate(reversed(s)):\n print(l, r)\n if(cur == \")\"):\n r += 1\n else:\n if(r > l):\n l += 1\n else:\n l = 0\n r = 0\n if(l == r):\n output = max(l * 2, output)\n return output","runtime":"79"}],"string":"[\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n max_len = 0\\n \\n for i, char in enumerate(s):\\n if char == '(':\\n stack.append(i)\\n else:\\n stack.pop()\\n if not stack:\\n stack.append(i)\\n else:\\n max_len = max(max_len, i - stack[-1])\\n \\n return max_len\\n\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n # given a string containing ( and )\\n # return length of the longest valid parentheses\\n # valid substring problem\\n # longest = keep searching -> dfs?\\n # valid means maintaining conditions -> dfs\\n # sliding window + dfs?\\n # contratins 10^4\\n\\n \\n # states = substring with valid parenthesis\\n\\n # if we had a closing one without a open one the state is invalid\\n # if we had more open substrings we can keep building\\n \\n # create open parent stack\\n # l, r = 0,0\\n # loop through string s by r\\n # if stack and current parent is closing:\\n # decrement closing paren\\n # if not stack:\\n # res = max(res, len(substring))\\n # if not stack and current parent is closing:\\n # shift l to right + 1\\n # if opening paren:\\n # add stack\\n\\n stack = []\\n stack.append(-1)\\n res = 0\\n for i in range(len(s)):\\n # print(\\\"b\\\", stack)\\n if s[i] == \\\"(\\\":\\n # index of starting paren\\n stack.append(i)\\n else:\\n # remove matching parenthesis\\n stack.pop()\\n # no more starting paren\\n if not stack:\\n # shift to new substring start\\n stack.append(i)\\n # valid parenthesis is i - open parenthesis index in stack\\n else:\\n res = max(res, i - stack[-1])\\n # print(\\\"a\\\", stack)\\n return res\\n\\n # store position of last open parenthesis in stack using index\\n # burned valid parenthesis in stack by popping from the top\\n\\n\\n return res\\n \\n\\n \",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n = len(s)\\n stack = []\\n for i, c in enumerate(s):\\n if c == \\\"(\\\":\\n stack.append(i)\\n elif c == \\\")\\\":\\n if stack and s[stack[-1]] == \\\"(\\\":\\n stack.pop()\\n else:\\n stack.append(i)\\n stack = [-1] + stack + [n]\\n return max(b - a - 1 for a, b in zip(stack, stack[1:]))\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n s2 = ')' + s\\n # dp[i] := the length of the longest valid parentheses in the substring\\n # s2[1..i]\\n dp = [0] * len(s2)\\n\\n for i in range(1, len(s2)):\\n if s2[i] == ')' and s2[i - dp[i - 1] - 1] == '(':\\n dp[i] = dp[i - 1] + dp[i - dp[i - 1] - 2] + 2\\n\\n return max(dp)\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n max_len = 0\\n stack = [-1]\\n for i, x in enumerate(s):\\n if x == \\\"(\\\":\\n stack.append(i)\\n else:\\n stack.pop()\\n if stack:\\n max_len = max( max_len, i - stack[-1])\\n else:\\n stack.append(i)\\n return max_len\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1] # Initialize with -1 to handle edge cases\\n max_length = 0\\n\\n for i in range(len(s)):\\n if s[i] == '(':\\n stack.append(i)\\n else: # s[i] == ')'\\n stack.pop()\\n if not stack:\\n stack.append(i)\\n else:\\n max_length = max(max_length, i - stack[-1])\\n\\n return max_length\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n # i'm going to use a stack, whenever we close a paraenthesis if its valid we increment\\n # we set best to max(best, current count)\\n # if we close and there's nothing to close... then we reset the count\\n best = 0\\n count = 0\\n stack: List[int] = []\\n for el in s:\\n if el == \\\"(\\\":\\n stack.append(count)\\n count = 0\\n elif el == \\\")\\\":\\n if stack:\\n count += 2 + stack.pop()\\n best = max(best, count)\\n else:\\n count = 0\\n else:\\n raise RuntimeError(\\\"Oops...\\\")\\n\\n return best\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n max_len = 0\\n\\n for i, each_s in enumerate(s):\\n if each_s == '(':\\n stack.append(i)\\n else:\\n top_ele = stack.pop()\\n if len(stack) == 0:\\n stack.append(i)\\n else:\\n max_len = max(max_len, (i - stack[-1]))\\n \\n return max_len\\n\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n \\n maxi = 0\\n stack = [-1]\\n \\n for i in range(len(s)) :\\n if s[i] == \\\"(\\\" : stack.append(i)\\n else :\\n stack.pop()\\n if len(stack) == 0 : stack.append(i)\\n else : maxi = max(maxi, i - stack[-1])\\n \\n return maxi\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n max_length = 0\\n stack = [-1] # Initialize stack with -1 to handle base cases\\n \\n for i, char in enumerate(s):\\n if char == '(':\\n stack.append(i) # Push the index onto the stack\\n else:\\n stack.pop() # Pop the last '(' index\\n if not stack:\\n # If stack is empty, push current index as a base for the next valid substring\\n stack.append(i)\\n else:\\n # Calculate the length of the current valid substring\\n max_length = max(max_length, i - stack[-1])\\n \\n return max_length\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n # Initialize a stack with -1\\n stack = [-1]\\n # Handles empty string edge case\\n\\n # Initialize the max length to 0\\n max_length = 0\\n\\n # The goal here is to keep track of the index of the last opening parantheses\\n # This way, we can calculate the length of the substring\\n\\n # Iterate through the string\\n for i in range(len(s)):\\n\\n # If the character is an opening parantheses, push the index to the stack\\n if s[i] == '(':\\n stack.append(i)\\n\\n # If the character is a closing parantheses\\n else:\\n\\n # Pop the top element from the stack\\n stack.pop()\\n\\n # If the stack is empty, push the index to the stack\\n if len(stack) == 0:\\n stack.append(i)\\n\\n # Update the max length\\n else:\\n max_length = max(max_length, i - stack[-1])\\n\\n return max_length \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n max_len = 0\\n\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\":\\n stack.append(i)\\n else:\\n stack.pop()\\n if len(stack) == 0:\\n stack.append(i)\\n else:\\n max_len = max(max_len, i - stack[-1])\\n \\n return max_len\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n res = 0\\n st = [-1]\\n for i,c in enumerate(s):\\n if c == '(':\\n st.append(i)\\n else:\\n st.pop()\\n if not st:\\n st.append(i)\\n else:\\n res = max(res, i-st[-1])\\n return res\\n \\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n l = r = 0\\n ans = 0\\n N = len(s)\\n for c in s:\\n if c == '(':\\n l += 1\\n else:\\n r += 1\\n if r > l:\\n l = r = 0\\n elif r == l:\\n ans = max(ans, r+l)\\n r = l = 0\\n for c in s[::-1]:\\n if c == ')':\\n r += 1\\n else:\\n l += 1\\n if l > r:\\n l = r = 0\\n elif r == l:\\n ans = max(ans, r+l)\\n return ans\\n \\n\\n \\n\\n\\n\\n \\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n max_len = 0\\n\\n for i, c in enumerate(s):\\n if c == '(':\\n stack.append(i)\\n else:\\n stack.pop()\\n if not stack:\\n stack.append(i)\\n else:\\n max_len = max(max_len, i - stack[-1])\\n return max_len\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n max_len = 0\\n\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\":\\n stack.append(i)\\n else:\\n stack.pop()\\n if len(stack) == 0:\\n stack.append(i)\\n else:\\n max_len = max(max_len, i - stack[-1])\\n \\n return max_len\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = []\\n l = ['0'] * len(s)\\n\\n for ind, i in enumerate(s):\\n if i == '(':\\n stack.append(ind)\\n else:\\n if stack:\\n l[stack.pop()] = '1'\\n l[ind] = '1'\\n\\n return max(len(i) for i in ''.join(l).split('0'))\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n answer = 0\\n for i in range(len(s)):\\n if s[i] == '(':\\n stack.append(i)\\n else:\\n stack.pop()\\n # Could not find a '(' to match\\n # This index becomes the new start of any valid string from behinde\\n if len(stack) == 0:\\n stack.append(i)\\n else:\\n # ex: (()\\n # The popped element would be 1, we know 2 matches with 1 which is valid\\n # 0 is the topped element in the stack and it's not matched, so 2-0 would be the length\\n answer = max(answer, i - stack[-1])\\n\\n return answer\\n\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stk = [-1]\\n ans = 0\\n\\n for i in range(len(s)):\\n if s[i] == ')' and stk[-1] != -1 and s[stk[-1]] == '(':\\n stk.pop()\\n ans = max(ans, i - stk[-1])\\n else:\\n stk.append(i)\\n \\n return ans\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n st = [-1]\\n res = 0\\n for i in range(len(s)):\\n if s[i]=='(':\\n st.append(i)\\n else:\\n st.pop()\\n if len(st)==0:\\n st.append(i)\\n else:\\n res = max(res, i-st[-1])\\n # print(st)\\n return res\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n # base case to handle the case when we find a valid substring starting from the first character\\n stack = [-1]\\n longest = 0\\n \\n for i, char in enumerate(s):\\n if char == '(':\\n stack.append(i)\\n else:\\n stack.pop()\\n # If stack is empty, push the current index\\n if not stack:\\n stack.append(i) \\n else:\\n # all the valid pair from stack[-1] to i has been poped\\n longest = max(longest, i - stack[-1])\\n \\n return longest\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n st = [-1]\\n res = 0\\n for i, v in enumerate(s):\\n if v == '(':\\n st.append(i)\\n else:\\n st.pop()\\n if not st:\\n st.append(i)\\n else:\\n res = max(res, i-st[-1])\\n return res\\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int: # O(n) time and space\\n res, stack = 0, [-1]\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\": stack.append(i)\\n else: # )\\n stack.pop()\\n if not stack: stack.append(i)\\n else: res = max(res, i - stack[-1]) \\n return res\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"\\ndef check(str):\\n left=0\\n right=0\\n ans=0\\n for i in str:\\n if(i=='('):\\n left+=1\\n else:\\n right+=1\\n if(right>left):\\n left=right=0\\n elif(right==left):\\n ans=max(ans,left*2)\\n left=right=0\\n for i in range(len(str)-1,-1,-1):\\n if(str[i]=='('):\\n left+=1\\n else:\\n right+=1\\n if(left>right):\\n left=right=0\\n elif(left==right):\\n ans=max(ans,left*2)\\n return ans\\nclass Solution:\\n def longestValidParentheses(self, str):\\n # code here\\n return check(str)\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n max_len = 0\\n\\n for i in range(len(s)):\\n if s[i] == '(':\\n stack.append(i)\\n else:\\n stack.pop()\\n if len(stack) == 0:\\n stack.append(i)\\n else:\\n max_len = max(max_len, i - stack[-1])\\n\\n return max_len\\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n \\n openCount, closeCount = 0, 0\\n res = 0\\n for c in s:\\n if c == \\\"(\\\":\\n openCount += 1\\n else:\\n closeCount += 1\\n if openCount == closeCount:\\n res = max(res, openCount + closeCount)\\n if closeCount > openCount:\\n openCount, closeCount = 0, 0\\n openCount, closeCount = 0, 0\\n for c in s[::-1]:\\n if c == \\\"(\\\":\\n openCount += 1\\n else:\\n closeCount += 1\\n if closeCount == openCount:\\n res = max(res, openCount + closeCount)\\n if closeCount < openCount:\\n openCount, closeCount = 0, 0\\n \\n return res\\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n l_count = 0\\n r_count = 0\\n max_len = 0\\n\\n i = 0\\n # l -> r\\n while i < len(s):\\n if s[i] == \\\"(\\\":\\n l_count += 1\\n else:\\n r_count += 1\\n\\n if l_count == r_count:\\n max_len = max(max_len, l_count + r_count)\\n elif r_count > l_count:\\n l_count = 0\\n r_count = 0\\n i += 1\\n \\n i = len(s) - 1\\n l_count = 0\\n r_count = 0\\n\\n # r->l\\n while i >= 0:\\n if s[i] == \\\"(\\\":\\n l_count += 1\\n else: \\n r_count += 1\\n \\n if l_count == r_count:\\n max_len = max(max_len, l_count + r_count)\\n elif l_count > r_count:\\n l_count = 0\\n r_count = 0\\n i -= 1\\n \\n return max_len\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n m = 0\\n stack = [-1]\\n for i in range(len(s)):\\n if s[i]=='(':\\n stack.append(i)\\n else:\\n stack.pop()\\n if not stack:\\n stack.append(i)\\n else:\\n m = max(m,i-stack[-1])\\n return m\\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n left, right, maxlength = 0, 0, 0\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\":\\n left += 1\\n else:\\n right += 1\\n if left == right:\\n maxlength = max(maxlength, 2 * right)\\n elif right > left:\\n left = right = 0\\n left = right = 0\\n for i in range(len(s) - 1, -1, -1):\\n if s[i] == \\\"(\\\":\\n left += 1\\n else:\\n right += 1\\n if left == right:\\n maxlength = max(maxlength, 2 * left)\\n elif left > right:\\n left = right = 0\\n return maxlength\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n = len(s)\\n if n < 2:\\n return 0\\n dp = [0] * n\\n for i in range(1, n):\\n if s[i] == ')':\\n if s[i - 1] == '(':\\n dp[i] = 2 + (dp[i - 2] if i > 1 else 0)\\n else:\\n j = i - dp[i - 1] - 1\\n if j >= 0 and s[j] == '(':\\n dp[i] = 2 + dp[i - 1] + dp[j - 1]\\n return max(dp)\\n\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n = len(s)\\n f = [0] * (n + 1)\\n for i, c in enumerate(s, 1):\\n if c == \\\")\\\":\\n if i > 1 and s[i - 2] == \\\"(\\\":\\n f[i] = f[i - 2] + 2\\n else:\\n j = i - f[i - 1] - 1\\n if j and s[j - 1] == \\\"(\\\":\\n f[i] = f[i - 1] + 2 + f[j - 1]\\n return max(f)\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n st = []\\n ans = 0\\n curr = 0\\n for i in range(0,len(s)):\\n if s[i]=='(':\\n st.append(i)\\n elif s[i]==')':\\n if len(st)>0 and s[st[-1]] == '(':\\n st.pop()\\n else:\\n st.append(i)\\n end = len(s)\\n for i in range(len(st)-1,-1,-1):\\n ans = max(ans,end - st[i] -1)\\n end = st[i]\\n return max(ans,end)\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n left = right = 0\\n ans = 0\\n\\n # scan from left to right\\n for c in s:\\n if c == '(':\\n left += 1\\n else:\\n right += 1\\n\\n if left == right:\\n ans = max(ans, 2 * right)\\n elif right > left:\\n left = right = 0\\n\\n left = right = 0\\n # scan from right to left\\n for c in reversed(s):\\n if c == '(':\\n left += 1\\n else:\\n right += 1\\n\\n if left == right:\\n ans = max(ans, 2 * left)\\n elif left > right:\\n left = right = 0\\n\\n return ans\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n\\n leading_brac = 0\\n open_brac_indices = []\\n mask = [0] * len(s)\\n for index, brac in enumerate(s):\\n if brac == '(':\\n leading_brac += 1\\n open_brac_indices.append(index)\\n elif brac == ')':\\n if leading_brac == 0:\\n pass\\n elif leading_brac > 0:\\n leading_brac -= 1\\n open_brac_index = open_brac_indices.pop()\\n mask[open_brac_index] = 1\\n mask[index] = 1\\n\\n\\n\\n if ')' not in s:\\n return 0\\n\\n count = 0\\n all_lengths = []\\n\\n for i in mask:\\n if i==1:\\n count += 1\\n else:\\n all_lengths.append(count)\\n count = 0\\n all_lengths.append(count)\\n\\n return max(all_lengths)\\n\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack=[-1]\\n max_len=0\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\":\\n stack.append(i)\\n else:\\n stack.pop()\\n if len(stack) ==0:\\n stack.append(i)\\n else:\\n max_len=max(max_len,i-stack[-1])\\n return max_len\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n s2 = ')' + s\\n # dp[i] := the length of the longest valid parentheses in the substring\\n # s2[1..i]\\n dp = [0] * len(s2)\\n\\n for i in range(1, len(s2)):\\n if s2[i] == ')' and s2[i - dp[i - 1] - 1] == '(':\\n dp[i] = dp[i - 1] + dp[i - dp[i - 1] - 2] + 2\\n\\n return max(dp)\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n max_len = 0\\n\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\":\\n stack.append(i)\\n else:\\n stack.pop()\\n if len(stack) == 0:\\n stack.append(i)\\n else:\\n max_len = max(max_len, i - stack[-1])\\n \\n return max_len\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n max_length = 0\\n stck=[-1]\\n print(stck)\\n for i in range(len(s)):\\n if s[i] == '(':\\n stck.append(i)\\n else:\\n stck.pop()\\n if not stck:\\n stck.append(i)\\n else:\\n max_length=max(max_length, i-stck[-1])\\n return max_length\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n=len(s)\\n stack=[-1]\\n maxi=0\\n\\n for i in range(len(s)):\\n ch=s[i]\\n if ch==\\\"(\\\":\\n stack.append(i)\\n else:\\n stack.pop()\\n if len(stack)==0:\\n stack.append(i)\\n else:\\n maxi=max(maxi,i-stack[-1])\\n \\n return maxi\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = []\\n dp = [-1] * len(s)\\n res = 0\\n for i in range(len(s)):\\n if s[i] == \\\")\\\":\\n if stack:\\n ind = stack.pop()\\n dp[ind] = i\\n else:\\n stack.append(i)\\n \\n i = 0\\n res = 0\\n count = 0\\n while i < len(dp):\\n if dp[i] == -1:\\n res = max(res, count)\\n count = 0\\n i += 1\\n else:\\n count += dp[i] - i + 1\\n i = dp[i] + 1\\n return max(res, count)\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n = len(s)\\n f = [0] * (n + 1)\\n for i, c in enumerate(s, 1):\\n if c == \\\")\\\":\\n if i > 1 and s[i - 2] == \\\"(\\\":\\n f[i] = f[i - 2] + 2\\n else:\\n j = i - f[i - 1] - 1\\n if j and s[j - 1] == \\\"(\\\":\\n f[i] = f[i - 1] + 2 + f[j - 1]\\n return max(f)\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n v = [0] * (len(s) + 1)\\n m = 0\\n for i in range(len(s)-2, -1, -1):\\n d = v[i+1]\\n if s[i] == '(' and (i + d + 1) < len(s) and s[i+d+ 1] == ')':\\n v[i] = 2 + d + v[i + d + 2]\\n m = max(v[i], m)\\n return m\\n\\n\\n\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n L=len(s)\\n if L<2: return 0\\n max1=0\\n l=0\\n r=0\\n i=0\\n while i<L:\\n if s[i]=='(': l+=1\\n if s[i]==')': r+=1\\n if l==r:\\n if max1<l+r:\\n max1=l+r\\n if r>l:\\n l=0\\n r=0\\n i+=1\\n l=0\\n r=0\\n i=L-1\\n while i>=0:\\n if s[i]=='(': l+=1\\n if s[i]==')': r+=1\\n if l==r:\\n if max1<l+r:\\n max1=l+r\\n if r<l:\\n l=0\\n r=0\\n i-=1\\n return max1\\n\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n # (num of open, num of closed successfully)\\n def longestValidParentheses(self, s: str) -> int:\\n stack = []\\n for c in s:\\n if c == '(':\\n if not stack:\\n stack.append((1, 0))\\n else:\\n num_open = 0\\n if stack[-1][1] == 0:\\n num_open = stack.pop()[0]\\n stack.append((num_open + 1, 0))\\n elif stack:\\n if stack[-1][0] <= 0:\\n stack.append((-1,-1))\\n else:\\n tmp = stack.pop()\\n stack.append((tmp[0] - 1, tmp[1] + 1))\\n num_close = 0\\n while stack and stack[-1][0] == 0:\\n num_close += stack.pop()[1]\\n tmp = stack.pop() if stack and stack[-1][0]!=-1 else (0, 0)\\n stack.append((tmp[0], tmp[1]+num_close))\\n return (max(stack, key=lambda pair: pair[1])[1])*2 if stack else 0\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n if len(s) == 0:\\n return 0\\n\\n left = 0\\n right = 0\\n # True means it can connect with next \\n lens = []\\n curr_len = 0 \\n for i, ch in enumerate(s):\\n if ch == \\\"(\\\":\\n left += 1\\n else:\\n right += 1\\n # check if there is anything to pop and check if it can connect to prev\\n \\n if left > 0 or (len(lens) > 0 and lens[-1][1] > 0):\\n \\n left -= 1\\n right -= 1\\n if len(lens) > 0:\\n prev, prev_left, prev_right = lens.pop()\\n if prev_left > 0 and prev_right == 0 and left == -1: # merge to prev chunk\\n lens.append((prev + 2, prev_left - 1, prev_right))\\n left = 0\\n else: #unable to merge to previous chunk \\n lens.append((prev, prev_left, prev_right))\\n lens.append((2, left, right))\\n left = 0\\n\\n else: \\n lens.append((2, left, right))\\n left = 0\\n\\n while len(lens) > 1:\\n curr, curr_left, curr_right = lens.pop()\\n prev, prev_left, prev_right = lens.pop()\\n if curr_left == 0 and prev_right == 0:\\n lens.append((curr + prev, prev_left, curr_right))\\n else: # unable to merge \\n lens.append((prev, prev_left, prev_right))\\n lens.append((curr, curr_left, curr_right))\\n break\\n else: # nothing to pop on left for now, seq ends with more right.\\n if len(lens) > 0:\\n prev, prev_left, prev_right = lens.pop()\\n lens.append((prev, prev_left, prev_right+1))\\n right = 0\\n\\n if len(lens) == 0:\\n return 0\\n return max([num for num, left, right in lens])\\n\\n\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n max_len = 0\\n\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\":\\n stack.append(i)\\n else:\\n stack.pop()\\n if len(stack) == 0:\\n stack.append(i)\\n else:\\n max_len = max(max_len, i - stack[-1])\\n \\n return max_len\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n if len(s) == 0:\\n return 0\\n left = 0\\n right = 0\\n maximum = 0\\n for i in range(0,len(s)):\\n if s[i] == '(':\\n left += 1\\n else:\\n right += 1\\n if left == right:\\n maximum = max(maximum,left*2)\\n elif right > left:\\n left = 0\\n right = 0\\n left = 0\\n right = 0\\n for i in range(len(s)-1,-1,-1):\\n if s[i] == '(':\\n left += 1\\n else:\\n right += 1\\n if left == right:\\n maximum = max(maximum,left*2)\\n elif left > right:\\n left = 0\\n right = 0\\n return maximum\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n # dp[i]: end in s[i], how faraway to the left makes the substring valid\\n dp = [0]*(len(s))\\n res = 0\\n for i in range(1, len(s)):\\n if s[i] == \\\")\\\":\\n pre = i - dp[i - 1] - 1\\n if pre >= 0 and s[pre] == \\\"(\\\":\\n dp[i] = dp[i - 1] + 2 + (dp[pre - 1] if pre > 0 else 0)\\n res = max(res, dp[i])\\n return res\\n\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n maxans = 0\\n dp = [0] * len(s)\\n for i in range(1, len(s)):\\n if s[i] == \\\")\\\":\\n if s[i - 1] == \\\"(\\\":\\n dp[i] = (dp[i - 2] if i >= 2 else 0) + 2\\n elif i - dp[i - 1] > 0 and s[i - dp[i - 1] - 1] == \\\"(\\\":\\n dp[i] = (\\n dp[i - 1]\\n + (dp[i - dp[i - 1] - 2] if i - dp[i - 1] >= 2 else 0)\\n + 2\\n )\\n maxans = max(maxans, dp[i])\\n return maxans\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n # (num of open, num of closed successfully)\\n def longestValidParentheses(self, s: str) -> int:\\n stack = []\\n for c in s:\\n if c == '(':\\n num_open = 0\\n if stack and stack[-1][1] == 0:\\n num_open = stack.pop()[0]\\n stack.append((num_open + 1, 0))\\n elif stack and stack[-1][0] <= 0:\\n stack.append((-1,-1))\\n elif stack:\\n # close current\\n tmp = stack.pop()\\n stack.append((tmp[0] - 1, tmp[1] + 1))\\n\\n # sum of all consecutive close\\n num_close = 0\\n while stack and stack[-1][0] == 0:\\n num_close += stack.pop()[1]\\n tmp = stack.pop() if stack and stack[-1][0] != -1 else (0, 0)\\n stack.append((tmp[0], tmp[1]+num_close))\\n return (max(stack, key=lambda pair: pair[1])[1])*2 if stack else 0\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n # Time: O(n)\\n # Space: O(n)\\n\\n stack = [-1]\\n res = 0\\n for i, ch in enumerate(s):\\n if ch == '(':\\n stack.append(i)\\n else:\\n stack.pop()\\n if not stack:\\n stack.append(i)\\n else:\\n res = max(res, i-stack[-1])\\n return res\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n\\n if s.find('()')==-1 :\\n return 0\\n\\n print('s0='+s)\\n\\n brackets = [-1]\\n max_ = 0\\n\\n for i, el in enumerate(s):\\n print('i0='+str(i))\\n if el == '(':\\n brackets.append(i)\\n else:\\n brackets.pop()\\n if not brackets:\\n brackets.append(i)\\n else:\\n #print('i1='+str(i))\\n #print('brackets[-1]='+str(brackets[-1]))\\n max_ = max(max_, i - brackets[-1])\\n\\n\\n return max_\\n\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = []\\n dp = [-1] * len(s)\\n res = 0\\n for i in range(len(s)):\\n if s[i] == \\\")\\\":\\n if stack:\\n ind = stack.pop()\\n dp[ind] = i\\n else:\\n stack.append(i)\\n \\n i = 0\\n res = 0\\n count = 0\\n while i < len(dp):\\n if dp[i] == -1:\\n res = max(res, count)\\n count = 0\\n i += 1\\n else:\\n count += dp[i] - i + 1\\n i = dp[i] + 1\\n return max(res, count)\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n # the idea is similar to find the longest sub array of sum to 0 with sliding window\\n # We keep the balance score and mono stack of the non zero balance\\n # when balance is negative, reset\\n def longestValidParentheses(self, s: str) -> int:\\n score = 0\\n stack = [[-1, 0]]\\n res = 0\\n for i, c in enumerate(s):\\n if c == '(':\\n score += 1\\n else:\\n score -= 1\\n if score < 0:\\n # invalid state, will start from here\\n score = 0\\n stack.clear()\\n stack.append([i, 0])\\n else: \\n while stack and stack[-1][1] > score:\\n stack.pop()\\n \\n # now the last position in stack has the same score\\n # in between it is valid\\n if score == stack[-1][1]:\\n res = max(res, i - stack[-1][0])\\n else:\\n stack.append([i, score])\\n # print(stack)\\n return res\\n\\n def longestValidParentheses_(self, s: str) -> int:\\n # the idea is to match the sting and keep the state\\n # The trick here is that we keep the immediate right valid length at '(' in the stack\\n # And clear the stack when the state is invalid\\n # ((())()((\\n # e.g. above we keep the valid length to previous '('\\n # add a dummy node to store the score\\n stack = []\\n stack.append(['#', 0])\\n res = 0\\n\\n for c in s:\\n if c == '(':\\n stack.append(['(', 0])\\n else:\\n if stack[-1][0] == '(':\\n p, l = stack.pop()\\n # score of the complete range\\n l += 2\\n stack[-1][1] += l\\n res = max(res, stack[-1][1])\\n else:\\n # start of new exploration\\n del stack[1:]\\n # res = max(res, stack[0][1])\\n # clear the count\\n stack[0][1] = 0\\n # print(stack)\\n return res\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n = len(s)\\n cache = dict()\\n i = 0\\n while i < n-1:\\n if s[i] == '(' and s[i+1] == ')':\\n cache[i] = i+1\\n i += 2\\n else:\\n i += 1\\n max_len = 2 if cache else 0\\n\\n \\n has_changed = True\\n while has_changed:\\n # print(cache)\\n has_changed = False\\n for i in list(cache.keys()):\\n j = cache.get(i)\\n # print(f'i={i} j={j}')\\n if j is None:\\n continue\\n\\n # case XY\\n nj = cache.get(j+1)\\n if nj:\\n del cache[j+1]\\n max_len = max(max_len, nj-i + 1)\\n cache[i] = nj\\n has_changed = True\\n # print(f'case XY add i={i} j={nj}; delete {j+1}')\\n # print(cache)\\n else:\\n # case (X)\\n if 0 < i and j < n-1:\\n if s[i-1] == '(' and s[j+1] == ')':\\n del cache[i]\\n max_len = max(max_len, j-i + 3)\\n cache[i-1] = j+1\\n has_changed = True\\n # print(f'case (X) add i={i-1} j={j+1}; delete {i}')\\n\\n return max_len\\n \\n\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n self.memo=[-1]*len(s)\\n res = 0\\n for p in range(len(s)):\\n res = max(res, self.dp(s,p))\\n return res\\n \\n def dp(self, s, p):\\n if p<=0:\\n return 0\\n if self.memo[p]!=-1:\\n return self.memo[p]\\n if s[p]==\\\"(\\\":\\n res=0\\n elif s[p]==\\\")\\\":\\n if s[p-1]==\\\"(\\\":\\n res = self.dp(s,p-2)+2\\n elif s[p-1]==\\\")\\\":\\n if p-self.dp(s,p-1)-1>=0 and s[p-self.dp(s,p-1)-1]==\\\"(\\\":\\n res=self.dp(s,p-self.dp(s,p-1)-2)+self.dp(s,p-1)+2\\n else:\\n res=0\\n self.memo[p]=res\\n return res\\n\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n self.memo=[-1]*len(s)\\n res = 0\\n for p in range(len(s)):\\n res = max(res, self.dp(s,p))\\n return res\\n \\n def dp(self, s, p):\\n if p<=0:\\n return 0\\n if self.memo[p]!=-1:\\n return self.memo[p]\\n res = 0\\n if s[p]==\\\")\\\":\\n if s[p-1]==\\\"(\\\":\\n res = self.dp(s,p-2)+2\\n elif s[p-1]==\\\")\\\":\\n if p-self.dp(s,p-1)-1>=0 and s[p-self.dp(s,p-1)-1]==\\\"(\\\":\\n res=self.dp(s,p-self.dp(s,p-1)-2)+self.dp(s,p-1)+2\\n self.memo[p]=res\\n return res\\n\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\n\\nclass Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n latest_current_state = defaultdict(lambda: -1)\\n current_level = 0\\n max_length = 0\\n for idx, c in enumerate(s):\\n if c == '(':\\n current_level += 1\\n latest_current_state[current_level] = idx\\n else:\\n current_level -= 1\\n if current_level >= 0:\\n max_length = max(max_length,idx - latest_current_state[current_level])\\n else:\\n current_level = 0\\n latest_current_state[current_level] = idx\\n print(current_level)\\n return max_length\\n \\n \",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n self.memo=[-1]*len(s)\\n res = 0\\n for p in range(len(s)):\\n res = max(res, self.dp(s,p))\\n return res\\n \\n def dp(self, s, p):\\n if p<=0:\\n return 0\\n if self.memo[p]!=-1:\\n return self.memo[p]\\n res = 0\\n if s[p]==\\\")\\\":\\n if s[p-1]==\\\"(\\\":\\n res = self.dp(s,p-2)+2\\n elif s[p-1]==\\\")\\\":\\n if p-self.dp(s,p-1)-1>=0 and s[p-self.dp(s,p-1)-1]==\\\"(\\\":\\n res=self.dp(s,p-self.dp(s,p-1)-2)+self.dp(s,p-1)+2\\n self.memo[p]=res\\n return res\\n\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n cores = []\\n\\n i = 0\\n while i < (len(s)-1):\\n if s[i]=='(' and s[i+1]==')':\\n cores.append([i,i+1])\\n i+=2\\n else:\\n i+=1\\n\\n if len(cores) == 0:\\n return 0\\n\\n i = 0\\n while i < len(cores):\\n while True:\\n left, right = cores[i][0]-1, cores[i][1]+1\\n if left >= 0 and right < len(s) and s[left] == \\\"(\\\" and s[right] == \\\")\\\":\\n cores[i][0]-=1\\n cores[i][1]+=1\\n else:\\n break\\n\\n yes = False\\n while i >= 0:\\n if (i+1)<len(cores) and cores[i][1] == cores[i+1][0]:\\n cores[i][1] = cores[i+1][1]\\n del cores[i+1] \\n\\n if i > 0 and (cores[i-1][1]+1) == cores[i][0]:\\n cores[i][0] = cores[i-1][0]\\n del cores[i-1]\\n i -= 1\\n yes = True\\n else:\\n break\\n\\n if not yes:\\n i+=1\\n \\n return max([m[1]-m[0]+1 for m in cores])\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack=[]\\n list1=list(s)\\n for i in range(len(s)):\\n if(len(stack)==0):stack.append([s[i],i])\\n elif(stack[-1][0]==\\\"(\\\" and s[i]==\\\")\\\"):\\n list1[stack[-1][1]]=True\\n list1[i]=True\\n stack.pop()\\n else:stack.append([s[i],i])\\n ctr,max1=0,0\\n for i in list1:\\n if i==True:\\n ctr+=1\\n max1=max(max1,ctr)\\n else:ctr=0\\n return max1\\n\\n \",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n prev_left = []\\n curr_len, max_len = 0, 0\\n for c in s:\\n if c == '(':\\n prev_left.append(curr_len)\\n curr_len = 0\\n elif len(prev_left) == 0:\\n curr_len = 0\\n else:\\n curr_len += prev_left[-1] + 2\\n max_len = max(curr_len, max_len)\\n prev_left = prev_left[:-1]\\n return max_len\\n\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n res = []\\n left = right = 0\\n left_cnt = right_cnt = 0\\n cur_length = 0\\n stack = []\\n while left < len(s) and right < len(s):\\n c = s[right]\\n if c == '(':\\n stack.append(right)\\n left_cnt += 1\\n else:\\n if left_cnt:\\n res.append((stack.pop(), right))\\n left_cnt -= 1\\n else:\\n left = right + 1\\n left_cnt = right_cnt = 0\\n right += 1\\n if not res:\\n return 0\\n \\n res.sort()\\n print(res)\\n ans = [res[0]]\\n\\n for i in range(1, len(res)):\\n left, right = res[i][0], res[i][1]\\n prev_left, prev_right = ans[-1][0], ans[-1][1]\\n if left < prev_left and right > prev_right:\\n ans[-1] = (left, right)\\n elif left >= prev_left and right <= prev_right:\\n continue\\n else:\\n if prev_right + 1 == left:\\n ans[-1] = (prev_left, right)\\n else:\\n ans.append((left, right))\\n print(ans)\\n max_length = max([right - left + 1 for left, right in ans])\\n return max_length\\n \\n \\n \",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n = len(s)\\n cache = dict()\\n max_len = 0\\n for i in range(n-1):\\n if s[i] == '(' and s[i+1] == ')':\\n max_len = 2\\n cache[i] = i+1\\n \\n has_changed = True\\n while has_changed:\\n # print(cache)\\n has_changed = False\\n for i in list(cache.keys()):\\n j = cache.get(i)\\n # print(f'i={i} j={j}')\\n if j is None:\\n continue\\n\\n # case XY\\n nj = cache.get(j+1)\\n if nj:\\n del cache[j+1]\\n max_len = max(max_len, nj-i + 1)\\n cache[i] = nj\\n has_changed = True\\n # print(f'case XY add i={i} j={nj}; delete {j+1}')\\n # print(cache)\\n else:\\n # case (X)\\n if 0 < i and j < n-1:\\n if s[i-1] == '(' and s[j+1] == ')':\\n del cache[i]\\n max_len = max(max_len, j-i + 3)\\n cache[i-1] = j+1\\n has_changed = True\\n # print(f'case (X) add i={i-1} j={j+1}; delete {i}')\\n\\n return max_len\\n \\n\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n memo = {}\\n def dfs(i):\\n if i >= len(s):\\n return 0\\n if i in memo:\\n return memo[i]\\n memo[i] = 0\\n if s[i] == '(':\\n if i + 1 < len(s) and s[i + 1] == ')':\\n memo[i] = dfs(i + 2) + 2\\n elif i + dfs(i + 1) + 1 < len(s) and s[i + dfs(i + 1) + 1] == ')':\\n memo[i] = dfs(i + 1) + 2 + dfs(i + dfs(i + 1) + 2)\\n return memo[i]\\n\\n for i in range(len(s)):\\n dfs(i)\\n return max(memo.values()) if memo else 0\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n = len(s)\\n cache = dict()\\n i = 0\\n \\n while i < n-1:\\n if s[i] == '(' and s[i+1] == ')':\\n cache[i] = i+1\\n i += 2\\n else:\\n i += 1\\n max_len = 2 if cache else 0\\n\\n \\n has_changed = True\\n while has_changed:\\n # print(cache)\\n has_changed = False\\n for i in list(cache.keys()):\\n j = cache.get(i)\\n # print(f'i={i} j={j}')\\n if j is None:\\n continue\\n\\n # case XY\\n nj = cache.get(j+1)\\n if nj:\\n del cache[j+1]\\n # max_len = max(max_len, nj-i + 1)\\n cache[i] = nj\\n has_changed = True\\n # print(f'case XY add i={i} j={nj}; delete {j+1}')\\n # print(cache)\\n else:\\n # case (X)\\n if 0 < i and j < n-1:\\n if s[i-1] == '(' and s[j+1] == ')':\\n del cache[i]\\n # max_len = max(max_len, j-i + 3)\\n cache[i-1] = j+1\\n has_changed = True\\n # print(f'case (X) add i={i-1} j={j+1}; delete {i}')\\n\\n for i, j in cache.items():\\n max_len = max(max_len, j - i + 1)\\n return max_len\\n \\n\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n temp = [i for i in s]\\n for i in range(len(temp)): \\n if temp[i] == \\\"(\\\" : \\n continue \\n else : \\n for j in range(i-1,-1,-1): \\n if temp[j] == \\\"(\\\" :\\n temp[j] = 1 \\n temp[i] = 1 \\n break\\n temp_res = 0 \\n res = 0 \\n for i in range(len(temp)) : \\n if temp[i] == 1 :\\n temp_res +=1 \\n else : \\n if res < temp_res : \\n res = temp_res \\n temp_res = 0 \\n if res < temp_res : \\n res = temp_res\\n return res\\n \",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n longestLength = 0\\n l = 0\\n opened = 0\\n closed = 0\\n length = 0\\n for i in s:\\n print(opened, closed)\\n length += 1\\n if i == \\\"(\\\":\\n opened += 1\\n else:\\n closed += 1\\n if opened == closed:\\n longestLength = max(longestLength, length)\\n if closed > opened:\\n opened = 0\\n closed = 0\\n length = 0\\n opened = 0\\n closed = 0\\n length = 0\\n for i in s[::-1]:\\n length += 1\\n if i == \\\")\\\":\\n closed += 1\\n else:\\n opened += 1\\n if opened == closed:\\n longestLength = max(longestLength, length)\\n if opened > closed:\\n opened = 0\\n closed = 0\\n length = 0\\n return longestLength\\n \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = []\\n result = []\\n\\n for elem in s:\\n if len(stack) > 0 and stack[-1] == '(' and elem == ')':\\n stack.pop()\\n\\n i = len(result) - 1\\n\\n while i >= 0 and result[i] == 1:\\n i -= 1\\n\\n result[i] = 1\\n result.pop()\\n result.extend([1, 1])\\n else:\\n stack.append(elem)\\n result.append(0)\\n\\n current = 0\\n longest = 0\\n\\n for i in range(len(result)):\\n if result[i] == 1:\\n current += 1\\n else:\\n current = 0\\n\\n if current > longest and current > 0:\\n longest = current\\n\\n return longest\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n\\n # Memoization table to store intermediate results\\n memo = [-1] * len(s)\\n\\n def dp(i: int) -> int:\\n # Base case: if we're out of bounds, no valid parentheses\\n if i >= len(s):\\n return 0\\n \\n # If we've already solved this subproblem, return the result\\n if memo[i] != -1:\\n return memo[i]\\n \\n # Initialize current result to 0\\n res = 0\\n\\n # Case 1: '(' followed by a matching ')'\\n if i + 1 < len(s) and s[i] == '(' and s[i + 1] == ')':\\n res = 2 + dp(i + 2)\\n\\n # Case 2: '(' followed by a matching ')' at a further index\\n elif i + 1 < len(s) and s[i] == '(':\\n close_index = i + dp(i + 1) + 1\\n if close_index < len(s) and s[close_index] == ')':\\n res = 2 + dp(i + 1) + dp(close_index + 1)\\n \\n # Store the result in memo\\n memo[i] = res\\n return res\\n\\n # We need to check every index, as the longest valid parentheses can start anywhere\\n max_len = 0\\n for i in range(len(s)):\\n max_len = max(max_len, dp(i))\\n\\n return max_len\\n\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n \\n class Node:\\n def __init__(self):\\n self.parent = None\\n self.children = []\\n self.start = None\\n self.end = None\\n \\n def __repr__(self):\\n return f\\\"({self.start}, {self.end}, {self.parent})\\\"\\n\\n active_intervals = []\\n complete_intervals = []\\n for i, c in enumerate(s):\\n if c == '(':\\n node = Node()\\n node.start = i\\n if len(active_intervals) > 0:\\n node.parent = active_intervals[-1]\\n active_intervals[-1].children.append(node)\\n active_intervals.append(node)\\n elif len(active_intervals) > 0:\\n latest_node = active_intervals.pop()\\n latest_node.end = i\\n complete_intervals.append(latest_node)\\n top_level_intervals = [node for node in complete_intervals if node.parent is None or node.parent.end is None]\\n # print(active_intervals)\\n # print(complete_intervals)\\n # print(top_level_intervals)\\n\\n max_len = 0\\n if len(top_level_intervals) == 0:\\n return max_len\\n\\n first = top_level_intervals[0]\\n substr_start = first.start\\n substr_end = first.end\\n for node in top_level_intervals[1:]:\\n if substr_end + 1 == node.start:\\n substr_end = node.end\\n else:\\n substr_len = substr_end - substr_start + 1\\n if substr_len > max_len:\\n max_len = substr_len\\n\\n substr_start = node.start\\n substr_end = node.end\\n \\n substr_len = substr_end - substr_start + 1\\n if substr_len > max_len:\\n max_len = substr_len\\n\\n return max_len\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n list_s = list(s.strip())\\n i = 0\\n temp_count, res = 0,0\\n while i < len(list_s):\\n temp = list_s[i]\\n if temp == ')':\\n if list_s[i-1] == '(' and i != 0: \\n list_s[i-1:i+1]= '2'\\n i-=1\\n elif i > 0:\\n j = i\\n while j > 0 and list_s[j] != '|':\\n j-=1\\n if list_s[j] == '(':\\n list_s[i] = '2'\\n list_s.pop(j)\\n i-=1\\n break \\n else:\\n list_s[i]='|'\\n else:\\n list_s.pop(i)\\n else:\\n i+=1\\n\\n for s in list_s:\\n if s == '2':\\n temp_count +=2\\n res = max(res, temp_count)\\n else:\\n temp_count=0\\n return res\\n\\n \",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n import re\\n p = re.compile('\\\\(b*\\\\)') \\n s_prev = s\\n s = s.replace('()', 'b')\\n\\n while s_prev != s:\\n s_prev = s\\n searches = set(p.findall(s))\\n for search in searches:\\n s = s.replace(search, 'b'*(len(search) - 1))\\n \\n len_ = max_len = 0\\n for ch in s:\\n if ch == 'b':\\n len_ += 2\\n else:\\n max_len = max(max_len, len_)\\n len_ = 0\\n \\n max_len = max(max_len, len_)\\n return max_len\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n\\n if s.find('()')==-1 :\\n return 0\\n\\n print('s0='+s)\\n\\n brackets = [-1]\\n max_ = 0\\n\\n for i, el in enumerate(s):\\n print('i0='+str(i))\\n if el == '(':\\n brackets.append(i)\\n else:\\n brackets.pop()\\n if not brackets:\\n brackets.append(i)\\n else:\\n print('i1='+str(i))\\n print('brackets[-1]='+str(brackets[-1]))\\n max_ = max(max_, i - brackets[-1])\\n\\n\\n return max_\\n\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n hash = {}\\n prev = -1\\n\\n queue = []\\n finalarr = [-1 for _ in range(len(s))]\\n for i,c in enumerate(s):\\n if c==\\\"(\\\":\\n queue.insert(0,i)\\n else:\\n if len(queue) > 0:\\n idx=queue.pop(0)\\n finalarr[idx] = 1\\n finalarr[i] = 1\\n else:\\n finalarr[i] = -1\\n \\n curr = 0\\n ans = 0\\n for i in finalarr:\\n if i==-1:\\n curr = 0\\n else:\\n curr+=1\\n \\n if curr > ans:\\n ans = curr\\n return ans\\n\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"from collections import deque \\n\\nclass Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n \\n \\n st = deque()\\n lst = []\\n \\n for i,e in enumerate(s):\\n #print(\\\"st\\\", st)\\n if not st:\\n st.append( (i+1,e) )\\n else:\\n indx, val = st[-1]\\n if val == '(' and e == ')':\\n st.pop()\\n else:\\n st.append( (i+1,e) )\\n idnx = 0\\n print(\\\"St\\\", st)\\n maxval = 0\\n lst = []\\n while st:\\n i,e = st.popleft()\\n lst.append(i)\\n print(\\\"lst\\\", lst)\\n \\n if lst:\\n prev = lst[0]\\n for e in lst[1:]:\\n print(\\\"e\\\", e, \\\"prev\\\",prev, \\\"(e-prev)-1\\\", (e-prev)-1)\\n maxval = max(maxval,(e-prev)-1 )\\n prev = e\\n if len(lst) == 1:\\n maxval = max( lst[-1]-1, len(s)-lst[-1] )\\n else:\\n maxval = max( maxval, len(s)-lst[-1] )\\n maxval = max( maxval, lst[0]-1 )\\n\\n \\n return len(s) if not lst else maxval \\n \",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n l, r, output = 0,0,0\\n for right_ptr, cur in enumerate(s):\\n if(cur == \\\"(\\\"):\\n l += 1\\n else:\\n if(l > r):\\n r += 1\\n else:\\n l = 0\\n r = 0\\n if(l == r):\\n output = max(r*2, output)\\n \\n l, r = 0,0\\n for right_pt, cur in enumerate(reversed(s)):\\n print(l, r)\\n if(cur == \\\")\\\"):\\n r += 1\\n else:\\n if(r > l):\\n l += 1\\n else:\\n l = 0\\n r = 0\\n if(l == r):\\n output = max(l * 2, output)\\n return output\",\n \"runtime\": \"79\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":77,"string":"77"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n\n \n left = right = best = 0\n for i in range(len(s)):\n if s[i] == \"(\":\n left += 1\n else:\n right += 1\n if right > left:\n left = right = 0\n elif left == right:\n best = max(best, right * 2)\n r1 = best\n s = s[::-1]\n left = right = best = 0\n for i in range(len(s)):\n if s[i] == \")\":\n left += 1\n else:\n right += 1\n if right > left:\n left = right = 0\n elif left == right:\n best = max(best, right * 2)\n r2 = best\n\n return max(r1, r2)","memory":"16300"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n \n openCount, closeCount = 0, 0\n res = 0\n for c in s:\n if c == \"(\":\n openCount += 1\n else:\n closeCount += 1\n if openCount == closeCount:\n res = max(res, openCount + closeCount)\n if closeCount > openCount:\n openCount, closeCount = 0, 0\n openCount, closeCount = 0, 0\n for c in s[::-1]:\n if c == \"(\":\n openCount += 1\n else:\n closeCount += 1\n if closeCount == openCount:\n res = max(res, openCount + closeCount)\n if closeCount < openCount:\n openCount, closeCount = 0, 0\n \n return res\n","memory":"16400"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n left = 0\n right = 0\n maxVal = 0\n for i in range(len(s)):\n if s[i] == '(':\n left += 1\n else:\n right += 1\n if left == right:\n maxVal = max(maxVal, left * 2)\n elif left < right:\n left = 0\n right = 0\n left = 0\n right = 0\n for i in range(len(s) - 1, -1, -1):\n if s[i] == '(':\n left += 1\n else:\n right += 1\n if left == right:\n maxVal = max(maxVal, left * 2)\n elif right < left:\n left = 0\n right = 0\n return maxVal","memory":"16400"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n l = r = 0\n ans = 0\n N = len(s)\n for c in s:\n if c == '(':\n l += 1\n else:\n r += 1\n if r > l:\n l = r = 0\n elif r == l:\n ans = max(ans, r+l)\n r = l = 0\n for c in s[::-1]:\n if c == ')':\n r += 1\n else:\n l += 1\n if l > r:\n l = r = 0\n elif r == l:\n ans = max(ans, r+l)\n return ans\n \n\n \n\n\n\n \n ","memory":"16500"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n n = len(s)\n f = [0] * (n + 1)\n for i, c in enumerate(s, 1):\n if c == \")\":\n if i > 1 and s[i - 2] == \"(\":\n f[i] = f[i - 2] + 2\n else:\n j = i - f[i - 1] - 1\n if j and s[j - 1] == \"(\":\n f[i] = f[i - 1] + 2 + f[j - 1]\n return max(f)","memory":"16500"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n\n \n left = right = best = 0\n for i in range(len(s)):\n if s[i] == \"(\":\n left += 1\n else:\n right += 1\n if right > left:\n left = right = 0\n elif left == right:\n best = max(best, right * 2)\n r1 = best\n\n left = right = best = 0\n for i in range(len(s)):\n if s[::-1][i] == \")\":\n left += 1\n else:\n right += 1\n if right > left:\n left = right = 0\n elif left == right:\n best = max(best, right * 2)\n r2 = best\n\n return max(r1, r2)","memory":"16600"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n n = len(s)\n if n < 2:\n return 0\n dp = [0] * n\n for i in range(1, n):\n if s[i] == ')':\n if s[i - 1] == '(':\n dp[i] = 2 + (dp[i - 2] if i > 1 else 0)\n else:\n j = i - dp[i - 1] - 1\n if j >= 0 and s[j] == '(':\n dp[i] = 2 + dp[i - 1] + dp[j - 1]\n return max(dp)\n\n ","memory":"16600"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n n = len(s)\n f = [0] * (n + 1)\n for i, c in enumerate(s, 1):\n if c == \")\":\n if i > 1 and s[i - 2] == \"(\":\n f[i] = f[i - 2] + 2\n else:\n j = i - f[i - 1] - 1\n if j and s[j - 1] == \"(\":\n f[i] = f[i - 1] + 2 + f[j - 1]\n return max(f)","memory":"16700"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n maxans = 0\n dp = [0] * len(s)\n for i in range(1, len(s)):\n if s[i] == \")\":\n if s[i - 1] == \"(\":\n dp[i] = (dp[i - 2] if i >= 2 else 0) + 2\n elif i - dp[i - 1] > 0 and s[i - dp[i - 1] - 1] == \"(\":\n dp[i] = (\n dp[i - 1]\n + (dp[i - dp[i - 1] - 2] if i - dp[i - 1] >= 2 else 0)\n + 2\n )\n maxans = max(maxans, dp[i])\n return maxans","memory":"16700"},{"code":"class Solution:\n # (num of open, num of closed successfully)\n def longestValidParentheses(self, s: str) -> int:\n stack = []\n for c in s:\n if c == '(':\n num_open = 0\n if stack and stack[-1][1] == 0:\n num_open = stack.pop()[0]\n stack.append((num_open + 1, 0))\n elif stack:\n if stack[-1][0] <= 0:\n stack.append((-1,-1))\n else:\n tmp = stack.pop()\n stack.append((tmp[0] - 1, tmp[1] + 1))\n num_close = 0\n while stack and stack[-1][0] == 0:\n num_close += stack.pop()[1]\n tmp = stack.pop() if stack and stack[-1][0]!=-1 else (0, 0)\n stack.append((tmp[0], tmp[1]+num_close))\n return (max(stack, key=lambda pair: pair[1])[1])*2 if stack else 0","memory":"16800"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n # i'm going to use a stack, whenever we close a paraenthesis if its valid we increment\n # we set best to max(best, current count)\n # if we close and there's nothing to close... then we reset the count\n best = 0\n count = 0\n stack: List[int] = []\n for el in s:\n if el == \"(\":\n stack.append(count)\n count = 0\n elif el == \")\":\n if stack:\n count += 2 + stack.pop()\n best = max(best, count)\n else:\n count = 0\n else:\n raise RuntimeError(\"Oops...\")\n\n return best","memory":"16800"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n if len(s) == 0:\n return 0\n\n # ((())))))() )( ()(())()))))()()()(((()))\n left = 0\n right = 0\n # True means it can connect with next \n lens = []\n curr_len = 0 \n for i, ch in enumerate(s):\n if ch == \"(\":\n left += 1\n else:\n right += 1\n # check if there is anything to pop and check if it can connect to prev\n \n if left > 0 or (len(lens) > 0 and lens[-1][1] > 0):\n \n left -= 1\n right -= 1\n if len(lens) > 0:\n print(\"debug\", lens)\n prev, prev_left, prev_right = lens.pop()\n if prev_left > 0 and prev_right == 0 and left == -1: # merge to prev chunk\n print(\"0\", lens)\n lens.append((prev + 2, prev_left - 1, prev_right))\n left = 0\n print(\"1\", lens)\n else: #unable to merge to previous chunk \n lens.append((prev, prev_left, prev_right))\n lens.append((2, left, right))\n left = 0\n\n else: \n lens.append((2, left, right))\n left = 0\n\n while len(lens) > 1:\n curr, curr_left, curr_right = lens.pop()\n prev, prev_left, prev_right = lens.pop()\n if curr_left == 0 and prev_right == 0:\n print(\"chunk merge\")\n lens.append((curr + prev, prev_left, curr_right))\n else: # unable to merge \n lens.append((prev, prev_left, prev_right))\n lens.append((curr, curr_left, curr_right))\n break\n else: # nothing to pop on left for now, seq ends with more right.\n if len(lens) > 0:\n prev, prev_left, prev_right = lens.pop()\n lens.append((prev, prev_left, prev_right+1))\n right = 0\n\n # lens.append((2, left == 0, right == 0))\n # while len(lens) > 1:\n # curr, curr_connect_left, curr_connect_right = lens.pop()\n # prev, prev_connect_left, prev_connect_right = lens.pop()\n # if curr_connect_left and prev_connect_right:\n # lens.append(curr + prev, prev_connect_left, curr_connect_right)\n # else: # unable to merge \n # lens.append(prev, prev_connect_left, prev_connect_right)\n # lens.append(curr, curr_connect_left, curr_connect_right)\n if len(lens) == 0:\n return 0\n return max([num for num, left, right in lens])\n\n","memory":"16900"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n v = [0] * (len(s) + 1)\n # v[i] == len() of longest starting at i\n for i in range(len(s)-2, -1, -1):\n d = v[i+1]\n print(\"i:\", i, \"d: \", d)\n '(....)('\n if s[i] == '(' and (i + d + 1) < len(s) and s[i+d+ 1] == ')':\n v[i] = 2 + d + v[i + d + 2]\n print (i, v[i])\n return max(v)\n\n\n","memory":"16900"},{"code":"class Solution:\n\n# Using a Stack\n#\n def longestValidParentheses(self, s: str) -> int:\n maxlen = 0\n stack = []\n stack.append(-1)\n\n for i in range(len(s)):\n if s[i] == '(':\n stack.append(i)\n else:\n stack.pop()\n if not stack:\n stack.append(i)\n else:\n maxlen = max(maxlen, i - stack[-1])\n return maxlen\n\n\n# Using Dynamic Programming\n#\n# def longestValidParentheses(self, s: str) -> int:\n# # s = \"())((())\"\n# # s = '))()()('\n# maxlen = 0\n# dp = [0] * len(s)\n#\n# for i in range(1, len(s)):\n# # Only valid if ends in \")\"\n# if s[i] == \")\":\n# if s[i - 1] == \"(\":\n# # Ends with \"...()\"\n# dp[i] = (dp[i - 2] if i >= 2 else 0) + 2\n# elif i - dp[i - 1] > 0 and s[i - dp[i - 1] - 1] == \"(\":\n# # Ends with \"...))\"\n# dp[i] = (\n# dp[i - 1]\n# + (dp[i - dp[i - 1] - 2] if i - dp[i - 1] >= 2 else 0)\n# + 2\n# )\n#\n# maxlen = max(maxlen, dp[i])\n#\n# print(\"maxlen:\", maxlen, \", dp:\", dp)\n# return maxlen\n\n\n# Brute force\n#\n# def isValid(self, s: str) -> bool:\n# stack = []\n# for char in s:\n# if char == '(':\n# stack.append('(')\n# elif stack and stack[-1] == '(':\n# stack.pop()\n# else:\n# return False\n# return len(stack) == 0\n#\n#\n# def longestValidParentheses(self, s: str) -> int:\n# maxlen = 0\n# for i in range(len(s)):\n# for j in range(i + 2, len(s) + 1, 2):\n# if self.isValid(s[i:j]):\n# maxlen = max(maxlen, j - i)\n# return maxlen\n#\n","memory":"17000"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n maxLen = 0\n\n for i in range(len(s)):\n if s[i] =='(':\n stack.append(i)\n else:\n stack.pop()\n if(len(stack)==0):\n stack.append(i)\n else:\n maxLen=max(maxLen, i - stack[-1])\n return maxLen","memory":"17000"},{"code":"\nclass Solution:\n def longestValidParentheses(self, s: str) -> int:\n\n if s.find('()')==-1 :\n return 0\n\n print('s0='+s)\n\n brackets = [-1]\n max_ = 0\n\n for i, el in enumerate(s):\n print('i0='+str(i))\n if el == '(':\n brackets.append(i)\n else:\n brackets.pop()\n if not brackets:\n brackets.append(i)\n else:\n #print('i1='+str(i))\n #print('brackets[-1]='+str(brackets[-1]))\n max_ = max(max_, i - brackets[-1])\n\n\n return max_\n","memory":"17100"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n l = [-1]\n res = 0\n for i in range(len(s)):\n if s[i] == \")\":\n l.pop()\n if len(l) == 0:\n l.append(i)\n else:\n res = max(res, i - l[-1]) \n else:\n l.append(i)\n return res","memory":"17100"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n max_len = 0\n\n for i in range(len(s)):\n if s[i] == '(':\n stack.append(i)\n else:\n stack.pop()\n if len(stack) == 0:\n stack.append(i)\n else:\n max_len = max(max_len, i - stack[-1])\n\n return max_len\n","memory":"17200"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack=[-1]\n max_len=0\n for i in range(len(s)):\n if s[i] == \"(\":\n stack.append(i)\n else:\n stack.pop()\n if len(stack) ==0:\n stack.append(i)\n else:\n max_len=max(max_len,i-stack[-1])\n return max_len\n ","memory":"17200"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n \n maxi = 0\n stack = [-1]\n \n for i in range(len(s)) :\n if s[i] == \"(\" : stack.append(i)\n else :\n stack.pop()\n if len(stack) == 0 : stack.append(i)\n else : maxi = max(maxi, i - stack[-1])\n \n return maxi","memory":"17300"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n st = []\n ans = 0\n curr = 0\n for i in range(0,len(s)):\n if s[i]=='(':\n st.append(i)\n elif s[i]==')':\n if len(st)>0 and s[st[-1]] == '(':\n st.pop()\n else:\n st.append(i)\n end = len(s)\n for i in range(len(st)-1,-1,-1):\n ans = max(ans,end - st[i] -1)\n end = st[i]\n return max(ans,end)","memory":"17300"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1] # Initialize stack with -1 to handle the base case\n max_length = 0\n\n for i, char in enumerate(s):\n if char == '(':\n stack.append(i)\n else:\n stack.pop()\n if not stack:\n stack.append(i)\n else:\n max_length = max(max_length, i - stack[-1])\n \n return max_length","memory":"17400"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n stack = [-1]\n max_len = 0\n\n for i, c in enumerate(s):\n if c == '(':\n stack.append(i)\n else:\n stack.pop()\n if not stack:\n stack.append(i)\n else:\n max_len = max(max_len, i - stack[-1])\n return max_len","memory":"17400"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n st = [-1]\n res = 0\n for i, v in enumerate(s):\n if v == '(':\n st.append(i)\n else:\n st.pop()\n if not st:\n st.append(i)\n else:\n res = max(res, i-st[-1])\n return res\n ","memory":"17500"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n if not s:\n return 0\n valid = [False] * len(s)\n stack = deque()\n for r in range(len(s)):\n assert s[r] in [\"(\", \")\"]\n if s[r] == \"(\":\n stack.append(r)\n elif stack:\n l = stack.pop()\n valid[l] = True\n valid[r] = True\n max_length = 0\n l = -1\n for r in range(len(valid)):\n if valid[r]:\n if l == -1:\n l = r\n elif l >= 0:\n length = r - l\n max_length = max(max_length, length)\n l = -1\n if valid[len(valid) - 1]:\n length = len(valid) - l\n max_length = max(max_length, length)\n return max_length","memory":"17600"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n errors = []\n for i in range(len(s)):\n if s[i] == \"(\" or len(errors) == 0 or s[errors[-1]] == \")\":\n errors.append(i)\n else:\n errors.pop()\n print(errors)\n ret = 0\n last = -1\n for i in errors:\n print(ret)\n if i-last - 1 > ret:\n ret = i-last - 1\n last = i\n if len(errors) == 0:\n return len(s)\n if len(s) - 1 - last > ret:\n return len(s)-1-last\n return ret","memory":"17700"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n errors = []\n for i in range(len(s)):\n if s[i] == \"(\" or len(errors) == 0 or s[errors[-1]] == \")\":\n errors.append(i)\n else:\n errors.pop()\n ret = 0\n last = -1\n for i in errors:\n print(ret)\n if i-last - 1 > ret:\n ret = i-last - 1\n last = i\n if len(errors) == 0:\n return len(s)\n if len(s) - 1 - last > ret:\n return len(s)-1-last\n return ret","memory":"17700"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n res = []\n left = right = 0\n left_cnt = right_cnt = 0\n cur_length = 0\n stack = []\n while left < len(s) and right < len(s):\n c = s[right]\n if c == '(':\n stack.append(right)\n left_cnt += 1\n else:\n if left_cnt:\n res.append((stack.pop(), right))\n left_cnt -= 1\n else:\n left = right + 1\n left_cnt = right_cnt = 0\n right += 1\n if not res:\n return 0\n res.sort()\n print(res)\n ans = [res[0]]\n for i in range(1, len(res)):\n left, right = res[i][0], res[i][1]\n prev_left, prev_right = ans[-1][0], ans[-1][1]\n if left < prev_left and right > prev_right:\n ans[-1] = (left, right)\n elif left >= prev_left and right <= prev_right:\n continue\n else:\n ans.append((left, right))\n print(ans)\n max_length = length = ans[0][1] - ans[0][0] + 1\n # print(length)\n for i in range(1, len(ans)):\n left = ans[i][0]\n right = ans[i][1]\n prev_right = ans[i - 1][1]\n if prev_right + 1 == left:\n length += right - left + 1\n # print(length)\n max_length = max(max_length, length)\n else:\n length = right - left + 1\n # print(length)\n max_length = max(max_length , length)\n return max_length\n \n \n ","memory":"17800"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n if s == \"((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((\" :\n return 0\n \n max_len = 0\n self.dp = {}\n\n for i in range(len(s)) :\n if s[i] == '(' :\n max_len = max(max_len, self.dfsUtil(s, i))\n \n return max_len\n \n def dfsUtil(self, s, i) :\n if i == len(s) or s[i] == ')':\n return 0\n \n if i in self.dp :\n return self.dp[i]\n\n j = i \n self.dp[i] = 0\n count = 0 \n \n while j < len(s) :\n count += 1 if s[j] == '(' else -1\n \n if count == 0 :\n self.dp[i] = (j-i) + 1 + self.dfsUtil(s, j+1)\n break\n elif count < 0 :\n return 0\n \n j += 1\n \n return self.dp[i] \n ","memory":"17900"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n res = []\n left = right = 0\n left_cnt = right_cnt = 0\n cur_length = 0\n stack = []\n while left < len(s) and right < len(s):\n c = s[right]\n if c == '(':\n stack.append(right)\n left_cnt += 1\n else:\n if left_cnt:\n res.append((stack.pop(), right))\n left_cnt -= 1\n else:\n left = right + 1\n left_cnt = right_cnt = 0\n right += 1\n if not res:\n return 0\n res.sort()\n print(res)\n ans = [res[0]]\n for i in range(1, len(res)):\n left, right = res[i][0], res[i][1]\n prev_left, prev_right = ans[-1][0], ans[-1][1]\n if left < prev_left and right > prev_right:\n ans[-1] = (left, right)\n elif left >= prev_left and right <= prev_right:\n continue\n else:\n if prev_right + 1 == left:\n ans[-1] = (prev_left, right)\n else:\n ans.append((left, right))\n print(ans)\n max_length = length = ans[0][1] - ans[0][0] + 1\n # print(length)\n for i in range(1, len(ans)):\n left = ans[i][0]\n right = ans[i][1]\n prev_right = ans[i - 1][1]\n if prev_right + 1 == left:\n length += right - left + 1\n # print(length)\n max_length = max(max_length, length)\n else:\n length = right - left + 1\n # print(length)\n max_length = max(max_length , length)\n return max_length\n \n \n ","memory":"17900"},{"code":"class Solution:\n def longestValidParentheses(self, s: str) -> int:\n # keep track of valid paranethese\n # if they are continuous join them\n valids = []\n pointer = 0\n\n stack = []\n\n for index, c in enumerate(s):\n if self.isClose(c):\n if not stack:\n continue\n \n opening = stack.pop()\n pair = self.isPair(opening[0], c)\n if not pair:\n continue\n\n # check if continuous\n if not valids:\n valids.append([opening[1], index])\n else:\n continuous = valids[pointer][1] + 1 == opening[1]\n if valids and continuous:\n valids[pointer][1] = index\n else:\n valids.append([opening[1], index])\n pointer += 1\n else:\n stack.append((c, index))\n\n # edge case\n if not valids:\n return 0\n\n # there might be overlaps again\n # example: \"()(())\" -> [[0, 1], [3, 4], [2, 5]]\n valids.sort(key=lambda x: x[0])\n overlaps = [valids[0]]\n pointer = 0\n\n for i in range(1, len(valids)):\n continuous = overlaps[pointer][1] + 1 >= valids[i][0]\n if continuous:\n overlaps[pointer][1] = max(overlaps[pointer][1], valids[i][1])\n else:\n overlaps.append(valids[i])\n pointer += 1\n \n # find the longest parentheses\n longest = 0\n for c in overlaps:\n longest = max(longest, c[1] - c[0] + 1)\n return longest\n\n \n def isClose(self, p):\n return p == \")\" or p == \"]\" or p == \"}\"\n\n def isPair(self, l, r):\n rounded = [\"(\", \")\"]\n square = [\"[\", \"]\"]\n curly = [\"{\", \"}\"]\n\n return (l in rounded and r in rounded) \\\n or (l in square and r in square) \\\n or (l in curly and r in curly)\n","memory":"18000"},{"code":"class Slab:\n def __init__(self, char, len):\n self.char = char\n self.len = len\n\nclass Solution:\n def longestValidParentheses(self, s: str) -> int:\n opening = '('\n closing = ')'\n stack = [Slab(None, 0)]\n longest = 0\n for char in s:\n if char == closing:\n if stack[-1].char == opening:\n complete_slab = stack.pop()\n stack[-1].len += complete_slab.len + 1\n longest = max(longest, stack[-1].len)\n else:\n stack.append(Slab(closing, 0))\n else:\n stack.append(Slab(opening, 0))\n\n return longest * 2\n","memory":"18100"},{"code":"class Solution:\n def longestValidParentheses(self, s):\n if len(s) < 2:\n return 0\n \n # contains [opens, len]\n heads = []\n max = 0\n \n for c in s:\n if c == '(':\n for e in heads:\n e[0] = e[0] + 1\n heads.append([1,0])\n else:\n for i in range(len(heads)-1, -1, -1):\n e = heads[i]\n e[0] = e[0] - 1\n e[1] = e[1] + 2\n if e[0] == 0:\n if e[1] > max:\n max = e[1]\n if e[0] == -1:\n # invalid\n del heads[i]\n\n return max\n\n","memory":"18200"}],"string":"[\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n\\n \\n left = right = best = 0\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\":\\n left += 1\\n else:\\n right += 1\\n if right > left:\\n left = right = 0\\n elif left == right:\\n best = max(best, right * 2)\\n r1 = best\\n s = s[::-1]\\n left = right = best = 0\\n for i in range(len(s)):\\n if s[i] == \\\")\\\":\\n left += 1\\n else:\\n right += 1\\n if right > left:\\n left = right = 0\\n elif left == right:\\n best = max(best, right * 2)\\n r2 = best\\n\\n return max(r1, r2)\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n \\n openCount, closeCount = 0, 0\\n res = 0\\n for c in s:\\n if c == \\\"(\\\":\\n openCount += 1\\n else:\\n closeCount += 1\\n if openCount == closeCount:\\n res = max(res, openCount + closeCount)\\n if closeCount > openCount:\\n openCount, closeCount = 0, 0\\n openCount, closeCount = 0, 0\\n for c in s[::-1]:\\n if c == \\\"(\\\":\\n openCount += 1\\n else:\\n closeCount += 1\\n if closeCount == openCount:\\n res = max(res, openCount + closeCount)\\n if closeCount < openCount:\\n openCount, closeCount = 0, 0\\n \\n return res\\n\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n left = 0\\n right = 0\\n maxVal = 0\\n for i in range(len(s)):\\n if s[i] == '(':\\n left += 1\\n else:\\n right += 1\\n if left == right:\\n maxVal = max(maxVal, left * 2)\\n elif left < right:\\n left = 0\\n right = 0\\n left = 0\\n right = 0\\n for i in range(len(s) - 1, -1, -1):\\n if s[i] == '(':\\n left += 1\\n else:\\n right += 1\\n if left == right:\\n maxVal = max(maxVal, left * 2)\\n elif right < left:\\n left = 0\\n right = 0\\n return maxVal\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n l = r = 0\\n ans = 0\\n N = len(s)\\n for c in s:\\n if c == '(':\\n l += 1\\n else:\\n r += 1\\n if r > l:\\n l = r = 0\\n elif r == l:\\n ans = max(ans, r+l)\\n r = l = 0\\n for c in s[::-1]:\\n if c == ')':\\n r += 1\\n else:\\n l += 1\\n if l > r:\\n l = r = 0\\n elif r == l:\\n ans = max(ans, r+l)\\n return ans\\n \\n\\n \\n\\n\\n\\n \\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n = len(s)\\n f = [0] * (n + 1)\\n for i, c in enumerate(s, 1):\\n if c == \\\")\\\":\\n if i > 1 and s[i - 2] == \\\"(\\\":\\n f[i] = f[i - 2] + 2\\n else:\\n j = i - f[i - 1] - 1\\n if j and s[j - 1] == \\\"(\\\":\\n f[i] = f[i - 1] + 2 + f[j - 1]\\n return max(f)\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n\\n \\n left = right = best = 0\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\":\\n left += 1\\n else:\\n right += 1\\n if right > left:\\n left = right = 0\\n elif left == right:\\n best = max(best, right * 2)\\n r1 = best\\n\\n left = right = best = 0\\n for i in range(len(s)):\\n if s[::-1][i] == \\\")\\\":\\n left += 1\\n else:\\n right += 1\\n if right > left:\\n left = right = 0\\n elif left == right:\\n best = max(best, right * 2)\\n r2 = best\\n\\n return max(r1, r2)\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n = len(s)\\n if n < 2:\\n return 0\\n dp = [0] * n\\n for i in range(1, n):\\n if s[i] == ')':\\n if s[i - 1] == '(':\\n dp[i] = 2 + (dp[i - 2] if i > 1 else 0)\\n else:\\n j = i - dp[i - 1] - 1\\n if j >= 0 and s[j] == '(':\\n dp[i] = 2 + dp[i - 1] + dp[j - 1]\\n return max(dp)\\n\\n \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n n = len(s)\\n f = [0] * (n + 1)\\n for i, c in enumerate(s, 1):\\n if c == \\\")\\\":\\n if i > 1 and s[i - 2] == \\\"(\\\":\\n f[i] = f[i - 2] + 2\\n else:\\n j = i - f[i - 1] - 1\\n if j and s[j - 1] == \\\"(\\\":\\n f[i] = f[i - 1] + 2 + f[j - 1]\\n return max(f)\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n maxans = 0\\n dp = [0] * len(s)\\n for i in range(1, len(s)):\\n if s[i] == \\\")\\\":\\n if s[i - 1] == \\\"(\\\":\\n dp[i] = (dp[i - 2] if i >= 2 else 0) + 2\\n elif i - dp[i - 1] > 0 and s[i - dp[i - 1] - 1] == \\\"(\\\":\\n dp[i] = (\\n dp[i - 1]\\n + (dp[i - dp[i - 1] - 2] if i - dp[i - 1] >= 2 else 0)\\n + 2\\n )\\n maxans = max(maxans, dp[i])\\n return maxans\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n # (num of open, num of closed successfully)\\n def longestValidParentheses(self, s: str) -> int:\\n stack = []\\n for c in s:\\n if c == '(':\\n num_open = 0\\n if stack and stack[-1][1] == 0:\\n num_open = stack.pop()[0]\\n stack.append((num_open + 1, 0))\\n elif stack:\\n if stack[-1][0] <= 0:\\n stack.append((-1,-1))\\n else:\\n tmp = stack.pop()\\n stack.append((tmp[0] - 1, tmp[1] + 1))\\n num_close = 0\\n while stack and stack[-1][0] == 0:\\n num_close += stack.pop()[1]\\n tmp = stack.pop() if stack and stack[-1][0]!=-1 else (0, 0)\\n stack.append((tmp[0], tmp[1]+num_close))\\n return (max(stack, key=lambda pair: pair[1])[1])*2 if stack else 0\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n # i'm going to use a stack, whenever we close a paraenthesis if its valid we increment\\n # we set best to max(best, current count)\\n # if we close and there's nothing to close... then we reset the count\\n best = 0\\n count = 0\\n stack: List[int] = []\\n for el in s:\\n if el == \\\"(\\\":\\n stack.append(count)\\n count = 0\\n elif el == \\\")\\\":\\n if stack:\\n count += 2 + stack.pop()\\n best = max(best, count)\\n else:\\n count = 0\\n else:\\n raise RuntimeError(\\\"Oops...\\\")\\n\\n return best\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n if len(s) == 0:\\n return 0\\n\\n # ((())))))() )( ()(())()))))()()()(((()))\\n left = 0\\n right = 0\\n # True means it can connect with next \\n lens = []\\n curr_len = 0 \\n for i, ch in enumerate(s):\\n if ch == \\\"(\\\":\\n left += 1\\n else:\\n right += 1\\n # check if there is anything to pop and check if it can connect to prev\\n \\n if left > 0 or (len(lens) > 0 and lens[-1][1] > 0):\\n \\n left -= 1\\n right -= 1\\n if len(lens) > 0:\\n print(\\\"debug\\\", lens)\\n prev, prev_left, prev_right = lens.pop()\\n if prev_left > 0 and prev_right == 0 and left == -1: # merge to prev chunk\\n print(\\\"0\\\", lens)\\n lens.append((prev + 2, prev_left - 1, prev_right))\\n left = 0\\n print(\\\"1\\\", lens)\\n else: #unable to merge to previous chunk \\n lens.append((prev, prev_left, prev_right))\\n lens.append((2, left, right))\\n left = 0\\n\\n else: \\n lens.append((2, left, right))\\n left = 0\\n\\n while len(lens) > 1:\\n curr, curr_left, curr_right = lens.pop()\\n prev, prev_left, prev_right = lens.pop()\\n if curr_left == 0 and prev_right == 0:\\n print(\\\"chunk merge\\\")\\n lens.append((curr + prev, prev_left, curr_right))\\n else: # unable to merge \\n lens.append((prev, prev_left, prev_right))\\n lens.append((curr, curr_left, curr_right))\\n break\\n else: # nothing to pop on left for now, seq ends with more right.\\n if len(lens) > 0:\\n prev, prev_left, prev_right = lens.pop()\\n lens.append((prev, prev_left, prev_right+1))\\n right = 0\\n\\n # lens.append((2, left == 0, right == 0))\\n # while len(lens) > 1:\\n # curr, curr_connect_left, curr_connect_right = lens.pop()\\n # prev, prev_connect_left, prev_connect_right = lens.pop()\\n # if curr_connect_left and prev_connect_right:\\n # lens.append(curr + prev, prev_connect_left, curr_connect_right)\\n # else: # unable to merge \\n # lens.append(prev, prev_connect_left, prev_connect_right)\\n # lens.append(curr, curr_connect_left, curr_connect_right)\\n if len(lens) == 0:\\n return 0\\n return max([num for num, left, right in lens])\\n\\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n v = [0] * (len(s) + 1)\\n # v[i] == len() of longest starting at i\\n for i in range(len(s)-2, -1, -1):\\n d = v[i+1]\\n print(\\\"i:\\\", i, \\\"d: \\\", d)\\n '(....)('\\n if s[i] == '(' and (i + d + 1) < len(s) and s[i+d+ 1] == ')':\\n v[i] = 2 + d + v[i + d + 2]\\n print (i, v[i])\\n return max(v)\\n\\n\\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n\\n# Using a Stack\\n#\\n def longestValidParentheses(self, s: str) -> int:\\n maxlen = 0\\n stack = []\\n stack.append(-1)\\n\\n for i in range(len(s)):\\n if s[i] == '(':\\n stack.append(i)\\n else:\\n stack.pop()\\n if not stack:\\n stack.append(i)\\n else:\\n maxlen = max(maxlen, i - stack[-1])\\n return maxlen\\n\\n\\n# Using Dynamic Programming\\n#\\n# def longestValidParentheses(self, s: str) -> int:\\n# # s = \\\"())((())\\\"\\n# # s = '))()()('\\n# maxlen = 0\\n# dp = [0] * len(s)\\n#\\n# for i in range(1, len(s)):\\n# # Only valid if ends in \\\")\\\"\\n# if s[i] == \\\")\\\":\\n# if s[i - 1] == \\\"(\\\":\\n# # Ends with \\\"...()\\\"\\n# dp[i] = (dp[i - 2] if i >= 2 else 0) + 2\\n# elif i - dp[i - 1] > 0 and s[i - dp[i - 1] - 1] == \\\"(\\\":\\n# # Ends with \\\"...))\\\"\\n# dp[i] = (\\n# dp[i - 1]\\n# + (dp[i - dp[i - 1] - 2] if i - dp[i - 1] >= 2 else 0)\\n# + 2\\n# )\\n#\\n# maxlen = max(maxlen, dp[i])\\n#\\n# print(\\\"maxlen:\\\", maxlen, \\\", dp:\\\", dp)\\n# return maxlen\\n\\n\\n# Brute force\\n#\\n# def isValid(self, s: str) -> bool:\\n# stack = []\\n# for char in s:\\n# if char == '(':\\n# stack.append('(')\\n# elif stack and stack[-1] == '(':\\n# stack.pop()\\n# else:\\n# return False\\n# return len(stack) == 0\\n#\\n#\\n# def longestValidParentheses(self, s: str) -> int:\\n# maxlen = 0\\n# for i in range(len(s)):\\n# for j in range(i + 2, len(s) + 1, 2):\\n# if self.isValid(s[i:j]):\\n# maxlen = max(maxlen, j - i)\\n# return maxlen\\n#\\n\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n maxLen = 0\\n\\n for i in range(len(s)):\\n if s[i] =='(':\\n stack.append(i)\\n else:\\n stack.pop()\\n if(len(stack)==0):\\n stack.append(i)\\n else:\\n maxLen=max(maxLen, i - stack[-1])\\n return maxLen\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n\\n if s.find('()')==-1 :\\n return 0\\n\\n print('s0='+s)\\n\\n brackets = [-1]\\n max_ = 0\\n\\n for i, el in enumerate(s):\\n print('i0='+str(i))\\n if el == '(':\\n brackets.append(i)\\n else:\\n brackets.pop()\\n if not brackets:\\n brackets.append(i)\\n else:\\n #print('i1='+str(i))\\n #print('brackets[-1]='+str(brackets[-1]))\\n max_ = max(max_, i - brackets[-1])\\n\\n\\n return max_\\n\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n l = [-1]\\n res = 0\\n for i in range(len(s)):\\n if s[i] == \\\")\\\":\\n l.pop()\\n if len(l) == 0:\\n l.append(i)\\n else:\\n res = max(res, i - l[-1]) \\n else:\\n l.append(i)\\n return res\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n max_len = 0\\n\\n for i in range(len(s)):\\n if s[i] == '(':\\n stack.append(i)\\n else:\\n stack.pop()\\n if len(stack) == 0:\\n stack.append(i)\\n else:\\n max_len = max(max_len, i - stack[-1])\\n\\n return max_len\\n\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack=[-1]\\n max_len=0\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\":\\n stack.append(i)\\n else:\\n stack.pop()\\n if len(stack) ==0:\\n stack.append(i)\\n else:\\n max_len=max(max_len,i-stack[-1])\\n return max_len\\n \",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n \\n maxi = 0\\n stack = [-1]\\n \\n for i in range(len(s)) :\\n if s[i] == \\\"(\\\" : stack.append(i)\\n else :\\n stack.pop()\\n if len(stack) == 0 : stack.append(i)\\n else : maxi = max(maxi, i - stack[-1])\\n \\n return maxi\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n st = []\\n ans = 0\\n curr = 0\\n for i in range(0,len(s)):\\n if s[i]=='(':\\n st.append(i)\\n elif s[i]==')':\\n if len(st)>0 and s[st[-1]] == '(':\\n st.pop()\\n else:\\n st.append(i)\\n end = len(s)\\n for i in range(len(st)-1,-1,-1):\\n ans = max(ans,end - st[i] -1)\\n end = st[i]\\n return max(ans,end)\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1] # Initialize stack with -1 to handle the base case\\n max_length = 0\\n\\n for i, char in enumerate(s):\\n if char == '(':\\n stack.append(i)\\n else:\\n stack.pop()\\n if not stack:\\n stack.append(i)\\n else:\\n max_length = max(max_length, i - stack[-1])\\n \\n return max_length\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n stack = [-1]\\n max_len = 0\\n\\n for i, c in enumerate(s):\\n if c == '(':\\n stack.append(i)\\n else:\\n stack.pop()\\n if not stack:\\n stack.append(i)\\n else:\\n max_len = max(max_len, i - stack[-1])\\n return max_len\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n st = [-1]\\n res = 0\\n for i, v in enumerate(s):\\n if v == '(':\\n st.append(i)\\n else:\\n st.pop()\\n if not st:\\n st.append(i)\\n else:\\n res = max(res, i-st[-1])\\n return res\\n \",\n \"memory\": \"17500\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n if not s:\\n return 0\\n valid = [False] * len(s)\\n stack = deque()\\n for r in range(len(s)):\\n assert s[r] in [\\\"(\\\", \\\")\\\"]\\n if s[r] == \\\"(\\\":\\n stack.append(r)\\n elif stack:\\n l = stack.pop()\\n valid[l] = True\\n valid[r] = True\\n max_length = 0\\n l = -1\\n for r in range(len(valid)):\\n if valid[r]:\\n if l == -1:\\n l = r\\n elif l >= 0:\\n length = r - l\\n max_length = max(max_length, length)\\n l = -1\\n if valid[len(valid) - 1]:\\n length = len(valid) - l\\n max_length = max(max_length, length)\\n return max_length\",\n \"memory\": \"17600\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n errors = []\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\" or len(errors) == 0 or s[errors[-1]] == \\\")\\\":\\n errors.append(i)\\n else:\\n errors.pop()\\n print(errors)\\n ret = 0\\n last = -1\\n for i in errors:\\n print(ret)\\n if i-last - 1 > ret:\\n ret = i-last - 1\\n last = i\\n if len(errors) == 0:\\n return len(s)\\n if len(s) - 1 - last > ret:\\n return len(s)-1-last\\n return ret\",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n errors = []\\n for i in range(len(s)):\\n if s[i] == \\\"(\\\" or len(errors) == 0 or s[errors[-1]] == \\\")\\\":\\n errors.append(i)\\n else:\\n errors.pop()\\n ret = 0\\n last = -1\\n for i in errors:\\n print(ret)\\n if i-last - 1 > ret:\\n ret = i-last - 1\\n last = i\\n if len(errors) == 0:\\n return len(s)\\n if len(s) - 1 - last > ret:\\n return len(s)-1-last\\n return ret\",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n res = []\\n left = right = 0\\n left_cnt = right_cnt = 0\\n cur_length = 0\\n stack = []\\n while left < len(s) and right < len(s):\\n c = s[right]\\n if c == '(':\\n stack.append(right)\\n left_cnt += 1\\n else:\\n if left_cnt:\\n res.append((stack.pop(), right))\\n left_cnt -= 1\\n else:\\n left = right + 1\\n left_cnt = right_cnt = 0\\n right += 1\\n if not res:\\n return 0\\n res.sort()\\n print(res)\\n ans = [res[0]]\\n for i in range(1, len(res)):\\n left, right = res[i][0], res[i][1]\\n prev_left, prev_right = ans[-1][0], ans[-1][1]\\n if left < prev_left and right > prev_right:\\n ans[-1] = (left, right)\\n elif left >= prev_left and right <= prev_right:\\n continue\\n else:\\n ans.append((left, right))\\n print(ans)\\n max_length = length = ans[0][1] - ans[0][0] + 1\\n # print(length)\\n for i in range(1, len(ans)):\\n left = ans[i][0]\\n right = ans[i][1]\\n prev_right = ans[i - 1][1]\\n if prev_right + 1 == left:\\n length += right - left + 1\\n # print(length)\\n max_length = max(max_length, length)\\n else:\\n length = right - left + 1\\n # print(length)\\n max_length = max(max_length , length)\\n return max_length\\n \\n \\n \",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n if s == \\\"((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((\\\" :\\n return 0\\n \\n max_len = 0\\n self.dp = {}\\n\\n for i in range(len(s)) :\\n if s[i] == '(' :\\n max_len = max(max_len, self.dfsUtil(s, i))\\n \\n return max_len\\n \\n def dfsUtil(self, s, i) :\\n if i == len(s) or s[i] == ')':\\n return 0\\n \\n if i in self.dp :\\n return self.dp[i]\\n\\n j = i \\n self.dp[i] = 0\\n count = 0 \\n \\n while j < len(s) :\\n count += 1 if s[j] == '(' else -1\\n \\n if count == 0 :\\n self.dp[i] = (j-i) + 1 + self.dfsUtil(s, j+1)\\n break\\n elif count < 0 :\\n return 0\\n \\n j += 1\\n \\n return self.dp[i] \\n \",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n res = []\\n left = right = 0\\n left_cnt = right_cnt = 0\\n cur_length = 0\\n stack = []\\n while left < len(s) and right < len(s):\\n c = s[right]\\n if c == '(':\\n stack.append(right)\\n left_cnt += 1\\n else:\\n if left_cnt:\\n res.append((stack.pop(), right))\\n left_cnt -= 1\\n else:\\n left = right + 1\\n left_cnt = right_cnt = 0\\n right += 1\\n if not res:\\n return 0\\n res.sort()\\n print(res)\\n ans = [res[0]]\\n for i in range(1, len(res)):\\n left, right = res[i][0], res[i][1]\\n prev_left, prev_right = ans[-1][0], ans[-1][1]\\n if left < prev_left and right > prev_right:\\n ans[-1] = (left, right)\\n elif left >= prev_left and right <= prev_right:\\n continue\\n else:\\n if prev_right + 1 == left:\\n ans[-1] = (prev_left, right)\\n else:\\n ans.append((left, right))\\n print(ans)\\n max_length = length = ans[0][1] - ans[0][0] + 1\\n # print(length)\\n for i in range(1, len(ans)):\\n left = ans[i][0]\\n right = ans[i][1]\\n prev_right = ans[i - 1][1]\\n if prev_right + 1 == left:\\n length += right - left + 1\\n # print(length)\\n max_length = max(max_length, length)\\n else:\\n length = right - left + 1\\n # print(length)\\n max_length = max(max_length , length)\\n return max_length\\n \\n \\n \",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n # keep track of valid paranethese\\n # if they are continuous join them\\n valids = []\\n pointer = 0\\n\\n stack = []\\n\\n for index, c in enumerate(s):\\n if self.isClose(c):\\n if not stack:\\n continue\\n \\n opening = stack.pop()\\n pair = self.isPair(opening[0], c)\\n if not pair:\\n continue\\n\\n # check if continuous\\n if not valids:\\n valids.append([opening[1], index])\\n else:\\n continuous = valids[pointer][1] + 1 == opening[1]\\n if valids and continuous:\\n valids[pointer][1] = index\\n else:\\n valids.append([opening[1], index])\\n pointer += 1\\n else:\\n stack.append((c, index))\\n\\n # edge case\\n if not valids:\\n return 0\\n\\n # there might be overlaps again\\n # example: \\\"()(())\\\" -> [[0, 1], [3, 4], [2, 5]]\\n valids.sort(key=lambda x: x[0])\\n overlaps = [valids[0]]\\n pointer = 0\\n\\n for i in range(1, len(valids)):\\n continuous = overlaps[pointer][1] + 1 >= valids[i][0]\\n if continuous:\\n overlaps[pointer][1] = max(overlaps[pointer][1], valids[i][1])\\n else:\\n overlaps.append(valids[i])\\n pointer += 1\\n \\n # find the longest parentheses\\n longest = 0\\n for c in overlaps:\\n longest = max(longest, c[1] - c[0] + 1)\\n return longest\\n\\n \\n def isClose(self, p):\\n return p == \\\")\\\" or p == \\\"]\\\" or p == \\\"}\\\"\\n\\n def isPair(self, l, r):\\n rounded = [\\\"(\\\", \\\")\\\"]\\n square = [\\\"[\\\", \\\"]\\\"]\\n curly = [\\\"{\\\", \\\"}\\\"]\\n\\n return (l in rounded and r in rounded) \\\\\\n or (l in square and r in square) \\\\\\n or (l in curly and r in curly)\\n\",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"class Slab:\\n def __init__(self, char, len):\\n self.char = char\\n self.len = len\\n\\nclass Solution:\\n def longestValidParentheses(self, s: str) -> int:\\n opening = '('\\n closing = ')'\\n stack = [Slab(None, 0)]\\n longest = 0\\n for char in s:\\n if char == closing:\\n if stack[-1].char == opening:\\n complete_slab = stack.pop()\\n stack[-1].len += complete_slab.len + 1\\n longest = max(longest, stack[-1].len)\\n else:\\n stack.append(Slab(closing, 0))\\n else:\\n stack.append(Slab(opening, 0))\\n\\n return longest * 2\\n\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def longestValidParentheses(self, s):\\n if len(s) < 2:\\n return 0\\n \\n # contains [opens, len]\\n heads = []\\n max = 0\\n \\n for c in s:\\n if c == '(':\\n for e in heads:\\n e[0] = e[0] + 1\\n heads.append([1,0])\\n else:\\n for i in range(len(heads)-1, -1, -1):\\n e = heads[i]\\n e[0] = e[0] - 1\\n e[1] = e[1] + 2\\n if e[0] == 0:\\n if e[1] > max:\\n max = e[1]\\n if e[0] == -1:\\n # invalid\\n del heads[i]\\n\\n return max\\n\\n\",\n \"memory\": \"18200\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":33,"string":"33"}}},{"rowIdx":69,"cells":{"question_id":{"kind":"number","value":33,"string":"33"},"name":{"kind":"string","value":"search-in-rotated-sorted-array"},"content":{"kind":"string","value":"<p>There is an integer array <code>nums</code> sorted in ascending order (with <strong>distinct</strong> values).</p>\n\n<p>Prior to being passed to your function, <code>nums</code> is <strong>possibly rotated</strong> at an unknown pivot index <code>k</code> (<code>1 <= k < nums.length</code>) such that the resulting array is <code>[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]</code> (<strong>0-indexed</strong>). For example, <code>[0,1,2,4,5,6,7]</code> might be rotated at pivot index <code>3</code> and become <code>[4,5,6,7,0,1,2]</code>.</p>\n\n<p>Given the array <code>nums</code> <strong>after</strong> the possible rotation and an integer <code>target</code>, return <em>the index of </em><code>target</code><em> if it is in </em><code>nums</code><em>, or </em><code>-1</code><em> if it is not in </em><code>nums</code>.</p>\n\n<p>You must write an algorithm with <code>O(log n)</code> runtime complexity.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<pre><strong>Input:</strong> nums = [4,5,6,7,0,1,2], target = 0\n<strong>Output:</strong> 4\n</pre><p><strong class=\"example\">Example 2:</strong></p>\n<pre><strong>Input:</strong> nums = [4,5,6,7,0,1,2], target = 3\n<strong>Output:</strong> -1\n</pre><p><strong class=\"example\">Example 3:</strong></p>\n<pre><strong>Input:</strong> nums = [1], target = 0\n<strong>Output:</strong> -1\n</pre>\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 5000</code></li>\n\t<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>\n\t<li>All values of <code>nums</code> are <strong>unique</strong>.</li>\n\t<li><code>nums</code> is an ascending array that is possibly rotated.</li>\n\t<li><code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":41.50811349418473,"string":"41.508113"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","binary-search"],"string":"[\n \"array\",\n \"binary-search\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"19\", 0.0027], [\"22\", 0.0109], [\"23\", 0.0462], [\"24\", 0.0082], [\"25\", 0.0272], [\"26\", 0.125], [\"27\", 0.182], [\"28\", 0.1331], [\"29\", 0.2146], [\"30\", 0.6982], [\"31\", 0.6439], [\"32\", 0.6031], [\"33\", 0.9807], [\"34\", 2.5564], [\"35\", 2.1408], [\"36\", 1.6626], [\"37\", 2.8118], [\"38\", 6.0692], [\"39\", 4.6483], [\"40\", 3.6621], [\"41\", 5.5856], [\"42\", 9.4651], [\"43\", 7.1341], [\"44\", 5.3547], [\"45\", 6.9983], [\"46\", 8.8022], [\"47\", 6.7348], [\"48\", 5.0069], [\"49\", 4.9825], [\"50\", 4.2109], [\"51\", 3.059]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16200\", 0.0054], [\"16400\", 0.0082], [\"16500\", 0.0299], [\"16600\", 0.3505], [\"16700\", 5.1862], [\"16800\", 22.9889], [\"16900\", 41.1557], [\"17000\", 25.2438]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def condition(self, nums: List[int], target: int, mid: int, left:int , right:int ):\n if nums[left]<= nums[mid]:\n if nums[left] <= target < nums[mid]:\n return True\n else:\n return False\n else:\n if nums[mid] < target <= nums[right]:\n return False\n else:\n return True\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n while left <= right: \n mid = left + (right - left) // 2\n if nums[mid] == target:\n return mid\n elif self.condition(nums, target, mid, left, right):\n right = mid - 1 \n else:\n left = mid + 1 \n return -1\n","runtime":"19"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n while left + 1 < right:\n mid = (left + right) // 2\n if nums[mid] == target:\n return mid\n elif nums[mid] < target:\n if self.is_in_first_segment(nums, mid):\n left = mid\n else:\n if target > nums[len(nums) - 1]:\n right = mid\n else:\n left = mid\n else:\n if self.is_in_first_segment(nums, mid):\n if target < nums[0]:\n left = mid\n else:\n right = mid\n else:\n right = mid\n if nums[left] == target:\n return left\n if nums[right] == target:\n return right\n return -1\n\n \n def is_in_first_segment(self, nums, mid):\n return nums[0] <= nums[mid]","runtime":"22"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n n = len(nums)\n left, right = 0, n-1\n\n # Find index of pivot element (the smallest element)\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] > nums[-1]:\n # Middle is more than right, so go right\n left = mid + 1\n else:\n # Middle is less than right, so go left\n right = mid - 1\n\n # Binary search over an inclusive range [left boundary to right boundary]\n def binarySearch(left_boundary, right_boundary, target):\n left, right = left_boundary, right_boundary\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] == target:\n return mid\n elif nums[mid] > target:\n right = mid - 1\n else:\n left = mid + 1\n return -1\n\n # Binary search over elements on the pivot element's left\n if (answer := binarySearch(0, left - 1, target)) != -1:\n return answer\n \n # Binary search over elements on the pivot element's right\n return binarySearch(left, n - 1, target)","runtime":"23"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left , right = 0 , len(nums)-1\n while(left<=right):\n mid = (left +right)//2\n if(nums[mid] == target):\n return mid\n if(nums[left]<=nums[mid]): # The first half is sorted hence binary search can be applied\n if(nums[left]<=target and nums[mid]>target):\n right = mid-1\n else:\n left = mid+1\n else: #This means the right half is sorted\n if(nums[mid]< target and nums[right]>=target):\n left = mid+1\n else:\n right = mid-1\n return -1\n\n \n \n \n \n ","runtime":"24"},{"code":"from typing import List\n\nclass Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] == target:\n return mid\n if nums[left] <= nums[mid]:\n if nums[left] <= target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n\n ","runtime":"25"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left=0\n right=len(nums)-1\n while left<=right:\n mid=(right+left)//2\n if nums[mid]==target:\n return mid\n if right==left:\n break\n if nums[mid]>=nums[left]:\n if nums[left]<=target<nums[mid]:\n right=mid-1\n else:\n left=mid+1\n else:\n if nums[mid]<target<=nums[right]:\n left=mid+1\n else:\n right=mid-1\n return -1\n","runtime":"26"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums)-1\n\n while left<=right:\n mid = (left+right)//2\n if nums[mid]==target:\n return mid\n \n if nums[left]<=nums[mid]:\n if nums[left]<=target<nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid]<target<=nums[right]:\n left = mid + 1\n else:\n right = mid -1\n return -1\n","runtime":"27"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n n = len(nums)\n left, right = 0, n-1\n\n while left <= right:\n mid = (left+right)//2\n\n if nums[mid] == target:\n return mid\n elif nums[left] <= nums[mid]:\n if target >= nums[left] and target < nums[mid]:\n right = mid-1\n else:\n left = mid+1\n elif nums[right] >= nums[mid]:\n if target <= nums[right] and target > nums[mid]:\n left = mid+1\n else:\n right = mid-1\n\n return -1\n ","runtime":"27"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n def getPivot():\n lo, hi = 0, len(nums)-1\n while lo<=hi:\n mid = lo+(hi-lo)//2\n if mid+1 < len(nums) and nums[mid] > nums[mid+1]:\n return mid+1\n if nums[mid] < nums[lo]:\n hi = mid-1\n else:\n lo = mid+1\n return lo\n pivot = getPivot()\n left = bisect_left(nums,target,0,pivot)\n right = bisect_left(nums,target,pivot,len(nums))\n if left < len(nums) and nums[left] == target:\n return left\n if right < len(nums) and nums[right] == target:\n return right\n return -1","runtime":"28"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if nums[mid] == target:\n return mid\n\n # Check if left half is sorted\n if nums[left] <= nums[mid]:\n if nums[left] <= target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n # Otherwise, right half is sorted\n else:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n\n return -1\n","runtime":"28"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] == target:\n return mid\n elif nums[mid] >= nums[left]:\n if nums[mid] > target >= nums[left]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n return -1","runtime":"29"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n\n while left <= right:\n mid = (right + left) // 2\n\n if nums[mid] == target:\n return mid\n \n if nums[left] <= nums[mid]:\n if nums[mid] > target and target >= nums[left]:\n right = mid - 1\n else:\n left = mid + 1\n\n else:\n if nums[mid] < target and target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n\n return -1","runtime":"30"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n\n while left <= right:\n mid = (left+right) // 2\n\n if nums[mid] == target:\n return mid\n\n if nums[left] <= nums[mid]:\n if nums[left] <= target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n \n return -1","runtime":"30"},{"code":"class Solution:\n def findMinPos(self,nums)->int:\n n = len(nums)-1\n left = 0\n right = n\n pos = 0\n while left<=right:\n ind = (left+right)//2\n curr = nums[ind]\n if curr<=nums[n]:#it means it is in right sorted arr\n pos = ind #but we are not sure wether this is the smallest so move the search to left\n right = ind-1\n else:#it means it is in right sorted arr we need to find smalles so move search to right\n left = ind+1 \n return pos\n\n def bs(self,nums,target,left,right)->int:\n print(f'left is {left} right is {right}')\n while left<=right:\n ind = (left+right)//2\n curr = nums[ind]\n print(f'ind is {ind} curr is {curr}')\n\n if curr<target:#move search to right\n left = ind+1\n elif curr>target:#move search to left\n right = ind-1\n else:\n return ind\n return -1\n\n def search(self, nums: List[int], target: int) -> int:\n #this can be rotated array ,then first find the minimum number in that array\n leftEle = nums[0]\n rightEle = nums[len(nums)-1]\n pos = self.findMinPos(nums)\n if pos == 0: #that means array is not rotated\n return self.bs(nums,target,0,len(nums)-1) \n minEle = nums[pos]\n print(f'pos is {pos} target is {target}')\n\n if minEle<=target and target<=rightEle:\n return self.bs(nums,target,pos,len(nums)-1)\n else:\n return self.bs(nums,target,0,pos-1)\n","runtime":"31"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left = 0\n rgt = len(nums) - 1\n\n while left <= rgt:\n mid = left + ((rgt - left) // 2)\n\n if nums[mid] == target:\n return mid\n \n if nums[left] <= nums[mid]:\n if nums[left] <= target < nums[mid]:\n rgt = mid - 1\n else:\n left = mid + 1\n \n else:\n if nums[mid] < target <= nums[rgt]:\n left = mid + 1\n else:\n rgt = mid - 1\n return -1\n ","runtime":"31"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n if target in nums:\n return nums.index(target)\n return -1","runtime":"32"},{"code":"# Input is an integer array nums sorted in ascending order w distinct values\n# nums is possibly rotated at some unkown pivot\n# Input is also a target value\n\n# Output is index of target value in nums if it exists, else -1\n\n# Example1\n# l\n# r\n# m\n# 0 1 2 3 4 5 6\n# nums = [4, 5, 6, 7, 0, 1, 2], target=0\n\n# Complexity: Assume n nums\n# time: O(log n)\n# space: O(1)\n\nclass Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if nums[mid] == target:\n return mid \n \n if nums[mid] < nums[right]:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n else:\n if nums[left] <= target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n \n return -1\n","runtime":"32"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if nums[mid] == target:\n return mid\n\n if nums[left] <= nums[mid]:\n if nums[left] <= target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n\n return -1","runtime":"33"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left,right=0,len(nums)-1\n if(len(nums)==1):\n return 0 if nums[0]==target else -1\n \n while left<right:\n mid = (left+right)//2\n if nums[mid] == target:\n return mid\n elif nums[mid] < nums[right]:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n\n else:\n if nums[left] <= target < nums[mid]:\n right = mid-1\n else:\n left = mid + 1\n\n print(left,right,mid)\n return -1 if nums[left] != target else left\n","runtime":"33"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n try:\n return nums.index(target)\n except:\n return -1","runtime":"34"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n # if nums only has 1 element, directly check if it equals target\n if len(nums) == 1:\n return 0 if nums[0] == target else -1\n\n def findPivot() -> int:\n L = 0\n R = len(nums) - 1\n while L < R:\n C = (L + R) // 2\n if L == C:\n break\n elif nums[L] > nums[C]:\n R = C\n elif nums[C] > nums[R]:\n L = C\n return L\n\n def findTarget(L: int, R: int):\n if L == R:\n return L if nums[L] == target else -1\n\n while L < R:\n C = (L + R) // 2\n if L == C:\n if target == nums[L]:\n return L\n elif target == nums[R]:\n return R\n else:\n return -1\n\n if target == nums[C]:\n return C\n elif target < nums[C]:\n R = C\n elif target > nums[C]:\n L = C\n\n return -1\n\n # if first num > last num; then not a rotated array\n # binary search from indexes 0 to n-1, like normal sorted array\n if nums[0] < nums[-1]:\n return findTarget(0, len(nums) - 1)\n\n # find pivot index of rotated array\n # with it, we practically have 2 sorted arrays, split at pivot index\n P = findPivot()\n\n # print(\"Pivot:\", P)\n\n # if target < pivot, then binary search in 1st-half of array\n if target <= nums[-1]:\n return findTarget(P + 1, len(nums) - 1)\n # else, binary search in 2nd-half of array\n else:\n return findTarget(0, P)","runtime":"34"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n if not nums:\n return -1\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] == target:\n return mid\n if nums[left] <= nums[mid]:\n if nums[left] <= target < nums[mid]:\n right = mid-1\n else:\n left = mid+1\n else:\n if nums[mid] < target <= nums[right]:\n left = mid+1\n else:\n right = mid-1\n return -1\n ","runtime":"35"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n \n while left <= right:\n mid = left + (right - left) // 2\n \n if nums[mid] == target:\n return mid\n \n if nums[left] <= nums[mid]:\n if nums[left] <= target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n \n return -1\n \n ","runtime":"35"},{"code":"# Using Binary Search\nclass Solution:\n def search(self, nums: List[int], target: int) -> int:\n\n n=len(nums)\n\n start=0\n end=n-1\n\n while start<=end:\n mid=(start+end)//2\n # if target is found return the index\n if nums[mid]==target:\n return mid\n # check which side is sorted eoither left or right\n # do the check on that side\n\n # left half is sorted\n if nums[start]<=nums[mid]:\n # if target is in this half\n if nums[start]<=target<=nums[mid]:\n end=mid-1\n # if target is not in this half\n else:\n start=mid+1\n\n \n # right half is sorted\n else:\n # if target is in this half\n if nums[mid]<=target<=nums[end]:\n start=mid+1\n # if target is not in this half\n else:\n end=mid-1\n return -1\n \n\n ","runtime":"36"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n ans = -1\n if target in nums:\n ans = nums.index(target)\n return ans","runtime":"36"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n for i in range(len(nums)):\n if(nums[i]==target):\n return i\n return -1\n \n","runtime":"37"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n if not nums:\n return -1\n if len(nums) == 1 and nums[0] != target:\n return -1\n index = self.findSmallest(nums)\n left, right = 0, 0\n if target > nums[-1]:\n right = index - 1\n elif target == nums[-1]:\n return len(nums) - 1\n else:\n left = index\n right = len(nums) - 1\n\n while left + 1 < right:\n mid = (left + right) // 2\n if nums[mid] < target:\n left = mid\n elif nums[mid] == target:\n return mid\n else:\n right = mid\n if nums[left] == target:\n return left\n if nums[right] == target:\n return right\n return -1\n \n\n def findSmallest(self, nums):\n left = 0\n right = len(nums) - 1\n while left + 1 < right:\n mid = (left + right) // 2\n if nums[mid] > nums[-1]:\n left = mid\n else:\n right = mid\n if nums[left] < nums[right]:\n return left\n return right","runtime":"37"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) -1\n # mid = 0\n while left <= right:\n # mid = (i+j)//2\n mid = (left+right)//2\n if nums[mid] == target:\n return mid\n print(mid)\n\n if nums[left] <= nums[mid]:\n if target > nums[mid] or target < nums[left]:\n left = mid + 1\n else:\n right = mid -1\n \n else:\n if target < nums[mid] or target > nums[right]:\n right = mid -1\n else:\n left = mid + 1\n \n\n\n\n # if nums[left] > target:\n # left = mid+1\n # else:\n # right = mid-1\n return -1","runtime":"38"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums)-1\n\n while left <right:\n mid = left + int(((right-left)/2))\n if nums[mid] >nums[right]:\n left = mid+1\n else:\n right = mid\n\n print(left)\n \n if target>=nums[left] and target<=nums[-1]:\n left1 = left\n right1 = len(nums) -1\n else:\n left1 = 0\n right1 = right-1\n print(left1,right1)\n while left1<=right1:\n mid = left1 + int(((right1-left1)/2))\n if nums[mid] == target:\n return mid\n elif nums[mid] <target:\n left1 = mid+1\n else:\n right1 = mid-1\n return -1 \n \n ","runtime":"38"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n return self.helper(nums, target, 0, len(nums))\n \n def helper(self, nums, target, i, j):\n if j - i == 0:\n return -1\n\n if j - i == 1:\n if nums[i] == target:\n return i\n else:\n return -1\n \n first = nums[i]\n last = nums[j-1]\n if target < first and target > last:\n return -1\n \n k = (j - i) // 2 + i\n return max(self.helper(nums, target, i, k), self.helper(nums, target, k, j))\n","runtime":"39"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums)-1\n while left <= right:\n mid = left+(right-left)//2\n if nums[mid]==target:\n return mid\n if nums[mid]>=nums[left]:\n if nums[mid]>=target and target >=nums[left]:\n right = mid\n else:\n left = mid+1\n else:\n if target <= nums[right] and target >nums[mid]:\n left = mid+1\n else:\n right = mid\n return -1","runtime":"39"},{"code":"class Solution:\n def search(self, nums: list[int], target: int) -> int:\n l,r = 0,len(nums)-1\n while l<r:\n mid= (l+r)//2\n if nums[mid]>nums[r]:\n l = mid+1\n elif nums[mid]<nums[r]:\n r = mid\n index_min = l\n if target == nums[index_min]:\n return index_min\n\n l,r=0,len(nums)-1\n if nums[l]<nums[r]:\n l,r=0,len(nums)-1\n \n\n elif nums[l]<=target<=nums[index_min-1]:\n r = index_min-1\n elif nums[index_min]<=target<=nums[r]:\n l = index_min\n\n while l<=r:\n mid= (l+r)//2\n if nums[mid]==target:\n return mid\n elif nums[mid]>target:\n r=mid-1\n elif nums[mid]<target:\n l=mid+1\n return -1","runtime":"40"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n #video: https://youtu.be/dO9OZJP_Hm8\n l = 0\n r = len(nums) - 1\n\n while l <= r:\n\n mid = (l+r)//2\n if nums[mid] == target:\n return mid\n\n # When part of the list is sorted \n elif nums[mid] >= nums[l]:\n if nums[l] <= target <= nums[mid]:\n r = mid-1\n else:\n l = mid+1\n # When right part of the list is sorted\n else:\n if nums[mid] <= target <= nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n\n return -1","runtime":"40"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n low = 0\n high = len(nums) - 1\n\n while low<=high:\n mid = (low+high)//2\n if nums[mid] == target:\n return mid\n if nums[low]<=nums[mid]:\n if nums[low]<=target<=nums[mid]:\n high = mid - 1\n else:\n low = mid + 1\n else:\n if nums[mid]<=target<=nums[high]:\n low = mid + 1\n else:\n high = mid - 1\n return -1","runtime":"41"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n # nums is sorted and numbers are distinct\n # idea 1: do two binary searches: first to find the pivot, then to find the target\n\n pivot = self.find_pivot(nums)\n print(pivot)\n low = pivot + 1\n high = pivot + len(nums)\n mid = (high + low) // 2\n\n while high >= low:\n value = nums[mid % len(nums)]\n print(high, low, mid, mid % len(nums), value)\n\n if value == target:\n return mid % len(nums)\n elif value > target:\n high = mid - 1\n elif value < target:\n low = mid + 1\n mid = (high + low) // 2\n return -1\n\n\n def find_pivot(self, nums):\n low = 0\n high = len(nums) -1\n mid = high // 2\n print('lets go')\n if nums[high] > nums[low]:\n return -1\n\n while high > low:\n if nums[mid] > nums[high]:\n low = mid \n elif nums[mid] < nums[low]:\n high = mid \n mid = (high + low) // 2\n if mid == low or mid == high:\n return mid\n return mid\n\n\n\n\n# solution = Solution()\n# print(solution.find_pivot([4,5,6,7,0,1,2]))","runtime":"41"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n l = 0\n r = len(nums) - 1\n\n while l <= r:\n mid = (l + r) // 2\n if target == nums[mid]:\n return mid\n \n if nums[l] <= nums[mid]:\n if target > nums[mid] or target < nums[l]:\n l = mid + 1\n else:\n r = mid - 1\n else:\n if target < nums[mid] or target > nums[r]:\n r = mid - 1\n else:\n l = mid + 1\n return -1","runtime":"42"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums) - 1\n\n while l <= r:\n mid = (l + r) // 2\n \n if nums[mid] == target:\n return mid\n \n\n # Left sorted\n if nums[l] <= nums[mid]:\n if target >= nums[l] and target < nums[mid]:\n r = mid - 1\n else:\n l = mid + 1\n # Right sorted\n else:\n if target <= nums[r] and target >= nums[mid]:\n l = mid + 1\n else:\n r = mid - 1\n \n return -1\n\n","runtime":"42"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums) - 1\n\n while l <= r:\n mid = (l+r) // 2\n if target == nums[mid]:\n return mid\n # Left Sorted\n if nums[l] <= nums[mid]:\n if target > nums[mid] or target < nums[l]:\n l = mid + 1\n else:\n r = mid - 1\n # if target <= nums[mid] and target >= nums[l]:\n # r = mid - 1\n # else:\n # l = mid + 1 \n\n # Right Sorted\n else:\n if target < nums[mid] or target > nums[r]:\n r = mid - 1\n else:\n l = mid + 1\n return -1\n\n ","runtime":"43"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n l,r = 0, len(nums)-1\n while l <= r:\n mid = (l+r)//2\n if nums[mid] == target:\n return mid\n if nums[mid] >= nums[l]:\n if nums[l] <= target and target < nums[mid]:\n r = mid - 1\n else:\n l = mid + 1\n else:\n if nums[mid] < target and target <= nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n return -1\n","runtime":"43"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n l=0\n r=len(nums)-1\n while l<=r:\n mid=(l+r)//2\n if nums[mid]==target: return mid\n if nums[mid]<target:\n if (target<=nums[-1] and nums[mid]<=nums[-1]) or (target>=nums[0] and nums[mid]>=nums[0]): l=mid+1\n else: r=mid-1\n elif nums[mid]>target:\n if (target<=nums[-1] and nums[mid]<=nums[-1]) or (target>=nums[0] and nums[mid]>=nums[0]): r=mid-1\n else: l=mid+1\n return -1 ","runtime":"44"},{"code":"class Solution:\n def findpivot(self, nums: List[int]) -> int:\n start = 0\n end = len(nums) - 1\n while(start < end):\n mid = start + (end - start)//2\n if nums[mid] >= nums[0]:\n start = mid + 1\n else:\n end = mid\n return start\n def binarysearch(self, nums:List[int] , start , end , target):\n while(start <= end):\n mid = start + (end - start)//2\n if(target == nums[mid]):\n return mid\n if(target >= nums[mid]):\n start = mid + 1\n else:\n end = mid - 1\n return -1\n def search(self, nums: List[int], target: int) -> int:\n pivot = self.findpivot(nums)\n if(nums[pivot] <= target <= nums[len(nums)-1]):\n return self.binarysearch(nums,pivot,len(nums)-1,target)\n else:\n return self.binarysearch(nums,0,pivot-1,target)","runtime":"44"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums)-1\n \n while left <= right:\n mid = (left+right)//2\n if nums[mid] == target:\n return mid\n if nums[left] <= nums[mid]:\n if nums[left] <= target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n\n \n ","runtime":"45"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n for i in range(len(nums)):\n if nums[i]==target:\n return i\n return -1\n ","runtime":"45"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums) - 1\n while l <= r:\n m = (l + r) // 2\n if nums[m] == target:\n return m\n if nums[m] > nums[r]: # left portion\n if nums[m] > target: # search smaller\n if target < nums[l]:\n l = m + 1\n else:\n r = m - 1\n else: # search larger\n l = m + 1\n else: # right portion\n if nums[m] < target: # search larger\n if target > nums[r]:\n r = m - 1\n else:\n l = m + 1\n else: # search smaller\n r = m - 1\n return -1","runtime":"46"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n\n l, r = 0, len(nums)-1\n while l <= r:\n mid = (l+r) // 2\n if nums[mid] == target:\n return mid\n \n if nums[mid] > nums[r]: # left side is sorted\n if target >= nums[l] and target < nums[mid]:\n r = mid - 1\n else:\n l = mid + 1\n else: #right part is sorted\n if target <= nums[r] and target > nums[mid]:\n l = mid + 1\n else:\n r = mid - 1\n return -1\n\n\n","runtime":"46"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n if len(nums)==0:\n return -1\n for i in range(len(nums)):\n if nums[i]==target:\n return i\n \n return -1\n","runtime":"47"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums) - 1\n while l <= r:\n mid = (r + l) // 2\n if nums[mid] == target:\n return mid\n if target < nums[mid]:\n if nums[mid] < nums[r] or target > nums[r]:\n r = mid - 1\n else:\n l = mid + 1\n else:\n if nums[mid] > nums[l] or target <= nums[r]:\n l = mid + 1\n else:\n r = mid -1\n\n \n return -1","runtime":"47"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n l = 0\n r = len(nums) -1 \n while l <= r:\n mid = l + (r-l)//2\n if nums[mid] == target:\n return mid\n elif nums[mid] < nums[r]:\n if nums[mid] < target <= nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n else:\n if nums[l] <= target < nums[mid]:\n r = mid - 1\n else:\n l = mid + 1\n return -1\n","runtime":"48"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n def binFindPivot() -> int:\n L = 0\n R = len(nums) - 1\n\n if nums[L] <= nums[R]:\n return 0 # is normal sorted list; no pivot\n\n while L <= R:\n M = (L + R) // 2\n if L == M:\n break\n elif nums[L] > nums[M]: # rotation in left half\n R = M\n elif nums[M] > nums[R]: # rotation in right half\n L = M\n return R\n\n def binFindTarget(L: int, R: int) -> int:\n while L <= R:\n M = (L + R) // 2\n if target == nums[M]:\n return M\n elif target < nums[M]:\n R = M - 1\n elif target > nums[M]:\n L = M + 1\n return -1\n\n P = binFindPivot()\n\n if target <= nums[-1]:\n return binFindTarget(P, len(nums) - 1) # right sorted portion\n else:\n return binFindTarget(0, P - 1) # left sorted portion","runtime":"48"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n\n while left <= right:\n mid = left + (right - left) // 2\n if nums[mid] == target:\n return mid\n elif nums[mid] >= nums[left]:\n if target >= nums[left] and target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if target <= nums[right] and target > nums[mid]:\n left = mid + 1\n else:\n right = mid - 1\n\n\n return -1","runtime":"49"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n L = 0\n R = len(nums) - 1\n\n # modified binary search\n # - get middle index\n # - determine if middle index is part of left or right sorted portion\n while L <= R:\n M = (L + R) // 2\n\n if nums[M] == target:\n return M\n\n # middle value is in left sorted portion\n if nums[L] <= nums[M]:\n # if target is outside of left sorted portion, binary search right\n if target < nums[L] or target > nums[M]:\n L = M + 1\n # else, target is within left portion, narrow left search\n else:\n R = M - 1\n # else, middle value in right sorted portion\n else:\n # if target is outside of right sorted portion, binary search left\n if target < nums[M] or target > nums[R]:\n R = M - 1\n # else, target is within right portion, narrow right search\n else:\n L = M + 1\n\n return -1","runtime":"49"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if nums[mid] == target:\n return mid\n elif nums[mid] >= nums[left]:\n if nums[left] <= target <= nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if nums[mid] <= target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n \n return -1\n \n","runtime":"50"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n i = 0\n j = len(nums) -1\n while i < j:\n mid = (i + j) // 2\n if nums[mid] == target:\n return mid\n if nums[i] > nums[mid] and nums[i] <= target:\n j = mid - 1\n elif nums[j] < nums[mid] and nums[j] >= target:\n i = mid + 1\n elif nums[mid] < target:\n i = mid + 1\n else:\n j = mid - 1\n return i if i == j and nums[i] == target else -1\n\n ","runtime":"50"},{"code":"class Solution:\n\n def bin_search(self, array, left, right, target):\n if left > right:\n return -1\n idx = (left + right) // 2\n if array[idx] == target:\n return idx\n elif array[idx] > target:\n return self.bin_search(array, left=left, right=idx - 1, target=target)\n else:\n return self.bin_search(array, left=idx + 1, right=right, target=target)\n\n\n def find_pivot(self, array, left, right):\n idx = (left + right) // 2\n if array[idx] > array[idx + 1]:\n return idx + 1\n if array[idx] > array[-1]:\n return self.find_pivot(array, left=idx + 1, right=right)\n else:\n return self.find_pivot(array, left=left, right=idx - 1)\n\n\n def search(self, nums: List[int], target: int) -> int:\n if nums[0] > nums[-1]:\n # find the pivot\n pivot = self.find_pivot(nums, 0, len(nums) - 1)\n if target >= nums[0]:\n return self.bin_search(nums, 0, pivot, target)\n else:\n return self.bin_search(nums, pivot, len(nums) - 1, target)\n else:\n return self.bin_search(nums, 0, len(nums) - 1, target)","runtime":"51"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums)-1\n mid = len(nums)//2\n if nums[mid]==target:\n return mid\n while left<=right:\n mid = left+(right-left)//2\n\n if nums[mid]==target:\n return mid\n if nums[mid]>=nums[left]:\n if target>=nums[left] and target < nums[mid]:\n right = mid-1\n else:\n left = mid+1\n else:\n if target<=nums[right] and target>nums[mid]:\n left = mid+1\n else:\n right=mid-1\n return -1","runtime":"51"}],"string":"[\n {\n \"code\": \"class Solution:\\n def condition(self, nums: List[int], target: int, mid: int, left:int , right:int ):\\n if nums[left]<= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n return True\\n else:\\n return False\\n else:\\n if nums[mid] < target <= nums[right]:\\n return False\\n else:\\n return True\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n while left <= right: \\n mid = left + (right - left) // 2\\n if nums[mid] == target:\\n return mid\\n elif self.condition(nums, target, mid, left, right):\\n right = mid - 1 \\n else:\\n left = mid + 1 \\n return -1\\n\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n while left + 1 < right:\\n mid = (left + right) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] < target:\\n if self.is_in_first_segment(nums, mid):\\n left = mid\\n else:\\n if target > nums[len(nums) - 1]:\\n right = mid\\n else:\\n left = mid\\n else:\\n if self.is_in_first_segment(nums, mid):\\n if target < nums[0]:\\n left = mid\\n else:\\n right = mid\\n else:\\n right = mid\\n if nums[left] == target:\\n return left\\n if nums[right] == target:\\n return right\\n return -1\\n\\n \\n def is_in_first_segment(self, nums, mid):\\n return nums[0] <= nums[mid]\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n n = len(nums)\\n left, right = 0, n-1\\n\\n # Find index of pivot element (the smallest element)\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] > nums[-1]:\\n # Middle is more than right, so go right\\n left = mid + 1\\n else:\\n # Middle is less than right, so go left\\n right = mid - 1\\n\\n # Binary search over an inclusive range [left boundary to right boundary]\\n def binarySearch(left_boundary, right_boundary, target):\\n left, right = left_boundary, right_boundary\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] > target:\\n right = mid - 1\\n else:\\n left = mid + 1\\n return -1\\n\\n # Binary search over elements on the pivot element's left\\n if (answer := binarySearch(0, left - 1, target)) != -1:\\n return answer\\n \\n # Binary search over elements on the pivot element's right\\n return binarySearch(left, n - 1, target)\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left , right = 0 , len(nums)-1\\n while(left<=right):\\n mid = (left +right)//2\\n if(nums[mid] == target):\\n return mid\\n if(nums[left]<=nums[mid]): # The first half is sorted hence binary search can be applied\\n if(nums[left]<=target and nums[mid]>target):\\n right = mid-1\\n else:\\n left = mid+1\\n else: #This means the right half is sorted\\n if(nums[mid]< target and nums[right]>=target):\\n left = mid+1\\n else:\\n right = mid-1\\n return -1\\n\\n \\n \\n \\n \\n \",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] == target:\\n return mid\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return -1\\n\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left=0\\n right=len(nums)-1\\n while left<=right:\\n mid=(right+left)//2\\n if nums[mid]==target:\\n return mid\\n if right==left:\\n break\\n if nums[mid]>=nums[left]:\\n if nums[left]<=target<nums[mid]:\\n right=mid-1\\n else:\\n left=mid+1\\n else:\\n if nums[mid]<target<=nums[right]:\\n left=mid+1\\n else:\\n right=mid-1\\n return -1\\n\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums)-1\\n\\n while left<=right:\\n mid = (left+right)//2\\n if nums[mid]==target:\\n return mid\\n \\n if nums[left]<=nums[mid]:\\n if nums[left]<=target<nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid]<target<=nums[right]:\\n left = mid + 1\\n else:\\n right = mid -1\\n return -1\\n\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n n = len(nums)\\n left, right = 0, n-1\\n\\n while left <= right:\\n mid = (left+right)//2\\n\\n if nums[mid] == target:\\n return mid\\n elif nums[left] <= nums[mid]:\\n if target >= nums[left] and target < nums[mid]:\\n right = mid-1\\n else:\\n left = mid+1\\n elif nums[right] >= nums[mid]:\\n if target <= nums[right] and target > nums[mid]:\\n left = mid+1\\n else:\\n right = mid-1\\n\\n return -1\\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n def getPivot():\\n lo, hi = 0, len(nums)-1\\n while lo<=hi:\\n mid = lo+(hi-lo)//2\\n if mid+1 < len(nums) and nums[mid] > nums[mid+1]:\\n return mid+1\\n if nums[mid] < nums[lo]:\\n hi = mid-1\\n else:\\n lo = mid+1\\n return lo\\n pivot = getPivot()\\n left = bisect_left(nums,target,0,pivot)\\n right = bisect_left(nums,target,pivot,len(nums))\\n if left < len(nums) and nums[left] == target:\\n return left\\n if right < len(nums) and nums[right] == target:\\n return right\\n return -1\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if nums[mid] == target:\\n return mid\\n\\n # Check if left half is sorted\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n # Otherwise, right half is sorted\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n return -1\\n\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] >= nums[left]:\\n if nums[mid] > target >= nums[left]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return -1\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n\\n while left <= right:\\n mid = (right + left) // 2\\n\\n if nums[mid] == target:\\n return mid\\n \\n if nums[left] <= nums[mid]:\\n if nums[mid] > target and target >= nums[left]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n\\n else:\\n if nums[mid] < target and target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n return -1\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n\\n while left <= right:\\n mid = (left+right) // 2\\n\\n if nums[mid] == target:\\n return mid\\n\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n return -1\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def findMinPos(self,nums)->int:\\n n = len(nums)-1\\n left = 0\\n right = n\\n pos = 0\\n while left<=right:\\n ind = (left+right)//2\\n curr = nums[ind]\\n if curr<=nums[n]:#it means it is in right sorted arr\\n pos = ind #but we are not sure wether this is the smallest so move the search to left\\n right = ind-1\\n else:#it means it is in right sorted arr we need to find smalles so move search to right\\n left = ind+1 \\n return pos\\n\\n def bs(self,nums,target,left,right)->int:\\n print(f'left is {left} right is {right}')\\n while left<=right:\\n ind = (left+right)//2\\n curr = nums[ind]\\n print(f'ind is {ind} curr is {curr}')\\n\\n if curr<target:#move search to right\\n left = ind+1\\n elif curr>target:#move search to left\\n right = ind-1\\n else:\\n return ind\\n return -1\\n\\n def search(self, nums: List[int], target: int) -> int:\\n #this can be rotated array ,then first find the minimum number in that array\\n leftEle = nums[0]\\n rightEle = nums[len(nums)-1]\\n pos = self.findMinPos(nums)\\n if pos == 0: #that means array is not rotated\\n return self.bs(nums,target,0,len(nums)-1) \\n minEle = nums[pos]\\n print(f'pos is {pos} target is {target}')\\n\\n if minEle<=target and target<=rightEle:\\n return self.bs(nums,target,pos,len(nums)-1)\\n else:\\n return self.bs(nums,target,0,pos-1)\\n\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left = 0\\n rgt = len(nums) - 1\\n\\n while left <= rgt:\\n mid = left + ((rgt - left) // 2)\\n\\n if nums[mid] == target:\\n return mid\\n \\n if nums[left] <= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n rgt = mid - 1\\n else:\\n left = mid + 1\\n \\n else:\\n if nums[mid] < target <= nums[rgt]:\\n left = mid + 1\\n else:\\n rgt = mid - 1\\n return -1\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n if target in nums:\\n return nums.index(target)\\n return -1\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"# Input is an integer array nums sorted in ascending order w distinct values\\n# nums is possibly rotated at some unkown pivot\\n# Input is also a target value\\n\\n# Output is index of target value in nums if it exists, else -1\\n\\n# Example1\\n# l\\n# r\\n# m\\n# 0 1 2 3 4 5 6\\n# nums = [4, 5, 6, 7, 0, 1, 2], target=0\\n\\n# Complexity: Assume n nums\\n# time: O(log n)\\n# space: O(1)\\n\\nclass Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if nums[mid] == target:\\n return mid \\n \\n if nums[mid] < nums[right]:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n else:\\n if nums[left] <= target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n \\n return -1\\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if nums[mid] == target:\\n return mid\\n\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n return -1\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left,right=0,len(nums)-1\\n if(len(nums)==1):\\n return 0 if nums[0]==target else -1\\n \\n while left<right:\\n mid = (left+right)//2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] < nums[right]:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n else:\\n if nums[left] <= target < nums[mid]:\\n right = mid-1\\n else:\\n left = mid + 1\\n\\n print(left,right,mid)\\n return -1 if nums[left] != target else left\\n\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n try:\\n return nums.index(target)\\n except:\\n return -1\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n # if nums only has 1 element, directly check if it equals target\\n if len(nums) == 1:\\n return 0 if nums[0] == target else -1\\n\\n def findPivot() -> int:\\n L = 0\\n R = len(nums) - 1\\n while L < R:\\n C = (L + R) // 2\\n if L == C:\\n break\\n elif nums[L] > nums[C]:\\n R = C\\n elif nums[C] > nums[R]:\\n L = C\\n return L\\n\\n def findTarget(L: int, R: int):\\n if L == R:\\n return L if nums[L] == target else -1\\n\\n while L < R:\\n C = (L + R) // 2\\n if L == C:\\n if target == nums[L]:\\n return L\\n elif target == nums[R]:\\n return R\\n else:\\n return -1\\n\\n if target == nums[C]:\\n return C\\n elif target < nums[C]:\\n R = C\\n elif target > nums[C]:\\n L = C\\n\\n return -1\\n\\n # if first num > last num; then not a rotated array\\n # binary search from indexes 0 to n-1, like normal sorted array\\n if nums[0] < nums[-1]:\\n return findTarget(0, len(nums) - 1)\\n\\n # find pivot index of rotated array\\n # with it, we practically have 2 sorted arrays, split at pivot index\\n P = findPivot()\\n\\n # print(\\\"Pivot:\\\", P)\\n\\n # if target < pivot, then binary search in 1st-half of array\\n if target <= nums[-1]:\\n return findTarget(P + 1, len(nums) - 1)\\n # else, binary search in 2nd-half of array\\n else:\\n return findTarget(0, P)\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n if not nums:\\n return -1\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] == target:\\n return mid\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n right = mid-1\\n else:\\n left = mid+1\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid+1\\n else:\\n right = mid-1\\n return -1\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n \\n while left <= right:\\n mid = left + (right - left) // 2\\n \\n if nums[mid] == target:\\n return mid\\n \\n if nums[left] <= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n return -1\\n \\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# Using Binary Search\\nclass Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n\\n n=len(nums)\\n\\n start=0\\n end=n-1\\n\\n while start<=end:\\n mid=(start+end)//2\\n # if target is found return the index\\n if nums[mid]==target:\\n return mid\\n # check which side is sorted eoither left or right\\n # do the check on that side\\n\\n # left half is sorted\\n if nums[start]<=nums[mid]:\\n # if target is in this half\\n if nums[start]<=target<=nums[mid]:\\n end=mid-1\\n # if target is not in this half\\n else:\\n start=mid+1\\n\\n \\n # right half is sorted\\n else:\\n # if target is in this half\\n if nums[mid]<=target<=nums[end]:\\n start=mid+1\\n # if target is not in this half\\n else:\\n end=mid-1\\n return -1\\n \\n\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n ans = -1\\n if target in nums:\\n ans = nums.index(target)\\n return ans\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n for i in range(len(nums)):\\n if(nums[i]==target):\\n return i\\n return -1\\n \\n\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n if not nums:\\n return -1\\n if len(nums) == 1 and nums[0] != target:\\n return -1\\n index = self.findSmallest(nums)\\n left, right = 0, 0\\n if target > nums[-1]:\\n right = index - 1\\n elif target == nums[-1]:\\n return len(nums) - 1\\n else:\\n left = index\\n right = len(nums) - 1\\n\\n while left + 1 < right:\\n mid = (left + right) // 2\\n if nums[mid] < target:\\n left = mid\\n elif nums[mid] == target:\\n return mid\\n else:\\n right = mid\\n if nums[left] == target:\\n return left\\n if nums[right] == target:\\n return right\\n return -1\\n \\n\\n def findSmallest(self, nums):\\n left = 0\\n right = len(nums) - 1\\n while left + 1 < right:\\n mid = (left + right) // 2\\n if nums[mid] > nums[-1]:\\n left = mid\\n else:\\n right = mid\\n if nums[left] < nums[right]:\\n return left\\n return right\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) -1\\n # mid = 0\\n while left <= right:\\n # mid = (i+j)//2\\n mid = (left+right)//2\\n if nums[mid] == target:\\n return mid\\n print(mid)\\n\\n if nums[left] <= nums[mid]:\\n if target > nums[mid] or target < nums[left]:\\n left = mid + 1\\n else:\\n right = mid -1\\n \\n else:\\n if target < nums[mid] or target > nums[right]:\\n right = mid -1\\n else:\\n left = mid + 1\\n \\n\\n\\n\\n # if nums[left] > target:\\n # left = mid+1\\n # else:\\n # right = mid-1\\n return -1\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums)-1\\n\\n while left <right:\\n mid = left + int(((right-left)/2))\\n if nums[mid] >nums[right]:\\n left = mid+1\\n else:\\n right = mid\\n\\n print(left)\\n \\n if target>=nums[left] and target<=nums[-1]:\\n left1 = left\\n right1 = len(nums) -1\\n else:\\n left1 = 0\\n right1 = right-1\\n print(left1,right1)\\n while left1<=right1:\\n mid = left1 + int(((right1-left1)/2))\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] <target:\\n left1 = mid+1\\n else:\\n right1 = mid-1\\n return -1 \\n \\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n return self.helper(nums, target, 0, len(nums))\\n \\n def helper(self, nums, target, i, j):\\n if j - i == 0:\\n return -1\\n\\n if j - i == 1:\\n if nums[i] == target:\\n return i\\n else:\\n return -1\\n \\n first = nums[i]\\n last = nums[j-1]\\n if target < first and target > last:\\n return -1\\n \\n k = (j - i) // 2 + i\\n return max(self.helper(nums, target, i, k), self.helper(nums, target, k, j))\\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums)-1\\n while left <= right:\\n mid = left+(right-left)//2\\n if nums[mid]==target:\\n return mid\\n if nums[mid]>=nums[left]:\\n if nums[mid]>=target and target >=nums[left]:\\n right = mid\\n else:\\n left = mid+1\\n else:\\n if target <= nums[right] and target >nums[mid]:\\n left = mid+1\\n else:\\n right = mid\\n return -1\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: list[int], target: int) -> int:\\n l,r = 0,len(nums)-1\\n while l<r:\\n mid= (l+r)//2\\n if nums[mid]>nums[r]:\\n l = mid+1\\n elif nums[mid]<nums[r]:\\n r = mid\\n index_min = l\\n if target == nums[index_min]:\\n return index_min\\n\\n l,r=0,len(nums)-1\\n if nums[l]<nums[r]:\\n l,r=0,len(nums)-1\\n \\n\\n elif nums[l]<=target<=nums[index_min-1]:\\n r = index_min-1\\n elif nums[index_min]<=target<=nums[r]:\\n l = index_min\\n\\n while l<=r:\\n mid= (l+r)//2\\n if nums[mid]==target:\\n return mid\\n elif nums[mid]>target:\\n r=mid-1\\n elif nums[mid]<target:\\n l=mid+1\\n return -1\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n #video: https://youtu.be/dO9OZJP_Hm8\\n l = 0\\n r = len(nums) - 1\\n\\n while l <= r:\\n\\n mid = (l+r)//2\\n if nums[mid] == target:\\n return mid\\n\\n # When part of the list is sorted \\n elif nums[mid] >= nums[l]:\\n if nums[l] <= target <= nums[mid]:\\n r = mid-1\\n else:\\n l = mid+1\\n # When right part of the list is sorted\\n else:\\n if nums[mid] <= target <= nums[r]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n\\n return -1\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n low = 0\\n high = len(nums) - 1\\n\\n while low<=high:\\n mid = (low+high)//2\\n if nums[mid] == target:\\n return mid\\n if nums[low]<=nums[mid]:\\n if nums[low]<=target<=nums[mid]:\\n high = mid - 1\\n else:\\n low = mid + 1\\n else:\\n if nums[mid]<=target<=nums[high]:\\n low = mid + 1\\n else:\\n high = mid - 1\\n return -1\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n # nums is sorted and numbers are distinct\\n # idea 1: do two binary searches: first to find the pivot, then to find the target\\n\\n pivot = self.find_pivot(nums)\\n print(pivot)\\n low = pivot + 1\\n high = pivot + len(nums)\\n mid = (high + low) // 2\\n\\n while high >= low:\\n value = nums[mid % len(nums)]\\n print(high, low, mid, mid % len(nums), value)\\n\\n if value == target:\\n return mid % len(nums)\\n elif value > target:\\n high = mid - 1\\n elif value < target:\\n low = mid + 1\\n mid = (high + low) // 2\\n return -1\\n\\n\\n def find_pivot(self, nums):\\n low = 0\\n high = len(nums) -1\\n mid = high // 2\\n print('lets go')\\n if nums[high] > nums[low]:\\n return -1\\n\\n while high > low:\\n if nums[mid] > nums[high]:\\n low = mid \\n elif nums[mid] < nums[low]:\\n high = mid \\n mid = (high + low) // 2\\n if mid == low or mid == high:\\n return mid\\n return mid\\n\\n\\n\\n\\n# solution = Solution()\\n# print(solution.find_pivot([4,5,6,7,0,1,2]))\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n l = 0\\n r = len(nums) - 1\\n\\n while l <= r:\\n mid = (l + r) // 2\\n if target == nums[mid]:\\n return mid\\n \\n if nums[l] <= nums[mid]:\\n if target > nums[mid] or target < nums[l]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n else:\\n if target < nums[mid] or target > nums[r]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n return -1\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums) - 1\\n\\n while l <= r:\\n mid = (l + r) // 2\\n \\n if nums[mid] == target:\\n return mid\\n \\n\\n # Left sorted\\n if nums[l] <= nums[mid]:\\n if target >= nums[l] and target < nums[mid]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n # Right sorted\\n else:\\n if target <= nums[r] and target >= nums[mid]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n \\n return -1\\n\\n\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums) - 1\\n\\n while l <= r:\\n mid = (l+r) // 2\\n if target == nums[mid]:\\n return mid\\n # Left Sorted\\n if nums[l] <= nums[mid]:\\n if target > nums[mid] or target < nums[l]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n # if target <= nums[mid] and target >= nums[l]:\\n # r = mid - 1\\n # else:\\n # l = mid + 1 \\n\\n # Right Sorted\\n else:\\n if target < nums[mid] or target > nums[r]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n return -1\\n\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n l,r = 0, len(nums)-1\\n while l <= r:\\n mid = (l+r)//2\\n if nums[mid] == target:\\n return mid\\n if nums[mid] >= nums[l]:\\n if nums[l] <= target and target < nums[mid]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n else:\\n if nums[mid] < target and target <= nums[r]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n return -1\\n\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n l=0\\n r=len(nums)-1\\n while l<=r:\\n mid=(l+r)//2\\n if nums[mid]==target: return mid\\n if nums[mid]<target:\\n if (target<=nums[-1] and nums[mid]<=nums[-1]) or (target>=nums[0] and nums[mid]>=nums[0]): l=mid+1\\n else: r=mid-1\\n elif nums[mid]>target:\\n if (target<=nums[-1] and nums[mid]<=nums[-1]) or (target>=nums[0] and nums[mid]>=nums[0]): r=mid-1\\n else: l=mid+1\\n return -1 \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def findpivot(self, nums: List[int]) -> int:\\n start = 0\\n end = len(nums) - 1\\n while(start < end):\\n mid = start + (end - start)//2\\n if nums[mid] >= nums[0]:\\n start = mid + 1\\n else:\\n end = mid\\n return start\\n def binarysearch(self, nums:List[int] , start , end , target):\\n while(start <= end):\\n mid = start + (end - start)//2\\n if(target == nums[mid]):\\n return mid\\n if(target >= nums[mid]):\\n start = mid + 1\\n else:\\n end = mid - 1\\n return -1\\n def search(self, nums: List[int], target: int) -> int:\\n pivot = self.findpivot(nums)\\n if(nums[pivot] <= target <= nums[len(nums)-1]):\\n return self.binarysearch(nums,pivot,len(nums)-1,target)\\n else:\\n return self.binarysearch(nums,0,pivot-1,target)\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums)-1\\n \\n while left <= right:\\n mid = (left+right)//2\\n if nums[mid] == target:\\n return mid\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return -1\\n\\n \\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n for i in range(len(nums)):\\n if nums[i]==target:\\n return i\\n return -1\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums) - 1\\n while l <= r:\\n m = (l + r) // 2\\n if nums[m] == target:\\n return m\\n if nums[m] > nums[r]: # left portion\\n if nums[m] > target: # search smaller\\n if target < nums[l]:\\n l = m + 1\\n else:\\n r = m - 1\\n else: # search larger\\n l = m + 1\\n else: # right portion\\n if nums[m] < target: # search larger\\n if target > nums[r]:\\n r = m - 1\\n else:\\n l = m + 1\\n else: # search smaller\\n r = m - 1\\n return -1\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n\\n l, r = 0, len(nums)-1\\n while l <= r:\\n mid = (l+r) // 2\\n if nums[mid] == target:\\n return mid\\n \\n if nums[mid] > nums[r]: # left side is sorted\\n if target >= nums[l] and target < nums[mid]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n else: #right part is sorted\\n if target <= nums[r] and target > nums[mid]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n return -1\\n\\n\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n if len(nums)==0:\\n return -1\\n for i in range(len(nums)):\\n if nums[i]==target:\\n return i\\n \\n return -1\\n\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums) - 1\\n while l <= r:\\n mid = (r + l) // 2\\n if nums[mid] == target:\\n return mid\\n if target < nums[mid]:\\n if nums[mid] < nums[r] or target > nums[r]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n else:\\n if nums[mid] > nums[l] or target <= nums[r]:\\n l = mid + 1\\n else:\\n r = mid -1\\n\\n \\n return -1\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n l = 0\\n r = len(nums) -1 \\n while l <= r:\\n mid = l + (r-l)//2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] < nums[r]:\\n if nums[mid] < target <= nums[r]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n else:\\n if nums[l] <= target < nums[mid]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n return -1\\n\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n def binFindPivot() -> int:\\n L = 0\\n R = len(nums) - 1\\n\\n if nums[L] <= nums[R]:\\n return 0 # is normal sorted list; no pivot\\n\\n while L <= R:\\n M = (L + R) // 2\\n if L == M:\\n break\\n elif nums[L] > nums[M]: # rotation in left half\\n R = M\\n elif nums[M] > nums[R]: # rotation in right half\\n L = M\\n return R\\n\\n def binFindTarget(L: int, R: int) -> int:\\n while L <= R:\\n M = (L + R) // 2\\n if target == nums[M]:\\n return M\\n elif target < nums[M]:\\n R = M - 1\\n elif target > nums[M]:\\n L = M + 1\\n return -1\\n\\n P = binFindPivot()\\n\\n if target <= nums[-1]:\\n return binFindTarget(P, len(nums) - 1) # right sorted portion\\n else:\\n return binFindTarget(0, P - 1) # left sorted portion\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n\\n while left <= right:\\n mid = left + (right - left) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] >= nums[left]:\\n if target >= nums[left] and target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if target <= nums[right] and target > nums[mid]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n\\n return -1\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n L = 0\\n R = len(nums) - 1\\n\\n # modified binary search\\n # - get middle index\\n # - determine if middle index is part of left or right sorted portion\\n while L <= R:\\n M = (L + R) // 2\\n\\n if nums[M] == target:\\n return M\\n\\n # middle value is in left sorted portion\\n if nums[L] <= nums[M]:\\n # if target is outside of left sorted portion, binary search right\\n if target < nums[L] or target > nums[M]:\\n L = M + 1\\n # else, target is within left portion, narrow left search\\n else:\\n R = M - 1\\n # else, middle value in right sorted portion\\n else:\\n # if target is outside of right sorted portion, binary search left\\n if target < nums[M] or target > nums[R]:\\n R = M - 1\\n # else, target is within right portion, narrow right search\\n else:\\n L = M + 1\\n\\n return -1\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] >= nums[left]:\\n if nums[left] <= target <= nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n else:\\n if nums[mid] <= target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n return -1\\n \\n\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n i = 0\\n j = len(nums) -1\\n while i < j:\\n mid = (i + j) // 2\\n if nums[mid] == target:\\n return mid\\n if nums[i] > nums[mid] and nums[i] <= target:\\n j = mid - 1\\n elif nums[j] < nums[mid] and nums[j] >= target:\\n i = mid + 1\\n elif nums[mid] < target:\\n i = mid + 1\\n else:\\n j = mid - 1\\n return i if i == j and nums[i] == target else -1\\n\\n \",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n\\n def bin_search(self, array, left, right, target):\\n if left > right:\\n return -1\\n idx = (left + right) // 2\\n if array[idx] == target:\\n return idx\\n elif array[idx] > target:\\n return self.bin_search(array, left=left, right=idx - 1, target=target)\\n else:\\n return self.bin_search(array, left=idx + 1, right=right, target=target)\\n\\n\\n def find_pivot(self, array, left, right):\\n idx = (left + right) // 2\\n if array[idx] > array[idx + 1]:\\n return idx + 1\\n if array[idx] > array[-1]:\\n return self.find_pivot(array, left=idx + 1, right=right)\\n else:\\n return self.find_pivot(array, left=left, right=idx - 1)\\n\\n\\n def search(self, nums: List[int], target: int) -> int:\\n if nums[0] > nums[-1]:\\n # find the pivot\\n pivot = self.find_pivot(nums, 0, len(nums) - 1)\\n if target >= nums[0]:\\n return self.bin_search(nums, 0, pivot, target)\\n else:\\n return self.bin_search(nums, pivot, len(nums) - 1, target)\\n else:\\n return self.bin_search(nums, 0, len(nums) - 1, target)\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums)-1\\n mid = len(nums)//2\\n if nums[mid]==target:\\n return mid\\n while left<=right:\\n mid = left+(right-left)//2\\n\\n if nums[mid]==target:\\n return mid\\n if nums[mid]>=nums[left]:\\n if target>=nums[left] and target < nums[mid]:\\n right = mid-1\\n else:\\n left = mid+1\\n else:\\n if target<=nums[right] and target>nums[mid]:\\n left = mid+1\\n else:\\n right=mid-1\\n return -1\",\n \"runtime\": \"51\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":55,"string":"55"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n while left <= right:\n middle = (left + right) // 2\n if nums[middle] == target:\n return middle\n if nums[middle] >= nums[left]:\n if nums[left] <= target <= nums[middle]:\n right = middle - 1\n else:\n left = middle + 1\n else:\n if nums[middle] <= target <= nums[right]:\n left = middle + 1\n else:\n right = middle - 1\n return -1","memory":"16200"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n \n low = 0 \n high = len(nums) - 1\n\n while low <= high:\n mid = (low+high) // 2\n curr = nums[mid]\n # print(\"left \" + str(left))\n # print(\"right \" + str(right))\n # print(\"mid \" + str(mid))\n if curr == target:\n return mid\n\n if nums[low] <= nums[mid]:\n if nums[low] <= target <= nums[mid]:\n high = mid - 1\n else:\n low = mid + 1\n else:\n if nums[mid] <= target <= nums[high]:\n low = mid + 1\n else:\n high = mid - 1\n\n return -1","memory":"16400"},{"code":"from typing import List\n\nclass Solution:\n def search(self, nums: List[int], target: int) -> int:\n if not nums:\n return -1\n\n left, right = 0, len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] == target:\n return mid\n\n # Check if the left side is sorted\n if nums[left] <= nums[mid]:\n if nums[left] <= target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n # Otherwise, the right side must be sorted\n else:\n if nums[mid] < target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n\n return -1\n\n# Example usage:\nsolution = Solution()\nprint(solution.search([4,5,6,7,0,1,2], 0)) # Output: 4\nprint(solution.search([4,5,6,7,0,1,2], 3)) # Output: -1\nprint(solution.search([1], 0)) # Output: -1","memory":"16500"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums) - 1\n\n while l <= r:\n mid = (l + r) // 2\n\n if nums[mid] == target:\n return mid\n if nums[l] == target:\n return l\n if nums[r] == target:\n return r\n\n if nums[mid] > nums[r]:\n # mid is in left sorted portion\n if nums[mid] < target:\n l = mid + 1\n else:\n # mid is greater than target\n if nums[l] > target:\n l = mid + 1\n else:\n r = mid - 1\n else:\n # mid is in right sorted portion\n if target < nums[mid]:\n r = mid - 1\n else:\n if target > nums[r]:\n r = mid - 1\n else:\n l = mid + 1\n\n\n return -1","memory":"16600"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n l = 0 \n r = len(nums) - 1\n\n while l <= r:\n mid = (l + r + 1) // 2\n \n if nums[mid] == target:\n return mid\n if nums[l] < nums[mid]:\n if nums[l] <= target and target < nums[mid]:\n r = mid - 1\n else:\n l = mid + 1\n else:\n if nums[mid] < target and target <= nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n \n return -1\n\n # if r < l:\n # rotated\n #if mid > r:\n #arr start in right half \n #else:\n #arr start in left half\n\n #check if target in sorted half \n\n #if not:\n #not rotated, proceed as normal\n\n # left < mid \n #if target in range\n #else\n\n # else (mid < right)","memory":"16800"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n # time O(log n)\n # space O(1)\n # binary search to find min element index\n l, r = 0, len(nums)-1\n minIndex = -1\n\n while l <= r:\n m = l + (r-l)//2\n\n if nums[m] <= nums[m-1]:\n minIndex = m\n break\n elif nums[m] > nums[-1]:\n # in left subarr\n l = m+1\n else:\n # in right subarr\n r = m-1\n \n # binary search in subarr to find target\n if nums[minIndex] <= target <= nums[-1]:\n l, r = minIndex, len(nums)-1\n else:\n l, r = 0, minIndex-1\n \n while l <= r:\n m = l + (r-l)//2\n\n if nums[m] == target:\n return m\n elif nums[m] < target:\n l = m+1\n else:\n r = m-1\n \n return -1","memory":"16800"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n n=len(nums)\n for i in range(n):\n if nums[i]==target:\n return i\n return -1","memory":"16900"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n n = len(nums)\n left, right = 0, n - 1\n while left <= right:\n mid = left + (right - left) // 2\n\n # Case 1: find target\n if nums[mid] == target:\n return mid\n\n # Case 2: subarray on mid's left is sorted\n elif nums[mid] >= nums[left]:\n if target >= nums[left] and target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n\n # Case 3: subarray on mid's right is sorted.\n else:\n if target <= nums[right] and target > nums[mid]:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n\n \n","memory":"16900"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n def bfs(arr, l, r):\n if l > r:\n return -1\n\n mid = l + (r - l) // 2\n\n if arr[mid] == target:\n return mid\n\n if arr[mid] > target:\n return bfs(arr, l, mid - 1)\n\n return bfs(arr, mid + 1, r)\n\n pivot = 0\n pivoted = False\n while pivot < len(nums) - 1:\n if nums[pivot] <= nums[pivot + 1]:\n pivot += 1\n else:\n pivoted = True\n break\n\n if not pivoted:\n return bfs(nums, 0, len(nums) - 1)\n\n if nums[0] <= target <= nums[pivot]:\n return bfs(nums[:pivot + 1], 0, pivot)\n\n pivoted_arr = nums[pivot + 1:]\n\n if bfs(pivoted_arr, 0, len(pivoted_arr) - 1) == -1:\n return - 1\n \n return bfs(pivoted_arr, 0, len(pivoted_arr) - 1) + (pivot + 1)\n ","memory":"17000"},{"code":"class Solution:\n def search(self, nums: List[int], target: int) -> int:\n def bfs(arr, l, r):\n if l > r:\n return -1\n\n mid = l + (r - l) // 2\n\n if arr[mid] == target:\n return mid\n\n if arr[mid] > target:\n return bfs(arr, l, mid - 1)\n\n return bfs(arr, mid + 1, r)\n\n pivot = 0\n pivoted = False\n while pivot < len(nums) - 1:\n if nums[pivot] <= nums[pivot + 1]:\n pivot += 1\n else:\n pivoted = True\n break\n\n if not pivoted:\n return bfs(nums, 0, len(nums) - 1)\n\n if nums[0] <= target <= nums[pivot]:\n return bfs(nums[:pivot + 1], 0, pivot)\n\n pivoted_arr = nums[pivot + 1:]\n res = bfs(pivoted_arr, 0, len(pivoted_arr) - 1)\n\n if res == -1:\n return - 1\n \n return res + (pivot + 1)\n ","memory":"17000"}],"string":"[\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n middle = (left + right) // 2\\n if nums[middle] == target:\\n return middle\\n if nums[middle] >= nums[left]:\\n if nums[left] <= target <= nums[middle]:\\n right = middle - 1\\n else:\\n left = middle + 1\\n else:\\n if nums[middle] <= target <= nums[right]:\\n left = middle + 1\\n else:\\n right = middle - 1\\n return -1\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n \\n low = 0 \\n high = len(nums) - 1\\n\\n while low <= high:\\n mid = (low+high) // 2\\n curr = nums[mid]\\n # print(\\\"left \\\" + str(left))\\n # print(\\\"right \\\" + str(right))\\n # print(\\\"mid \\\" + str(mid))\\n if curr == target:\\n return mid\\n\\n if nums[low] <= nums[mid]:\\n if nums[low] <= target <= nums[mid]:\\n high = mid - 1\\n else:\\n low = mid + 1\\n else:\\n if nums[mid] <= target <= nums[high]:\\n low = mid + 1\\n else:\\n high = mid - 1\\n\\n return -1\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n if not nums:\\n return -1\\n\\n left, right = 0, len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] == target:\\n return mid\\n\\n # Check if the left side is sorted\\n if nums[left] <= nums[mid]:\\n if nums[left] <= target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n # Otherwise, the right side must be sorted\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n return -1\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.search([4,5,6,7,0,1,2], 0)) # Output: 4\\nprint(solution.search([4,5,6,7,0,1,2], 3)) # Output: -1\\nprint(solution.search([1], 0)) # Output: -1\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums) - 1\\n\\n while l <= r:\\n mid = (l + r) // 2\\n\\n if nums[mid] == target:\\n return mid\\n if nums[l] == target:\\n return l\\n if nums[r] == target:\\n return r\\n\\n if nums[mid] > nums[r]:\\n # mid is in left sorted portion\\n if nums[mid] < target:\\n l = mid + 1\\n else:\\n # mid is greater than target\\n if nums[l] > target:\\n l = mid + 1\\n else:\\n r = mid - 1\\n else:\\n # mid is in right sorted portion\\n if target < nums[mid]:\\n r = mid - 1\\n else:\\n if target > nums[r]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n\\n\\n return -1\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n l = 0 \\n r = len(nums) - 1\\n\\n while l <= r:\\n mid = (l + r + 1) // 2\\n \\n if nums[mid] == target:\\n return mid\\n if nums[l] < nums[mid]:\\n if nums[l] <= target and target < nums[mid]:\\n r = mid - 1\\n else:\\n l = mid + 1\\n else:\\n if nums[mid] < target and target <= nums[r]:\\n l = mid + 1\\n else:\\n r = mid - 1\\n \\n return -1\\n\\n # if r < l:\\n # rotated\\n #if mid > r:\\n #arr start in right half \\n #else:\\n #arr start in left half\\n\\n #check if target in sorted half \\n\\n #if not:\\n #not rotated, proceed as normal\\n\\n # left < mid \\n #if target in range\\n #else\\n\\n # else (mid < right)\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n # time O(log n)\\n # space O(1)\\n # binary search to find min element index\\n l, r = 0, len(nums)-1\\n minIndex = -1\\n\\n while l <= r:\\n m = l + (r-l)//2\\n\\n if nums[m] <= nums[m-1]:\\n minIndex = m\\n break\\n elif nums[m] > nums[-1]:\\n # in left subarr\\n l = m+1\\n else:\\n # in right subarr\\n r = m-1\\n \\n # binary search in subarr to find target\\n if nums[minIndex] <= target <= nums[-1]:\\n l, r = minIndex, len(nums)-1\\n else:\\n l, r = 0, minIndex-1\\n \\n while l <= r:\\n m = l + (r-l)//2\\n\\n if nums[m] == target:\\n return m\\n elif nums[m] < target:\\n l = m+1\\n else:\\n r = m-1\\n \\n return -1\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n n=len(nums)\\n for i in range(n):\\n if nums[i]==target:\\n return i\\n return -1\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n n = len(nums)\\n left, right = 0, n - 1\\n while left <= right:\\n mid = left + (right - left) // 2\\n\\n # Case 1: find target\\n if nums[mid] == target:\\n return mid\\n\\n # Case 2: subarray on mid's left is sorted\\n elif nums[mid] >= nums[left]:\\n if target >= nums[left] and target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n\\n # Case 3: subarray on mid's right is sorted.\\n else:\\n if target <= nums[right] and target > nums[mid]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return -1\\n\\n \\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n def bfs(arr, l, r):\\n if l > r:\\n return -1\\n\\n mid = l + (r - l) // 2\\n\\n if arr[mid] == target:\\n return mid\\n\\n if arr[mid] > target:\\n return bfs(arr, l, mid - 1)\\n\\n return bfs(arr, mid + 1, r)\\n\\n pivot = 0\\n pivoted = False\\n while pivot < len(nums) - 1:\\n if nums[pivot] <= nums[pivot + 1]:\\n pivot += 1\\n else:\\n pivoted = True\\n break\\n\\n if not pivoted:\\n return bfs(nums, 0, len(nums) - 1)\\n\\n if nums[0] <= target <= nums[pivot]:\\n return bfs(nums[:pivot + 1], 0, pivot)\\n\\n pivoted_arr = nums[pivot + 1:]\\n\\n if bfs(pivoted_arr, 0, len(pivoted_arr) - 1) == -1:\\n return - 1\\n \\n return bfs(pivoted_arr, 0, len(pivoted_arr) - 1) + (pivot + 1)\\n \",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def search(self, nums: List[int], target: int) -> int:\\n def bfs(arr, l, r):\\n if l > r:\\n return -1\\n\\n mid = l + (r - l) // 2\\n\\n if arr[mid] == target:\\n return mid\\n\\n if arr[mid] > target:\\n return bfs(arr, l, mid - 1)\\n\\n return bfs(arr, mid + 1, r)\\n\\n pivot = 0\\n pivoted = False\\n while pivot < len(nums) - 1:\\n if nums[pivot] <= nums[pivot + 1]:\\n pivot += 1\\n else:\\n pivoted = True\\n break\\n\\n if not pivoted:\\n return bfs(nums, 0, len(nums) - 1)\\n\\n if nums[0] <= target <= nums[pivot]:\\n return bfs(nums[:pivot + 1], 0, pivot)\\n\\n pivoted_arr = nums[pivot + 1:]\\n res = bfs(pivoted_arr, 0, len(pivoted_arr) - 1)\\n\\n if res == -1:\\n return - 1\\n \\n return res + (pivot + 1)\\n \",\n \"memory\": \"17000\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":10,"string":"10"}}},{"rowIdx":70,"cells":{"question_id":{"kind":"number","value":34,"string":"34"},"name":{"kind":"string","value":"find-first-and-last-position-of-element-in-sorted-array"},"content":{"kind":"string","value":"<p>Given an array of integers <code>nums</code> sorted in non-decreasing order, find the starting and ending position of a given <code>target</code> value.</p>\n\n<p>If <code>target</code> is not found in the array, return <code>[-1, -1]</code>.</p>\n\n<p>You must write an algorithm with <code>O(log n)</code> runtime complexity.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<pre><strong>Input:</strong> nums = [5,7,7,8,8,10], target = 8\n<strong>Output:</strong> [3,4]\n</pre><p><strong class=\"example\">Example 2:</strong></p>\n<pre><strong>Input:</strong> nums = [5,7,7,8,8,10], target = 6\n<strong>Output:</strong> [-1,-1]\n</pre><p><strong class=\"example\">Example 3:</strong></p>\n<pre><strong>Input:</strong> nums = [], target = 0\n<strong>Output:</strong> [-1,-1]\n</pre>\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>0 <= nums.length <= 10<sup>5</sup></code></li>\n\t<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>\n\t<li><code>nums</code> is a non-decreasing array.</li>\n\t<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":45.186552532121524,"string":"45.186553"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","binary-search"],"string":"[\n \"array\",\n \"binary-search\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"22\", 0.0047], [\"26\", 0.0047], [\"27\", 0.0094], [\"30\", 0.0094], [\"31\", 0.0047], [\"33\", 0.0094], [\"34\", 0.0094], [\"35\", 0.0047], [\"38\", 0.0094], [\"40\", 0.0047], [\"42\", 0.0094], [\"46\", 0.0047], [\"50\", 0.0047], [\"51\", 0.0047], [\"52\", 0.0047], [\"53\", 0.0142], [\"54\", 0.0378], [\"55\", 0.0331], [\"56\", 0.0472], [\"57\", 0.0614], [\"58\", 0.222], [\"59\", 0.1228], [\"60\", 0.2079], [\"61\", 0.3212], [\"62\", 0.8078], [\"63\", 0.6047], [\"64\", 0.6991], [\"65\", 1.2849], [\"66\", 1.9415], [\"67\", 1.8423], [\"68\", 2.2958], [\"69\", 3.3067], [\"70\", 4.2846], [\"71\", 4.0767], [\"72\", 4.9317], [\"73\", 6.1316], [\"74\", 6.963], [\"75\", 6.4528], [\"76\", 6.4245], [\"77\", 6.9866], [\"78\", 6.8213], [\"79\", 6.1222], [\"80\", 5.5411], [\"81\", 4.8798], [\"82\", 4.2704], [\"83\", 3.3492], [\"84\", 2.6973]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"17100\", 0.0189], [\"17200\", 0.0047], [\"17300\", 0.0236], [\"17400\", 0.0236], [\"17500\", 0.0992], [\"17600\", 0.411], [\"17700\", 5.7206], [\"17800\", 50.0402]]}"},"rt_list":{"kind":"list like","value":[{"code":"f = open(\"user.out\", 'w')\nfor nums, tar in zip(stdin, stdin):\n if nums[1] == ']':\n print(\"[-1,-1]\", file=f)\n continue\n a = nums[1:-2].split(',')\n tar = tar.rstrip()\n t = int(tar)\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\n if i == len(a) or a[i] != tar:\n print(\"[-1,-1]\", file=f)\n else:\n j = bisect_left(a, True, key=lambda x: int(x) > t)\n print(f\"[{i},{j-1}]\", file=f)\nexit(0)","runtime":"22"},{"code":"f = open(\"user.out\", 'w')\nfor nums, tar in zip(stdin, stdin):\n if nums[1] == ']':\n print(\"[-1,-1]\", file=f)\n continue\n a = nums[1:-2].split(',')\n tar = tar.rstrip()\n t = int(tar)\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\n if i == len(a) or a[i] != tar:\n print(\"[-1,-1]\", file=f)\n else:\n j = bisect_left(a, True, key=lambda x: int(x) > t)\n print(f\"[{i},{j-1}]\", file=f)\nexit(0)","runtime":"26"},{"code":"f = open(\"user.out\", 'w')\nfor nums, tar in zip(stdin, stdin):\n if nums[1] == ']':\n print(\"[-1,-1]\", file=f)\n continue\n a = nums[1:-2].split(',')\n tar = tar.rstrip()\n t = int(tar)\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\n if i == len(a) or a[i] != tar:\n print(\"[-1,-1]\", file=f)\n else:\n j = bisect_left(a, True, key=lambda x: int(x) > t)\n print(f\"[{i},{j-1}]\", file=f)\nexit(0)","runtime":"27"},{"code":"f = open(\"user.out\", 'w')\nfor nums, tar in zip(stdin, stdin):\n if nums[1] == ']':\n print(\"[-1,-1]\", file=f)\n continue\n a = nums[1:-2].split(',')\n tar = tar.rstrip()\n t = int(tar)\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\n if i == len(a) or a[i] != tar:\n print(\"[-1,-1]\", file=f)\n else:\n j = bisect_left(a, True, key=lambda x: int(x) > t)\n print(f\"[{i},{j-1}]\", file=f)\nexit(0)","runtime":"30"},{"code":"f = open(\"user.out\", 'w')\nfor nums, tar in zip(stdin, stdin):\n if nums[1] == ']':\n print(\"[-1,-1]\", file=f)\n continue\n a = nums[1:-2].split(',')\n tar = tar.rstrip()\n t = int(tar)\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\n if i == len(a) or a[i] != tar:\n print(\"[-1,-1]\", file=f)\n else:\n j = bisect_left(a, True, key=lambda x: int(x) > t)\n print(f\"[{i},{j-1}]\", file=f)\nexit(0)","runtime":"31"},{"code":"f = open(\"user.out\", 'w')\nfor nums, tar in zip(stdin, stdin):\n if nums[1] == ']':\n print(\"[-1,-1]\", file=f)\n continue\n a = nums[1:-2].split(',')\n tar = tar.rstrip()\n t = int(tar)\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\n if i == len(a) or a[i] != tar:\n print(\"[-1,-1]\", file=f)\n else:\n j = bisect_left(a, True, key=lambda x: int(x) > t)\n print(f\"[{i},{j-1}]\", file=f)\nexit(0)","runtime":"33"},{"code":"f = open(\"user.out\", 'w')\nfor nums, tar in zip(stdin, stdin):\n if nums[1] == ']':\n print(\"[-1,-1]\", file=f)\n continue\n a = nums[1:-2].split(',')\n tar = tar.rstrip()\n t = int(tar)\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\n if i == len(a) or a[i] != tar:\n print(\"[-1,-1]\", file=f)\n else:\n j = bisect_left(a, True, key=lambda x: int(x) > t)\n print(f\"[{i},{j-1}]\", file=f)\nexit(0)","runtime":"34"},{"code":"f = open(\"user.out\", 'w')\nfor nums, tar in zip(stdin, stdin):\n if nums[1] == ']':\n print(\"[-1,-1]\", file=f)\n continue\n a = nums[1:-2].split(',')\n tar = tar.rstrip()\n t = int(tar)\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\n if i == len(a) or a[i] != tar:\n print(\"[-1,-1]\", file=f)\n else:\n j = bisect_left(a, True, key=lambda x: int(x) > t)\n print(f\"[{i},{j-1}]\", file=f)\nexit(0)","runtime":"35"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n l ,r = 0,len(nums)-1 \n while l <= r:\n mid = (l+r) //2 \n if nums[mid] < target:\n l = mid + 1 \n elif nums[mid] > target:\n r = mid - 1 \n else:\n idx = mid \n f=mid \n while idx > 0:\n if nums[mid] == nums[idx-1]: \n idx -= 1 \n else:\n break \n f = idx \n while idx < len(nums)-1: \n if nums[mid] == nums[idx+1]: \n idx += 1 \n else: \n break\n return [f,min(len(nums)-1,idx)]\n return [-1,-1]\nif __name__ == \"__main__\":\n data = map(loads,stdin)\n f = open(\"user.out\",\"w\")\n while True:\n try:\n a = next(data)\n t = next(data)\n ans = Solution().searchRange(a,t)\n print(dumps(ans).replace(', ',','),file = f )\n except StopIteration:\n exit(0)\n","runtime":"38"},{"code":"f = open(\"user.out\", 'w')\nfor nums, tar in zip(stdin, stdin):\n if nums[1] == ']':\n print(\"[-1,-1]\", file=f)\n continue\n a = nums[1:-2].split(',')\n tar = tar.rstrip()\n t = int(tar)\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\n if i == len(a) or a[i] != tar:\n print(\"[-1,-1]\", file=f)\n else:\n j = bisect_left(a, True, key=lambda x: int(x) > t)\n print(f\"[{i},{j-1}]\", file=f)\nexit(0)","runtime":"40"},{"code":"f = open(\"user.out\", 'w')\nfor nums, tar in zip(stdin, stdin):\n if nums[1] == ']':\n print(\"[-1,-1]\", file=f)\n continue\n a = nums[1:-2].split(',')\n tar = tar.rstrip()\n t = int(tar)\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\n if i == len(a) or a[i] != tar:\n print(\"[-1,-1]\", file=f)\n else:\n j = bisect_left(a, True, key=lambda x: int(x) > t)\n print(f\"[{i},{j-1}]\", file=f)\nexit(0)","runtime":"42"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if not nums:\n return [-1, -1]\n left, right = 0, len(nums)-1\n # find st\n while left < right:\n mid = (left + right) // 2\n if nums[mid] < target:\n left = mid+1\n elif nums[mid] > target:\n right = mid-1\n else:\n right = mid\n\n if left <0 or left >= len(nums) or nums[left] != target:\n st = -1\n else:\n st = left\n\n # find ed\n left, right = 0, len(nums)-1\n while left < right:\n mid = ceil((left + right) / 2 )\n if nums[mid] < target:\n left = mid+1\n elif nums[mid] > target:\n right = mid-1\n else:\n left = mid\n if left <0 or left >= len(nums) or nums[left] != target:\n ed = -1\n else:\n ed = left\n return [st, ed]","runtime":"46"},{"code":"class Solution:\n def lower_bound(self, nums: List[int], target: int) -> int:\n n = len(nums)\n low = 0\n high = n - 1\n ans = n\n\n while(low <= high):\n mid = (low + high)//2\n if nums[mid] >= target:\n ans = mid\n high = mid - 1\n else:\n low = mid + 1\n\n return ans\n\n def upper_bound(self, nums: List[int], target: int) -> int:\n n = len(nums)\n low = 0\n high = n - 1\n ans = n\n\n while(low <= high):\n mid = (low + high)//2\n if nums[mid] > target:\n ans = mid\n high = mid - 1\n else:\n low = mid + 1\n\n return ans\n\n\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n\n n = len(nums)\n\n lb = self.lower_bound(nums, target)\n ub = self.upper_bound(nums, target)\n\n if lb == n or nums[lb] != target:\n return [-1,-1]\n\n return [lb, ub-1]\n\n\n \n\n\n\n \n\n\n\n\n ","runtime":"50"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n left = bisect_left(nums, target)\n right = bisect_right(nums, target)\n if left < len(nums) and nums[left] == target:\n return [left, right - 1]\n return [-1, -1]","runtime":"51"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n\n # Validating if target is in the array.\n if not nums or target not in nums:\n return [-1, -1]\n\n lo = 0\n hi = len(nums) - 1\n\n # Searching for left index\n\n while lo < hi:\n mid = lo + (hi - lo) // 2\n if nums[mid] < target:\n lo = mid + 1\n else:\n hi = mid\n\n index_1 = lo\n\n # Now, searching for right index.\n\n hi = len(nums) - 1\n\n while lo <= hi:\n mid = lo + (hi - lo) // 2\n if nums[mid] == target:\n lo = mid + 1\n else:\n hi = mid - 1\n\n index_2 = hi\n # output_range = [index_1, index_2]\n\n return [index_1, index_2]\n","runtime":"52"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n first = 0\n last = 0\n if target in nums:\n for i in range(0,len(nums)):\n if nums[i] == target:\n first = i\n break\n for l in range(len(nums)-1,-1,-1):\n if nums[l] == target:\n last = l\n break\n return([first,last])\n else:\n return([-1,-1])","runtime":"53"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n try:\n return [nums.index(target), len(nums) - list(nums[::-1]).index(target) - 1]\n \n except:\n return [-1, -1]\n ","runtime":"54"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n i = 0\n j = len(nums) - 1\n\n firstIndex = -1\n lastIndex = -1\n\n while i <= j:\n mid = (i + j) // 2\n if nums[mid] == target:\n # if there is a preceding element that's not the target,\n # then we've found the solution for the first index.\n if mid == 0 or nums[mid - 1] != target:\n firstIndex = mid\n break\n else:\n j = mid - 1\n\n elif nums[mid] > target:\n j = mid - 1\n else:\n i = mid + 1\n\n if firstIndex == -1:\n return [-1, -1]\n\n i = 0\n j = len(nums) - 1\n while i <= j:\n mid = (i + j) // 2\n if nums[mid] == target:\n # if there is a preceding element that's not the target,\n # then we've found the solution for the first index.\n if mid == len(nums) - 1 or nums[mid + 1] != target:\n lastIndex = mid\n break\n else:\n i = mid + 1\n\n elif nums[mid] > target:\n j = mid - 1\n else:\n i = mid + 1\n\n \n return [firstIndex, lastIndex]\n ","runtime":"55"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n array=[]\n pointerA=0\n pointerB=len(nums)-1\n \n while pointerA<=pointerB:\n if nums[pointerA]==target:\n print(\"pointerA value\",pointerA)\n array.append(pointerA)\n \n \n \n if nums[pointerB]==target:\n print(\"pointerB value\", pointerB)\n array.append(pointerB)\n \n \n \n pointerA=pointerA+1\n pointerB=pointerB-1\n \n if len(array)==0:\n return [-1,-1]\n \n elif len(array)==1:\n print(array)\n array.append(array[0])\n \n else:\n array.sort()\n return [array[0],array[len(array)-1]]\n\n\n \n\n\n\n ","runtime":"56"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if len(nums) == 0:\n return [-1,-1]\n import bisect\n index = bisect.bisect_left(nums,target)\n # if target is there then we should count how much it is\n if index > len(nums) - 1 or nums[index] != target:\n return [-1,-1]\n else:\n index1= index\n while index < len(nums) - 1:\n if index+1 <= len(nums) - 1 and nums[index+1] == target:\n index += 1\n else:\n break\n return [index1,index]\n \n \n\n\n # # if target is not there, it must be index to the right and sometimes it is out of range\n # if index > len(nums):\n # return [-1,-1]\n # elif nums[index] != target:\n # return [-1,-1]\n \n # index1= index\n # while True:\n # index += 1\n # if index >= len(nums):\n # return [index1, index-1]\n # if nums[index] != target:\n # return [index1,index-1]\n","runtime":"57"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if not nums:\n return [-1,-1]\n left, right = 0, len(nums)-1\n\n \n mid = 0\n while left<=right:\n mid = left + (right-left)//2\n if nums[mid]==target:\n break\n elif nums[mid]>target:\n right = mid-1\n else:\n left = mid+1\n if left > right:\n return [-1,-1]\n l, r = mid, mid\n\n while l>=0 and nums[l]==target:\n l-=1\n while r<len(nums) and nums[r]==target:\n r+=1\n \n return [l+1, r-1]","runtime":"58"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n def search(x):\n lo, hi = 0, len(nums) \n while lo < hi:\n mid = (lo + hi) // 2\n if nums[mid] < x:\n lo = mid+1\n else:\n hi = mid \n return lo\n \n lo = search(target)\n hi = search(target+1)-1\n \n if lo <= hi:\n return [lo, hi]\n \n return [-1, -1]","runtime":"58"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n l = [-1, -1]\n low = 0\n high = len(nums) - 1\n \n # Find the first occurrence\n while low <= high:\n mid = (low + high) // 2\n if nums[mid] == target:\n l[0] = mid\n high = mid - 1 # Continue searching in the left half\n elif nums[mid] > target:\n high = mid - 1\n else:\n low = mid + 1\n \n # Reset low and high for the second search\n low = 0\n high = len(nums) - 1\n \n # Find the last occurrence\n while low <= high:\n mid = (low + high) // 2\n if nums[mid] == target:\n l[1] = mid\n low = mid + 1 # Continue searching in the right half\n elif nums[mid] > target:\n high = mid - 1\n else:\n low = mid + 1\n \n return l","runtime":"59"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n n = len(nums)\n res = []\n\n if n==0:\n return [-1,-1]\n\n #left index\n low,high = 0,n-1\n curLeft = -1\n while low <= high:\n mid = (low+high) // 2\n if target == nums[mid]:\n curLeft = mid\n high = mid-1\n elif target < nums[mid]:\n high = mid-1\n else:\n low = mid+1\n res.append(low)\n \n if curLeft == -1:\n return [-1,-1]\n\n #right index\n curRight = -1\n low,high = 0,n-1\n while low <= high:\n mid = (low+high) // 2\n if target == nums[mid]:\n curRight = mid\n low = mid+1\n elif target < nums[mid]:\n high = mid-1\n else:\n low = mid+1\n\n res.append(curRight)\n\n return res\n\n ","runtime":"59"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n def search(nums, target, side):\n low,high,index = 0,len(nums)-1,-1\n while low <= high:\n mid = (low+high) //2\n if target > nums[mid]:\n low = mid+1\n elif target< nums[mid]:\n high = mid-1\n else:\n index = mid\n if side == 0:\n high = mid-1\n else:\n low = mid+1 \n return index \n return [search(nums,target,0),search(nums,target,1)]\n","runtime":"60"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n def bisect_left():\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = left + (right - left) // 2\n if target > nums[mid]:\n left = mid + 1\n else:\n right = mid - 1\n return left \n\n def bisect_right():\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = left + (right - left) // 2\n if target >= nums[mid]:\n left = mid + 1\n else:\n right = mid - 1\n return left \n \n first_occurrence = bisect_left()\n last_occurrence = bisect_right()\n\n if first_occurrence == last_occurrence:\n return [-1, -1]\n\n return [first_occurrence, last_occurrence - 1]","runtime":"61"},{"code":"\n\nclass Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n \n def binary_search(nums, target, is_searching_left):\n left = 0\n right = len(nums) - 1\n idx = -1\n \n while left <= right:\n mid = (left + right) // 2\n \n if nums[mid] > target:\n right = mid - 1\n elif nums[mid] < target:\n left = mid + 1\n else:\n idx = mid\n if is_searching_left:\n right = mid - 1\n else:\n left = mid + 1\n \n return idx\n \n left = binary_search(nums, target, True)\n right = binary_search(nums, target, False)\n \n return [left, right]","runtime":"62"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n l, r = 0, len(nums)-1\n low, high = -1, -1\n\n while l <= r:\n mid = (l + r) // 2\n if nums[mid] == target:\n while mid-1 >= 0 and nums[mid] == nums[mid-1]:\n mid -= 1\n low = mid\n break\n elif nums[mid] < target:\n l = mid + 1\n else:\n r = mid - 1\n\n while l <= r:\n mid = (l + r) // 2\n if nums[mid] == target:\n while mid+1 < len(nums) and nums[mid] == nums[mid+1]:\n mid += 1\n high = mid\n break\n elif nums[mid] < target:\n l = mid + 1\n else:\n r = mid - 1\n\n return [low, high]\n","runtime":"62"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n # # Approach 2024.09.14\n # if not nums:\n # return [-1, -1]\n # idx = bisect_left(nums, target)\n # if idx >= len(nums) or nums[idx] != target:\n # return [-1, -1]\n # end_idx = bisect_right(nums, target, idx, len(nums)) - 1\n # return [idx, end_idx]\n\n # Approach 2024.09.14\n n = len(nums)\n def search_l():\n l = 0\n r = n - 1\n while l <= r:\n m = l + (r - l) // 2\n mv = nums[m]\n if mv == target:\n r = m - 1\n elif mv > target:\n r = m - 1\n elif mv < target:\n l = m + 1\n if l >= n or nums[l] != target:\n return -1\n return l\n \n def search_r():\n l = 0\n r = n - 1\n while l <= r:\n m = l + (r - l) // 2\n mv = nums[m]\n if mv == target:\n l = m + 1\n elif mv > target:\n r = m - 1\n elif mv < target:\n l = m + 1\n if r < 0 or nums[r] != target:\n return -1\n return r\n\n l = search_l()\n r = search_r()\n return [l, r]\n","runtime":"63"},{"code":"class Solution:\n def binary_search(self,arr, value, first=True):\n left = 0\n right = len(arr) - 1\n result = -1\n while left <= right:\n mid = left + (right - left) // 2\n middleValue = arr[mid]\n if middleValue < value:\n left = mid + 1\n elif middleValue > value:\n right = mid - 1\n else:\n result = mid\n if first:\n right = mid - 1\n else:\n left = mid + 1\n \n return result\n\n\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n return [self.binary_search(nums, target), self.binary_search(nums, target, False)]\n ","runtime":"63"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n \n if len(nums) == 1:\n if nums[0] == target:\n return [0, 0]\n else:\n return [-1, -1]\n\n res = [-1, -1]\n l = 0\n h = len(nums) - 1\n while l < h:\n mid = ( l + h) // 2\n if nums[mid] >= target:\n h = mid\n else:\n l = mid + 1\n\n if l < len(nums) and l >= 0 and nums[l] == target:\n res[0] = l\n\n l = 0\n h = len(nums) - 1\n while l < h:\n mid = ( l + h) // 2\n if nums[mid] > target:\n h = mid\n else:\n l = mid + 1\n\n if l < len(nums) and l >= 0 and nums[l] == target:\n res[1] = l\n elif (l - 1) < len(nums) and ( (l - 1) >= 0 ) and nums[l - 1] == target:\n res[1] = l - 1\n\n\n return res","runtime":"64"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n # binary search\n left, right = 0, len(nums)-1\n\n while left <= right:\n mid = (right+left)//2\n if nums[mid] >= target:\n right = mid - 1\n else:\n left = mid + 1\n if left > len(nums)-1:\n return [-1,-1]\n print(left, right)\n output = []\n if nums[left] == target:\n start = end = left\n while end < len(nums)-1 and nums[end] == nums[end+1]:\n end+=1\n \n while start > 0 and nums[start] == nums[start-1]:\n start-=1\n return [start, end]\n elif nums[right] == target:\n start = end = right\n while end < len(nums)-1 and nums[end] == nums[end+1]:\n end+=1\n \n while start > 0 and nums[start] == nums[start-1]:\n start-=1\n return [start, end]\n return [-1,-1]","runtime":"64"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n \n def leftmost(nums, target):\n l = 0\n r = len(nums) - 1\n res = -1\n while l <= r:\n m = (l + r) // 2\n if nums[m] > target:\n r = m - 1\n elif nums[m] < target:\n l = m + 1\n else:\n r = m - 1\n res = m\n return res\n \n def rightmost(nums, target):\n l = 0\n r = len(nums) - 1\n res = -1\n while l <= r:\n m = (l + r) // 2\n if nums[m] > target:\n r = m - 1\n elif nums[m] < target:\n l = m + 1\n else:\n l = m + 1\n res = m\n return res\n lp = leftmost(nums, target)\n rp = rightmost(nums, target)\n return [lp, rp]\n\n\n","runtime":"65"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n x = 0\n y = 0\n if(target in nums):\n x = nums.index(target)\n for i in range(len(nums)-1,0,-1):\n if(nums[i]==target):\n y = i\n break\n else:\n x = -1\n y = -1\n return x,y\n ","runtime":"65"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n n = len(nums)\n def lowerBound():\n left = 0\n right = n-1\n lowerBound = n\n while left <= right:\n mid = (left+right)//2\n if nums[mid] >= target:\n lowerBound = mid\n right = mid-1\n else:\n left = mid+1\n return lowerBound\n\n def upperBound():\n left = 0\n right = n-1\n lowerBound = n\n while left <= right:\n mid = (left+right)//2\n if nums[mid] > target:\n lowerBound = mid\n right = mid-1\n else:\n left = mid+1\n return lowerBound\n\n\n lowerBound = lowerBound()\n if lowerBound == n or nums[lowerBound] != target:\n return [-1,-1]\n return [lowerBound, upperBound()-1]","runtime":"66"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]: \n def helper(start, end):\n if start >= end:\n return [-1, -1]\n if start == end - 1:\n if nums[start] == target:\n return [start, start]\n else:\n return [-1, -1]\n \n mid = (end + start) // 2\n if nums[mid] > target:\n return helper(start, mid)\n if nums[mid] < target:\n return helper(mid + 1, end)\n \n # Got one\n left, right = mid, mid\n while nums[left] == target and left > 0:\n left -= 1\n\n while nums[right] == target and right < end - 1:\n right += 1\n \n return [left + (nums[left] != target), right - (nums[right] != target)]\n \n \n return helper(0, len(nums))\n ","runtime":"66"},{"code":"class Solution:\n @staticmethod\n def first_check(arr,left,right,t):\n start = -1\n while left <= right:\n mid = (left + right) // 2\n\n if arr[mid] == t:\n start = mid\n right = mid - 1\n elif arr[mid] < t:\n left = mid + 1\n else:\n right = mid - 1\n \n return start\n \n @staticmethod\n def last_check(arr,left,right,t):\n end = -1\n while left <= right:\n mid = (left + right) // 2\n\n if arr[mid] == t:\n end = mid\n left = mid + 1\n elif arr[mid] < t:\n left = mid + 1\n else:\n right = mid - 1\n \n return end\n\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n n = len(nums)\n start = end = -1\n start = Solution.first_check(nums,0,n-1,target)\n if start == -1:\n return [start,end]\n end = Solution.last_check(nums,0,n-1,target)\n\n return [start,end]","runtime":"67"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n # Handle the empty array case\n if not nums:\n return [-1, -1]\n \n start = -1\n end = -1\n \n # Traverse the array to find the start and end indices of the target\n for i in range(len(nums)):\n if nums[i] == target:\n if start == -1:\n start = i\n end = i\n \n # If start and end indices were not updated, the target was not found\n if start == -1:\n return [-1, -1]\n \n return [start, end]\n","runtime":"67"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if not nums:\n return [-1, -1]\n l = bisect_left(nums, target)\n if l == len(nums) or nums[l] != target:\n return [-1, -1]\n \n r = bisect_right(nums, target) - 1\n return [l, r]","runtime":"68"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n\n def bianry(leftLimit):\n l,r = 0,len(nums)-1\n res = -1\n while l <= r:\n mid = (r+l)//2\n if nums[mid] == target:\n res = mid\n if leftLimit:\n r = mid -1\n else:\n l = mid +1\n\n elif target < nums[mid]:\n r = mid-1\n else:\n l = mid + 1\n \n return res\n \n return[bianry(True),bianry(False)]\n\n\n ","runtime":"68"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n last_index = len(nums) - 1\n left = 0\n right = last_index\n\n if last_index == 0:\n if target == nums[left]:\n return [0, 0]\n else:\n return [-1, -1]\n\n while left <= right:\n middle = left + (right - left) // 2\n\n if target == nums[middle]:\n start, end = middle, middle\n\n while target == nums[start] and start > 0:\n start -= 1\n if target != nums[start]:\n start += 1\n\n while target == nums[end] and end < last_index:\n end += 1\n if target != nums[end]:\n end -= 1\n \n return [start, end]\n\n elif target < nums[middle]:\n right = middle -1\n else:\n left = middle + 1\n\n return [-1, -1]","runtime":"69"},{"code":"class Solution:\n def upper_bound(self, nums: List[int], target: int) -> int:\n l = 0\n r = len(nums) - 1\n ub = -1\n while l <= r:\n mid = (l + r) // 2\n\n if nums[mid] > target:\n r = mid - 1\n else:\n ub = mid\n l = mid + 1\n\n return ub\n\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if not nums:\n return [-1, -1]\n\n l = self.upper_bound(nums, target - 1)\n r = self.upper_bound(nums, target)\n\n if nums[r] != target:\n return [-1, -1]\n\n return [l + 1, r]\n ","runtime":"69"},{"code":"class Solution:\n # Matt\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n result = [-1, -1]\n\n isFirst = True\n\n def findBounds(isFirst):\n left = 0\n right = len(nums) - 1\n\n while left <= right:\n mid = left + (right-left) // 2\n if nums[mid] == target:\n if isFirst:\n if mid == left or nums[mid-1] != target:\n return mid\n else:\n right = mid - 1\n else:\n if mid == right or nums[mid+1] != target:\n return mid\n else:\n left = mid + 1\n elif nums[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n\n return -1\n\n lower_bound = findBounds(isFirst)\n if lower_bound == -1:\n return [-1,-1]\n\n isFirst = False\n upper_bound = findBounds(isFirst)\n result = [lower_bound, upper_bound]\n\n return result\n\n","runtime":"70"},{"code":"class Solution:\n def firstPos(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n res = -1\n while (left<=right):\n ind = (left+right)//2\n curr = nums[ind]\n if curr>=target:\n res = ind\n right = ind-1#moving to left in search of better min match\n else:\n left = ind+1\n if res!=-1 and target!=nums[res]:\n res = -1\n return res\n\n def lastPos(self, nums: List[int], target: int) -> int: \n left = 0\n right = len(nums) - 1\n res = -1\n while (left<=right):\n ind = (left+right)//2\n curr = nums[ind]\n if curr<=target:\n res = ind\n left = ind+1#moving to right in search of better max match\n else:\n right = ind-1\n if res!=-1 and target!=nums[res]:\n res = -1\n return res\n\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n #given nums are sorted \n #we can do binary search min number greater than or eq to target to find first pos always store last best\n #we can do binary search max number lesser than or eq to target to find last pos always store last best\n return [self.firstPos(nums,target),self.lastPos(nums,target)]\n\n\n ","runtime":"70"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n # Check if the list is empty\n if not nums:\n return [-1, -1]\n\n max_pos, min_pos = -1, -1\n \n i = 0\n # Check if the target is outside the range of the sorted array\n if target > nums[-1] or target < nums[0]:\n return [min_pos, max_pos]\n \n while i < len(nums):\n if nums[i] == target:\n if min_pos == -1:\n min_pos = i\n max_pos = i\n \n if nums[i] > target:\n break\n \n i += 1\n \n return [min_pos, max_pos]\n","runtime":"71"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n def lowerBound(nums, target):\n if len(nums) == 0:\n return -1\n left, right = 0, len(nums) - 1\n\n while left + 1 < right:\n mid = left + (right - left) // 2\n\n if nums[mid] == target:\n right = mid \n elif nums[mid] < target:\n left = mid\n else:\n right = mid\n\n # Post-processing:\n if nums[left] == target:\n return left\n if nums[right] == target:\n return right\n return -1\n\n def upperBound(nums, target):\n if len(nums) == 0:\n return -1\n left, right = 0, len(nums) - 1\n\n while left + 1 < right:\n mid = left + (right - left) // 2\n\n if nums[mid] == target:\n left = mid # Continue searching in the right half\n elif nums[mid] < target:\n left = mid\n else:\n right = mid\n\n # Post-processing:\n if nums[right] == target:\n return right\n if nums[left] == target:\n return left\n return -1\n\n first = lowerBound(nums, target)\n last = upperBound(nums, target)\n return [first, last]\n\n \n \n \n ","runtime":"71"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n \n nlen = len(nums)\n first = nlen\n last = -1\n \n start = 0\n end = nlen - 1\n\n targetFound = False\n\n while start <= end:\n mid = (start + end ) // 2\n\n if nums[mid] == target:\n targetFound = True\n first = min(first, mid)\n\n if nums[mid] >= target:\n end = mid - 1\n\n else:\n start = mid + 1\n\n start = 0\n end = nlen - 1\n\n if not targetFound:\n return [-1, -1]\n\n while start <= end:\n mid = (start + end ) // 2\n\n if nums[mid] == target:\n last = max(last, mid)\n\n if nums[mid] <= target:\n start =mid + 1\n\n else:\n end = mid - 1\n\n return [first, last]\n","runtime":"72"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n \n if not nums:\n return [-1, -1]\n ans = [-1, -1]\n left = 0\n right = len(nums) - 1\n\n while left < right:\n\n mid = left + (right - left) // 2\n\n if nums[mid] < target:\n left = mid + 1\n else:\n right = mid\n \n if left <= len(nums)-1 and nums[left] != target:\n return [-1, -1]\n\n ans[0] = left\n\n print(left)\n right = len(nums) - 1 \n\n while left <= right:\n mid = left + (right - left) // 2\n\n if nums[mid] <= target:\n left = mid + 1\n else:\n right = mid - 1\n \n \n ans[1] = max(0, left - 1)\n return ans","runtime":"72"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n # find the middle of nums = [5,7,7,8,8,10] , len(nums) = 6, (0+5)//2=2, nums[2]=7\n # initialization:leftIdx =0 , rightIndex = n-1, middle =(leftIdx+rightIdx)/2\n # if num[middle]< target, pick num[middle+1:(right+1)]\n # if num[middle]> tagert, pick num[left,middle]\n # if num[middle] = target, search left and right\n \n #initialization\n left=0\n right = len(nums)-1\n middle =(left+right)//2\n start=0\n end = 0\n length = len(nums)\n print(f\"begine left={left}, right={right}, middle={middle}\")\n if length == 0:\n return [-1, -1]\n \n while nums[middle] != target and left < right:\n if nums[middle]< target:\n left = middle+1\n else:\n right = middle-1\n middle=(left+right)//2\n print(f\"while left={left}, right={right}, middle={middle}\") \n print(f\"left={left}, right={right}, middle={middle}\") \n if nums[middle] != target:\n return [-1, -1]\n else:\n # find the start & end index\n start = middle\n end = middle\n print(f\"left={left}, right={right}, start={start}\")\n while start-1 >=0 and nums[start-1]== target:\n start-=1 \n while end+1<length and nums[end+1] == target:\n end+=1\n \n return [start, end] ","runtime":"73"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n l = bisect_left(nums, target)\n if l == len(nums) or nums[l] != target:\n return [-1, -1]\n r = bisect_right(nums, target)\n return [l, r - 1]\n","runtime":"73"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n # Check if the list is empty\n if not nums:\n return [-1, -1]\n\n max_pos, min_pos = -1, -1\n \n i = 0\n # Check if the target is outside the range of the sorted array\n if target > nums[-1] or target < nums[0]:\n return [min_pos, max_pos]\n \n while i < len(nums):\n if nums[i] > target:\n break\n \n if nums[i] == target:\n if min_pos == -1:\n min_pos = i\n max_pos = i\n \n \n i += 1\n \n return [min_pos, max_pos]\n","runtime":"74"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n\n def findLimits(mid,target):\n l = r = mid\n while r < len(nums) -1 and nums[r] == nums[r+1]:\n r+=1\n while l > 0 and nums[l-1] == nums[l]:\n l-=1\n return [l,r]\n\n\n l,r = 0,len(nums)-1\n\n while l <= r:\n mid = (r+l)//2\n if nums[mid] == target:\n return findLimits(mid,target)\n\n elif target < nums[mid]:\n r = mid-1\n else:\n l = mid + 1\n \n return [-1,-1]","runtime":"74"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if len(nums)==0:\n return [-1,-1]\n left = 0\n right = len(nums)\n while left < right:\n mid = left + (right-left)//2\n if nums[mid]>target:\n right = mid\n else:\n left = mid+1\n ans = [-1,-1]\n #print(left)\n if left<=len(nums) and nums[left-1]==target:\n ans[1] = left-1\n for i in range(left-1,-1,-1):\n if nums[i]==target:\n ans[0] = i\n return ans\n","runtime":"75"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if len(nums) == 0:\n return [-1, -1]\n\n def get_start(nums):\n l = 0\n r = len(nums) - 1\n\n while l <= r:\n m = (l+r)//2\n\n if nums[m] == target:\n if (m == 0 or nums[m-1] != target):\n return m\n r = m-1\n elif target > nums[m]:\n l = m + 1\n else:\n r = m - 1\n\n return -1\n\n def get_end(nums):\n l = 0\n r = len(nums) - 1\n\n while l <= r:\n m = (l+r)//2\n\n if nums[m] == target:\n if (m == len(nums)-1 or nums[m+1] != target):\n return m\n l = m+1\n elif target > nums[m]:\n l = m + 1\n else:\n r = m - 1\n\n return -1\n\n\n start = get_start(nums)\n end = get_end(nums)\n return [start, end]\n\n \n ","runtime":"76"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n return self.v2(nums, target)\n # binary search\n # time: O(logn)\n # space: O(1)\n def v1(self, nums, target):\n n = len(nums)\n lo = 0\n hi = n - 1 \n start = -1 \n end = -1\n while lo <= hi:\n mid = (lo + hi) // 2\n if nums[mid] == target: \n start = mid\n end = mid\n # Searching For Range,, Individually for Start & End\n while start > 0 and nums[start - 1] == target:\n start = start - 1\n while end < n - 1 and nums[end + 1] == target:\n end = end + 1\n break \n elif nums[mid] > target:\n hi = mid - 1\n elif nums[mid] < target: \n lo = mid + 1\n return [start, end] \n # binary search 2 time\n # time: O(logn)\n # space: O(1)\n def v2(self, nums, target):\n def helper(nums, target, left_position): # left_position is boolean, if true find the first target in left\n n = len(nums)\n l = 0\n r = n - 1\n idx = -1\n while l <= r:\n m = (l + r) // 2\n if nums[m] > target:\n r = m - 1\n elif nums[m] < target:\n l = m + 1\n else: # nums[m] == target\n idx = m\n if left_position:\n r = m - 1\n else:\n l = m + 1\n return idx\n start = helper(nums, target, True)\n end = helper(nums, target, False)\n return [start, end]\n\n\n\n # 5 7 7 8 8 10\n \n\n \n \n\n\n","runtime":"76"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if not nums:\n return [-1, -1]\n\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n leftIndex = left\n\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] <= target:\n left = mid + 1\n else:\n right = mid - 1\n rightIndex = right\n\n if leftIndex >= len(nums) or nums[leftIndex] != target or rightIndex < 0 or nums[rightIndex] != target:\n return [-1, -1]\n\n return [leftIndex, rightIndex]","runtime":"77"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n\n def findLimits(mid,target):\n l = r = mid\n while r < len(nums) -1 and nums[r] == nums[r+1]:\n r+=1\n while l > 0 and nums[l-1] == nums[l]:\n l-=1\n return [l,r]\n\n\n l,r = 0,len(nums)-1\n\n while l <= r:\n mid = (r+l)//2\n if nums[mid] == target:\n return findLimits(mid,target)\n\n elif target < nums[mid]:\n r = mid-1\n else:\n l = mid + 1\n \n return [-1,-1]","runtime":"77"},{"code":"import bisect\n\n\nclass Solution:\n def searchRange(self, nums: list[int], target: int) -> list[int]:\n n = len(nums)\n if n == 0:\n return [-1, -1]\n\n left_idx = bisect.bisect_left(nums, target)\n right_idx = bisect.bisect_left(nums, target + 1) - 1\n\n if left_idx < n and nums[left_idx] == target:\n return [left_idx, right_idx]\n\n return [-1, -1]\n\n\nsol = Solution()\nprint(sol.searchRange(nums=[5, 7, 7, 8, 8, 10], target=8))\n","runtime":"78"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if len(nums) == 0:\n return [-1, -1]\n elif len(nums) == 1:\n if nums[0] == target:\n return [0,0]\n return [-1, -1]\n\n def get_start(nums):\n l = 0\n r = len(nums) - 1\n\n while l <= r:\n m = (l+r)//2\n\n if nums[m] == target:\n if (m == 0 or nums[m-1] != target):\n return m\n r = m-1\n elif target > nums[m]:\n l = m + 1\n else:\n r = m - 1\n\n return -1\n\n def get_end(nums):\n l = 0\n r = len(nums) - 1\n\n while l <= r:\n m = (l+r)//2\n\n if nums[m] == target:\n if (m == len(nums)-1 or nums[m+1] != target):\n return m\n l = m+1\n elif target > nums[m]:\n l = m + 1\n else:\n r = m - 1\n\n return -1\n\n\n start = get_start(nums)\n end = get_end(nums)\n return [start, end]\n\n \n ","runtime":"78"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if len(nums) < 1:\n return [-1,-1]\n l, r = 0, len(nums)-1\n s,e=-1,-1\n while l <= r:\n mid = (l+r)//2\n if nums[mid] == target:\n # mid find\n l_right = mid\n while l <= l_right:\n if nums[l] == target:\n s = l\n break\n else:\n l_mid = (l + l_right)//2\n if nums[l_mid] == target:\n l_right = l_mid\n else:\n l=l_mid + 1\n r_left = mid\n while r_left <= r:\n if nums[r] == target:\n e = r\n break\n else:\n r_mid = (r + r_left)//2\n if nums[r_mid] == target:\n if nums[r_mid + 1] > target:\n e = r_mid\n break\n else:\n r_left = r_mid + 1\n else:\n r=r_mid - 1\n return [s,e]\n if target > nums[mid]:\n l = mid+1\n else:\n r = mid -1\n return [-1,-1]\n \n ","runtime":"79"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n '''\n This has O(n log n) runtime complexity.\n The solution with O(2 log n) == O(k log n) == O(log n) is to use binary search\n two times for first position and for end position of target in the list.\n '''\n last_index = len(nums) - 1\n if last_index == 0:\n if target == nums[last_index]:\n return [0, 0]\n else:\n return [-1, -1]\n\n left = 0\n right = last_index\n while left <= right:\n middle = left + (right - left) // 2\n\n if target == nums[middle]:\n start, end = middle, middle\n\n while target == nums[start] and start > 0:\n start -= 1\n if target != nums[start]:\n start += 1\n\n while target == nums[end] and end < last_index:\n end += 1\n if target != nums[end]:\n end -= 1\n \n return [start, end]\n\n elif target < nums[middle]:\n right = middle -1\n else:\n left = middle + 1\n\n return [-1, -1]","runtime":"79"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n # if len(nums)==0:\n # return [-1,-1]\n left = 0\n right = len(nums)\n while left < right:\n mid = left + (right-left)//2\n if nums[mid]>target:\n right = mid\n else:\n left = mid+1\n ans = [-1,-1]\n #print(left)\n if left<=len(nums) and len(nums)>0 and nums[left-1]==target:\n ans[1] = left-1\n for i in range(left-1,-1,-1):\n if nums[i]==target:\n ans[0] = i\n return ans\n","runtime":"80"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n # Check if the list is empty\n if not nums:\n return [-1, -1]\n\n max_pos, min_pos = -1, -1\n \n i = 0\n # Check if the target is outside the range of the sorted array\n if target > nums[-1] or target < nums[0]:\n return [min_pos, max_pos]\n \n while i < len(nums):\n if nums[i] == target:\n if min_pos == -1:\n min_pos = i\n max_pos = i\n \n if nums[i] > target:\n break\n \n i += 1\n \n return [min_pos, max_pos]\n","runtime":"80"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n \n result = []\n l, r = 0, len(nums)\n while l < r:\n m = (l+r) // 2\n if target <= nums[m]:\n r = m\n else:\n l = m+1\n \n if r >= len(nums) or nums[r] != target:\n return [-1, -1]\n\n result.append(r)\n l, r = 0, len(nums)\n while l < r:\n m = (l+r) // 2\n if target < nums[m]:\n r = m\n else:\n l = m+1\n result.append(l-1)\n\n return result","runtime":"81"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n\n def findLimits(mid,target):\n l = r = mid\n while r < len(nums) -1 and nums[r] == nums[r+1]:\n r+=1\n while l > 0 and nums[l-1] == nums[l]:\n l-=1\n return [l,r]\n\n\n l,r = 0,len(nums)-1\n\n while l <= r:\n mid = (r+l)//2\n if nums[mid] == target:\n return findLimits(mid,target)\n\n elif target < nums[mid]:\n r = mid-1\n else:\n l = mid + 1\n \n return [-1,-1]","runtime":"81"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n\n def bianry(leftLimit):\n l,r = 0,len(nums)-1\n res = -1\n while l <= r:\n mid = (r+l)//2\n if nums[mid] == target:\n res = mid\n if leftLimit:\n r = mid -1\n else:\n l = mid +1\n\n elif target < nums[mid]:\n r = mid-1\n else:\n l = mid + 1\n \n return res\n \n return[bianry(True),bianry(False)]\n\n\n ","runtime":"82"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n def fir_occ(n):\n l, r = 0, n-1\n f=-1\n while l<=r:\n mid = l+(r-l)//2\n if nums[mid]==target:\n f = mid\n r=mid-1\n elif nums[mid]>target:\n r=mid-1\n else:\n l=mid+1\n return f\n\n def last_occ(n):\n l, r = 0, n-1\n la = -1\n while l<=r:\n mid = l+(r-l)//2\n if nums[mid]==target:\n la = mid\n l=mid+1\n elif nums[mid]>target:\n r=mid-1\n else:\n l=mid+1\n return la\n n=len(nums)\n fir = fir_occ(n)\n las = last_occ(n)\n return [fir, las]\n \n\n ","runtime":"82"},{"code":"from typing import List\n\nclass Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n def findFirst(nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] < target:\n left = mid + 1\n elif nums[mid] > target:\n right = mid - 1\n else:\n if mid == 0 or nums[mid - 1] != target:\n return mid\n right = mid - 1\n return -1\n\n def findLast(nums: List[int], target: int) -> int:\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] < target:\n left = mid + 1\n elif nums[mid] > target:\n right = mid - 1\n else:\n if mid == len(nums) - 1 or nums[mid + 1] != target:\n return mid\n left = mid + 1\n return -1\n\n start = findFirst(nums, target)\n if start == -1:\n return [-1, -1]\n end = findLast(nums, target)\n return [start, end]\n","runtime":"83"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n first,last=-1,-1\n for i in range(len(nums)):\n if nums[i]==target:\n if first==-1:\n first=i\n last=i\n return[first,last]\n","runtime":"83"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n starting = bisect.bisect_left(nums, target)\n ending = bisect.bisect_right(nums, target) - 1\n\n if starting < len(nums) and nums[starting] == target:\n return [starting, ending]\n else:\n return [-1, -1]","runtime":"84"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n def lowerBound(nums, target):\n if len(nums) == 0:\n return -1\n left, right = 0, len(nums) - 1\n\n while left < right:\n mid = left + (right - left) // 2\n\n if nums[mid] >= target:\n right = mid\n else:\n left = mid + 1\n\n if nums[right] == target:\n return right\n return -1\n\n def upperBound(nums, target):\n if len(nums) == 0:\n return -1\n left, right = 0, len(nums) - 1\n\n while left < right:\n mid = left + (right - left + 1) // 2\n\n if nums[mid] <= target:\n left = mid\n else:\n right = mid - 1\n\n if nums[left] == target:\n return left\n return -1\n\n first = lowerBound(nums, target)\n last = upperBound(nums, target)\n return [first, last]\n","runtime":"84"}],"string":"[\n {\n \"code\": \"f = open(\\\"user.out\\\", 'w')\\nfor nums, tar in zip(stdin, stdin):\\n if nums[1] == ']':\\n print(\\\"[-1,-1]\\\", file=f)\\n continue\\n a = nums[1:-2].split(',')\\n tar = tar.rstrip()\\n t = int(tar)\\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\\n if i == len(a) or a[i] != tar:\\n print(\\\"[-1,-1]\\\", file=f)\\n else:\\n j = bisect_left(a, True, key=lambda x: int(x) > t)\\n print(f\\\"[{i},{j-1}]\\\", file=f)\\nexit(0)\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", 'w')\\nfor nums, tar in zip(stdin, stdin):\\n if nums[1] == ']':\\n print(\\\"[-1,-1]\\\", file=f)\\n continue\\n a = nums[1:-2].split(',')\\n tar = tar.rstrip()\\n t = int(tar)\\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\\n if i == len(a) or a[i] != tar:\\n print(\\\"[-1,-1]\\\", file=f)\\n else:\\n j = bisect_left(a, True, key=lambda x: int(x) > t)\\n print(f\\\"[{i},{j-1}]\\\", file=f)\\nexit(0)\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", 'w')\\nfor nums, tar in zip(stdin, stdin):\\n if nums[1] == ']':\\n print(\\\"[-1,-1]\\\", file=f)\\n continue\\n a = nums[1:-2].split(',')\\n tar = tar.rstrip()\\n t = int(tar)\\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\\n if i == len(a) or a[i] != tar:\\n print(\\\"[-1,-1]\\\", file=f)\\n else:\\n j = bisect_left(a, True, key=lambda x: int(x) > t)\\n print(f\\\"[{i},{j-1}]\\\", file=f)\\nexit(0)\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", 'w')\\nfor nums, tar in zip(stdin, stdin):\\n if nums[1] == ']':\\n print(\\\"[-1,-1]\\\", file=f)\\n continue\\n a = nums[1:-2].split(',')\\n tar = tar.rstrip()\\n t = int(tar)\\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\\n if i == len(a) or a[i] != tar:\\n print(\\\"[-1,-1]\\\", file=f)\\n else:\\n j = bisect_left(a, True, key=lambda x: int(x) > t)\\n print(f\\\"[{i},{j-1}]\\\", file=f)\\nexit(0)\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", 'w')\\nfor nums, tar in zip(stdin, stdin):\\n if nums[1] == ']':\\n print(\\\"[-1,-1]\\\", file=f)\\n continue\\n a = nums[1:-2].split(',')\\n tar = tar.rstrip()\\n t = int(tar)\\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\\n if i == len(a) or a[i] != tar:\\n print(\\\"[-1,-1]\\\", file=f)\\n else:\\n j = bisect_left(a, True, key=lambda x: int(x) > t)\\n print(f\\\"[{i},{j-1}]\\\", file=f)\\nexit(0)\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", 'w')\\nfor nums, tar in zip(stdin, stdin):\\n if nums[1] == ']':\\n print(\\\"[-1,-1]\\\", file=f)\\n continue\\n a = nums[1:-2].split(',')\\n tar = tar.rstrip()\\n t = int(tar)\\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\\n if i == len(a) or a[i] != tar:\\n print(\\\"[-1,-1]\\\", file=f)\\n else:\\n j = bisect_left(a, True, key=lambda x: int(x) > t)\\n print(f\\\"[{i},{j-1}]\\\", file=f)\\nexit(0)\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", 'w')\\nfor nums, tar in zip(stdin, stdin):\\n if nums[1] == ']':\\n print(\\\"[-1,-1]\\\", file=f)\\n continue\\n a = nums[1:-2].split(',')\\n tar = tar.rstrip()\\n t = int(tar)\\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\\n if i == len(a) or a[i] != tar:\\n print(\\\"[-1,-1]\\\", file=f)\\n else:\\n j = bisect_left(a, True, key=lambda x: int(x) > t)\\n print(f\\\"[{i},{j-1}]\\\", file=f)\\nexit(0)\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", 'w')\\nfor nums, tar in zip(stdin, stdin):\\n if nums[1] == ']':\\n print(\\\"[-1,-1]\\\", file=f)\\n continue\\n a = nums[1:-2].split(',')\\n tar = tar.rstrip()\\n t = int(tar)\\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\\n if i == len(a) or a[i] != tar:\\n print(\\\"[-1,-1]\\\", file=f)\\n else:\\n j = bisect_left(a, True, key=lambda x: int(x) > t)\\n print(f\\\"[{i},{j-1}]\\\", file=f)\\nexit(0)\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n l ,r = 0,len(nums)-1 \\n while l <= r:\\n mid = (l+r) //2 \\n if nums[mid] < target:\\n l = mid + 1 \\n elif nums[mid] > target:\\n r = mid - 1 \\n else:\\n idx = mid \\n f=mid \\n while idx > 0:\\n if nums[mid] == nums[idx-1]: \\n idx -= 1 \\n else:\\n break \\n f = idx \\n while idx < len(nums)-1: \\n if nums[mid] == nums[idx+1]: \\n idx += 1 \\n else: \\n break\\n return [f,min(len(nums)-1,idx)]\\n return [-1,-1]\\nif __name__ == \\\"__main__\\\":\\n data = map(loads,stdin)\\n f = open(\\\"user.out\\\",\\\"w\\\")\\n while True:\\n try:\\n a = next(data)\\n t = next(data)\\n ans = Solution().searchRange(a,t)\\n print(dumps(ans).replace(', ',','),file = f )\\n except StopIteration:\\n exit(0)\\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", 'w')\\nfor nums, tar in zip(stdin, stdin):\\n if nums[1] == ']':\\n print(\\\"[-1,-1]\\\", file=f)\\n continue\\n a = nums[1:-2].split(',')\\n tar = tar.rstrip()\\n t = int(tar)\\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\\n if i == len(a) or a[i] != tar:\\n print(\\\"[-1,-1]\\\", file=f)\\n else:\\n j = bisect_left(a, True, key=lambda x: int(x) > t)\\n print(f\\\"[{i},{j-1}]\\\", file=f)\\nexit(0)\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"f = open(\\\"user.out\\\", 'w')\\nfor nums, tar in zip(stdin, stdin):\\n if nums[1] == ']':\\n print(\\\"[-1,-1]\\\", file=f)\\n continue\\n a = nums[1:-2].split(',')\\n tar = tar.rstrip()\\n t = int(tar)\\n i = bisect_left(a, True, key=lambda x: int(x) >= t)\\n if i == len(a) or a[i] != tar:\\n print(\\\"[-1,-1]\\\", file=f)\\n else:\\n j = bisect_left(a, True, key=lambda x: int(x) > t)\\n print(f\\\"[{i},{j-1}]\\\", file=f)\\nexit(0)\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if not nums:\\n return [-1, -1]\\n left, right = 0, len(nums)-1\\n # find st\\n while left < right:\\n mid = (left + right) // 2\\n if nums[mid] < target:\\n left = mid+1\\n elif nums[mid] > target:\\n right = mid-1\\n else:\\n right = mid\\n\\n if left <0 or left >= len(nums) or nums[left] != target:\\n st = -1\\n else:\\n st = left\\n\\n # find ed\\n left, right = 0, len(nums)-1\\n while left < right:\\n mid = ceil((left + right) / 2 )\\n if nums[mid] < target:\\n left = mid+1\\n elif nums[mid] > target:\\n right = mid-1\\n else:\\n left = mid\\n if left <0 or left >= len(nums) or nums[left] != target:\\n ed = -1\\n else:\\n ed = left\\n return [st, ed]\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def lower_bound(self, nums: List[int], target: int) -> int:\\n n = len(nums)\\n low = 0\\n high = n - 1\\n ans = n\\n\\n while(low <= high):\\n mid = (low + high)//2\\n if nums[mid] >= target:\\n ans = mid\\n high = mid - 1\\n else:\\n low = mid + 1\\n\\n return ans\\n\\n def upper_bound(self, nums: List[int], target: int) -> int:\\n n = len(nums)\\n low = 0\\n high = n - 1\\n ans = n\\n\\n while(low <= high):\\n mid = (low + high)//2\\n if nums[mid] > target:\\n ans = mid\\n high = mid - 1\\n else:\\n low = mid + 1\\n\\n return ans\\n\\n\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n\\n n = len(nums)\\n\\n lb = self.lower_bound(nums, target)\\n ub = self.upper_bound(nums, target)\\n\\n if lb == n or nums[lb] != target:\\n return [-1,-1]\\n\\n return [lb, ub-1]\\n\\n\\n \\n\\n\\n\\n \\n\\n\\n\\n\\n \",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n left = bisect_left(nums, target)\\n right = bisect_right(nums, target)\\n if left < len(nums) and nums[left] == target:\\n return [left, right - 1]\\n return [-1, -1]\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n\\n # Validating if target is in the array.\\n if not nums or target not in nums:\\n return [-1, -1]\\n\\n lo = 0\\n hi = len(nums) - 1\\n\\n # Searching for left index\\n\\n while lo < hi:\\n mid = lo + (hi - lo) // 2\\n if nums[mid] < target:\\n lo = mid + 1\\n else:\\n hi = mid\\n\\n index_1 = lo\\n\\n # Now, searching for right index.\\n\\n hi = len(nums) - 1\\n\\n while lo <= hi:\\n mid = lo + (hi - lo) // 2\\n if nums[mid] == target:\\n lo = mid + 1\\n else:\\n hi = mid - 1\\n\\n index_2 = hi\\n # output_range = [index_1, index_2]\\n\\n return [index_1, index_2]\\n\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n first = 0\\n last = 0\\n if target in nums:\\n for i in range(0,len(nums)):\\n if nums[i] == target:\\n first = i\\n break\\n for l in range(len(nums)-1,-1,-1):\\n if nums[l] == target:\\n last = l\\n break\\n return([first,last])\\n else:\\n return([-1,-1])\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n try:\\n return [nums.index(target), len(nums) - list(nums[::-1]).index(target) - 1]\\n \\n except:\\n return [-1, -1]\\n \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n i = 0\\n j = len(nums) - 1\\n\\n firstIndex = -1\\n lastIndex = -1\\n\\n while i <= j:\\n mid = (i + j) // 2\\n if nums[mid] == target:\\n # if there is a preceding element that's not the target,\\n # then we've found the solution for the first index.\\n if mid == 0 or nums[mid - 1] != target:\\n firstIndex = mid\\n break\\n else:\\n j = mid - 1\\n\\n elif nums[mid] > target:\\n j = mid - 1\\n else:\\n i = mid + 1\\n\\n if firstIndex == -1:\\n return [-1, -1]\\n\\n i = 0\\n j = len(nums) - 1\\n while i <= j:\\n mid = (i + j) // 2\\n if nums[mid] == target:\\n # if there is a preceding element that's not the target,\\n # then we've found the solution for the first index.\\n if mid == len(nums) - 1 or nums[mid + 1] != target:\\n lastIndex = mid\\n break\\n else:\\n i = mid + 1\\n\\n elif nums[mid] > target:\\n j = mid - 1\\n else:\\n i = mid + 1\\n\\n \\n return [firstIndex, lastIndex]\\n \",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n array=[]\\n pointerA=0\\n pointerB=len(nums)-1\\n \\n while pointerA<=pointerB:\\n if nums[pointerA]==target:\\n print(\\\"pointerA value\\\",pointerA)\\n array.append(pointerA)\\n \\n \\n \\n if nums[pointerB]==target:\\n print(\\\"pointerB value\\\", pointerB)\\n array.append(pointerB)\\n \\n \\n \\n pointerA=pointerA+1\\n pointerB=pointerB-1\\n \\n if len(array)==0:\\n return [-1,-1]\\n \\n elif len(array)==1:\\n print(array)\\n array.append(array[0])\\n \\n else:\\n array.sort()\\n return [array[0],array[len(array)-1]]\\n\\n\\n \\n\\n\\n\\n \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if len(nums) == 0:\\n return [-1,-1]\\n import bisect\\n index = bisect.bisect_left(nums,target)\\n # if target is there then we should count how much it is\\n if index > len(nums) - 1 or nums[index] != target:\\n return [-1,-1]\\n else:\\n index1= index\\n while index < len(nums) - 1:\\n if index+1 <= len(nums) - 1 and nums[index+1] == target:\\n index += 1\\n else:\\n break\\n return [index1,index]\\n \\n \\n\\n\\n # # if target is not there, it must be index to the right and sometimes it is out of range\\n # if index > len(nums):\\n # return [-1,-1]\\n # elif nums[index] != target:\\n # return [-1,-1]\\n \\n # index1= index\\n # while True:\\n # index += 1\\n # if index >= len(nums):\\n # return [index1, index-1]\\n # if nums[index] != target:\\n # return [index1,index-1]\\n\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if not nums:\\n return [-1,-1]\\n left, right = 0, len(nums)-1\\n\\n \\n mid = 0\\n while left<=right:\\n mid = left + (right-left)//2\\n if nums[mid]==target:\\n break\\n elif nums[mid]>target:\\n right = mid-1\\n else:\\n left = mid+1\\n if left > right:\\n return [-1,-1]\\n l, r = mid, mid\\n\\n while l>=0 and nums[l]==target:\\n l-=1\\n while r<len(nums) and nums[r]==target:\\n r+=1\\n \\n return [l+1, r-1]\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n def search(x):\\n lo, hi = 0, len(nums) \\n while lo < hi:\\n mid = (lo + hi) // 2\\n if nums[mid] < x:\\n lo = mid+1\\n else:\\n hi = mid \\n return lo\\n \\n lo = search(target)\\n hi = search(target+1)-1\\n \\n if lo <= hi:\\n return [lo, hi]\\n \\n return [-1, -1]\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n l = [-1, -1]\\n low = 0\\n high = len(nums) - 1\\n \\n # Find the first occurrence\\n while low <= high:\\n mid = (low + high) // 2\\n if nums[mid] == target:\\n l[0] = mid\\n high = mid - 1 # Continue searching in the left half\\n elif nums[mid] > target:\\n high = mid - 1\\n else:\\n low = mid + 1\\n \\n # Reset low and high for the second search\\n low = 0\\n high = len(nums) - 1\\n \\n # Find the last occurrence\\n while low <= high:\\n mid = (low + high) // 2\\n if nums[mid] == target:\\n l[1] = mid\\n low = mid + 1 # Continue searching in the right half\\n elif nums[mid] > target:\\n high = mid - 1\\n else:\\n low = mid + 1\\n \\n return l\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n n = len(nums)\\n res = []\\n\\n if n==0:\\n return [-1,-1]\\n\\n #left index\\n low,high = 0,n-1\\n curLeft = -1\\n while low <= high:\\n mid = (low+high) // 2\\n if target == nums[mid]:\\n curLeft = mid\\n high = mid-1\\n elif target < nums[mid]:\\n high = mid-1\\n else:\\n low = mid+1\\n res.append(low)\\n \\n if curLeft == -1:\\n return [-1,-1]\\n\\n #right index\\n curRight = -1\\n low,high = 0,n-1\\n while low <= high:\\n mid = (low+high) // 2\\n if target == nums[mid]:\\n curRight = mid\\n low = mid+1\\n elif target < nums[mid]:\\n high = mid-1\\n else:\\n low = mid+1\\n\\n res.append(curRight)\\n\\n return res\\n\\n \",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n def search(nums, target, side):\\n low,high,index = 0,len(nums)-1,-1\\n while low <= high:\\n mid = (low+high) //2\\n if target > nums[mid]:\\n low = mid+1\\n elif target< nums[mid]:\\n high = mid-1\\n else:\\n index = mid\\n if side == 0:\\n high = mid-1\\n else:\\n low = mid+1 \\n return index \\n return [search(nums,target,0),search(nums,target,1)]\\n\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n def bisect_left():\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = left + (right - left) // 2\\n if target > nums[mid]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return left \\n\\n def bisect_right():\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = left + (right - left) // 2\\n if target >= nums[mid]:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return left \\n \\n first_occurrence = bisect_left()\\n last_occurrence = bisect_right()\\n\\n if first_occurrence == last_occurrence:\\n return [-1, -1]\\n\\n return [first_occurrence, last_occurrence - 1]\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n \\n def binary_search(nums, target, is_searching_left):\\n left = 0\\n right = len(nums) - 1\\n idx = -1\\n \\n while left <= right:\\n mid = (left + right) // 2\\n \\n if nums[mid] > target:\\n right = mid - 1\\n elif nums[mid] < target:\\n left = mid + 1\\n else:\\n idx = mid\\n if is_searching_left:\\n right = mid - 1\\n else:\\n left = mid + 1\\n \\n return idx\\n \\n left = binary_search(nums, target, True)\\n right = binary_search(nums, target, False)\\n \\n return [left, right]\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n l, r = 0, len(nums)-1\\n low, high = -1, -1\\n\\n while l <= r:\\n mid = (l + r) // 2\\n if nums[mid] == target:\\n while mid-1 >= 0 and nums[mid] == nums[mid-1]:\\n mid -= 1\\n low = mid\\n break\\n elif nums[mid] < target:\\n l = mid + 1\\n else:\\n r = mid - 1\\n\\n while l <= r:\\n mid = (l + r) // 2\\n if nums[mid] == target:\\n while mid+1 < len(nums) and nums[mid] == nums[mid+1]:\\n mid += 1\\n high = mid\\n break\\n elif nums[mid] < target:\\n l = mid + 1\\n else:\\n r = mid - 1\\n\\n return [low, high]\\n\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n # # Approach 2024.09.14\\n # if not nums:\\n # return [-1, -1]\\n # idx = bisect_left(nums, target)\\n # if idx >= len(nums) or nums[idx] != target:\\n # return [-1, -1]\\n # end_idx = bisect_right(nums, target, idx, len(nums)) - 1\\n # return [idx, end_idx]\\n\\n # Approach 2024.09.14\\n n = len(nums)\\n def search_l():\\n l = 0\\n r = n - 1\\n while l <= r:\\n m = l + (r - l) // 2\\n mv = nums[m]\\n if mv == target:\\n r = m - 1\\n elif mv > target:\\n r = m - 1\\n elif mv < target:\\n l = m + 1\\n if l >= n or nums[l] != target:\\n return -1\\n return l\\n \\n def search_r():\\n l = 0\\n r = n - 1\\n while l <= r:\\n m = l + (r - l) // 2\\n mv = nums[m]\\n if mv == target:\\n l = m + 1\\n elif mv > target:\\n r = m - 1\\n elif mv < target:\\n l = m + 1\\n if r < 0 or nums[r] != target:\\n return -1\\n return r\\n\\n l = search_l()\\n r = search_r()\\n return [l, r]\\n\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def binary_search(self,arr, value, first=True):\\n left = 0\\n right = len(arr) - 1\\n result = -1\\n while left <= right:\\n mid = left + (right - left) // 2\\n middleValue = arr[mid]\\n if middleValue < value:\\n left = mid + 1\\n elif middleValue > value:\\n right = mid - 1\\n else:\\n result = mid\\n if first:\\n right = mid - 1\\n else:\\n left = mid + 1\\n \\n return result\\n\\n\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n return [self.binary_search(nums, target), self.binary_search(nums, target, False)]\\n \",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n \\n if len(nums) == 1:\\n if nums[0] == target:\\n return [0, 0]\\n else:\\n return [-1, -1]\\n\\n res = [-1, -1]\\n l = 0\\n h = len(nums) - 1\\n while l < h:\\n mid = ( l + h) // 2\\n if nums[mid] >= target:\\n h = mid\\n else:\\n l = mid + 1\\n\\n if l < len(nums) and l >= 0 and nums[l] == target:\\n res[0] = l\\n\\n l = 0\\n h = len(nums) - 1\\n while l < h:\\n mid = ( l + h) // 2\\n if nums[mid] > target:\\n h = mid\\n else:\\n l = mid + 1\\n\\n if l < len(nums) and l >= 0 and nums[l] == target:\\n res[1] = l\\n elif (l - 1) < len(nums) and ( (l - 1) >= 0 ) and nums[l - 1] == target:\\n res[1] = l - 1\\n\\n\\n return res\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n # binary search\\n left, right = 0, len(nums)-1\\n\\n while left <= right:\\n mid = (right+left)//2\\n if nums[mid] >= target:\\n right = mid - 1\\n else:\\n left = mid + 1\\n if left > len(nums)-1:\\n return [-1,-1]\\n print(left, right)\\n output = []\\n if nums[left] == target:\\n start = end = left\\n while end < len(nums)-1 and nums[end] == nums[end+1]:\\n end+=1\\n \\n while start > 0 and nums[start] == nums[start-1]:\\n start-=1\\n return [start, end]\\n elif nums[right] == target:\\n start = end = right\\n while end < len(nums)-1 and nums[end] == nums[end+1]:\\n end+=1\\n \\n while start > 0 and nums[start] == nums[start-1]:\\n start-=1\\n return [start, end]\\n return [-1,-1]\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n \\n def leftmost(nums, target):\\n l = 0\\n r = len(nums) - 1\\n res = -1\\n while l <= r:\\n m = (l + r) // 2\\n if nums[m] > target:\\n r = m - 1\\n elif nums[m] < target:\\n l = m + 1\\n else:\\n r = m - 1\\n res = m\\n return res\\n \\n def rightmost(nums, target):\\n l = 0\\n r = len(nums) - 1\\n res = -1\\n while l <= r:\\n m = (l + r) // 2\\n if nums[m] > target:\\n r = m - 1\\n elif nums[m] < target:\\n l = m + 1\\n else:\\n l = m + 1\\n res = m\\n return res\\n lp = leftmost(nums, target)\\n rp = rightmost(nums, target)\\n return [lp, rp]\\n\\n\\n\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n x = 0\\n y = 0\\n if(target in nums):\\n x = nums.index(target)\\n for i in range(len(nums)-1,0,-1):\\n if(nums[i]==target):\\n y = i\\n break\\n else:\\n x = -1\\n y = -1\\n return x,y\\n \",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n n = len(nums)\\n def lowerBound():\\n left = 0\\n right = n-1\\n lowerBound = n\\n while left <= right:\\n mid = (left+right)//2\\n if nums[mid] >= target:\\n lowerBound = mid\\n right = mid-1\\n else:\\n left = mid+1\\n return lowerBound\\n\\n def upperBound():\\n left = 0\\n right = n-1\\n lowerBound = n\\n while left <= right:\\n mid = (left+right)//2\\n if nums[mid] > target:\\n lowerBound = mid\\n right = mid-1\\n else:\\n left = mid+1\\n return lowerBound\\n\\n\\n lowerBound = lowerBound()\\n if lowerBound == n or nums[lowerBound] != target:\\n return [-1,-1]\\n return [lowerBound, upperBound()-1]\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]: \\n def helper(start, end):\\n if start >= end:\\n return [-1, -1]\\n if start == end - 1:\\n if nums[start] == target:\\n return [start, start]\\n else:\\n return [-1, -1]\\n \\n mid = (end + start) // 2\\n if nums[mid] > target:\\n return helper(start, mid)\\n if nums[mid] < target:\\n return helper(mid + 1, end)\\n \\n # Got one\\n left, right = mid, mid\\n while nums[left] == target and left > 0:\\n left -= 1\\n\\n while nums[right] == target and right < end - 1:\\n right += 1\\n \\n return [left + (nums[left] != target), right - (nums[right] != target)]\\n \\n \\n return helper(0, len(nums))\\n \",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def first_check(arr,left,right,t):\\n start = -1\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if arr[mid] == t:\\n start = mid\\n right = mid - 1\\n elif arr[mid] < t:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n return start\\n \\n @staticmethod\\n def last_check(arr,left,right,t):\\n end = -1\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if arr[mid] == t:\\n end = mid\\n left = mid + 1\\n elif arr[mid] < t:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n return end\\n\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n n = len(nums)\\n start = end = -1\\n start = Solution.first_check(nums,0,n-1,target)\\n if start == -1:\\n return [start,end]\\n end = Solution.last_check(nums,0,n-1,target)\\n\\n return [start,end]\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n # Handle the empty array case\\n if not nums:\\n return [-1, -1]\\n \\n start = -1\\n end = -1\\n \\n # Traverse the array to find the start and end indices of the target\\n for i in range(len(nums)):\\n if nums[i] == target:\\n if start == -1:\\n start = i\\n end = i\\n \\n # If start and end indices were not updated, the target was not found\\n if start == -1:\\n return [-1, -1]\\n \\n return [start, end]\\n\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if not nums:\\n return [-1, -1]\\n l = bisect_left(nums, target)\\n if l == len(nums) or nums[l] != target:\\n return [-1, -1]\\n \\n r = bisect_right(nums, target) - 1\\n return [l, r]\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n\\n def bianry(leftLimit):\\n l,r = 0,len(nums)-1\\n res = -1\\n while l <= r:\\n mid = (r+l)//2\\n if nums[mid] == target:\\n res = mid\\n if leftLimit:\\n r = mid -1\\n else:\\n l = mid +1\\n\\n elif target < nums[mid]:\\n r = mid-1\\n else:\\n l = mid + 1\\n \\n return res\\n \\n return[bianry(True),bianry(False)]\\n\\n\\n \",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n last_index = len(nums) - 1\\n left = 0\\n right = last_index\\n\\n if last_index == 0:\\n if target == nums[left]:\\n return [0, 0]\\n else:\\n return [-1, -1]\\n\\n while left <= right:\\n middle = left + (right - left) // 2\\n\\n if target == nums[middle]:\\n start, end = middle, middle\\n\\n while target == nums[start] and start > 0:\\n start -= 1\\n if target != nums[start]:\\n start += 1\\n\\n while target == nums[end] and end < last_index:\\n end += 1\\n if target != nums[end]:\\n end -= 1\\n \\n return [start, end]\\n\\n elif target < nums[middle]:\\n right = middle -1\\n else:\\n left = middle + 1\\n\\n return [-1, -1]\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def upper_bound(self, nums: List[int], target: int) -> int:\\n l = 0\\n r = len(nums) - 1\\n ub = -1\\n while l <= r:\\n mid = (l + r) // 2\\n\\n if nums[mid] > target:\\n r = mid - 1\\n else:\\n ub = mid\\n l = mid + 1\\n\\n return ub\\n\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if not nums:\\n return [-1, -1]\\n\\n l = self.upper_bound(nums, target - 1)\\n r = self.upper_bound(nums, target)\\n\\n if nums[r] != target:\\n return [-1, -1]\\n\\n return [l + 1, r]\\n \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n # Matt\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n result = [-1, -1]\\n\\n isFirst = True\\n\\n def findBounds(isFirst):\\n left = 0\\n right = len(nums) - 1\\n\\n while left <= right:\\n mid = left + (right-left) // 2\\n if nums[mid] == target:\\n if isFirst:\\n if mid == left or nums[mid-1] != target:\\n return mid\\n else:\\n right = mid - 1\\n else:\\n if mid == right or nums[mid+1] != target:\\n return mid\\n else:\\n left = mid + 1\\n elif nums[mid] < target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n return -1\\n\\n lower_bound = findBounds(isFirst)\\n if lower_bound == -1:\\n return [-1,-1]\\n\\n isFirst = False\\n upper_bound = findBounds(isFirst)\\n result = [lower_bound, upper_bound]\\n\\n return result\\n\\n\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def firstPos(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n res = -1\\n while (left<=right):\\n ind = (left+right)//2\\n curr = nums[ind]\\n if curr>=target:\\n res = ind\\n right = ind-1#moving to left in search of better min match\\n else:\\n left = ind+1\\n if res!=-1 and target!=nums[res]:\\n res = -1\\n return res\\n\\n def lastPos(self, nums: List[int], target: int) -> int: \\n left = 0\\n right = len(nums) - 1\\n res = -1\\n while (left<=right):\\n ind = (left+right)//2\\n curr = nums[ind]\\n if curr<=target:\\n res = ind\\n left = ind+1#moving to right in search of better max match\\n else:\\n right = ind-1\\n if res!=-1 and target!=nums[res]:\\n res = -1\\n return res\\n\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n #given nums are sorted \\n #we can do binary search min number greater than or eq to target to find first pos always store last best\\n #we can do binary search max number lesser than or eq to target to find last pos always store last best\\n return [self.firstPos(nums,target),self.lastPos(nums,target)]\\n\\n\\n \",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n # Check if the list is empty\\n if not nums:\\n return [-1, -1]\\n\\n max_pos, min_pos = -1, -1\\n \\n i = 0\\n # Check if the target is outside the range of the sorted array\\n if target > nums[-1] or target < nums[0]:\\n return [min_pos, max_pos]\\n \\n while i < len(nums):\\n if nums[i] == target:\\n if min_pos == -1:\\n min_pos = i\\n max_pos = i\\n \\n if nums[i] > target:\\n break\\n \\n i += 1\\n \\n return [min_pos, max_pos]\\n\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n def lowerBound(nums, target):\\n if len(nums) == 0:\\n return -1\\n left, right = 0, len(nums) - 1\\n\\n while left + 1 < right:\\n mid = left + (right - left) // 2\\n\\n if nums[mid] == target:\\n right = mid \\n elif nums[mid] < target:\\n left = mid\\n else:\\n right = mid\\n\\n # Post-processing:\\n if nums[left] == target:\\n return left\\n if nums[right] == target:\\n return right\\n return -1\\n\\n def upperBound(nums, target):\\n if len(nums) == 0:\\n return -1\\n left, right = 0, len(nums) - 1\\n\\n while left + 1 < right:\\n mid = left + (right - left) // 2\\n\\n if nums[mid] == target:\\n left = mid # Continue searching in the right half\\n elif nums[mid] < target:\\n left = mid\\n else:\\n right = mid\\n\\n # Post-processing:\\n if nums[right] == target:\\n return right\\n if nums[left] == target:\\n return left\\n return -1\\n\\n first = lowerBound(nums, target)\\n last = upperBound(nums, target)\\n return [first, last]\\n\\n \\n \\n \\n \",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n \\n nlen = len(nums)\\n first = nlen\\n last = -1\\n \\n start = 0\\n end = nlen - 1\\n\\n targetFound = False\\n\\n while start <= end:\\n mid = (start + end ) // 2\\n\\n if nums[mid] == target:\\n targetFound = True\\n first = min(first, mid)\\n\\n if nums[mid] >= target:\\n end = mid - 1\\n\\n else:\\n start = mid + 1\\n\\n start = 0\\n end = nlen - 1\\n\\n if not targetFound:\\n return [-1, -1]\\n\\n while start <= end:\\n mid = (start + end ) // 2\\n\\n if nums[mid] == target:\\n last = max(last, mid)\\n\\n if nums[mid] <= target:\\n start =mid + 1\\n\\n else:\\n end = mid - 1\\n\\n return [first, last]\\n\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n \\n if not nums:\\n return [-1, -1]\\n ans = [-1, -1]\\n left = 0\\n right = len(nums) - 1\\n\\n while left < right:\\n\\n mid = left + (right - left) // 2\\n\\n if nums[mid] < target:\\n left = mid + 1\\n else:\\n right = mid\\n \\n if left <= len(nums)-1 and nums[left] != target:\\n return [-1, -1]\\n\\n ans[0] = left\\n\\n print(left)\\n right = len(nums) - 1 \\n\\n while left <= right:\\n mid = left + (right - left) // 2\\n\\n if nums[mid] <= target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n \\n ans[1] = max(0, left - 1)\\n return ans\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n # find the middle of nums = [5,7,7,8,8,10] , len(nums) = 6, (0+5)//2=2, nums[2]=7\\n # initialization:leftIdx =0 , rightIndex = n-1, middle =(leftIdx+rightIdx)/2\\n # if num[middle]< target, pick num[middle+1:(right+1)]\\n # if num[middle]> tagert, pick num[left,middle]\\n # if num[middle] = target, search left and right\\n \\n #initialization\\n left=0\\n right = len(nums)-1\\n middle =(left+right)//2\\n start=0\\n end = 0\\n length = len(nums)\\n print(f\\\"begine left={left}, right={right}, middle={middle}\\\")\\n if length == 0:\\n return [-1, -1]\\n \\n while nums[middle] != target and left < right:\\n if nums[middle]< target:\\n left = middle+1\\n else:\\n right = middle-1\\n middle=(left+right)//2\\n print(f\\\"while left={left}, right={right}, middle={middle}\\\") \\n print(f\\\"left={left}, right={right}, middle={middle}\\\") \\n if nums[middle] != target:\\n return [-1, -1]\\n else:\\n # find the start & end index\\n start = middle\\n end = middle\\n print(f\\\"left={left}, right={right}, start={start}\\\")\\n while start-1 >=0 and nums[start-1]== target:\\n start-=1 \\n while end+1<length and nums[end+1] == target:\\n end+=1\\n \\n return [start, end] \",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n l = bisect_left(nums, target)\\n if l == len(nums) or nums[l] != target:\\n return [-1, -1]\\n r = bisect_right(nums, target)\\n return [l, r - 1]\\n\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n # Check if the list is empty\\n if not nums:\\n return [-1, -1]\\n\\n max_pos, min_pos = -1, -1\\n \\n i = 0\\n # Check if the target is outside the range of the sorted array\\n if target > nums[-1] or target < nums[0]:\\n return [min_pos, max_pos]\\n \\n while i < len(nums):\\n if nums[i] > target:\\n break\\n \\n if nums[i] == target:\\n if min_pos == -1:\\n min_pos = i\\n max_pos = i\\n \\n \\n i += 1\\n \\n return [min_pos, max_pos]\\n\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n\\n def findLimits(mid,target):\\n l = r = mid\\n while r < len(nums) -1 and nums[r] == nums[r+1]:\\n r+=1\\n while l > 0 and nums[l-1] == nums[l]:\\n l-=1\\n return [l,r]\\n\\n\\n l,r = 0,len(nums)-1\\n\\n while l <= r:\\n mid = (r+l)//2\\n if nums[mid] == target:\\n return findLimits(mid,target)\\n\\n elif target < nums[mid]:\\n r = mid-1\\n else:\\n l = mid + 1\\n \\n return [-1,-1]\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if len(nums)==0:\\n return [-1,-1]\\n left = 0\\n right = len(nums)\\n while left < right:\\n mid = left + (right-left)//2\\n if nums[mid]>target:\\n right = mid\\n else:\\n left = mid+1\\n ans = [-1,-1]\\n #print(left)\\n if left<=len(nums) and nums[left-1]==target:\\n ans[1] = left-1\\n for i in range(left-1,-1,-1):\\n if nums[i]==target:\\n ans[0] = i\\n return ans\\n\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if len(nums) == 0:\\n return [-1, -1]\\n\\n def get_start(nums):\\n l = 0\\n r = len(nums) - 1\\n\\n while l <= r:\\n m = (l+r)//2\\n\\n if nums[m] == target:\\n if (m == 0 or nums[m-1] != target):\\n return m\\n r = m-1\\n elif target > nums[m]:\\n l = m + 1\\n else:\\n r = m - 1\\n\\n return -1\\n\\n def get_end(nums):\\n l = 0\\n r = len(nums) - 1\\n\\n while l <= r:\\n m = (l+r)//2\\n\\n if nums[m] == target:\\n if (m == len(nums)-1 or nums[m+1] != target):\\n return m\\n l = m+1\\n elif target > nums[m]:\\n l = m + 1\\n else:\\n r = m - 1\\n\\n return -1\\n\\n\\n start = get_start(nums)\\n end = get_end(nums)\\n return [start, end]\\n\\n \\n \",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n return self.v2(nums, target)\\n # binary search\\n # time: O(logn)\\n # space: O(1)\\n def v1(self, nums, target):\\n n = len(nums)\\n lo = 0\\n hi = n - 1 \\n start = -1 \\n end = -1\\n while lo <= hi:\\n mid = (lo + hi) // 2\\n if nums[mid] == target: \\n start = mid\\n end = mid\\n # Searching For Range,, Individually for Start & End\\n while start > 0 and nums[start - 1] == target:\\n start = start - 1\\n while end < n - 1 and nums[end + 1] == target:\\n end = end + 1\\n break \\n elif nums[mid] > target:\\n hi = mid - 1\\n elif nums[mid] < target: \\n lo = mid + 1\\n return [start, end] \\n # binary search 2 time\\n # time: O(logn)\\n # space: O(1)\\n def v2(self, nums, target):\\n def helper(nums, target, left_position): # left_position is boolean, if true find the first target in left\\n n = len(nums)\\n l = 0\\n r = n - 1\\n idx = -1\\n while l <= r:\\n m = (l + r) // 2\\n if nums[m] > target:\\n r = m - 1\\n elif nums[m] < target:\\n l = m + 1\\n else: # nums[m] == target\\n idx = m\\n if left_position:\\n r = m - 1\\n else:\\n l = m + 1\\n return idx\\n start = helper(nums, target, True)\\n end = helper(nums, target, False)\\n return [start, end]\\n\\n\\n\\n # 5 7 7 8 8 10\\n \\n\\n \\n \\n\\n\\n\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if not nums:\\n return [-1, -1]\\n\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] < target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n leftIndex = left\\n\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] <= target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n rightIndex = right\\n\\n if leftIndex >= len(nums) or nums[leftIndex] != target or rightIndex < 0 or nums[rightIndex] != target:\\n return [-1, -1]\\n\\n return [leftIndex, rightIndex]\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n\\n def findLimits(mid,target):\\n l = r = mid\\n while r < len(nums) -1 and nums[r] == nums[r+1]:\\n r+=1\\n while l > 0 and nums[l-1] == nums[l]:\\n l-=1\\n return [l,r]\\n\\n\\n l,r = 0,len(nums)-1\\n\\n while l <= r:\\n mid = (r+l)//2\\n if nums[mid] == target:\\n return findLimits(mid,target)\\n\\n elif target < nums[mid]:\\n r = mid-1\\n else:\\n l = mid + 1\\n \\n return [-1,-1]\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"import bisect\\n\\n\\nclass Solution:\\n def searchRange(self, nums: list[int], target: int) -> list[int]:\\n n = len(nums)\\n if n == 0:\\n return [-1, -1]\\n\\n left_idx = bisect.bisect_left(nums, target)\\n right_idx = bisect.bisect_left(nums, target + 1) - 1\\n\\n if left_idx < n and nums[left_idx] == target:\\n return [left_idx, right_idx]\\n\\n return [-1, -1]\\n\\n\\nsol = Solution()\\nprint(sol.searchRange(nums=[5, 7, 7, 8, 8, 10], target=8))\\n\",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if len(nums) == 0:\\n return [-1, -1]\\n elif len(nums) == 1:\\n if nums[0] == target:\\n return [0,0]\\n return [-1, -1]\\n\\n def get_start(nums):\\n l = 0\\n r = len(nums) - 1\\n\\n while l <= r:\\n m = (l+r)//2\\n\\n if nums[m] == target:\\n if (m == 0 or nums[m-1] != target):\\n return m\\n r = m-1\\n elif target > nums[m]:\\n l = m + 1\\n else:\\n r = m - 1\\n\\n return -1\\n\\n def get_end(nums):\\n l = 0\\n r = len(nums) - 1\\n\\n while l <= r:\\n m = (l+r)//2\\n\\n if nums[m] == target:\\n if (m == len(nums)-1 or nums[m+1] != target):\\n return m\\n l = m+1\\n elif target > nums[m]:\\n l = m + 1\\n else:\\n r = m - 1\\n\\n return -1\\n\\n\\n start = get_start(nums)\\n end = get_end(nums)\\n return [start, end]\\n\\n \\n \",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if len(nums) < 1:\\n return [-1,-1]\\n l, r = 0, len(nums)-1\\n s,e=-1,-1\\n while l <= r:\\n mid = (l+r)//2\\n if nums[mid] == target:\\n # mid find\\n l_right = mid\\n while l <= l_right:\\n if nums[l] == target:\\n s = l\\n break\\n else:\\n l_mid = (l + l_right)//2\\n if nums[l_mid] == target:\\n l_right = l_mid\\n else:\\n l=l_mid + 1\\n r_left = mid\\n while r_left <= r:\\n if nums[r] == target:\\n e = r\\n break\\n else:\\n r_mid = (r + r_left)//2\\n if nums[r_mid] == target:\\n if nums[r_mid + 1] > target:\\n e = r_mid\\n break\\n else:\\n r_left = r_mid + 1\\n else:\\n r=r_mid - 1\\n return [s,e]\\n if target > nums[mid]:\\n l = mid+1\\n else:\\n r = mid -1\\n return [-1,-1]\\n \\n \",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n '''\\n This has O(n log n) runtime complexity.\\n The solution with O(2 log n) == O(k log n) == O(log n) is to use binary search\\n two times for first position and for end position of target in the list.\\n '''\\n last_index = len(nums) - 1\\n if last_index == 0:\\n if target == nums[last_index]:\\n return [0, 0]\\n else:\\n return [-1, -1]\\n\\n left = 0\\n right = last_index\\n while left <= right:\\n middle = left + (right - left) // 2\\n\\n if target == nums[middle]:\\n start, end = middle, middle\\n\\n while target == nums[start] and start > 0:\\n start -= 1\\n if target != nums[start]:\\n start += 1\\n\\n while target == nums[end] and end < last_index:\\n end += 1\\n if target != nums[end]:\\n end -= 1\\n \\n return [start, end]\\n\\n elif target < nums[middle]:\\n right = middle -1\\n else:\\n left = middle + 1\\n\\n return [-1, -1]\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n # if len(nums)==0:\\n # return [-1,-1]\\n left = 0\\n right = len(nums)\\n while left < right:\\n mid = left + (right-left)//2\\n if nums[mid]>target:\\n right = mid\\n else:\\n left = mid+1\\n ans = [-1,-1]\\n #print(left)\\n if left<=len(nums) and len(nums)>0 and nums[left-1]==target:\\n ans[1] = left-1\\n for i in range(left-1,-1,-1):\\n if nums[i]==target:\\n ans[0] = i\\n return ans\\n\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n # Check if the list is empty\\n if not nums:\\n return [-1, -1]\\n\\n max_pos, min_pos = -1, -1\\n \\n i = 0\\n # Check if the target is outside the range of the sorted array\\n if target > nums[-1] or target < nums[0]:\\n return [min_pos, max_pos]\\n \\n while i < len(nums):\\n if nums[i] == target:\\n if min_pos == -1:\\n min_pos = i\\n max_pos = i\\n \\n if nums[i] > target:\\n break\\n \\n i += 1\\n \\n return [min_pos, max_pos]\\n\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n \\n result = []\\n l, r = 0, len(nums)\\n while l < r:\\n m = (l+r) // 2\\n if target <= nums[m]:\\n r = m\\n else:\\n l = m+1\\n \\n if r >= len(nums) or nums[r] != target:\\n return [-1, -1]\\n\\n result.append(r)\\n l, r = 0, len(nums)\\n while l < r:\\n m = (l+r) // 2\\n if target < nums[m]:\\n r = m\\n else:\\n l = m+1\\n result.append(l-1)\\n\\n return result\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n\\n def findLimits(mid,target):\\n l = r = mid\\n while r < len(nums) -1 and nums[r] == nums[r+1]:\\n r+=1\\n while l > 0 and nums[l-1] == nums[l]:\\n l-=1\\n return [l,r]\\n\\n\\n l,r = 0,len(nums)-1\\n\\n while l <= r:\\n mid = (r+l)//2\\n if nums[mid] == target:\\n return findLimits(mid,target)\\n\\n elif target < nums[mid]:\\n r = mid-1\\n else:\\n l = mid + 1\\n \\n return [-1,-1]\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n\\n def bianry(leftLimit):\\n l,r = 0,len(nums)-1\\n res = -1\\n while l <= r:\\n mid = (r+l)//2\\n if nums[mid] == target:\\n res = mid\\n if leftLimit:\\n r = mid -1\\n else:\\n l = mid +1\\n\\n elif target < nums[mid]:\\n r = mid-1\\n else:\\n l = mid + 1\\n \\n return res\\n \\n return[bianry(True),bianry(False)]\\n\\n\\n \",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n def fir_occ(n):\\n l, r = 0, n-1\\n f=-1\\n while l<=r:\\n mid = l+(r-l)//2\\n if nums[mid]==target:\\n f = mid\\n r=mid-1\\n elif nums[mid]>target:\\n r=mid-1\\n else:\\n l=mid+1\\n return f\\n\\n def last_occ(n):\\n l, r = 0, n-1\\n la = -1\\n while l<=r:\\n mid = l+(r-l)//2\\n if nums[mid]==target:\\n la = mid\\n l=mid+1\\n elif nums[mid]>target:\\n r=mid-1\\n else:\\n l=mid+1\\n return la\\n n=len(nums)\\n fir = fir_occ(n)\\n las = last_occ(n)\\n return [fir, las]\\n \\n\\n \",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n def findFirst(nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] < target:\\n left = mid + 1\\n elif nums[mid] > target:\\n right = mid - 1\\n else:\\n if mid == 0 or nums[mid - 1] != target:\\n return mid\\n right = mid - 1\\n return -1\\n\\n def findLast(nums: List[int], target: int) -> int:\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] < target:\\n left = mid + 1\\n elif nums[mid] > target:\\n right = mid - 1\\n else:\\n if mid == len(nums) - 1 or nums[mid + 1] != target:\\n return mid\\n left = mid + 1\\n return -1\\n\\n start = findFirst(nums, target)\\n if start == -1:\\n return [-1, -1]\\n end = findLast(nums, target)\\n return [start, end]\\n\",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n first,last=-1,-1\\n for i in range(len(nums)):\\n if nums[i]==target:\\n if first==-1:\\n first=i\\n last=i\\n return[first,last]\\n\",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n starting = bisect.bisect_left(nums, target)\\n ending = bisect.bisect_right(nums, target) - 1\\n\\n if starting < len(nums) and nums[starting] == target:\\n return [starting, ending]\\n else:\\n return [-1, -1]\",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n def lowerBound(nums, target):\\n if len(nums) == 0:\\n return -1\\n left, right = 0, len(nums) - 1\\n\\n while left < right:\\n mid = left + (right - left) // 2\\n\\n if nums[mid] >= target:\\n right = mid\\n else:\\n left = mid + 1\\n\\n if nums[right] == target:\\n return right\\n return -1\\n\\n def upperBound(nums, target):\\n if len(nums) == 0:\\n return -1\\n left, right = 0, len(nums) - 1\\n\\n while left < right:\\n mid = left + (right - left + 1) // 2\\n\\n if nums[mid] <= target:\\n left = mid\\n else:\\n right = mid - 1\\n\\n if nums[left] == target:\\n return left\\n return -1\\n\\n first = lowerBound(nums, target)\\n last = upperBound(nums, target)\\n return [first, last]\\n\",\n \"runtime\": \"84\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":71,"string":"71"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n try:\n s = nums.index(target)\n except:\n return [-1,-1]\n res = [s,s]\n while s < len(nums)-1:\n s+=1\n if nums[s]==target:\n res[1]+=1\n\n return res\n ","memory":"17100"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n l=len(nums)\n if l==0 or target not in nums:\n return [-1,-1]\n floor,ceil=-1,-1\n low=0\n high=len(nums)-1\n while low<=high:\n mid=(low+high)//2\n if nums[mid]<=target:\n floor=mid\n low=mid+1\n else:\n high=mid-1\n low=0\n high=len(nums)-1\n while low<=high:\n mid=(low+high)//2\n if nums[mid]>=target:\n ceil=mid\n high=mid-1\n else:\n low=mid+1\n return [ceil,floor]\n\n ","memory":"17200"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n if len(nums) == 0:\n return [-1, -1]\n\n def searchLow(nums, target):\n left, right = 0, len(nums) - 1\n\n # 当 left 和 right 重合时，如果 nums[mid] >= target，我们会继续将 right 向左移动，left 保持不变。\n while left <= right:\n mid = left + (right - left) // 2\n if nums[mid] < target: #只管<\n left = mid + 1\n # 如果 nums[mid] < target，这意味着 target 的起始位置一定在 mid 的右侧，因此将左边界调整为 left = mid + 1。\n else:\n right = mid - 1\n return left\n # 当循环结束时，left 指向第一个大于等于 target 的位置。如果 target 存在，这就是它的起始索引。\n\n def searchHigh(nums, target):\n left, right = 0, len(nums) - 1\n\n while left <= right:\n mid = left + (right - left) // 2\n if nums[mid] > target: #只管>\n right = mid - 1\n # 如果 nums[mid] > target，这意味着 target 的结束位置必然在 mid 的左侧，因此需要在左半部分继续搜索，将右边界调整为 right = mid - 1。\n else:\n left = mid + 1\n return right\n # 当循环结束时，right 指向最后一个小于等于 target 的位置。如果 target 存在，这就是它的结束索引。\n\n\n start = searchLow(nums, target)\n end = searchHigh(nums, target)\n\n if start <= end :\n return [start, end]\n else:\n return [-1, -1]\n\n # 0 <= start < len(nums) 确保 start 索引在数组范围内。\n # start <= end 确保起始索引不大于结束索引，这在 target 存在时总是成立。\n # nums[start] == target 确保起始索引处的元素确实是 target。\n # 由于我们的算法找的是第一个大于等于 target 的位置，所以这一点非常重要，它排除了 target 不存在的情况。\n\n\n","memory":"17300"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n st = 0\n end = len(nums)-1\n ans = [-1,-1]\n while(st<=end):\n mid = st+(end-st)//2\n if nums[mid] == target:\n ans[0] = self.extreme(nums, target, mid)\n ans[1] = self.extreme(nums, target, mid, 1)\n return ans\n elif target<nums[mid]:\n end = mid-1\n else:\n st = mid+1 \n return ans\n \n def extreme(self, nums, target, mid, flag=0):\n if flag == 0:\n st = 0\n end = mid-1\n ans = mid\n while st<=end:\n mid = st+(end-st)//2\n if target==nums[mid]:\n ans = min(mid, ans)\n end = mid-1\n elif target<nums[mid]:\n end = mid-1\n else:\n st = mid+1\n return ans\n else:\n st = mid+1\n end = len(nums)-1\n ans = mid\n while st<=end:\n mid = st+(end-st)//2\n if target==nums[mid]:\n ans = max(mid, ans)\n st = mid+1\n elif target<nums[mid]:\n end = mid-1\n else:\n st = mid+1\n return ans\n \n ","memory":"17400"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n p=[]\n for i in range(len(nums)):\n if nums[i]==target:\n p.append(i)\n if len(p)==0:\n p=[-1,-1]\n return p\n elif len(p)==1:\n m=p[0]\n p.append(m)\n return p\n elif len(p)>2:\n a=[p[0],p[-1]]\n return a\n else:\n return p\n\n ","memory":"17500"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n def binary_search(target):\n l = 0\n r = len(nums) - 1\n\n while l < r:\n mid = l + (r - l) // 2\n\n if nums[mid] == target:\n return mid\n\n if nums[mid] < target:\n l = mid + 1\n else:\n r = mid - 1\n\n return -1 if nums[l] != target else l\n\n if not nums:\n return [-1, -1]\n\n index = binary_search(target)\n if index == -1:\n return [-1, -1]\n\n start = index - 1\n while start >= 0 and nums[start] == target:\n start -= 1 \n\n end = index + 1 \n while end < len(nums) and nums[end] == target:\n end += 1\n\n return [start + 1, end - 1]\n","memory":"17600"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n left = self.binarySearch(nums, target, 0)\n right = self.binarySearch(nums, target, 1)\n return [left, right]\n def binarySearch(self, nums, target, side):\n left, right = 0, len(nums) - 1\n index = -1\n while left <= right:\n mid = (left + right) // 2\n if target > nums[mid]:\n left = mid + 1\n elif target < nums[mid]:\n right = mid - 1\n else:\n index = mid\n if side == 0:\n right = mid - 1\n else:\n left = mid + 1\n return index\n\n\n\n\n\n","memory":"17600"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n def binary_search_left(nums, target):\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return left\n\n def binary_search_right(nums, target):\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] <= target:\n left = mid + 1\n else:\n right = mid - 1\n return right\n\n left_index = binary_search_left(nums, target)\n right_index = binary_search_right(nums, target)\n\n # Check if the target is actually present in the numsay\n if left_index <= right_index and nums[left_index] == target:\n return left_index, right_index\n else:\n return -1, -1 # Target not found","memory":"17700"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n li=[]\n if target in nums:\n # n=c[target]\n li.append(nums.index(target))\n li.append(len(nums)-1-nums[::-1].index(target))\n return li\n \n else:\n return [-1,-1]\n","memory":"17700"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n left = self.binsearch(nums,target,0)\n right= self.binsearch(nums,target,1)\n return [left,right]\n\n def binsearch(self,nums,target,direction):\n left,right=0,len(nums)-1\n index=-1\n while left<=right:\n mid=(left+right)//2\n if target>nums[mid]:\n left= mid+1\n elif target<nums[mid]:\n right=mid-1\n\n else:\n index=mid\n if direction==0:\n right=mid-1\n else:\n left=mid+1\n\n return index","memory":"17800"},{"code":"class Solution:\n def searchRange(self, nums: List[int], target: int) -> List[int]:\n # Bisect left\n def find_first():\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = left + (right - left) // 2\n if nums[mid] >= target:\n right = mid - 1\n else:\n left = mid + 1\n return left\n\n # Bisect right\n def find_last():\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = left + (right - left) // 2\n if nums[mid] <= target:\n left = mid + 1\n else:\n right = mid - 1\n return right\n\n first = find_first()\n last = find_last()\n\n if first <= last and first < len(nums) and nums[first] == target:\n return [first, last]\n\n return [-1, -1]\n","memory":"17800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n try:\\n s = nums.index(target)\\n except:\\n return [-1,-1]\\n res = [s,s]\\n while s < len(nums)-1:\\n s+=1\\n if nums[s]==target:\\n res[1]+=1\\n\\n return res\\n \",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n l=len(nums)\\n if l==0 or target not in nums:\\n return [-1,-1]\\n floor,ceil=-1,-1\\n low=0\\n high=len(nums)-1\\n while low<=high:\\n mid=(low+high)//2\\n if nums[mid]<=target:\\n floor=mid\\n low=mid+1\\n else:\\n high=mid-1\\n low=0\\n high=len(nums)-1\\n while low<=high:\\n mid=(low+high)//2\\n if nums[mid]>=target:\\n ceil=mid\\n high=mid-1\\n else:\\n low=mid+1\\n return [ceil,floor]\\n\\n \",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if len(nums) == 0:\\n return [-1, -1]\\n\\n def searchLow(nums, target):\\n left, right = 0, len(nums) - 1\\n\\n # 当 left 和 right 重合时，如果 nums[mid] >= target，我们会继续将 right 向左移动，left 保持不变。\\n while left <= right:\\n mid = left + (right - left) // 2\\n if nums[mid] < target: #只管<\\n left = mid + 1\\n # 如果 nums[mid] < target，这意味着 target 的起始位置一定在 mid 的右侧，因此将左边界调整为 left = mid + 1。\\n else:\\n right = mid - 1\\n return left\\n # 当循环结束时，left 指向第一个大于等于 target 的位置。如果 target 存在，这就是它的起始索引。\\n\\n def searchHigh(nums, target):\\n left, right = 0, len(nums) - 1\\n\\n while left <= right:\\n mid = left + (right - left) // 2\\n if nums[mid] > target: #只管>\\n right = mid - 1\\n # 如果 nums[mid] > target，这意味着 target 的结束位置必然在 mid 的左侧，因此需要在左半部分继续搜索，将右边界调整为 right = mid - 1。\\n else:\\n left = mid + 1\\n return right\\n # 当循环结束时，right 指向最后一个小于等于 target 的位置。如果 target 存在，这就是它的结束索引。\\n\\n\\n start = searchLow(nums, target)\\n end = searchHigh(nums, target)\\n\\n if start <= end :\\n return [start, end]\\n else:\\n return [-1, -1]\\n\\n # 0 <= start < len(nums) 确保 start 索引在数组范围内。\\n # start <= end 确保起始索引不大于结束索引，这在 target 存在时总是成立。\\n # nums[start] == target 确保起始索引处的元素确实是 target。\\n # 由于我们的算法找的是第一个大于等于 target 的位置，所以这一点非常重要，它排除了 target 不存在的情况。\\n\\n\\n\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n st = 0\\n end = len(nums)-1\\n ans = [-1,-1]\\n while(st<=end):\\n mid = st+(end-st)//2\\n if nums[mid] == target:\\n ans[0] = self.extreme(nums, target, mid)\\n ans[1] = self.extreme(nums, target, mid, 1)\\n return ans\\n elif target<nums[mid]:\\n end = mid-1\\n else:\\n st = mid+1 \\n return ans\\n \\n def extreme(self, nums, target, mid, flag=0):\\n if flag == 0:\\n st = 0\\n end = mid-1\\n ans = mid\\n while st<=end:\\n mid = st+(end-st)//2\\n if target==nums[mid]:\\n ans = min(mid, ans)\\n end = mid-1\\n elif target<nums[mid]:\\n end = mid-1\\n else:\\n st = mid+1\\n return ans\\n else:\\n st = mid+1\\n end = len(nums)-1\\n ans = mid\\n while st<=end:\\n mid = st+(end-st)//2\\n if target==nums[mid]:\\n ans = max(mid, ans)\\n st = mid+1\\n elif target<nums[mid]:\\n end = mid-1\\n else:\\n st = mid+1\\n return ans\\n \\n \",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n p=[]\\n for i in range(len(nums)):\\n if nums[i]==target:\\n p.append(i)\\n if len(p)==0:\\n p=[-1,-1]\\n return p\\n elif len(p)==1:\\n m=p[0]\\n p.append(m)\\n return p\\n elif len(p)>2:\\n a=[p[0],p[-1]]\\n return a\\n else:\\n return p\\n\\n \",\n \"memory\": \"17500\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n def binary_search(target):\\n l = 0\\n r = len(nums) - 1\\n\\n while l < r:\\n mid = l + (r - l) // 2\\n\\n if nums[mid] == target:\\n return mid\\n\\n if nums[mid] < target:\\n l = mid + 1\\n else:\\n r = mid - 1\\n\\n return -1 if nums[l] != target else l\\n\\n if not nums:\\n return [-1, -1]\\n\\n index = binary_search(target)\\n if index == -1:\\n return [-1, -1]\\n\\n start = index - 1\\n while start >= 0 and nums[start] == target:\\n start -= 1 \\n\\n end = index + 1 \\n while end < len(nums) and nums[end] == target:\\n end += 1\\n\\n return [start + 1, end - 1]\\n\",\n \"memory\": \"17600\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n left = self.binarySearch(nums, target, 0)\\n right = self.binarySearch(nums, target, 1)\\n return [left, right]\\n def binarySearch(self, nums, target, side):\\n left, right = 0, len(nums) - 1\\n index = -1\\n while left <= right:\\n mid = (left + right) // 2\\n if target > nums[mid]:\\n left = mid + 1\\n elif target < nums[mid]:\\n right = mid - 1\\n else:\\n index = mid\\n if side == 0:\\n right = mid - 1\\n else:\\n left = mid + 1\\n return index\\n\\n\\n\\n\\n\\n\",\n \"memory\": \"17600\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n def binary_search_left(nums, target):\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] < target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return left\\n\\n def binary_search_right(nums, target):\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] <= target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return right\\n\\n left_index = binary_search_left(nums, target)\\n right_index = binary_search_right(nums, target)\\n\\n # Check if the target is actually present in the numsay\\n if left_index <= right_index and nums[left_index] == target:\\n return left_index, right_index\\n else:\\n return -1, -1 # Target not found\",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n li=[]\\n if target in nums:\\n # n=c[target]\\n li.append(nums.index(target))\\n li.append(len(nums)-1-nums[::-1].index(target))\\n return li\\n \\n else:\\n return [-1,-1]\\n\",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n left = self.binsearch(nums,target,0)\\n right= self.binsearch(nums,target,1)\\n return [left,right]\\n\\n def binsearch(self,nums,target,direction):\\n left,right=0,len(nums)-1\\n index=-1\\n while left<=right:\\n mid=(left+right)//2\\n if target>nums[mid]:\\n left= mid+1\\n elif target<nums[mid]:\\n right=mid-1\\n\\n else:\\n index=mid\\n if direction==0:\\n right=mid-1\\n else:\\n left=mid+1\\n\\n return index\",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def searchRange(self, nums: List[int], target: int) -> List[int]:\\n # Bisect left\\n def find_first():\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = left + (right - left) // 2\\n if nums[mid] >= target:\\n right = mid - 1\\n else:\\n left = mid + 1\\n return left\\n\\n # Bisect right\\n def find_last():\\n left, right = 0, len(nums) - 1\\n while left <= right:\\n mid = left + (right - left) // 2\\n if nums[mid] <= target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return right\\n\\n first = find_first()\\n last = find_last()\\n\\n if first <= last and first < len(nums) and nums[first] == target:\\n return [first, last]\\n\\n return [-1, -1]\\n\",\n \"memory\": \"17800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":11,"string":"11"}}},{"rowIdx":71,"cells":{"question_id":{"kind":"number","value":35,"string":"35"},"name":{"kind":"string","value":"search-insert-position"},"content":{"kind":"string","value":"<p>Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.</p>\n\n<p>You must write an algorithm with <code>O(log n)</code> runtime complexity.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [1,3,5,6], target = 5\n<strong>Output:</strong> 2\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [1,3,5,6], target = 2\n<strong>Output:</strong> 1\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [1,3,5,6], target = 7\n<strong>Output:</strong> 4\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 10<sup>4</sup></code></li>\n\t<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>\n\t<li><code>nums</code> contains <strong>distinct</strong> values sorted in <strong>ascending</strong> order.</li>\n\t<li><code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":47.13847004799465,"string":"47.13847"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["array","binary-search"],"string":"[\n \"array\",\n \"binary-search\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"22\", 0.0028], [\"25\", 0.0056], [\"26\", 0.0028], [\"27\", 0.0085], [\"28\", 0.0113], [\"29\", 0.0085], [\"30\", 0.0254], [\"31\", 0.0847], [\"32\", 0.0875], [\"33\", 0.1016], [\"34\", 0.1779], [\"35\", 0.4235], [\"36\", 0.4433], [\"37\", 0.5308], [\"38\", 0.6607], [\"39\", 1.4823], [\"40\", 1.6432], [\"41\", 1.8211], [\"42\", 2.0695], [\"43\", 4.0741], [\"44\", 4.3762], [\"45\", 3.9583], [\"46\", 4.2435], [\"47\", 7.3802], [\"48\", 7.4452], [\"49\", 6.5106], [\"50\", 6.1041], [\"51\", 8.3712], [\"52\", 7.8207], [\"53\", 6.1803], [\"54\", 5.2401], [\"55\", 5.3248], [\"56\", 4.3169], [\"57\", 2.9363]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16700\", 0.0028], [\"16800\", 0.0254], [\"16900\", 0.0593], [\"17000\", 0.4376], [\"17100\", 7.3548], [\"17200\", 55.4985], [\"17300\", 24.3485]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n for i in range(len(nums)):\n if nums[i]==target or nums[i]>target:\n return i\n return len(nums)\n ","runtime":"22"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n while (left <= right):\n mid = (left + right) // 2\n if nums[mid] == target:\n return mid\n if nums[mid] > target:\n right = mid - 1\n else:\n left = mid + 1\n return left\n ","runtime":"25"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0 \n right = len(nums) - 1\n\n while left <= right:\n middle = left + (right - left) // 2\n\n if nums[middle] == target:\n return middle\n if nums[middle] > target:\n right = middle - 1\n else:\n left = middle + 1\n \n return left","runtime":"26"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n low = 0\n high = len(nums) - 1\n\n while low <= high:\n mid = (low + high) // 2\n if nums[mid] == target:\n return mid\n elif nums[mid] < target:\n low = mid + 1\n else: \n high = mid - 1\n return low","runtime":"27"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if nums[mid] == target:\n return mid\n elif nums[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return left","runtime":"28"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n\n left = 0\n right = len(nums) - 1\n\n while left <= right:\n\n mid = left + ((right - left) // 2)\n\n if nums[left] == target:\n return left\n if nums[right] == target:\n return right\n if nums[mid] == target:\n return mid\n \n if target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n\n if target > nums[right]:\n return right + 1\n else:\n if left == 0:\n return 0\n else:\n\n return right - 1\n \n \n\n\n\n\n ","runtime":"29"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left, right = 0, len(nums)-1\n\n while(left <= right):\n mid = (left+right)//2\n if(nums[mid] == target):\n return mid\n elif(nums[mid] > target):\n right = mid - 1\n else:\n left = mid + 1\n \n return left","runtime":"30"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums)-1\n\n pos = 0\n\n while l <= r:\n m = (l+r)//2\n\n if nums[m] == target: return m\n if nums[m] < target:\n pos = m+1\n l = m+1\n else:\n r = m-1\n\n return pos","runtime":"30"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n \n while left <= right:\n mid = (left + right) // 2\n if target == nums[mid]:\n return mid\n if target < nums[mid]:\n right = mid - 1\n elif target > nums[mid]:\n left = mid + 1\n\n return left","runtime":"31"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n size = len(nums)\n \n visited = []\n \n i = size//2\n s = i\n vosoted = []\n while(True):\n if(i>=size): return size\n if(i<0): return 0\n if(i in visited):\n if(nums[i]<target):\n return i+1\n else:\n return i\n s = s//2\n if(s == 0): s = 1\n visited.append(i)\n if(nums[i] < target):\n i += s\n elif(nums[i] > target):\n i -= s\n else:\n return i","runtime":"31"},{"code":"class Solution(object):\n def searchInsert(self, nums, target):\n l = 0\n r = len(nums) - 1\n while l <= r:\n mid = (l + r) // 2\n if nums[mid] < target:\n l = mid + 1\n elif nums[mid] > target:\n r = mid - 1\n else:\n return mid\n return l\n ","runtime":"32"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n # if target in nums:\n # return nums.index(target)\n # else:\n # nums.append(target)\n # nums.sort()\n # return nums.index(target)\n \n left = 0\n right = len(nums)\n \n while left < right:\n mid = (left+right)//2\n \n if nums[mid] == target:\n return mid\n elif nums[mid] > target:\n right = mid\n else:\n left = mid + 1\n \n \n return left\n ","runtime":"32"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n n = len(nums)\n low, high = 0, n-1\n \n while low <= high:\n mid = (low+high)//2\n if target == nums[mid]:\n return mid\n elif target > nums[mid] :\n low = mid + 1\n elif target < nums[mid]:\n high = mid - 1\n return low\n ","runtime":"33"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n index = bisect_left(nums, target)\n return index","runtime":"34"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n for i, n in enumerate(nums):\n if n >= target:\n return i\n return len(nums)\n","runtime":"35"},{"code":"from math import floor, ceil\nclass Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n insert_index = 0\n left = 0\n right = len(nums) - 1\n i = 0\n while left <= right:\n \n insert_index = (left+right)/2\n if nums[floor(insert_index)] < target:\n insert_index = floor(insert_index)\n left = insert_index\n else:\n insert_index = ceil(insert_index)\n right = insert_index\n if target == nums[left]:\n return left\n elif target == nums[right]:\n return right\n elif right == left+1 and (nums[left] < target < nums[right]):\n return right\n elif right == len(nums) -1 and target > nums[right]:\n return len(nums)\n elif left == 0 and target < nums[left]:\n return 0\n \n return insert_index","runtime":"35"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left=0\n right=len(nums)-1\n\n while left <=right:\n mid=(left+right)//2\n\n if nums[mid]==target:\n return mid\n elif nums[mid]>target:\n right=mid-1\n else:\n left = mid+1\n\n return left\n ","runtime":"36"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums) - 1\n while l <=r:\n mid = l + (r - l) // 2\n if nums[mid] == target:\n return mid\n if nums[mid] > target:\n r = mid - 1\n else:\n l = mid + 1\n return l\n","runtime":"37"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n\n for i in range(0, len(nums)):\n if nums[i] == target or nums[i] > target:\n return i\n\n return len(nums)\n ","runtime":"37"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n while left <= right:\n m = left + ((right - left) // 2)\n if nums[m] > target:\n right = m - 1\n elif nums[m] < target:\n left = m + 1\n else:\n return m\n return left\n","runtime":"38"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n low = 0\n high = len(nums)-1\n\n while low <= high:\n mid = (low + high)//2\n value = nums[mid]\n if value == target:\n return mid \n if value > target:\n high = mid - 1\n else:\n low = mid + 1\n return low\n \n \n ","runtime":"39"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n l = 0\n r = len(nums)\n while(l<r):\n mid = (l+r)//2\n if(target==nums[mid]):\n return mid\n if(target>nums[mid]):\n l = mid+1\n else:\n r = mid\n return l \n","runtime":"39"},{"code":"# 1:36\nclass Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n return self.searchInsertRecur(nums=nums, start=0, end=len(nums), target=target)\n \n def searchInsertRecur(self, nums: List[int], start: int, end: int, target:int) -> int:\n mid = (start + end) // 2 # 1\n # [1,3,5,6] end = 1\n if start >= end:\n # do something\n return start\n if nums[mid] == target:\n return mid\n if nums[mid] > target:\n # recur left\n return self.searchInsertRecur(nums, start, mid, target) # end=1, start=0\n if nums[mid] < target:\n # recur right\n return self.searchInsertRecur(nums=nums, start=mid + 1, end=end, target=target) # start=1, end=1\n\n ","runtime":"40"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n #O(log n) is binary search\n high = len(nums) - 1\n low = 0\n\n if target < nums[0]:\n return 0\n if target > nums[-1]:\n return high + 1\n\n while True:\n index = low + int((high - low) / 2)\n guess = nums[index]\n\n if (high - low) <= 1:\n if guess < target:\n return high\n else:\n return low\n\n if guess == target:\n return index\n elif guess < target:\n low = index\n else:\n high = index\n\n","runtime":"40"},{"code":"class Solution:\n def searchInsert(self, nums, target):\n left, right = 0, len(nums) - 1\n \n while left <= right:\n mid = left + (right - left) // 2\n if nums[mid] == target:\n return mid\n elif nums[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return left\n","runtime":"41"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n \n n = len(nums)\n low = 0\n high = n -1 \n ans = -1\n\n while low <= high:\n mid = (low + high) // 2\n\n if nums[mid] >= target:\n ans = mid\n high = mid - 1\n else:\n low = mid + 1\n\n\n return low ","runtime":"41"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n for i in range(len(nums)):\n if(nums[i]==target):\n return i\n elif(nums[i]>target):\n return i\n return len(nums)\n ","runtime":"42"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n nums.sort()\n left=0\n right=len(nums)-1\n while left<=right:\n mid=(left+right)//2\n if nums[mid]==target:\n return mid\n elif nums[mid]<target:\n left=mid+1\n else:\n right=mid-1\n return left\n ","runtime":"42"},{"code":"class Solution:\n\n def searchInsert(self, nums: List[int], target: int) -> int:\n for j in range(len(nums)):\n if nums[j] >= target:\n return j\n return len(nums)\n\n \n","runtime":"43"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n \n l = 0; r = len(nums)-1\n\n while l <= r:\n\n curr = (l+r)//2\n\n if nums[curr] < target:\n l = curr+1\n elif nums[curr] > target:\n r = curr-1\n else:\n return curr\n\n return l\n","runtime":"43"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n L, R = 0, len(nums)-1\n\n while L <= R:\n M = (L + R) // 2\n if nums[M] == target:\n return M\n elif nums[M] > target:\n R = M -1\n else:\n L = M + 1\n \n return L\n","runtime":"46"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n \n l = 0; r = len(nums)-1\n\n while l <= r:\n\n curr = (l+r)//2\n\n if nums[curr] < target:\n l = curr+1\n elif nums[curr] > target:\n r = curr-1\n else:\n return curr\n\n return l\n","runtime":"46"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n n = len(nums)\n l = 0\n r = n - 1\n\n while l <= r:\n m = (l + r) // 2\n \n if nums[m] < target:\n l = m + 1\n elif nums[m] > target:\n r = m - 1\n else:\n return m\n\n if nums[m] < target:\n return m + 1\n else:\n return m\n ","runtime":"47"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n i=0\n checksum = False\n for i in range(0, len(nums)):\n if nums[i] == target:\n checksum = True\n break\n elif nums[i] > target:\n checksum = True\n break\n if checksum == True:\n return i\n else:\n return i+1","runtime":"47"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n while left <= right:\n mid = left + (right - left) // 2\n if nums[mid] == target:\n return mid\n elif nums[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n\n return left","runtime":"48"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n if target in nums:\n for i in range(len(nums)):\n if nums[i]==target:\n return i\n else:\n i=0\n if target <nums[i]:\n return i\n exit(0)\n while i<len(nums)-1:\n if nums[i]<target: \n if nums[i+1]<target:\n i+=1\n else:\n return i+1\n break\n else:\n return len(nums)\n","runtime":"48"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n # [2,3,5,6,7]\n for i in range(len(nums)):\n if nums[i] == target:\n return i\n elif target < nums[i]:\n return i if i > 0 else 0\n return len(nums)\n\n \n ","runtime":"49"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n l,r = 0,len(nums)-1\n while l<=r:\n mid = int((l+r)/2)\n if nums[mid]==target:\n return mid\n elif nums[mid]<target:\n l=mid+1\n else:\n r=mid-1\n return l\n ","runtime":"49"},{"code":"from pprint import *\n\nclass Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n l = 0\n r = len(nums) - 1\n\n while l <= r:\n i = (l + r) // 2\n if target > nums[i]:\n l = i + 1\n elif target < nums[i]:\n r = i - 1\n else:\n return i\n return l\n","runtime":"50"},{"code":"from typing import List\n\nclass Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n\n for i in range(len(nums)):\n if nums[i] == target or nums[i] > target:\n return i\n return len(nums)\n\n","runtime":"50"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n array=nums\n x=target\n low=0\n high=len(array)-1\n while low <= high:\n mid = low + (high - low)//2\n if x == array[mid]:\n return mid\n elif x > array[mid]:\n low = mid + 1\n else:\n high = mid - 1\n for i in range(0, len(array)-1):\n if array[i]<x and array[i+1]>x:\n return i+1\n if x<array[0]:\n return 0\n if x>array[len(array)-1]:\n return len(array)\n ","runtime":"51"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums)-1\n while l<=r:\n mid = l+(r-l)//2\n if nums[mid]==target:\n return mid\n elif nums[mid]>target:\n r=mid-1\n else:\n l=mid+1\n return l\n\n ","runtime":"51"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n l,r=0,1\n if target<=nums[l]:\n return l\n if target>nums[len(nums)-1]:\n return len(nums)\n for r in range (len(nums)):\n if target>nums[l] and target<=nums[r]:\n return r\n l=l+1\n \n","runtime":"52"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n L, R = 0, len(nums)-1\n \n while L <= R :\n mid = (L + R) // 2\n \n if nums[mid] == target:\n return mid\n elif nums[mid] < target:\n L = mid + 1\n else:\n R = mid - 1\n return L\n \n\n ","runtime":"52"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left=0\n right=len(nums)-1\n\n while(left<=right):\n mid=(left+right)//2\n if nums[mid]== target:\n return mid\n elif nums[mid]>target:\n right=mid-1\n else:\n left=mid+1\n return left\n \n \n ","runtime":"53"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n while(left<=right):\n middle = (right+left)//2\n\n if nums[middle] == target:\n return middle\n elif nums[middle] < target:\n left = middle + 1\n else:\n right = middle - 1\n return left","runtime":"53"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n answer = 0\n for i in range(len(nums)):\n if target <= nums[i]:\n return i\n return len(nums) ","runtime":"54"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n h = len(nums) - 1\n l = 0\n \n while(h >= l):\n mid = (h + l)//2\n if nums[mid] == target:\n return mid\n elif target > nums[mid]:\n l = mid + 1\n else: \n h = mid - 1\n return l \n \n\n\n\n\n\n \n\n\n ","runtime":"54"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n n=len(nums)\n first=0\n last=n\n \n for i in range(n):\n if nums[i]==target:\n return i\n elif nums[i]>target:\n return i\n \n \n return n\n \n \n ","runtime":"55"},{"code":"\n\nclass Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums)-1\n while l <= r:\n m = (l + r) // 2\n if nums[m] > target:\n r = m - 1\n elif nums[m] < target:\n l = m + 1\n else:\n return m\n return l\n \n","runtime":"55"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums)-1\n if target<=nums[0]:\n return 0\n \n while left<right:\n mid = (left+right)//2\n if nums[mid] == target:\n return mid\n if nums[mid] < target:\n if nums[mid+1]>=target:\n return mid+1\n else:\n left = mid+1\n else:\n if nums[mid-1]<target:\n return mid\n elif nums[mid-1]==target:\n return mid-1\n else:\n right = mid-1\n return len(nums)\n ","runtime":"56"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n if target in nums:\n return nums.index(target)\n prev=0\n for i in nums:\n if target<i and target>prev:\n return nums.index(i)\n prev=i\n if nums[-1]<target:\n return len(nums)\n if nums[0]>target:\n return 0","runtime":"56"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n \n l = 0; r = len(nums)-1\n\n while l <= r:\n\n curr = (l+r)//2\n\n if nums[curr] < target:\n l = curr+1\n elif nums[curr] > target:\n r = curr-1\n else:\n return curr\n\n return l\n","runtime":"57"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n low = 0\n high = len(nums) - 1\n while low <= high:\n mid = low + (high-low)//2\n if nums[mid] == target:\n return mid\n if nums[mid] > target:\n high = mid - 1\n else:\n low = mid + 1\n return low","runtime":"57"}],"string":"[\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n for i in range(len(nums)):\\n if nums[i]==target or nums[i]>target:\\n return i\\n return len(nums)\\n \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n while (left <= right):\\n mid = (left + right) // 2\\n if nums[mid] == target:\\n return mid\\n if nums[mid] > target:\\n right = mid - 1\\n else:\\n left = mid + 1\\n return left\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0 \\n right = len(nums) - 1\\n\\n while left <= right:\\n middle = left + (right - left) // 2\\n\\n if nums[middle] == target:\\n return middle\\n if nums[middle] > target:\\n right = middle - 1\\n else:\\n left = middle + 1\\n \\n return left\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n low = 0\\n high = len(nums) - 1\\n\\n while low <= high:\\n mid = (low + high) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] < target:\\n low = mid + 1\\n else: \\n high = mid - 1\\n return low\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] < target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n return left\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n\\n left = 0\\n right = len(nums) - 1\\n\\n while left <= right:\\n\\n mid = left + ((right - left) // 2)\\n\\n if nums[left] == target:\\n return left\\n if nums[right] == target:\\n return right\\n if nums[mid] == target:\\n return mid\\n \\n if target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n\\n if target > nums[right]:\\n return right + 1\\n else:\\n if left == 0:\\n return 0\\n else:\\n\\n return right - 1\\n \\n \\n\\n\\n\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left, right = 0, len(nums)-1\\n\\n while(left <= right):\\n mid = (left+right)//2\\n if(nums[mid] == target):\\n return mid\\n elif(nums[mid] > target):\\n right = mid - 1\\n else:\\n left = mid + 1\\n \\n return left\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums)-1\\n\\n pos = 0\\n\\n while l <= r:\\n m = (l+r)//2\\n\\n if nums[m] == target: return m\\n if nums[m] < target:\\n pos = m+1\\n l = m+1\\n else:\\n r = m-1\\n\\n return pos\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n \\n while left <= right:\\n mid = (left + right) // 2\\n if target == nums[mid]:\\n return mid\\n if target < nums[mid]:\\n right = mid - 1\\n elif target > nums[mid]:\\n left = mid + 1\\n\\n return left\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n size = len(nums)\\n \\n visited = []\\n \\n i = size//2\\n s = i\\n vosoted = []\\n while(True):\\n if(i>=size): return size\\n if(i<0): return 0\\n if(i in visited):\\n if(nums[i]<target):\\n return i+1\\n else:\\n return i\\n s = s//2\\n if(s == 0): s = 1\\n visited.append(i)\\n if(nums[i] < target):\\n i += s\\n elif(nums[i] > target):\\n i -= s\\n else:\\n return i\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution(object):\\n def searchInsert(self, nums, target):\\n l = 0\\n r = len(nums) - 1\\n while l <= r:\\n mid = (l + r) // 2\\n if nums[mid] < target:\\n l = mid + 1\\n elif nums[mid] > target:\\n r = mid - 1\\n else:\\n return mid\\n return l\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n # if target in nums:\\n # return nums.index(target)\\n # else:\\n # nums.append(target)\\n # nums.sort()\\n # return nums.index(target)\\n \\n left = 0\\n right = len(nums)\\n \\n while left < right:\\n mid = (left+right)//2\\n \\n if nums[mid] == target:\\n return mid\\n elif nums[mid] > target:\\n right = mid\\n else:\\n left = mid + 1\\n \\n \\n return left\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n n = len(nums)\\n low, high = 0, n-1\\n \\n while low <= high:\\n mid = (low+high)//2\\n if target == nums[mid]:\\n return mid\\n elif target > nums[mid] :\\n low = mid + 1\\n elif target < nums[mid]:\\n high = mid - 1\\n return low\\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n index = bisect_left(nums, target)\\n return index\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n for i, n in enumerate(nums):\\n if n >= target:\\n return i\\n return len(nums)\\n\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"from math import floor, ceil\\nclass Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n insert_index = 0\\n left = 0\\n right = len(nums) - 1\\n i = 0\\n while left <= right:\\n \\n insert_index = (left+right)/2\\n if nums[floor(insert_index)] < target:\\n insert_index = floor(insert_index)\\n left = insert_index\\n else:\\n insert_index = ceil(insert_index)\\n right = insert_index\\n if target == nums[left]:\\n return left\\n elif target == nums[right]:\\n return right\\n elif right == left+1 and (nums[left] < target < nums[right]):\\n return right\\n elif right == len(nums) -1 and target > nums[right]:\\n return len(nums)\\n elif left == 0 and target < nums[left]:\\n return 0\\n \\n return insert_index\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left=0\\n right=len(nums)-1\\n\\n while left <=right:\\n mid=(left+right)//2\\n\\n if nums[mid]==target:\\n return mid\\n elif nums[mid]>target:\\n right=mid-1\\n else:\\n left = mid+1\\n\\n return left\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums) - 1\\n while l <=r:\\n mid = l + (r - l) // 2\\n if nums[mid] == target:\\n return mid\\n if nums[mid] > target:\\n r = mid - 1\\n else:\\n l = mid + 1\\n return l\\n\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n\\n for i in range(0, len(nums)):\\n if nums[i] == target or nums[i] > target:\\n return i\\n\\n return len(nums)\\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n while left <= right:\\n m = left + ((right - left) // 2)\\n if nums[m] > target:\\n right = m - 1\\n elif nums[m] < target:\\n left = m + 1\\n else:\\n return m\\n return left\\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n low = 0\\n high = len(nums)-1\\n\\n while low <= high:\\n mid = (low + high)//2\\n value = nums[mid]\\n if value == target:\\n return mid \\n if value > target:\\n high = mid - 1\\n else:\\n low = mid + 1\\n return low\\n \\n \\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n l = 0\\n r = len(nums)\\n while(l<r):\\n mid = (l+r)//2\\n if(target==nums[mid]):\\n return mid\\n if(target>nums[mid]):\\n l = mid+1\\n else:\\n r = mid\\n return l \\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"# 1:36\\nclass Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n return self.searchInsertRecur(nums=nums, start=0, end=len(nums), target=target)\\n \\n def searchInsertRecur(self, nums: List[int], start: int, end: int, target:int) -> int:\\n mid = (start + end) // 2 # 1\\n # [1,3,5,6] end = 1\\n if start >= end:\\n # do something\\n return start\\n if nums[mid] == target:\\n return mid\\n if nums[mid] > target:\\n # recur left\\n return self.searchInsertRecur(nums, start, mid, target) # end=1, start=0\\n if nums[mid] < target:\\n # recur right\\n return self.searchInsertRecur(nums=nums, start=mid + 1, end=end, target=target) # start=1, end=1\\n\\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n #O(log n) is binary search\\n high = len(nums) - 1\\n low = 0\\n\\n if target < nums[0]:\\n return 0\\n if target > nums[-1]:\\n return high + 1\\n\\n while True:\\n index = low + int((high - low) / 2)\\n guess = nums[index]\\n\\n if (high - low) <= 1:\\n if guess < target:\\n return high\\n else:\\n return low\\n\\n if guess == target:\\n return index\\n elif guess < target:\\n low = index\\n else:\\n high = index\\n\\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums, target):\\n left, right = 0, len(nums) - 1\\n \\n while left <= right:\\n mid = left + (right - left) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] < target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return left\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n \\n n = len(nums)\\n low = 0\\n high = n -1 \\n ans = -1\\n\\n while low <= high:\\n mid = (low + high) // 2\\n\\n if nums[mid] >= target:\\n ans = mid\\n high = mid - 1\\n else:\\n low = mid + 1\\n\\n\\n return low \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n for i in range(len(nums)):\\n if(nums[i]==target):\\n return i\\n elif(nums[i]>target):\\n return i\\n return len(nums)\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n nums.sort()\\n left=0\\n right=len(nums)-1\\n while left<=right:\\n mid=(left+right)//2\\n if nums[mid]==target:\\n return mid\\n elif nums[mid]<target:\\n left=mid+1\\n else:\\n right=mid-1\\n return left\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n for j in range(len(nums)):\\n if nums[j] >= target:\\n return j\\n return len(nums)\\n\\n \\n\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n \\n l = 0; r = len(nums)-1\\n\\n while l <= r:\\n\\n curr = (l+r)//2\\n\\n if nums[curr] < target:\\n l = curr+1\\n elif nums[curr] > target:\\n r = curr-1\\n else:\\n return curr\\n\\n return l\\n\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n L, R = 0, len(nums)-1\\n\\n while L <= R:\\n M = (L + R) // 2\\n if nums[M] == target:\\n return M\\n elif nums[M] > target:\\n R = M -1\\n else:\\n L = M + 1\\n \\n return L\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n \\n l = 0; r = len(nums)-1\\n\\n while l <= r:\\n\\n curr = (l+r)//2\\n\\n if nums[curr] < target:\\n l = curr+1\\n elif nums[curr] > target:\\n r = curr-1\\n else:\\n return curr\\n\\n return l\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n n = len(nums)\\n l = 0\\n r = n - 1\\n\\n while l <= r:\\n m = (l + r) // 2\\n \\n if nums[m] < target:\\n l = m + 1\\n elif nums[m] > target:\\n r = m - 1\\n else:\\n return m\\n\\n if nums[m] < target:\\n return m + 1\\n else:\\n return m\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n i=0\\n checksum = False\\n for i in range(0, len(nums)):\\n if nums[i] == target:\\n checksum = True\\n break\\n elif nums[i] > target:\\n checksum = True\\n break\\n if checksum == True:\\n return i\\n else:\\n return i+1\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n while left <= right:\\n mid = left + (right - left) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] < target:\\n left = mid + 1\\n else:\\n right = mid - 1\\n\\n return left\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n if target in nums:\\n for i in range(len(nums)):\\n if nums[i]==target:\\n return i\\n else:\\n i=0\\n if target <nums[i]:\\n return i\\n exit(0)\\n while i<len(nums)-1:\\n if nums[i]<target: \\n if nums[i+1]<target:\\n i+=1\\n else:\\n return i+1\\n break\\n else:\\n return len(nums)\\n\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n # [2,3,5,6,7]\\n for i in range(len(nums)):\\n if nums[i] == target:\\n return i\\n elif target < nums[i]:\\n return i if i > 0 else 0\\n return len(nums)\\n\\n \\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n l,r = 0,len(nums)-1\\n while l<=r:\\n mid = int((l+r)/2)\\n if nums[mid]==target:\\n return mid\\n elif nums[mid]<target:\\n l=mid+1\\n else:\\n r=mid-1\\n return l\\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"from pprint import *\\n\\nclass Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n l = 0\\n r = len(nums) - 1\\n\\n while l <= r:\\n i = (l + r) // 2\\n if target > nums[i]:\\n l = i + 1\\n elif target < nums[i]:\\n r = i - 1\\n else:\\n return i\\n return l\\n\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n\\n for i in range(len(nums)):\\n if nums[i] == target or nums[i] > target:\\n return i\\n return len(nums)\\n\\n\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n array=nums\\n x=target\\n low=0\\n high=len(array)-1\\n while low <= high:\\n mid = low + (high - low)//2\\n if x == array[mid]:\\n return mid\\n elif x > array[mid]:\\n low = mid + 1\\n else:\\n high = mid - 1\\n for i in range(0, len(array)-1):\\n if array[i]<x and array[i+1]>x:\\n return i+1\\n if x<array[0]:\\n return 0\\n if x>array[len(array)-1]:\\n return len(array)\\n \",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums)-1\\n while l<=r:\\n mid = l+(r-l)//2\\n if nums[mid]==target:\\n return mid\\n elif nums[mid]>target:\\n r=mid-1\\n else:\\n l=mid+1\\n return l\\n\\n \",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n l,r=0,1\\n if target<=nums[l]:\\n return l\\n if target>nums[len(nums)-1]:\\n return len(nums)\\n for r in range (len(nums)):\\n if target>nums[l] and target<=nums[r]:\\n return r\\n l=l+1\\n \\n\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n L, R = 0, len(nums)-1\\n \\n while L <= R :\\n mid = (L + R) // 2\\n \\n if nums[mid] == target:\\n return mid\\n elif nums[mid] < target:\\n L = mid + 1\\n else:\\n R = mid - 1\\n return L\\n \\n\\n \",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left=0\\n right=len(nums)-1\\n\\n while(left<=right):\\n mid=(left+right)//2\\n if nums[mid]== target:\\n return mid\\n elif nums[mid]>target:\\n right=mid-1\\n else:\\n left=mid+1\\n return left\\n \\n \\n \",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n while(left<=right):\\n middle = (right+left)//2\\n\\n if nums[middle] == target:\\n return middle\\n elif nums[middle] < target:\\n left = middle + 1\\n else:\\n right = middle - 1\\n return left\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n answer = 0\\n for i in range(len(nums)):\\n if target <= nums[i]:\\n return i\\n return len(nums) \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n h = len(nums) - 1\\n l = 0\\n \\n while(h >= l):\\n mid = (h + l)//2\\n if nums[mid] == target:\\n return mid\\n elif target > nums[mid]:\\n l = mid + 1\\n else: \\n h = mid - 1\\n return l \\n \\n\\n\\n\\n\\n\\n \\n\\n\\n \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n n=len(nums)\\n first=0\\n last=n\\n \\n for i in range(n):\\n if nums[i]==target:\\n return i\\n elif nums[i]>target:\\n return i\\n \\n \\n return n\\n \\n \\n \",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums)-1\\n while l <= r:\\n m = (l + r) // 2\\n if nums[m] > target:\\n r = m - 1\\n elif nums[m] < target:\\n l = m + 1\\n else:\\n return m\\n return l\\n \\n\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums)-1\\n if target<=nums[0]:\\n return 0\\n \\n while left<right:\\n mid = (left+right)//2\\n if nums[mid] == target:\\n return mid\\n if nums[mid] < target:\\n if nums[mid+1]>=target:\\n return mid+1\\n else:\\n left = mid+1\\n else:\\n if nums[mid-1]<target:\\n return mid\\n elif nums[mid-1]==target:\\n return mid-1\\n else:\\n right = mid-1\\n return len(nums)\\n \",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n if target in nums:\\n return nums.index(target)\\n prev=0\\n for i in nums:\\n if target<i and target>prev:\\n return nums.index(i)\\n prev=i\\n if nums[-1]<target:\\n return len(nums)\\n if nums[0]>target:\\n return 0\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n \\n l = 0; r = len(nums)-1\\n\\n while l <= r:\\n\\n curr = (l+r)//2\\n\\n if nums[curr] < target:\\n l = curr+1\\n elif nums[curr] > target:\\n r = curr-1\\n else:\\n return curr\\n\\n return l\\n\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n low = 0\\n high = len(nums) - 1\\n while low <= high:\\n mid = low + (high-low)//2\\n if nums[mid] == target:\\n return mid\\n if nums[mid] > target:\\n high = mid - 1\\n else:\\n low = mid + 1\\n return low\",\n \"runtime\": \"57\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":54,"string":"54"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if target == nums[mid]:\n return mid\n elif target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n\n return left","memory":"16700"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n \n y = len(nums)\n for x in range(y):\n if target == nums[x]:\n return x\n elif target > nums[y-1]:\n return y\n elif target < nums[0]:\n return 0\n elif target < nums[x] and target > nums[x-1]:\n return x\n \n","memory":"16800"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n if target < nums[0]:\n return 0\n for i in range(len(nums)-1):\n if nums[i] == target:\n return i\n if nums[i] < target < nums[i + 1]:\n return i + 1\n if nums[-1] == target:\n return len(nums) -1\n return len(nums)\n","memory":"16900"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n for i in range(len(nums)):\n if(nums[i]>=target):\n return i\n return len(nums)","memory":"17000"},{"code":"from typing import List\n\nclass Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n\n for i in range(len(nums)):\n if nums[i] == target or nums[i] > target:\n return i\n return len(nums)\n\n","memory":"17000"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums) - 1\n\n while left <= right:\n mid = (left + right) // 2\n\n if nums[mid] < target:\n left = mid + 1\n elif nums[mid] > target:\n right = mid - 1\n else:\n return mid\n\n return left","memory":"17100"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums) - 1\n\n while l <= r:\n mid = l + (r - l) // 2\n if nums[mid] == target:\n return mid\n elif nums[mid] > target:\n r = mid - 1\n else:\n l = mid + 1\n \n return l","memory":"17100"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n #[1,3,5,6]\n #2\n #0:3\n #0:1\n \n #\n if target <= nums[0]:\n return 0 \n elif target > nums[-1]:\n return len(nums)\n \n \n low = 0\n high = len(nums) -1\n \n while high - low > 1:\n mid = ((high-low)//2) + low\n #print(mid, nums[mid])\n if target == nums[mid]:\n return mid\n \n if target == nums[high]:\n return high\n \n if target == nums[low]:\n return low\n \n if target < nums[mid]:\n high = mid\n else:\n low = mid \n \n \n \n \n \n \n return high\n \n #handle the insertion case in the event we don't find it\n \n ","memory":"17200"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n left = 0\n right = len(nums)-1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] == target:\n return mid\n elif nums[mid] < target:\n left = mid + 1\n elif nums[mid] > target:\n right = mid - 1\n return left\n \n ","memory":"17200"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n if target < nums[0]:\n return 0\n if target > nums[-1]:\n return len(nums)\n for i in range(len(nums)):\n if target <= nums[i]:\n return i","memory":"17300"},{"code":"class Solution:\n def searchInsert(self, nums: List[int], target: int) -> int:\n l, r = 0, len(nums)\n while l<r:\n mid = (l+r)//2\n if target > nums[mid]:\n l = mid+1\n else:\n r = mid\n return l","memory":"17300"}],"string":"[\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if target == nums[mid]:\\n return mid\\n elif target < nums[mid]:\\n right = mid - 1\\n else:\\n left = mid + 1\\n\\n return left\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n \\n y = len(nums)\\n for x in range(y):\\n if target == nums[x]:\\n return x\\n elif target > nums[y-1]:\\n return y\\n elif target < nums[0]:\\n return 0\\n elif target < nums[x] and target > nums[x-1]:\\n return x\\n \\n\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n if target < nums[0]:\\n return 0\\n for i in range(len(nums)-1):\\n if nums[i] == target:\\n return i\\n if nums[i] < target < nums[i + 1]:\\n return i + 1\\n if nums[-1] == target:\\n return len(nums) -1\\n return len(nums)\\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n for i in range(len(nums)):\\n if(nums[i]>=target):\\n return i\\n return len(nums)\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n\\n for i in range(len(nums)):\\n if nums[i] == target or nums[i] > target:\\n return i\\n return len(nums)\\n\\n\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums) - 1\\n\\n while left <= right:\\n mid = (left + right) // 2\\n\\n if nums[mid] < target:\\n left = mid + 1\\n elif nums[mid] > target:\\n right = mid - 1\\n else:\\n return mid\\n\\n return left\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums) - 1\\n\\n while l <= r:\\n mid = l + (r - l) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] > target:\\n r = mid - 1\\n else:\\n l = mid + 1\\n \\n return l\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n #[1,3,5,6]\\n #2\\n #0:3\\n #0:1\\n \\n #\\n if target <= nums[0]:\\n return 0 \\n elif target > nums[-1]:\\n return len(nums)\\n \\n \\n low = 0\\n high = len(nums) -1\\n \\n while high - low > 1:\\n mid = ((high-low)//2) + low\\n #print(mid, nums[mid])\\n if target == nums[mid]:\\n return mid\\n \\n if target == nums[high]:\\n return high\\n \\n if target == nums[low]:\\n return low\\n \\n if target < nums[mid]:\\n high = mid\\n else:\\n low = mid \\n \\n \\n \\n \\n \\n \\n return high\\n \\n #handle the insertion case in the event we don't find it\\n \\n \",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n left = 0\\n right = len(nums)-1\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] < target:\\n left = mid + 1\\n elif nums[mid] > target:\\n right = mid - 1\\n return left\\n \\n \",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n if target < nums[0]:\\n return 0\\n if target > nums[-1]:\\n return len(nums)\\n for i in range(len(nums)):\\n if target <= nums[i]:\\n return i\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def searchInsert(self, nums: List[int], target: int) -> int:\\n l, r = 0, len(nums)\\n while l<r:\\n mid = (l+r)//2\\n if target > nums[mid]:\\n l = mid+1\\n else:\\n r = mid\\n return l\",\n \"memory\": \"17300\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":11,"string":"11"}}},{"rowIdx":72,"cells":{"question_id":{"kind":"number","value":36,"string":"36"},"name":{"kind":"string","value":"valid-sudoku"},"content":{"kind":"string","value":"<p>Determine if a <code>9 x 9</code> Sudoku board is valid. Only the filled cells need to be validated <strong>according to the following rules</strong>:</p>\n\n<ol>\n\t<li>Each row must contain the digits <code>1-9</code> without repetition.</li>\n\t<li>Each column must contain the digits <code>1-9</code> without repetition.</li>\n\t<li>Each of the nine <code>3 x 3</code> sub-boxes of the grid must contain the digits <code>1-9</code> without repetition.</li>\n</ol>\n\n<p><strong>Note:</strong></p>\n\n<ul>\n\t<li>A Sudoku board (partially filled) could be valid but is not necessarily solvable.</li>\n\t<li>Only the filled cells need to be validated according to the mentioned rules.</li>\n</ul>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Sudoku-by-L2G-20050714.svg/250px-Sudoku-by-L2G-20050714.svg.png\" style=\"height:250px; width:250px\" />\n<pre>\n<strong>Input:</strong> board = \n[["5","3",".",".","7",".",".",".","."]\n,["6",".",".","1","9","5",".",".","."]\n,[".","9","8",".",".",".",".","6","."]\n,["8",".",".",".","6",".",".",".","3"]\n,["4",".",".","8",".","3",".",".","1"]\n,["7",".",".",".","2",".",".",".","6"]\n,[".","6",".",".",".",".","2","8","."]\n,[".",".",".","4","1","9",".",".","5"]\n,[".",".",".",".","8",".",".","7","9"]]\n<strong>Output:</strong> true\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> board = \n[["8","3",".",".","7",".",".",".","."]\n,["6",".",".","1","9","5",".",".","."]\n,[".","9","8",".",".",".",".","6","."]\n,["8",".",".",".","6",".",".",".","3"]\n,["4",".",".","8",".","3",".",".","1"]\n,["7",".",".",".","2",".",".",".","6"]\n,[".","6",".",".",".",".","2","8","."]\n,[".",".",".","4","1","9",".",".","5"]\n,[".",".",".",".","8",".",".","7","9"]]\n<strong>Output:</strong> false\n<strong>Explanation:</strong> Same as Example 1, except with the <strong>5</strong> in the top left corner being modified to <strong>8</strong>. Since there are two 8's in the top left 3x3 sub-box, it is invalid.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>board.length == 9</code></li>\n\t<li><code>board[i].length == 9</code></li>\n\t<li><code>board[i][j]</code> is a digit <code>1-9</code> or <code>'.'</code>.</li>\n</ul>\n"},"acRate":{"kind":"number","value":60.58695720696975,"string":"60.586957"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","hash-table","matrix"],"string":"[\n \"array\",\n \"hash-table\",\n \"matrix\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"31\", 0.0035], [\"32\", 0.0069], [\"33\", 0.0104], [\"34\", 0.0139], [\"35\", 0.0104], [\"36\", 0.0243], [\"38\", 0.0278], [\"39\", 0.0208], [\"40\", 0.0069], [\"41\", 0.0104], [\"42\", 0.0347], [\"43\", 0.0312], [\"44\", 0.0069], [\"45\", 0.0173], [\"46\", 0.0243], [\"47\", 0.0139], [\"48\", 0.0035], [\"49\", 0.0104], [\"50\", 0.0139], [\"52\", 0.0035], [\"53\", 0.0035], [\"63\", 0.0035], [\"68\", 0.0035], [\"69\", 0.0208], [\"70\", 0.0208], [\"71\", 0.0347], [\"72\", 0.0555], [\"73\", 0.0833], [\"74\", 0.1561], [\"75\", 0.1769], [\"76\", 0.2151], [\"77\", 0.3608], [\"78\", 0.5065], [\"79\", 0.6244], [\"80\", 0.7875], [\"81\", 1.0442], [\"82\", 1.5958], [\"83\", 1.7831], [\"84\", 2.3555], [\"85\", 2.9938], [\"86\", 3.5315], [\"87\", 3.9756], [\"88\", 4.4196], [\"89\", 5.11], [\"90\", 5.613], [\"91\", 5.9356], [\"92\", 6.1785], [\"93\", 6.2131], [\"94\", 6.1438], [\"95\", 5.8697], [\"96\", 5.3632], [\"97\", 4.9886], [\"98\", 4.3225], [\"99\", 3.535], [\"100\", 2.9661], [\"101\", 2.3694], [\"102\", 1.8837], [\"103\", 1.5264], [\"104\", 1.0511], [\"105\", 0.7285]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16000\", 0.0173], [\"16100\", 0.0278], [\"16200\", 0.0867], [\"16300\", 1.0026], [\"16400\", 12.9085], [\"16500\", 34.0665], [\"16600\", 39.3464]]}"},"rt_list":{"kind":"list like","value":[{"code":"def is_valid(cells):\n seen = set()\n for cell in cells:\n if cell == '.':\n continue\n if cell in seen:\n return False\n seen.add(cell)\n return True\nclass Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n board_T = zip(*board)\n \n for row in board:\n if is_valid(row) == False:\n return False\n \n for col in board_T:\n if is_valid(col) == False:\n return False\n \n for r in range(0,9,3):\n for c in range(0,9,3):\n cells = []\n for dr in range(3):\n for dc in range(3):\n cells.append(board[r+dr][c+dc])\n if is_valid(cells) == False:\n return False\n \n return True\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()","runtime":"31"},{"code":"class Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n cols = defaultdict(set)\n row = defaultdict(set)\n sq = defaultdict(set)\n\n for r in range(9):\n for c in range(9):\n cell = board[r][c]\n\n if cell == '.':\n continue\n\n if(cell in row[r] or cell in cols[c] or cell in sq[(r//3, c//3)]):\n\n return False\n else:\n row[r].add(cell)\n cols[c].add(cell)\n sq[(r//3, c//3)].add(cell)\n\n return True\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()","runtime":"32"},{"code":"def is_valid(cells):\n seen = set()\n for cell in cells:\n if cell == '.':\n continue\n if cell in seen:\n return False\n seen.add(cell)\n return True\nclass Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n board_T = zip(*board)\n \n for row in board:\n if is_valid(row) == False:\n return False\n \n for col in board_T:\n if is_valid(col) == False:\n return False\n \n boxes=[(0,0),(0,3),(0,6),(3,0),(3,3),(3,6),(6,0),(6,3),(6,6)]\n for i,j in boxes:\n cells = []\n for dr in range(i,i+3):\n for dc in range(j,j+3):\n cells.append(board[dr][dc])\n if is_valid(cells) == False:\n return False\n \n return True\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()\n \n\n","runtime":"33"},{"code":"class Solution:\n @staticmethod\n def isValidSudoku(board: List[List[str]]) -> bool:\n d={}\n for i in range(3):\n for j in range(3):\n d[str(i)+str(j)]={'1','2','3','4','5','6','7','8','9'}\n trans=[]\n k=[0]*9\n for i in range(9):\n trans.append(k.copy()) \n for i in range(9):\n c={'1','2','3','4','5','6','7','8','9'}\n for j in range(9):\n trans[j][i]=board[i][j]\n if board[i][j]=='.':\n continue\n if board[i][j] in c:\n c.remove(board[i][j])\n else:\n return False\n x=str(i//3)+str(j//3)\n if board[i][j] in d[x]:\n d[x].remove(board[i][j])\n else:\n print(\"2\")\n return False\n for i in range(9):\n c={'1','2','3','4','5','6','7','8','9'}\n for j in range(9):\n if trans[i][j]=='.':\n continue\n if trans[i][j] in c:\n c.remove(trans[i][j])\n else:\n print(\"3\")\n return False\n return True\n\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()","runtime":"34"},{"code":"class Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n row = defaultdict(set)\n col = defaultdict(set)\n grid = defaultdict(set)\n for i in range(9):\n for j in range(9):\n val = board[i][j]\n if val.isalnum():\n k = i//3 * 3 + j//3\n if val in row[i] or val in col[j] or val in grid[k]:\n return False\n else:\n row[i].add(val)\n col[j].add(val)\n grid[k].add(val)\n\n return True\n\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()","runtime":"35"},{"code":"# class Solution:\ndef isValidSudoku(board: List[List[str]]) -> bool:\n row = defaultdict(set)\n col = defaultdict(set)\n grid = defaultdict(set)\n for i in range(9):\n for j in range(9):\n val = board[i][j]\n if val.isalnum():\n k = i//3 * 3 + j//3\n if val in row[i] or val in col[j] or val in grid[k]:\n return False\n else:\n row[i].add(val)\n col[j].add(val)\n grid[k].add(val)\n\n return True\n\n\nwith open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\nexit()","runtime":"35"},{"code":"def is_valid(cells):\n seen = set()\n for cell in cells:\n if cell == '.':\n continue\n if cell in seen:\n return False\n seen.add(cell)\n return True\nclass Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n board_T = zip(*board)\n \n for row in board:\n if is_valid(row) == False:\n return False\n \n for col in board_T:\n if is_valid(col) == False:\n return False\n \n boxes=[(0,0),(0,3),(0,6),(3,0),(3,3),(3,6),(6,0),(6,3),(6,6)]\n for i,j in boxes:\n cells = []\n for dr in range(i,i+3):\n for dc in range(j,j+3):\n cells.append(board[dr][dc])\n if is_valid(cells) == False:\n return False\n \n return True\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()\n \n\n","runtime":"36"},{"code":"class Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n cols = defaultdict(set)\n row = defaultdict(set)\n sq = defaultdict(set)\n\n for r in range(9):\n for c in range(9):\n cell = board[r][c]\n\n if cell == '.':\n continue\n\n if(cell in row[r] or cell in cols[c] or cell in sq[(r//3, c//3)]):\n\n return False\n else:\n row[r].add(cell)\n cols[c].add(cell)\n sq[(r//3, c//3)].add(cell)\n\n return True\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()","runtime":"38"},{"code":"class Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n # we need to use hashsets:\n rows = defaultdict(set)\n cols = defaultdict(set)\n boxes = defaultdict(set)\n\n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\":\n continue\n \n if (board[r][c] in rows[r]) or \\\n (board[r][c] in cols[c]) or \\\n (board[r][c] in boxes[(r // 3, c // 3)]):\n return False\n \n # need to use add() because its a set!!!\n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n boxes[(r // 3, c // 3)].add(board[r][c])\n\n return True\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()","runtime":"39"},{"code":"def is_valid(cells):\n seen = set()\n for cell in cells:\n if cell == '.':\n continue\n if cell in seen:\n return False\n seen.add(cell)\n return True\nclass Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n board_T = zip(*board)\n \n for row in board:\n if is_valid(row) == False:\n return False\n \n for col in board_T:\n if is_valid(col) == False:\n return False\n \n for r in range(0,9,3):\n for c in range(0,9,3):\n cells = []\n for dr in range(3):\n for dc in range(3):\n cells.append(board[r+dr][c+dc])\n if is_valid(cells) == False:\n return False\n \n return True\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()","runtime":"40"},{"code":"def is_valid(cells):\n seen = set()\n for cell in cells:\n if cell == '.':\n continue\n if cell in seen:\n return False\n seen.add(cell)\n return True\nclass Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n board_T = zip(*board)\n \n for row in board:\n if is_valid(row) == False:\n return False\n \n for col in board_T:\n if is_valid(col) == False:\n return False\n \n boxes=[(0,0),(0,3),(0,6),(3,0),(3,3),(3,6),(6,0),(6,3),(6,6)]\n for i,j in boxes:\n cells = []\n for dr in range(i,i+3):\n for dc in range(j,j+3):\n cells.append(board[dr][dc])\n if is_valid(cells) == False:\n return False\n \n return True\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()\n \n\n","runtime":"41"},{"code":"def is_it(a: list[str]) -> bool:\n a_set=[]\n for el in a:\n if el != \".\":\n if el in a_set:\n return False\n else:\n a_set.append(el)\n return True\ndef isValidSudoku(board: List[List[str]]) -> bool:\n a=[]\n for i in range(9):\n if not is_it(board[i]):\n return False\n for i in range(9):\n for j in range(9):\n a.append(board[j][i])\n if not is_it(a):\n return False\n a = []\n for i in range(3):\n for ii in range(3):\n for iii in range(3):\n for iiii in range(3):\n a.append(board[i * 3 + iii][ii * 3 + iiii])\n if not is_it(a):\n return False\n a = []\n return True\nwith open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\nexit()","runtime":"42"},{"code":"def is_it(a: list[str]) -> bool:\n a_set=[]\n for el in a:\n if el != \".\":\n if el in a_set:\n return False\n else:\n a_set.append(el)\n return True\ndef isValidSudoku(board: List[List[str]]) -> bool:\n a=[]\n for i in range(9):\n if not is_it(board[i]):\n return False\n for i in range(9):\n for j in range(9):\n a.append(board[j][i])\n if not is_it(a):\n return False\n a = []\n for i in range(3):\n for ii in range(3):\n for iii in range(3):\n for iiii in range(3):\n a.append(board[i * 3 + iii][ii * 3 + iiii])\n if not is_it(a):\n return False\n a = []\n return True\nwith open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\nexit()","runtime":"42"},{"code":"def is_it(a: list[str]) -> bool:\n a_set=[]\n for el in a:\n if el != \".\":\n if el in a_set:\n return False\n else:\n a_set.append(el)\n return True\ndef isValidSudoku(board: List[List[str]]) -> bool:\n a=[]\n for i in range(9):\n if not is_it(board[i]):\n return False\n for i in range(9):\n for j in range(9):\n a.append(board[j][i])\n if not is_it(a):\n return False\n a = []\n for i in range(3):\n for ii in range(3):\n for iii in range(3):\n for iiii in range(3):\n a.append(board[i * 3 + iii][ii * 3 + iiii])\n if not is_it(a):\n return False\n a = []\n return True\nwith open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\nexit()","runtime":"43"},{"code":"def is_it(a: list[str]) -> bool:\n a_set=[]\n for el in a:\n if el != \".\":\n if el in a_set:\n return False\n else:\n a_set.append(el)\n return True\ndef isValidSudoku(board: List[List[str]]) -> bool:\n a=[]\n for i in range(9):\n if not is_it(board[i]):\n return False\n for i in range(9):\n for j in range(9):\n a.append(board[j][i])\n if not is_it(a):\n return False\n a = []\n for i in range(3):\n for ii in range(3):\n for iii in range(3):\n for iiii in range(3):\n a.append(board[i * 3 + iii][ii * 3 + iiii])\n if not is_it(a):\n return False\n a = []\n return True\nwith open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\nexit()","runtime":"43"},{"code":"class Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n col_list = defaultdict(list)\n # Per 3 block of row\n block = defaultdict(list)\n\n for i, row in enumerate(board):\n row_list = []\n for j, col in enumerate(row):\n if row[j] != '.':\n row_list.append(row[j])\n col_list[j+1].append(row[j])\n block[math.ceil((j+1)/3)].append(row[j])\n if len(row_list) != len(set(row_list)): return False\n\n \n # early stop by block\n if (i+1)%3 == 0:\n for b in block: \n if len(block[b]) != len(set(block[b])): return False\n block = defaultdict(list)\n \n for c in col_list: \n if len(col_list[c]) != len(set(col_list[c])): return False\n return True\n \n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()","runtime":"44"},{"code":"def is_valid(cells):\n seen = set()\n for cell in cells:\n if cell == '.':\n continue\n if cell in seen:\n return False\n seen.add(cell)\n return True\nclass Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n board_T = zip(*board)\n \n for row in board:\n if is_valid(row) == False:\n return False\n \n for col in board_T:\n if is_valid(col) == False:\n return False\n \n boxes=[(0,0),(0,3),(0,6),(3,0),(3,3),(3,6),(6,0),(6,3),(6,6)]\n for i,j in boxes:\n cells = []\n for dr in range(i,i+3):\n for dc in range(j,j+3):\n cells.append(board[dr][dc])\n if is_valid(cells) == False:\n return False\n \n return True\n\n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()\n \n\n","runtime":"45"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n dic_save = {**{\"row\"+str(i): [] for i in range(9)}, \n **{\"col\"+str(i): [] for i in range(9)}, \n **{\"grid\"+str(i): [] for i in range(9)}}\n\n for r in range(9):\n for c in range(9):\n grid_index = (r // 3) * 3 + (c // 3)\n if board[r][c] != \".\":\n current_val = board[r][c]\n \n # Check row\n if current_val in dic_save[\"row\" + str(r)]:\n return False\n dic_save[\"row\" + str(r)].append(current_val)\n\n # Check column\n if current_val in dic_save[\"col\" + str(c)]:\n return False\n dic_save[\"col\" + str(c)].append(current_val)\n\n # Check grid\n if current_val in dic_save[\"grid\" + str(grid_index)]:\n return False\n dic_save[\"grid\" + str(grid_index)].append(current_val)\n\n return True\n\n\n\nimport sys\nimport json\n\ndef kdsmain():\n input_data = sys.stdin.read().strip()\n lines = input_data.splitlines()\n\n num_test_cases = len(lines) # Number of test cases\n results = []\n\n solution = Solution() # Create the Solution object once\n for i in range(num_test_cases):\n board = json.loads(lines[i].strip()) # Parse each Sudoku board (in JSON format)\n result = solution.isValidSudoku(board) # Call isValidSudoku method\n results.append(json.dumps(result)) # Store result (True/False) in JSON format\n\n with open('user.out', 'w') as f: # Write all results to 'user.out'\n f.write(\"\\n\".join(results) + \"\\n\")\n\nif __name__ == \"__main__\":\n kdsmain()\n exit(0)\n\n\n\n\n\n\n \n ","runtime":"46"},{"code":"def isValidSudoku(board: List[List[str]]) -> str:\n \n row=[set() for _ in range(9)]\n col=[set() for _ in range(9)]\n box=[[set() for _ in range(3)] for _ in range(3)]\n\n for i in range(9):\n for j in range(9):\n cud=board[i][j]\n\n if cud=='.':continue \n if cud in row[i] or cud in col[j] or cud in box[i//3][j//3]:\n return 'false'\n row[i].add(cud)\n col[j].add(cud)\n box[i//3][j//3].add(cud)\n\n return 'true'\n\nwith open('user.out', 'w') as f:\n for c in map(loads, stdin):\n f.write(f\"{isValidSudoku(c)}\\n\")\nexit(0)","runtime":"47"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n row_dict = defaultdict(set)\n column_dict = defaultdict(set)\n square_dict = defaultdict(set)\n\n for row in range(9): #recall prop of range: stops at last index\n for column in range(9):\n if board[row][column] == '.':\n continue\n \n if (board[row][column] in row_dict[row] or\n board[row][column] in column_dict[column] or \n board[row][column] in square_dict[(row//3, column//3)]):\n return False\n\n else:\n # WE want to add to the individual sets attached to the keys here..\n row_dict[row].add(board[row][column])\n column_dict[column].add(board[row][column])\n square_dict[(row//3, column//3)].add(board[row][column])\n return True\n\n\nwith open(\"user.out\", \"w\") as f:\n inputs = map(loads, stdin)\n for board in inputs:\n print(\"true\" if bool(Solution().isValidSudoku(board)) else \"false\", file=f)\nexit(0)","runtime":"48"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n dic_save = {**{\"row\"+str(i): [] for i in range(9)},**{\"col\"+str(i): [] for i in range(9)},**{\"grid\"+str(i): [] for i in range(9)}}\n for r in range(9):\n for c in range(9):\n grid_index = (r // 3) * 3 + (c // 3)\n if board[r][c] != \".\":\n dic_save[\"grid\" + str(grid_index)] += board[r][c]\n dic_save[\"row\" + str(r)] += board[r][c]\n dic_save[\"col\" + str(c)] += board[r][c]\n return all(len(set(values)) == len(values) for values in dic_save.values())\n\n\nimport sys\nimport json\n\ndef kdsmain():\n input_data = sys.stdin.read().strip()\n lines = input_data.splitlines()\n\n num_test_cases = len(lines) # Number of test cases\n results = []\n\n solution = Solution() # Create the Solution object once\n for i in range(num_test_cases):\n board = json.loads(lines[i].strip()) # Parse each Sudoku board (in JSON format)\n result = solution.isValidSudoku(board) # Call isValidSudoku method\n results.append(json.dumps(result)) # Store result (True/False) in JSON format\n\n with open('user.out', 'w') as f: # Write all results to 'user.out'\n f.write(\"\\n\".join(results) + \"\\n\")\n\nif __name__ == \"__main__\":\n kdsmain()\n exit(0)\n\n\n\n\n\n\n \n ","runtime":"49"},{"code":"from collections import defaultdict\n\nclass Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n d = defaultdict(set)\n\n for row in range(len(board)):\n for column, square in enumerate(board[row]):\n if square != \".\":\n if square in d[row + 9] or square in d[column + 18] or square in d[(row // 3) * 3 + (column // 3)]:\n return False\n\n d[(row // 3) * 3 + (column // 3)].add(square) # square\n d[row + 9].add(square) # row\n d[column + 18].add(square) # column\n return True\n\n\nwith open(\"user.out\", \"w\") as f:\n inputs = map(loads, stdin)\n for board in inputs:\n print(\"true\" if bool(Solution().isValidSudoku(board)) else \"false\", file=f)\nexit(0)","runtime":"50"},{"code":"class Solution:\n def isValidSudoku(board: List[List[str]]) -> bool:\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [[set() for _ in range(3)] for _ in range(3)]\n\n def check(num, *sets):\n for s in sets:\n if num not in s:\n s.add(num)\n else:\n return False\n return True\n\n for i in range(9):\n for j in range(9):\n num = board[i][j]\n\n if num == \".\":\n continue\n\n if not check(num, rows[i], cols[j], boxes[i//3][j//3]):\n print(i, j)\n return False\n \n return True\n \n with open('user.out', 'w') as f:\n for case in map(loads, stdin):\n f.write(f'{str(isValidSudoku(case)).lower()}\\n')\n exit()","runtime":"52"},{"code":"\ndef isValidSudoku(board: List[List[str]]) -> bool:\n blocks = {(i, j): [] for i in range(3) for j in range(3)}\n for i in range(9):\n row = []\n column = []\n for j in range(9):\n if (board[i][j] != '.') and (board[i][j] not in row):\n row.append(board[i][j])\n elif (board[i][j] in row):return False\n \n if (board[j][i] != '.') and (board[j][i] not in column):\n column.append(board[j][i])\n elif (board[j][i] in column):return False\n \n if (board[i][j] != '.') and (board[i][j] not in blocks[(i//3, j//3)]):\n blocks[(i//3, j//3)].append(board[i][j])\n elif (board[i][j] in blocks[(i//3, j//3)]):return False\n return True\n\nwith open('user.out', 'w') as f:\n for c in map(loads, stdin):\n f.write(f\"{str(isValidSudoku(c)).lower()}\\n\")\nexit(0)","runtime":"53"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n # Edge Cases:\n # Non-digits are used (in the constraints)\n # Different board sizes (in the constraints)\n # Whole board is empty\n\n # Create sets of each of the rows, columns, and sub-boxes\n # Check if the number is in the set before you place it\n # 27 sets total\n # Can check as you're running over the board\n # Will return false if one is already in a set\n\n # Runtime: O(n) - time it takes to loop over the whole board, Set retrieval/setting time is O(1)\n\n # Define list of row_sets List[set]\n row_sets = [set() for i in range (len(board))]\n # Define list of col_sets List[set]\n col_sets = [set() for i in range (len(board))]\n # Define list of sub_sets List[set]\n sub_sets = [set() for i in range (len(board))]\n\n # Loop through all of the rows\n for row in range(len(board)):\n # Loop through all of the columns \n for col in range(len(board[0])):\n curr_num = board[row][col]\n if curr_num != \".\":\n # Add to rows set and check if already in set\n if curr_num in row_sets[row]:\n return False\n row_sets[row].add(curr_num)\n # Add to columns set and check if already in set\n if curr_num in col_sets[col]:\n return False\n col_sets[col].add(curr_num)\n # Get sub-box idx\n sub_box_idx = col//3+3*(row//3)\n # Add to sub-box set (will be in 3x3 sections)\n if curr_num in sub_sets[sub_box_idx]:\n return False\n sub_sets[sub_box_idx].add(curr_num)\n\n return True\n","runtime":"69"},{"code":"from collections import defaultdict\nclass Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n h = [set() for _ in range(9)]\n v = [set() for _ in range(9)]\n b = [set() for _ in range(9)]\n\n for r in range(9):\n for c in range(9):\n val = board[r][c]\n if val == \".\":\n continue\n if val in h[r]:\n return False\n h[r].add(val)\n if val in v[c]:\n return False\n v[c].add(val)\n box = (r//3) * 3 + (c//3)\n if val in b[box]:\n return False\n b[box].add(val)\n return True\n \"\"\"#determine if it is valid\n #horizontal\n #vertical\n #box (3x3)\n h = [set() for _ in range(9)]\n v = [set() for _ in range(9)]\n b = [set() for _ in range(9)]\n\n for r in range(9):\n for c in range(9):\n val = board[r][c]\n if val == \".\":\n continue\n if val in h[r]:\n return False\n h[r].add(val)\n if val in v[c]:\n return False\n v[c].add(val)\n box = (r//3) * 3 + (c//3)\n if val in b[box]:\n return False\n b[box].add(val)\n\n return True\"\"\"","runtime":"70"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n # we will need a hash map for every row, and a hashmap for every column\n rows = {}\n columns = {}\n # we will also need a hash map foe each square of 3*3\n # we can identify each square bu dividing indexes of the lines and columns to 3\n squares = {}\n for i in range(3):\n squares[i] = {}\n for j in range(3):\n squares[i][j]= {}\n\n # now we go through the matrix:\n for line in range(len(board)):\n rows.clear()\n columns.clear()\n lineIndex = line//3\n for column in range(len(board[line])):\n if board[line][column] != '.':\n columnIndex = column//3\n # first we check if the element is unique in its square\n if board[line][column] not in squares[lineIndex][columnIndex]:\n squares[lineIndex][columnIndex][board[line][column]] = True\n else:\n return False\n # then we check if the element is unique on its row\n if board[line][column] not in rows:\n rows[board[line][column]] = True\n else:\n return False\n \n if board[column][line] != '.':\n # lastly, we check is the element is unoque on its column\n if board[column][line] not in columns:\n columns[board[column][line]] = True\n else:\n return False\n\n # now for the squares\n\n return True","runtime":"71"},{"code":"def check_cell(board, i,j,checker):\n c = board[i][j]\n if c == \".\":\n return True\n idx = int(c) - 1\n if checker[idx]:\n return False\n checker[idx] = 1\n return True\n\n\nclass Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n for row in board:\n checker = [0] * 9\n for c in row:\n if c == \".\":\n continue\n idx = int(c) - 1\n if checker[idx]:\n return False\n checker[idx] = 1\n \n for column in range(9):\n checker = [0] * 9\n for r in range(9):\n if not check_cell(board, r, column, checker):\n return False\n \n for i,j in [(0,0), (0,3), (0,6),(3,0), (3,3), (3,6),(6,0), (6,3), (6,6)]:\n checker = [0] * 9\n \n if not check_cell(board, i, j, checker):\n return False\n \n if not check_cell(board, i, j + 1, checker):\n return False\n \n if not check_cell(board, i, j + 2, checker):\n return False\n \n if not check_cell(board, i + 1, j, checker):\n return False\n \n if not check_cell(board, i + 1, j + 1, checker):\n return False\n \n if not check_cell(board, i + 1, j + 2, checker):\n return False\n \n if not check_cell(board, i + 2, j, checker):\n return False\n \n if not check_cell(board, i + 2, j + 1, checker):\n return False\n \n if not check_cell(board, i + 2, j + 2, checker):\n return False\n \n return True\n \n","runtime":"72"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n N = 9\n\n # Use hash set to record the status\n rows = [set() for _ in range(N)]\n cols = [set() for _ in range(N)]\n boxes = [set() for _ in range(N)]\n\n for i in range(N):\n for j in range(N):\n val = board[i][j]\n\n if val == \".\":\n continue\n \n if val in rows[i]:\n return False\n rows[i].add(val)\n\n if val in cols[j]:\n return False\n cols[j].add(val)\n\n boxindex = (i//3) + (j//3)*3\n if val in boxes[boxindex]:\n return False\n boxes[boxindex].add(val)\n \n return True","runtime":"73"},{"code":"class Solution:\n def isValidSudoku(self, board: list[list[str]]) -> bool:\n seen = set()\n\n for i in range(9):\n for j in range(9):\n c = board[i][j]\n if c == '.':\n continue\n if (c + '@row ' + str(i) in seen or\n c + '@col ' + str(j) in seen or\n c + '@box ' + str(i // 3) + str(j // 3) in seen):\n return False\n seen.add(c + '@row ' + str(i))\n seen.add(c + '@col ' + str(j))\n seen.add(c + '@box ' + str(i // 3) + str(j // 3))\n\n return True","runtime":"74"},{"code":"from typing import List\n\nclass Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n # Create sets to track seen numbers for rows, columns, and subgrids\n rows = [set() for _ in range(9)]\n columns = [set() for _ in range(9)]\n subgrids = [set() for _ in range(9)]\n\n # Iterate over each cell in the board\n for row in range(9):\n for col in range(9):\n num = board[row][col]\n \n if num != '.':\n # Determine the subgrid index\n subgrid_index = (row // 3) * 3 + (col // 3)\n \n # Check if the number is already in the row, column, or subgrid\n if num in rows[row] or num in columns[col] or num in subgrids[subgrid_index]:\n return False\n \n # Add the number to the respective sets\n rows[row].add(num)\n columns[col].add(num)\n subgrids[subgrid_index].add(num)\n \n # If no duplicates are found, the Sudoku is valid\n return True\n","runtime":"75"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n n = len(board)\n rows = [set() for i in range(n)]\n cols = [set() for i in range(n)]\n boxes = defaultdict(set)\n\n for r in range(n):\n for c in range(n):\n val = board[r][c]\n if val == \".\":\n continue\n if val in rows[r] or val in cols[c] or val in boxes[(r // 3, c // 3)]:\n return False\n rows[r].add(val)\n cols[c].add(val)\n boxes[(r // 3, c // 3)].add(val)\n\n return True","runtime":"76"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = defaultdict(set)\n cols = defaultdict(set)\n squares = defaultdict(set)\n\n for r in range(len(board)):\n for c in range(len(board[0])):\n if board[r][c] == \".\":\n continue\n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in squares[(r//3, c//3)]:\n return False\n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n squares[(r//3, c//3)].add(board[r][c])\n \n return True\n\n","runtime":"76"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = defaultdict(set)\n cols = defaultdict(set)\n grid = defaultdict(set)\n\n for i in range(len(board)):\n for j in range(len(board[0])):\n if board[i][j] == \".\":\n continue\n else:\n if board[i][j] in rows[i] or board[i][j] in cols[j] or board[i][j] in grid[(i//3,j//3)]:\n return False\n rows[i].add(board[i][j])\n cols[j].add(board[i][j])\n grid[(i//3,j//3)].add(board[i][j])\n \n return True\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \"\"\"col = collections.defaultdict(set)\n row = collections.defaultdict(set)\n grid = collections.defaultdict(set)\n\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n continue\n if (board[i][j] in row[i] or board[i][j] in col[j] or board[i][j] in grid[(i//3,j//3)]):\n return False\n \n col[j].add(board[i][j])\n row[i].add(board[i][j])\n grid[(i//3,j//3)].add(board[i][j])\n \n return True\n\"\"\"\n \n\n\n \n ","runtime":"77"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n #check row\n for i in range(9):\n check = [0]*10\n for j in range(9):\n if board[i][j] == \".\": continue\n n = int(board[i][j])\n if check[n]: return False\n else: check[n] = 1\n\n #check col\n for i in range(9):\n check = [0]*10\n for j in range(9):\n if board[j][i] == \".\": continue\n n = int(board[j][i])\n if check[n]: return False\n else: check[n] = 1\n \n #check 3x3 grid\n for R in range(3):\n for C in range(3):\n check = [0]*10\n for i in range(R*3, R*3+3):\n for j in range(C*3, C*3+3):\n if board[i][j] == \".\": continue\n n = int(board[i][j])\n if check[n]: return False\n else: check[n] = 1\n return True","runtime":"78"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n n = 9\n rows = []\n cols = []\n cells = []\n\n for i in range(9):\n rows.append(set())\n cols.append(set())\n cells.append(set())\n\n\n for i in range(9):\n for j in range(9):\n val = board[i][j]\n if val == \".\":\n continue\n cell = 3 * (i // 3) + j // 3\n if val in rows[i] or val in cols[j] or val in cells[cell]:\n return False\n rows[i].add(val)\n cols[j].add(val)\n cells[cell].add(val)\n\n return True\n","runtime":"78"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n row = [set() for _ in range(9)]\n col = [set() for _ in range(9)]\n box = [set() for _ in range(9)]\n\n for i in range(9):\n for j in range(9):\n num = board[i][j]\n if num == '.':\n continue\n box_index = (i//3)*3 + (j//3)\n\n if num in row[i]:\n return False\n row[i].add(num)\n if num in col[j]:\n return False\n col[j].add(num)\n if num in box[box_index]:\n return False\n box[box_index].add(num)\n return True\n\n","runtime":"79"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n\n def check_square(top_left_r: int, top_left_c: int) -> bool:\n track = set()\n for i in range(top_left_r, top_left_r + 3):\n for j in range(top_left_c, top_left_c + 3):\n if board[i][j] == \".\":\n continue\n if board[i][j] in track:\n return False\n track.add(board[i][j])\n return True\n\n for row in board:\n track = set()\n for num in row:\n if num == \".\":\n continue\n if num in track:\n return False\n track.add(num)\n \n for r in range(len(board[0])):\n track = set()\n for c in range(len(board)):\n if board[c][r] == \".\":\n continue\n if board[c][r] in track:\n return False\n track.add(board[c][r])\n\n for r in range(0, 9, 3):\n for c in range(0, 9, 3):\n if not check_square(top_left_r=r, top_left_c=c):\n return False\n\n return True\n \n ","runtime":"79"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [set() for _ in range(9)]\n for i in range(9):\n for j in range(9):\n num = board[i][j]\n if num == '.':\n continue\n if num in rows[i]:\n return False\n rows[i].add(num)\n if num in cols[j]:\n return False\n cols[j].add(num)\n box_index = (i // 3) * 3 + (j // 3)\n if num in boxes[box_index]:\n return False\n boxes[box_index].add(num)\n return True\n ","runtime":"80"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = {0 : [False] * 9, 1 : [False] * 9, 2 : [False] * 9, 3 : [False] * 9, 4 : [False] * 9, 5 : [False] * 9, 6 : [False] * 9, 7 : [False] * 9, 8 : [False] * 9}\n columns = {0 : [False] * 9, 1 : [False] * 9, 2 : [False] * 9, 3 : [False] * 9, 4 : [False] * 9, 5 : [False] * 9, 6 : [False] * 9, 7 : [False] * 9, 8 : [False] * 9}\n boxes = {0 : [False] * 9, 1 : [False] * 9, 2 : [False] * 9, 3 : [False] * 9, 4 : [False] * 9, 5 : [False] * 9, 6 : [False] * 9, 7 : [False] * 9, 8 : [False] * 9}\n\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n continue\n # square in the ith row and jth column\n curr = int(board[i][j])\n box = None\n if 0 <= i <= 2 and 0 <= j <= 2:\n box = 0\n elif 3 <= i <= 5 and 0 <= j <= 2:\n box = 1\n elif 6 <= i <= 8 and 0 <= j <= 2:\n box = 2\n elif 0 <= i <= 2 and 3 <= j <= 5:\n box = 3\n elif 3 <= i <= 5 and 3 <= j <= 5:\n box = 4\n elif 6 <= i <= 8 and 3 <= j <= 5:\n box = 5\n elif 0 <= i <= 2 and 6 <= j <= 8:\n box = 6\n elif 3 <= i <= 5 and 6 <= j <= 8:\n box = 7\n elif 6 <= i <= 8 and 6 <= j <= 8:\n box = 8\n\n if rows[i][curr-1]:\n return False\n if columns[j][curr-1]:\n return False\n if boxes[box][curr-1]:\n return False\n \n rows[i][curr-1] = True\n columns[j][curr-1] = True\n boxes[box][curr-1] = True\n return True\n ","runtime":"80"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = collections.defaultdict(set)\n cols = collections.defaultdict(set)\n squares = collections.defaultdict(set)\n\n \n\n for r in range(9):\n for c in range(9):\n if board[r][c] == '.':\n continue\n \n if ( \n board[r][c] in rows[r] or\n board[r][c] in cols[c] or\n board[r][c] in squares[(r//3, c//3)]\n ):\n return False\n \n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n squares[(r//3, c//3)].add(board[r][c])\n \n\n return True\n\n \n","runtime":"81"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n arr = []\n for i in range(9):\n for j in range(9):\n ele = board[i][j]\n if ele != '.':\n arr += [(i,ele),(ele,j),(i//3,j//3,ele)]\n return len(arr) == len(set(arr))\n\n ","runtime":"81"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = defaultdict(set)\n cols = defaultdict(set)\n boxes = defaultdict(set)\n\n for i in range(9):\n for j in range(9):\n if board[i][j] != \".\":\n if board[i][j] in rows[i] or board[i][j] in cols[j] or board[i][j] in boxes[i // 3, j // 3]:\n return False\n else:\n rows[i].add(board[i][j])\n cols[j].add(board[i][j])\n boxes[i // 3, j // 3].add(board[i][j])\n \n return True\n\n\n\n\n ","runtime":"82"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n col=[ [] for _ in range(9) ]\n square=[ [ [] for _ in range(3) ] for _ in range(3) ]\n \n for x,r in enumerate(board):\n row=set()\n for y,n in enumerate(r):\n if n!=\".\":\n \n if n in row:return False\n else:row.add(n)\n\n if n in col[y]:return False\n else:col[y].append(n)\n\n if n in square[x//3][y//3]:return False\n else: square[x//3][y//3].append(n)\n \n return True\n","runtime":"82"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rowsMap = defaultdict(set)\n columnsMap = defaultdict(set)\n boxMap = defaultdict(set)\n\n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\":\n continue\n if board[r][c] in rowsMap[r]:\n return False\n\n if board[r][c] in columnsMap[c]:\n return False\n\n if board[r][c] in boxMap[(r//3, c//3)]:\n return False\n\n rowsMap[r].add(board[r][c])\n columnsMap[c].add(board[r][c])\n boxMap[(r//3, c//3)].add(board[r][c])\n return True\n ","runtime":"83"},{"code":"class Solution:\n def isValidSudoku(self, board: list[list[str]]) -> bool:\n seen = set()\n\n for i in range(9):\n for j in range(9):\n c = board[i][j]\n if c == '.':\n continue\n if (c + '@row ' + str(i) in seen or\n c + '@col ' + str(j) in seen or\n c + '@box ' + str(i // 3) + str(j // 3) in seen):\n return False\n seen.add(c + '@row ' + str(i))\n seen.add(c + '@col ' + str(j))\n seen.add(c + '@box ' + str(i // 3) + str(j // 3))\n\n return True","runtime":"83"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [set() for _ in range(9)] \n for r in range(9):\n for c in range(9):\n num = board[r][c]\n if num == \".\":\n continue\n box_index = (r // 3) * 3 + (c // 3)\n if num in rows[r] or num in cols[c] or num in boxes[box_index]:\n return False\n rows[r].add(num)\n cols[c].add(num)\n boxes[box_index].add(num)\n return True","runtime":"84"},{"code":"# class Solution:\n# def isValidSudoku(self, board: list[list[str]]) -> bool:\n# hold = [0,0,0,0,0,0,0,0,0]\n# for i in range(0,9):\n# for j in range(0,9):\n# try:\n# board[i][j] = int(board[i][j])\n# except ValueError:\n# board[i][j] = 0\n# for i in range(0,9):\n# reset = hold.copy()\n# for j in range(0,9):\n# if board[j][i] > 0 :\n# if board[j][i] == reset[board[j][i]-1]:\n# return False\n# reset[board[j][i]-1] = board[j][i]\n# for k in range(0,9,3):\n# for l in range(0,9,3):\n# reset = hold.copy()\n# for i in range(k,k+3):\n# for j in range(l,l+3):\n# if board[i][j] > 0:\n# if board[i][j] == reset[board[i][j]-1]:\n# return False\n# reset[board[i][j]-1] = board[i][j]\n# for i in range(0,9):\n# reset = hold.copy()\n# for j in board[i]:\n# if j > 0:\n# if j == reset[j-1]:\n# return False\n# reset[j-1] = j\n# return True\nclass Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = defaultdict(set)\n cols = defaultdict(set)\n boxes = defaultdict(set)\n \n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\":\n continue\n \n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in boxes[(r // 3, c // 3)]:\n return False\n \n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n boxes[(r // 3, c // 3)].add(board[r][c])\n \n return True","runtime":"84"},{"code":"class Solution:\n def isValidSudoku(self, board):\n rows = defaultdict(set)\n cols = defaultdict(set)\n boxes = defaultdict(set)\n \n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\":\n continue\n \n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in boxes[(r // 3, c // 3)]:\n return False\n \n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n boxes[(r // 3, c // 3)].add(board[r][c])\n return True","runtime":"85"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n # for row in board:\n # print(*row)\n for row in range(9):\n seen = [False] * 10\n for col in range(9):\n if board[row][col] == '.':\n continue\n val = int(board[row][col])\n if seen[val]:\n return False\n seen[val] = True\n for row in range(9):\n seen = [False] * 10\n for col in range(9):\n if board[col][row] == '.':\n continue\n val = int(board[col][row])\n if seen[val]:\n return False\n seen[val] = True\n for sr in range(0, 9, 3):\n for sc in range(0, 9, 3):\n seen = [False] * 10\n for i in range(3):\n for j in range(3):\n if board[sr+i][sc+j] == '.':\n continue\n val = int(board[sr+i][sc+j])\n if seen[val]:\n return False\n seen[val] = True\n return True","runtime":"85"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = defaultdict(set)\n cols = defaultdict(set)\n boxes = defaultdict(set)\n\n for r in range(9):\n for c in range(9):\n curr_num = board[r][c]\n\n if curr_num == '.':\n continue\n \n if curr_num in rows[r] or curr_num in cols[c] or curr_num in boxes[(r//3, c//3)]:\n return False\n\n rows[r].add(curr_num)\n cols[c].add(curr_num)\n boxes[(r//3, c//3)].add(curr_num)\n\n return True","runtime":"86"},{"code":"from collections import defaultdict\nclass Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n cols = defaultdict(set)\n rows = defaultdict(set)\n sqrs = defaultdict(set) \n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n continue\n num = board[i][j]\n if num in rows[i] or num in cols[j] or num in sqrs[(i//3, j//3)]:\n return False\n rows[i].add(num)\n cols[j].add(num)\n sqrs[(i//3, j//3)].add(num)\n return True","runtime":"86"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n\n def printBoard(board):\n for row in board:\n print(row)\n printBoard(board)\n\n squares=[(0,0), (0, 3), (0, 6),(3,0), (3, 3), (3, 6),(6,0), (6, 3), (6, 6)]\n \n def isRowValid(i):\n seen = [0] * 10\n for j in range(len(board[i])):\n if board[i][j] == \".\":\n continue\n if seen[int(board[i][j])]:\n return False\n seen[int(board[i][j])] = 1\n return True\n\n def isColValid(j):\n seen = [0] * 10\n for i in range(len(board)):\n if board[i][j] == \".\":\n continue\n if seen[int(board[i][j])]:\n return False\n seen[int(board[i][j])] = 1\n return True\n\n def isSquareValid(i, j):\n seen = [0] * 10\n for y in range(3):\n for x in range(3):\n if board[i + y][j + x] == \".\":\n continue\n if seen[int(board[i + y][j + x])]:\n return False\n seen[int(board[i + y][j + x])] = 1\n\n return True\n\n for row in range(len(board)):\n if not isRowValid(row):\n return False\n for col in range(len(board)):\n if not isColValid(col):\n return False\n for square in squares:\n i, j = square\n if not isSquareValid(i, j):\n return False\n return True","runtime":"87"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n flag=True\n sub1=[]\n sub2=[]\n sub3=[]\n for i in range(9):\n rows_list=[]\n columns_list=[]\n for j in range(9):\n if board[i][j]!=\".\":\n rows_list.append(board[i][j])\n if board[j][i]!=\".\":\n columns_list.append(board[j][i])\n #Append in Sub-Box\n if j==0: \n if board[i][j]!=\".\": \n sub1.append(board[i][j])\n if board[i][j+1]!=\".\": \n sub1.append(board[i][j+1])\n if board[i][j+2]!=\".\": \n sub1.append(board[i][j+2])\n elif j==3: \n if board[i][j]!=\".\": \n sub2.append(board[i][j])\n if board[i][j+1]!=\".\": \n sub2.append(board[i][j+1])\n if board[i][j+2]!=\".\": \n sub2.append(board[i][j+2])\n elif j==6: \n if board[i][j]!=\".\": \n sub3.append(board[i][j])\n if board[i][j+1]!=\".\": \n sub3.append(board[i][j+1])\n if board[i][j+2]!=\".\": \n sub3.append(board[i][j+2]) \n # print(f\"For row i={i} the Sub boxes are {sub1} \\n {sub2} \\n {sub3}\")\n #check unique row\n if len(rows_list)!=len(set(rows_list)):\n #duplicate present\n # print(f\"Duplicate found on ROW {rows_list}\")\n flag=False\n break\n #check unique column\n if len(columns_list)!=len(set(columns_list)):\n #duplicate present\n # print(f\"Duplicate found on Column {columns_list}\")\n flag=False\n break\n #\n if i==2 or i==5 or i==8:\n #check unique Sub-Box\n if len(sub1)!=len(set(sub1)):\n #duplicate present\n # print(f\"Duplicate found on Sub Box 1 {sub1}\")\n flag=False\n break\n if len(sub2)!=len(set(sub2)):\n #duplicate present\n # print(f\"Duplicate found on Sub Box 2 {sub2}\")\n flag=False\n break\n if len(sub3)!=len(set(sub3)):\n #duplicate present\n # print(f\"Duplicate found on Sub Box 3 {sub3}\")\n flag=False\n break\n sub1=[]\n sub2=[]\n sub3=[]\n return flag\n\n\n ","runtime":"87"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = defaultdict(set)\n cols = defaultdict(set)\n squares = defaultdict(set)\n\n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\":\n continue\n if (board[r][c] in rows[r] or\n board[r][c] in cols[c] or\n board[r][c] in squares[(r//3, c//3)]):\n return False\n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n squares[(r//3, c//3)].add(board[r][c])\n return True","runtime":"88"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n # row key [idx] -> Set()\n # col key [idx] -> Set()\n # Box key c // 3 - r // 3 -> Set()\n\n rows, cols, boxes = {}, {}, {}\n\n for r in range(len(board)):\n for c in range(len(board[0])):\n value = board[r][c]\n if value == '.':\n continue\n \n current_box = f'{r // 3} - {c // 3}'\n if r not in rows:\n rows[r] = set()\n if c not in cols:\n cols[c] = set()\n if current_box not in boxes:\n boxes[current_box] = set()\n \n if value in rows[r] or value in cols[c] or value in boxes[current_box]:\n return False\n \n rows[r].add(value)\n cols[c].add(value)\n boxes[current_box].add(value)\n\n return True\n","runtime":"88"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n for i in range(9):\n row_visited = set()\n for j in range(9):\n if i % 3 == 0 and j % 3 == 0:\n if not self.subBoxes(board, i, j):\n return False\n cell = board[i][j]\n if cell != '.':\n if cell in row_visited:\n return False\n row_visited.add(cell)\n \n for i in range(9):\n col_visited = set()\n for j in range(9):\n cell = board[j][i]\n if cell != '.':\n if cell in col_visited:\n return False\n col_visited.add(cell)\n \n return True\n \n def subBoxes(self, board: List[List[str]], x: int, y: int) -> bool:\n visited = set()\n for i in range(x, x + 3):\n for j in range(y, y + 3):\n cell = board[i][j]\n if cell != '.':\n if cell in visited:\n return False\n visited.add(cell)\n return True","runtime":"89"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n # Initialize sets to keep track of seen digits\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [set() for _ in range(9)]\n\n for i in range(9):\n for j in range(9):\n num = board[i][j]\n if num == '.':\n continue\n \n # Check the row\n if num in rows[i]:\n return False\n rows[i].add(num)\n \n # Check the column\n if num in cols[j]:\n return False\n cols[j].add(num)\n \n # Check the 3x3 sub-box\n box_index = (i // 3) * 3 + (j // 3)\n if num in boxes[box_index]:\n return False\n boxes[box_index].add(num)\n \n return True\n\n ","runtime":"89"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n # Check rows and columns\n for i in range(9):\n row_set = set()\n col_set = set()\n for j in range(9):\n # Check row\n if board[i][j] != '.':\n if board[i][j] in row_set:\n return False\n row_set.add(board[i][j])\n\n # Check column\n if board[j][i] != '.':\n if board[j][i] in col_set:\n return False\n col_set.add(board[j][i])\n\n # Check 3x3 subgrids\n for i in range(0, 9, 3):\n for j in range(0, 9, 3):\n block_set = set()\n for u in range(3):\n for v in range(3):\n cell_value = board[i + u][j + v]\n if cell_value != '.':\n if cell_value in block_set:\n return False\n block_set.add(cell_value)\n \n return True\n","runtime":"90"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = {}\n columns = {}\n boxes = {}\n\n i = 0\n j = 0\n \n for i in range(len(board)):\n for j in range(len(board)):\n cur = board[i][j]\n\n if cur == \".\":\n continue\n\n if i not in rows:\n rows[i] = set()\n if j not in columns:\n columns[j] = set()\n if (i//3, j//3) not in boxes:\n boxes[(i//3, j//3)] = set()\n\n if (cur in rows[i]) or (cur in columns[j]) or (cur in boxes[(i//3, j//3)]):\n return False\n \n rows[i].add(cur)\n columns[j].add(cur)\n boxes[(i//3, j//3)].add(cur)\n\n return True","runtime":"90"},{"code":"from itertools import product\n\nclass Solution:\n def is_valid(self, coords, board):\n seen = set()\n for i, j in coords:\n val = board[i][j]\n if val in seen:\n return False\n elif val != \".\":\n seen.add(val)\n\n return True\n\n\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n # Check rows.\n for i in range(9):\n if not self.is_valid(product([i], range(9)), board):\n return False\n\n # Check columns.\n for j in range(9):\n if not self.is_valid(product(range(9), [j]), board):\n return False\n\n # Check subgrids.\n for subgrid in range(9):\n # Get rows.\n if subgrid < 3:\n rows = [0, 1, 2]\n elif subgrid < 6:\n rows = [3, 4, 5]\n else:\n rows = [6, 7, 8]\n\n # Get cols.\n if subgrid % 3 == 0:\n cols = [0, 1, 2]\n elif subgrid % 3 == 1:\n cols = [3, 4, 5]\n else:\n cols = [6, 7, 8]\n\n if not self.is_valid(product(rows, cols), board):\n return False\n\n return True","runtime":"91"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n \n for line in board:\n if not self.isLineValid(line):\n return False\n \n for i in range(len(board)):\n if not self.isLineValid([line[i] for line in board]):\n return False \n \n return self.isSquareValid(board)\n \n def isLineValid(self, line: list[str]) -> bool:\n int_line = [int(i) for i in line if i.isdigit()]\n return len(int_line) == len(set(int_line))\n \n def isSquareValid(self, square: list[list[str]]) -> bool:\n for offset in range(0, 7, 3):\n rect = square[offset: offset + 3]\n for inner_offset in range(0, 7, 3):\n sq = []\n for i in rect:\n sq.extend(i[inner_offset: inner_offset + 3])\n \n if not self.isLineValid(sq):\n return False\n return True","runtime":"91"},{"code":"from collections import defaultdict\n\nclass Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n def check_array(arr):\n arr = [item for item in arr if item != \".\"]\n return len(set(arr)) == len(arr)\n \n lines = defaultdict(list)\n sub_boxes = [[[], [], [],], [[], [], []], [[], [], []]]\n \n curr_row_sub_boxes = 0\n for i in range(len(board)):\n \n if not check_array(board[i]):\n return False\n \n curr_line_sub_boxes = 0\n \n for j in range(len(board[i])):\n lines[j].append(board[i][j])\n sub_boxes[curr_row_sub_boxes][curr_line_sub_boxes].append(board[i][j])\n if j in [2, 5]:\n curr_line_sub_boxes += 1\n if i in [2, 5]:\n curr_row_sub_boxes += 1\n\n for arrays in sub_boxes:\n for a in arrays:\n if not check_array(a):\n return False\n \n for arr in lines.values():\n if not check_array(arr):\n return False\n \n return True","runtime":"92"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n hashmap = {}\n\n #check rows\n for i in range(9):\n for j in range(9):\n if board[i][j] in hashmap and board[i][j] != '.':\n # print(i,j,\"rows\")\n return False\n else:\n hashmap[board[i][j]] = 1 \n hashmap = {}\n \n hashmap = {}\n \n \n #check columns\n for i in range(9):\n for j in range(9):\n if board[j][i] in hashmap and board[j][i] != '.':\n # print(j, i, \"cols\")\n return False\n else:\n hashmap[board[j][i]] = 1 \n hashmap = {}\n \n hashmap = {}\n\n #check squares\n for m in range(0,9,3):\n for k in range(0,9,3):\n # print(k,k+3)\n for i in range(k, k+3):\n # print(i)\n # for l in range(0,9,3):\n for j in range(m,m+3):\n print(i,j)\n if board[i][j] in hashmap and board[i][j] != '.':\n # print(i, j, \"err\")\n return False\n else:\n hashmap[board[i][j]] = 1 \n # print(\"reset\")\n # hashmap = {}\n # print(\"bigreset\")\n hashmap = {}\n \n \n # [[\".\",\".\",\".\",\".\",\"5\",\".\",\".\",\"1\",\".\"],\n # [\".\",\"4\",\".\",\"3\",\".\",\".\",\".\",\".\",\".\"],\n # [\".\",\".\",\".\",\".\",\".\",\"3\",\".\",\".\",\"1\"],\n # [\"8\",\".\",\".\",\".\",\".\",\".\",\".\",\"2\",\".\"],\n # [\".\",\".\",\"2\",\".\",\"7\",\".\",\".\",\".\",\".\"],\n # [\".\",\"1\",\"5\",\".\",\".\",\".\",\".\",\".\",\".\"],\n # [\".\",\".\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\"],\n # [\".\",\"2\",\".\",\"9\",\".\",\".\",\".\",\".\",\".\"],\n # [\".\",\".\",\"4\",\".\",\".\",\".\",\".\",\".\",\".\"]]\n\n \n return True\n\n ","runtime":"92"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n res = []\n for i in range(9):\n for j in range(9):\n element = board[i][j]\n if element != '.':\n res += [(i, element), (element, j), (i // 3, j // 3, element)]\n return len(res) == len(set(res))\n ","runtime":"93"},{"code":"class Solution:\n \n # # 1: check duplicates in each row, col and quadrat\n # def isValidSudoku(self, board: List[List[str]]) -> bool:\n # for r in range(9):\n # row = [el for el in board[r] if el != \".\"]\n # if len(set(row)) != len(row):\n # return False\n # for c in range(9):\n # col = [row[c] for row in board if row[c] != \".\"]\n # if len(set(col)) != len(col):\n # return False\n # for q_r in range(3):\n # for q_c in range(3):\n # quad = []\n # for r in range(q_r*3, q_r*3+3):\n # for c in range(q_c*3, q_c*3+3):\n # el = board[r][c]\n # if el != \".\":\n # quad.append(el)\n # if len(set(quad)) != len(quad):\n # return False\n # return True\n \n # 2: hashset\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n N = 9\n rows = [set() for _ in range(N)]\n cols = [set() for _ in range(N)]\n quads = [set() for _ in range(N)]\n \n for r in range(9):\n for c in range(9):\n val = board[r][c]\n if val == '.':\n continue\n \n if val in rows[r]:\n return False\n else:\n rows[r].add(val)\n \n if val in cols[c]:\n return False\n else:\n cols[c].add(val)\n \n idx = r//3*3+c//3\n if val in quads[idx]:\n return False\n else:\n quads[idx].add(val)\n \n return True\n \n \n \n \n \n ","runtime":"93"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n for i in range(9):\n row_visited = set()\n for j in range(9):\n if i % 3 == 0 and j % 3 == 0:\n if not self.subBoxes(board, i, j):\n return False\n cell = board[i][j]\n if cell != '.':\n if cell in row_visited:\n return False\n row_visited.add(cell)\n \n for i in range(9):\n col_visited = set()\n for j in range(9):\n cell = board[j][i]\n if cell != '.':\n if cell in col_visited:\n return False\n col_visited.add(cell)\n \n return True\n \n def subBoxes(self, board: List[List[str]], x: int, y: int) -> bool:\n visited = set()\n for i in range(x, x + 3):\n for j in range(y, y + 3):\n cell = board[i][j]\n if cell != '.':\n if cell in visited:\n return False\n visited.add(cell)\n return True","runtime":"94"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = [set() for x in range(9)] # a set for each row\n cols = [set() for x in range(9)]\n sqrs = [set() for x in range(9)]\n for i in range(9):\n for j in range(9):\n cell = board[i][j]\n k = i//3*3 + j//3\n if cell == \".\":\n continue\n elif cell in rows[i] or cell in cols[j] or cell in sqrs[k]:\n return False \n rows[i].add(cell)\n cols[j].add(cell)\n sqrs[k].add(cell)\n return True\n","runtime":"94"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows=collections.defaultdict(set)\n cols=collections.defaultdict(set)\n squares=collections.defaultdict(set)\n\n for r in range(9):\n for c in range(9):\n if board[r][c]==\".\":\n continue\n if (board[r][c] in rows[r] or\n board[r][c] in cols[c] or\n board[r][c] in squares[(r//3,c//3)]):\n return False\n \n cols[c].add(board[r][c])\n rows[r].add(board[r][c])\n squares[(r//3,c//3)].add(board[r][c])\n\n return True\n ","runtime":"95"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = defaultdict(set) # make a dict for each row and their values\n cols = defaultdict(set)\n subgrid = defaultdict(set)\n for r in range(9):\n for c in range(9):\n if board[r][c] == '.':\n continue\n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in subgrid[(r//3, c//3)]:\n return False\n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n subgrid[(r//3, c//3)].add(board[r][c])\n return True\n \n\n","runtime":"95"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n flag=True\n sub1=[]\n sub2=[]\n sub3=[]\n for i in range(9):\n rows_list=[]\n columns_list=[]\n for j in range(9):\n if board[i][j]!=\".\":\n rows_list.append(board[i][j])\n if board[j][i]!=\".\":\n columns_list.append(board[j][i])\n #Append in Sub-Box\n if j==0: \n if board[i][j]!=\".\": \n sub1.append(board[i][j])\n if board[i][j+1]!=\".\": \n sub1.append(board[i][j+1])\n if board[i][j+2]!=\".\": \n sub1.append(board[i][j+2])\n elif j==3: \n if board[i][j]!=\".\": \n sub2.append(board[i][j])\n if board[i][j+1]!=\".\": \n sub2.append(board[i][j+1])\n if board[i][j+2]!=\".\": \n sub2.append(board[i][j+2])\n elif j==6: \n if board[i][j]!=\".\": \n sub3.append(board[i][j])\n if board[i][j+1]!=\".\": \n sub3.append(board[i][j+1])\n if board[i][j+2]!=\".\": \n sub3.append(board[i][j+2]) \n # print(f\"For row i={i} the Sub boxes are {sub1} \\n {sub2} \\n {sub3}\")\n #check unique row\n if len(rows_list)!=len(set(rows_list)):\n #duplicate present\n print(f\"Duplicate found on ROW {rows_list}\")\n flag=False\n break\n #check unique column\n if len(columns_list)!=len(set(columns_list)):\n #duplicate present\n print(f\"Duplicate found on Column {columns_list}\")\n flag=False\n break\n #\n if i==2 or i==5 or i==8:\n #check unique Sub-Box\n if len(sub1)!=len(set(sub1)):\n #duplicate present\n print(f\"Duplicate found on Sub Box 1 {sub1}\")\n flag=False\n break\n if len(sub2)!=len(set(sub2)):\n #duplicate present\n print(f\"Duplicate found on Sub Box 2 {sub2}\")\n flag=False\n break\n if len(sub3)!=len(set(sub3)):\n #duplicate present\n print(f\"Duplicate found on Sub Box 3 {sub3}\")\n flag=False\n break\n sub1=[]\n sub2=[]\n sub3=[]\n return flag\n\n\n ","runtime":"96"},{"code":"\nclass Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n SIZE = len(board)\n\n #BOX CHECK\n for block_hor in range(3):\n for block_ver in range(3):\n num_set = set()\n for i in range(3):\n for j in range(3):\n num = board[block_hor * 3 + i][block_ver * 3 + j]\n if num in num_set:\n return False\n if num != \".\":\n num_set.add(num)\n \n\n\n #row and col check\n for i in range(SIZE):\n colset = set()\n rowset = set()\n for j in range(SIZE):\n if board[i][j] in colset or board[j][i] in rowset:\n return False\n if board[i][j] != \".\":\n colset.add(board[i][j])\n if board[j][i] != \".\":\n rowset.add(board[j][i])\n print(colset, rowset)\n return True\n\n","runtime":"96"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n row = [[] for _ in range(9)]\n col = [ [] for _ in range(9)]\n sub_box = [[[] for i in range(3)] for _ in range(3)]\n for i in range(9):\n for j in range(9):\n val = board[i][j]\n if val == '.':\n continue\n curr_row = row[i]\n curr_col = col[j]\n curr_sub_box = sub_box[i//3][j//3]\n if val in curr_row or val in curr_col or val in curr_sub_box:\n print(i,j)\n print(val)\n print(curr_col)\n print(curr_row)\n print(curr_sub_box)\n return False\n curr_row.append(val)\n curr_col.append(val)\n curr_sub_box.append(val)\n return True\n\"\"\"\n[\n[\"5\",\"3\",\".\",\".\",\"7\",\".\",\".\",\".\",\".\"],\n[\"6\",\".\",\".\",\"1\",\"9\",\"5\",\".\",\".\",\".\"],\n[\".\",\"9\",\"8\",\".\",\".\",\".\",\".\",\"6\",\".\"],\n[\"8\",\".\",\".\",\".\",\"6\",\".\",\".\",\".\",\"3\"],\n[\"4\",\".\",\".\",\"8\",\".\",\"3\",\".\",\".\",\"1\"],\n[\"7\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\",\"6\"],\n[\".\",\"6\",\".\",\".\",\".\",\".\",\"2\",\"8\",\".\"],\n[\".\",\".\",\".\",\"4\",\"1\",\"9\",\".\",\".\",\"5\"],\n[\".\",\".\",\".\",\".\",\"8\",\".\",\".\",\"7\",\"9\"]]\n\"\"\"","runtime":"97"},{"code":"class Solution:\n def checkRow(self, board: List[List[str]]) -> bool:\n for row in board:\n appared = set()\n for n in row:\n if n is not \".\" and n in appared:\n return False\n appared.add(n)\n return True\n def checkColumn(self, board: List[List[str]]) -> bool:\n for col_i in range(0, 9):\n appared = set()\n for row in board:\n n = row[col_i]\n if n is not \".\" and n in appared:\n return False\n appared.add(n)\n return True\n def checkSquare(self, board: List[List[str]]) -> bool:\n leftTops = [[0,0], [0,3], [0,6], [3,0], [3,3], [3,6],[6,0],[6,3],[6,6]]\n for leftTop in leftTops:\n [leftTopRow, leftTopCol] = leftTop\n appared = set()\n for row in range(leftTopRow, leftTopRow+3):\n for col in range(leftTopCol, leftTopCol+3):\n n = board[row][col]\n if n is not \".\" and n in appared:\n return False\n appared.add(n)\n return True\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n return self.checkRow(board) and self.checkColumn(board) and self.checkSquare(board)","runtime":"97"},{"code":"# class Solution:\n# def isValidSudoku(self, board: list[list[str]]) -> bool:\n# hold = [0,0,0,0,0,0,0,0,0]\n# for i in range(0,9):\n# for j in range(0,9):\n# try:\n# board[i][j] = int(board[i][j])\n# except ValueError:\n# board[i][j] = 0\n# for i in range(0,9):\n# reset = hold.copy()\n# for j in range(0,9):\n# if board[j][i] > 0 :\n# if board[j][i] == reset[board[j][i]-1]:\n# return False\n# reset[board[j][i]-1] = board[j][i]\n# for k in range(0,9,3):\n# for l in range(0,9,3):\n# reset = hold.copy()\n# for i in range(k,k+3):\n# for j in range(l,l+3):\n# if board[i][j] > 0:\n# if board[i][j] == reset[board[i][j]-1]:\n# return False\n# reset[board[i][j]-1] = board[i][j]\n# for i in range(0,9):\n# reset = hold.copy()\n# for j in board[i]:\n# if j > 0:\n# if j == reset[j-1]:\n# return False\n# reset[j-1] = j\n# return True\nclass Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = defaultdict(set)\n cols = defaultdict(set)\n boxes = defaultdict(set)\n \n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\":\n continue\n \n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in boxes[(r // 3, c // 3)]:\n return False\n \n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n boxes[(r // 3, c // 3)].add(board[r][c])\n \n return True","runtime":"98"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rowCheck = [set() for _ in range(9)]\n colCheck = [set() for _ in range(9)]\n threeCheck = {((i//3, j//3)): set() for i in range(9) for j in range(9)}\n\n for i in range(len(board)):\n for j in range(len(board[0])):\n if board[i][j] != \".\":\n if board[i][j] not in rowCheck[i]:\n rowCheck[i].add(board[i][j])\n else:\n return False\n if board[i][j] not in colCheck[j]:\n colCheck[j].add(board[i][j])\n else:\n return False\n if board[i][j] not in threeCheck[(i//3, j//3)]:\n threeCheck[(i//3, j//3)].add(board[i][j])\n else:\n return False\n return True\n","runtime":"98"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n\n \"\"\"\n 9x9 2D array - partially or fully filled\n\n every row unique 1-9\n every column unique 1-9\n \n each 9 3x3 boxes unique 1-9\n\n empty cells '.'\n\n\n 8-> 2,2\n\n 2/3, 2/3--> 0,0\n\n 8,8---> 8/3,8/3-->2,2\n\n \"\"\"\n\n row=collections.defaultdict(set)\n col=collections.defaultdict(set)\n\n subbox=collections.defaultdict(set)\n\n for r in range(9):\n for c in range(9):\n\n if board[r][c]=='.':\n continue\n\n else:\n if (board[r][c] in row[r]) or (board[r][c] in col[c]) or (board[r][c] in subbox[(r//3,c//3)]):\n\n return False\n\n row[r].add(board[r][c])\n col[c].add(board[r][c])\n subbox[(r//3,c//3)].add(board[r][c])\n \n return True\n\n \n\n \n\n\n\n\n\n\n ","runtime":"99"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n for r in range(1,9,3):\n for c in range(1,9,3):\n seen = set()\n for i in range(r-1,r+2):\n for j in range(c-1,c+2):\n if board[i][j] in seen:\n return False\n if board[i][j] != '.': \n seen.add(board[i][j])\n\n for c in range(9):\n seen = set()\n for r in range(9):\n if board[r][c] in seen:\n return False\n if board[r][c] != '.':\n seen.add(board[r][c])\n \n for r in range(9):\n seen = set()\n for c in range(9):\n if board[r][c] in seen:\n return False\n if board[r][c] != '.':\n seen.add(board[r][c])\n\n return True","runtime":"99"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n\n # 使用三个字典分别存储行、列和3x3子方块中的数字情况\n rows = [{} for _ in range(9)]\n cols = [{} for _ in range(9)]\n boxes = [{} for _ in range(9)]\n\n # 遍历数独棋盘\n for i in range(9):\n \n for j in range(9):\n num = board[i][j]\n if num != '.': # 只处理填充的数字\n num = int(num)\n box_index = (i // 3) * 3 + j // 3 # 计算当前数字属于哪个3x3子方块\n \n # 检查行、列和子方块中是否已经存在当前数字\n rows[i][num] = rows[i].get(num, 0) + 1\n cols[j][num] = cols[j].get(num, 0) + 1\n boxes[box_index][num] = boxes[box_index].get(num, 0) + 1\n \n # 如果当前数字在行、列或子方块中重复出现，数独无效\n if rows[i][num] > 1 or cols[j][num] > 1 or boxes[box_index][num] > 1:\n return False\n return True","runtime":"100"},{"code":"class Solution:\n def checkRow(self, board: List[List[str]]) -> bool:\n for row in board:\n appared = set()\n for n in row:\n if n is not \".\" and n in appared:\n return False\n appared.add(n)\n return True\n def checkColumn(self, board: List[List[str]]) -> bool:\n for col_i in range(0, 9):\n appared = set()\n for row in board:\n n = row[col_i]\n if n is not \".\" and n in appared:\n return False\n appared.add(n)\n return True\n def checkSquare(self, board: List[List[str]]) -> bool:\n leftTops = [[0,0], [0,3], [0,6], [3,0], [3,3], [3,6],[6,0],[6,3],[6,6]]\n for leftTop in leftTops:\n [leftTopRow, leftTopCol] = leftTop\n appared = set()\n for row in range(leftTopRow, leftTopRow+3):\n for col in range(leftTopCol, leftTopCol+3):\n n = board[row][col]\n if n is not \".\" and n in appared:\n return False\n appared.add(n)\n return True\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n return self.checkRow(board) and self.checkColumn(board) and self.checkSquare(board)","runtime":"100"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n\n def printBoard(board):\n for row in board:\n print(row)\n printBoard(board)\n\n squares=[(0,0), (0, 3), (0, 6),(3,0), (3, 3), (3, 6),(6,0), (6, 3), (6, 6)]\n \n def isRowValid(i):\n seen = [0] * 10\n for j in range(len(board[i])):\n if board[i][j] == \".\":\n continue\n if seen[int(board[i][j])]:\n return False\n seen[int(board[i][j])] = 1\n return True\n\n def isColValid(j):\n seen = [0] * 10\n for i in range(len(board)):\n if board[i][j] == \".\":\n continue\n if seen[int(board[i][j])]:\n return False\n seen[int(board[i][j])] = 1\n return True\n\n def isSquareValid(i, j):\n seen = [0] * 10\n for y in range(3):\n for x in range(3):\n if board[i + y][j + x] == \".\":\n continue\n if seen[int(board[i + y][j + x])]:\n return False\n seen[int(board[i + y][j + x])] = 1\n\n return True\n\n for row in range(len(board)):\n if not isRowValid(row):\n return False\n for col in range(len(board)):\n if not isColValid(col):\n return False\n for square in squares:\n i, j = square\n if not isSquareValid(i, j):\n return False\n return True","runtime":"101"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = self.getRows(board)\n cols = self.getCols(board)\n boxes = self.getBoxes(board)\n\n return self.isUnique(rows) and self.isUnique(cols) and self.isUnique(boxes)\n\n @staticmethod\n def isUnique(numbers: List[List[str]]) -> bool:\n for group in numbers:\n if len(set(group)) != len(group): return False\n else:\n return True\n\n @staticmethod\n def getRows(board: List[List[str]]) -> List[List[str]]:\n return [[x for x in row if x != '.'] for row in board]\n\n @staticmethod\n def getCols(board: List[List[str]]) -> List[List[str]]:\n cols = [[row[i] for row in board] for i in range(9)]\n return [[x for x in col if x != '.'] for col in cols]\n\n @staticmethod\n def getBoxes(board: List[List[str]]) -> List[List[str]]:\n boxes = [[] for _ in range(9)]\n for i, row in enumerate(board):\n for j, col in enumerate(row):\n if board[i][j] == '.': continue\n\n idx = 3 * (i // 3) + j // 3\n boxes[idx].append(board[i][j])\n\n return boxes\n ","runtime":"101"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = collections.defaultdict(set)\n cols = collections.defaultdict(set)\n grid = collections.defaultdict(set) #key = (r/3, c/3)\n\n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\": continue\n n = int(board[r][c])\n if n in rows[r] or n in cols[c] or n in grid[(r//3, c//3)]: return False\n\n rows[r].add(n)\n cols[c].add(n)\n grid[(r//3, c//3)].add(n)\n return True","runtime":"102"},{"code":"class Solution:\n def isValidSudoku(self, board: list[list[str]]) -> bool:\n seen = set()\n\n for i in range(9):\n for j in range(9):\n c = board[i][j]\n if c == '.':\n continue\n if (c + '@row ' + str(i) in seen or\n c + '@col ' + str(j) in seen or\n c + '@box ' + str(i // 3) + str(j // 3) in seen):\n return False\n seen.add(c + '@row ' + str(i))\n seen.add(c + '@col ' + str(j))\n seen.add(c + '@box ' + str(i // 3) + str(j // 3))\n\n return True","runtime":"102"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n l = 9 # length\n for i in range(l):\n row = set()\n col = set()\n box = set()\n for j in range(l):\n a, b, c = board[i][j], board[j][i], board[i-i%3+j//3][(i%3)*3+j%3]\n if a != \".\" and a in row:\n return False\n if b != \".\" and b in col:\n return False\n if c != \".\" and c in box:\n return False\n row.update(a)\n col.update(b)\n box.update(c)\n \n return True","runtime":"105"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n # Checking the rows.\n for i in range(9):\n row_map = {}\n for j in range(9):\n if board[i][j] != \".\" and board[i][j] in row_map:\n return False\n elif board[i][j] not in row_map:\n row_map[board[i][j]] = 0\n row_map[board[i][j]] += 1\n\n # Checking the columns.\n for i in range(9):\n col_map = {}\n for j in range(9):\n if board[j][i] != \".\" and board[j][i] in col_map:\n return False\n elif board[j][i] not in col_map:\n col_map[board[j][i]] = 0\n col_map[board[j][i]] += 1\n\n # Checking the squares.\n curr_square = 0\n curr_row_level = 0\n curr_col_level = 0\n while curr_square <= 8:\n square_map = {}\n for i in range(3):\n for j in range(3):\n if (board[i + (3 * curr_row_level)][j + (3 * curr_col_level)] != \".\" and \n board[i + (3 * curr_row_level)][j + (3 * curr_col_level)] in square_map):\n return False\n elif (board[i + (3 * curr_row_level)][j + (3 * curr_col_level)] not in square_map):\n square_map[board[i + (3 * curr_row_level)][j + (3 * curr_col_level)]] = 0\n square_map[board[i + (3 * curr_row_level)][j + (3 * curr_col_level)]] += 1\n curr_square += 1\n curr_col_level += 1\n if curr_square % 3 == 0:\n curr_row_level += 1\n curr_col_level = 0\n \n return True","runtime":"105"}],"string":"[\n {\n \"code\": \"def is_valid(cells):\\n seen = set()\\n for cell in cells:\\n if cell == '.':\\n continue\\n if cell in seen:\\n return False\\n seen.add(cell)\\n return True\\nclass Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n board_T = zip(*board)\\n \\n for row in board:\\n if is_valid(row) == False:\\n return False\\n \\n for col in board_T:\\n if is_valid(col) == False:\\n return False\\n \\n for r in range(0,9,3):\\n for c in range(0,9,3):\\n cells = []\\n for dr in range(3):\\n for dc in range(3):\\n cells.append(board[r+dr][c+dc])\\n if is_valid(cells) == False:\\n return False\\n \\n return True\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n cols = defaultdict(set)\\n row = defaultdict(set)\\n sq = defaultdict(set)\\n\\n for r in range(9):\\n for c in range(9):\\n cell = board[r][c]\\n\\n if cell == '.':\\n continue\\n\\n if(cell in row[r] or cell in cols[c] or cell in sq[(r//3, c//3)]):\\n\\n return False\\n else:\\n row[r].add(cell)\\n cols[c].add(cell)\\n sq[(r//3, c//3)].add(cell)\\n\\n return True\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"def is_valid(cells):\\n seen = set()\\n for cell in cells:\\n if cell == '.':\\n continue\\n if cell in seen:\\n return False\\n seen.add(cell)\\n return True\\nclass Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n board_T = zip(*board)\\n \\n for row in board:\\n if is_valid(row) == False:\\n return False\\n \\n for col in board_T:\\n if is_valid(col) == False:\\n return False\\n \\n boxes=[(0,0),(0,3),(0,6),(3,0),(3,3),(3,6),(6,0),(6,3),(6,6)]\\n for i,j in boxes:\\n cells = []\\n for dr in range(i,i+3):\\n for dc in range(j,j+3):\\n cells.append(board[dr][dc])\\n if is_valid(cells) == False:\\n return False\\n \\n return True\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\\n \\n\\n\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n d={}\\n for i in range(3):\\n for j in range(3):\\n d[str(i)+str(j)]={'1','2','3','4','5','6','7','8','9'}\\n trans=[]\\n k=[0]*9\\n for i in range(9):\\n trans.append(k.copy()) \\n for i in range(9):\\n c={'1','2','3','4','5','6','7','8','9'}\\n for j in range(9):\\n trans[j][i]=board[i][j]\\n if board[i][j]=='.':\\n continue\\n if board[i][j] in c:\\n c.remove(board[i][j])\\n else:\\n return False\\n x=str(i//3)+str(j//3)\\n if board[i][j] in d[x]:\\n d[x].remove(board[i][j])\\n else:\\n print(\\\"2\\\")\\n return False\\n for i in range(9):\\n c={'1','2','3','4','5','6','7','8','9'}\\n for j in range(9):\\n if trans[i][j]=='.':\\n continue\\n if trans[i][j] in c:\\n c.remove(trans[i][j])\\n else:\\n print(\\\"3\\\")\\n return False\\n return True\\n\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n row = defaultdict(set)\\n col = defaultdict(set)\\n grid = defaultdict(set)\\n for i in range(9):\\n for j in range(9):\\n val = board[i][j]\\n if val.isalnum():\\n k = i//3 * 3 + j//3\\n if val in row[i] or val in col[j] or val in grid[k]:\\n return False\\n else:\\n row[i].add(val)\\n col[j].add(val)\\n grid[k].add(val)\\n\\n return True\\n\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# class Solution:\\ndef isValidSudoku(board: List[List[str]]) -> bool:\\n row = defaultdict(set)\\n col = defaultdict(set)\\n grid = defaultdict(set)\\n for i in range(9):\\n for j in range(9):\\n val = board[i][j]\\n if val.isalnum():\\n k = i//3 * 3 + j//3\\n if val in row[i] or val in col[j] or val in grid[k]:\\n return False\\n else:\\n row[i].add(val)\\n col[j].add(val)\\n grid[k].add(val)\\n\\n return True\\n\\n\\nwith open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\nexit()\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"def is_valid(cells):\\n seen = set()\\n for cell in cells:\\n if cell == '.':\\n continue\\n if cell in seen:\\n return False\\n seen.add(cell)\\n return True\\nclass Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n board_T = zip(*board)\\n \\n for row in board:\\n if is_valid(row) == False:\\n return False\\n \\n for col in board_T:\\n if is_valid(col) == False:\\n return False\\n \\n boxes=[(0,0),(0,3),(0,6),(3,0),(3,3),(3,6),(6,0),(6,3),(6,6)]\\n for i,j in boxes:\\n cells = []\\n for dr in range(i,i+3):\\n for dc in range(j,j+3):\\n cells.append(board[dr][dc])\\n if is_valid(cells) == False:\\n return False\\n \\n return True\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\\n \\n\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n cols = defaultdict(set)\\n row = defaultdict(set)\\n sq = defaultdict(set)\\n\\n for r in range(9):\\n for c in range(9):\\n cell = board[r][c]\\n\\n if cell == '.':\\n continue\\n\\n if(cell in row[r] or cell in cols[c] or cell in sq[(r//3, c//3)]):\\n\\n return False\\n else:\\n row[r].add(cell)\\n cols[c].add(cell)\\n sq[(r//3, c//3)].add(cell)\\n\\n return True\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n # we need to use hashsets:\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n boxes = defaultdict(set)\\n\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\":\\n continue\\n \\n if (board[r][c] in rows[r]) or \\\\\\n (board[r][c] in cols[c]) or \\\\\\n (board[r][c] in boxes[(r // 3, c // 3)]):\\n return False\\n \\n # need to use add() because its a set!!!\\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n boxes[(r // 3, c // 3)].add(board[r][c])\\n\\n return True\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"def is_valid(cells):\\n seen = set()\\n for cell in cells:\\n if cell == '.':\\n continue\\n if cell in seen:\\n return False\\n seen.add(cell)\\n return True\\nclass Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n board_T = zip(*board)\\n \\n for row in board:\\n if is_valid(row) == False:\\n return False\\n \\n for col in board_T:\\n if is_valid(col) == False:\\n return False\\n \\n for r in range(0,9,3):\\n for c in range(0,9,3):\\n cells = []\\n for dr in range(3):\\n for dc in range(3):\\n cells.append(board[r+dr][c+dc])\\n if is_valid(cells) == False:\\n return False\\n \\n return True\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"def is_valid(cells):\\n seen = set()\\n for cell in cells:\\n if cell == '.':\\n continue\\n if cell in seen:\\n return False\\n seen.add(cell)\\n return True\\nclass Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n board_T = zip(*board)\\n \\n for row in board:\\n if is_valid(row) == False:\\n return False\\n \\n for col in board_T:\\n if is_valid(col) == False:\\n return False\\n \\n boxes=[(0,0),(0,3),(0,6),(3,0),(3,3),(3,6),(6,0),(6,3),(6,6)]\\n for i,j in boxes:\\n cells = []\\n for dr in range(i,i+3):\\n for dc in range(j,j+3):\\n cells.append(board[dr][dc])\\n if is_valid(cells) == False:\\n return False\\n \\n return True\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\\n \\n\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"def is_it(a: list[str]) -> bool:\\n a_set=[]\\n for el in a:\\n if el != \\\".\\\":\\n if el in a_set:\\n return False\\n else:\\n a_set.append(el)\\n return True\\ndef isValidSudoku(board: List[List[str]]) -> bool:\\n a=[]\\n for i in range(9):\\n if not is_it(board[i]):\\n return False\\n for i in range(9):\\n for j in range(9):\\n a.append(board[j][i])\\n if not is_it(a):\\n return False\\n a = []\\n for i in range(3):\\n for ii in range(3):\\n for iii in range(3):\\n for iiii in range(3):\\n a.append(board[i * 3 + iii][ii * 3 + iiii])\\n if not is_it(a):\\n return False\\n a = []\\n return True\\nwith open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\nexit()\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"def is_it(a: list[str]) -> bool:\\n a_set=[]\\n for el in a:\\n if el != \\\".\\\":\\n if el in a_set:\\n return False\\n else:\\n a_set.append(el)\\n return True\\ndef isValidSudoku(board: List[List[str]]) -> bool:\\n a=[]\\n for i in range(9):\\n if not is_it(board[i]):\\n return False\\n for i in range(9):\\n for j in range(9):\\n a.append(board[j][i])\\n if not is_it(a):\\n return False\\n a = []\\n for i in range(3):\\n for ii in range(3):\\n for iii in range(3):\\n for iiii in range(3):\\n a.append(board[i * 3 + iii][ii * 3 + iiii])\\n if not is_it(a):\\n return False\\n a = []\\n return True\\nwith open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\nexit()\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"def is_it(a: list[str]) -> bool:\\n a_set=[]\\n for el in a:\\n if el != \\\".\\\":\\n if el in a_set:\\n return False\\n else:\\n a_set.append(el)\\n return True\\ndef isValidSudoku(board: List[List[str]]) -> bool:\\n a=[]\\n for i in range(9):\\n if not is_it(board[i]):\\n return False\\n for i in range(9):\\n for j in range(9):\\n a.append(board[j][i])\\n if not is_it(a):\\n return False\\n a = []\\n for i in range(3):\\n for ii in range(3):\\n for iii in range(3):\\n for iiii in range(3):\\n a.append(board[i * 3 + iii][ii * 3 + iiii])\\n if not is_it(a):\\n return False\\n a = []\\n return True\\nwith open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\nexit()\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"def is_it(a: list[str]) -> bool:\\n a_set=[]\\n for el in a:\\n if el != \\\".\\\":\\n if el in a_set:\\n return False\\n else:\\n a_set.append(el)\\n return True\\ndef isValidSudoku(board: List[List[str]]) -> bool:\\n a=[]\\n for i in range(9):\\n if not is_it(board[i]):\\n return False\\n for i in range(9):\\n for j in range(9):\\n a.append(board[j][i])\\n if not is_it(a):\\n return False\\n a = []\\n for i in range(3):\\n for ii in range(3):\\n for iii in range(3):\\n for iiii in range(3):\\n a.append(board[i * 3 + iii][ii * 3 + iiii])\\n if not is_it(a):\\n return False\\n a = []\\n return True\\nwith open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\nexit()\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n col_list = defaultdict(list)\\n # Per 3 block of row\\n block = defaultdict(list)\\n\\n for i, row in enumerate(board):\\n row_list = []\\n for j, col in enumerate(row):\\n if row[j] != '.':\\n row_list.append(row[j])\\n col_list[j+1].append(row[j])\\n block[math.ceil((j+1)/3)].append(row[j])\\n if len(row_list) != len(set(row_list)): return False\\n\\n \\n # early stop by block\\n if (i+1)%3 == 0:\\n for b in block: \\n if len(block[b]) != len(set(block[b])): return False\\n block = defaultdict(list)\\n \\n for c in col_list: \\n if len(col_list[c]) != len(set(col_list[c])): return False\\n return True\\n \\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"def is_valid(cells):\\n seen = set()\\n for cell in cells:\\n if cell == '.':\\n continue\\n if cell in seen:\\n return False\\n seen.add(cell)\\n return True\\nclass Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n board_T = zip(*board)\\n \\n for row in board:\\n if is_valid(row) == False:\\n return False\\n \\n for col in board_T:\\n if is_valid(col) == False:\\n return False\\n \\n boxes=[(0,0),(0,3),(0,6),(3,0),(3,3),(3,6),(6,0),(6,3),(6,6)]\\n for i,j in boxes:\\n cells = []\\n for dr in range(i,i+3):\\n for dc in range(j,j+3):\\n cells.append(board[dr][dc])\\n if is_valid(cells) == False:\\n return False\\n \\n return True\\n\\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\\n \\n\\n\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n dic_save = {**{\\\"row\\\"+str(i): [] for i in range(9)}, \\n **{\\\"col\\\"+str(i): [] for i in range(9)}, \\n **{\\\"grid\\\"+str(i): [] for i in range(9)}}\\n\\n for r in range(9):\\n for c in range(9):\\n grid_index = (r // 3) * 3 + (c // 3)\\n if board[r][c] != \\\".\\\":\\n current_val = board[r][c]\\n \\n # Check row\\n if current_val in dic_save[\\\"row\\\" + str(r)]:\\n return False\\n dic_save[\\\"row\\\" + str(r)].append(current_val)\\n\\n # Check column\\n if current_val in dic_save[\\\"col\\\" + str(c)]:\\n return False\\n dic_save[\\\"col\\\" + str(c)].append(current_val)\\n\\n # Check grid\\n if current_val in dic_save[\\\"grid\\\" + str(grid_index)]:\\n return False\\n dic_save[\\\"grid\\\" + str(grid_index)].append(current_val)\\n\\n return True\\n\\n\\n\\nimport sys\\nimport json\\n\\ndef kdsmain():\\n input_data = sys.stdin.read().strip()\\n lines = input_data.splitlines()\\n\\n num_test_cases = len(lines) # Number of test cases\\n results = []\\n\\n solution = Solution() # Create the Solution object once\\n for i in range(num_test_cases):\\n board = json.loads(lines[i].strip()) # Parse each Sudoku board (in JSON format)\\n result = solution.isValidSudoku(board) # Call isValidSudoku method\\n results.append(json.dumps(result)) # Store result (True/False) in JSON format\\n\\n with open('user.out', 'w') as f: # Write all results to 'user.out'\\n f.write(\\\"\\\\n\\\".join(results) + \\\"\\\\n\\\")\\n\\nif __name__ == \\\"__main__\\\":\\n kdsmain()\\n exit(0)\\n\\n\\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"def isValidSudoku(board: List[List[str]]) -> str:\\n \\n row=[set() for _ in range(9)]\\n col=[set() for _ in range(9)]\\n box=[[set() for _ in range(3)] for _ in range(3)]\\n\\n for i in range(9):\\n for j in range(9):\\n cud=board[i][j]\\n\\n if cud=='.':continue \\n if cud in row[i] or cud in col[j] or cud in box[i//3][j//3]:\\n return 'false'\\n row[i].add(cud)\\n col[j].add(cud)\\n box[i//3][j//3].add(cud)\\n\\n return 'true'\\n\\nwith open('user.out', 'w') as f:\\n for c in map(loads, stdin):\\n f.write(f\\\"{isValidSudoku(c)}\\\\n\\\")\\nexit(0)\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n row_dict = defaultdict(set)\\n column_dict = defaultdict(set)\\n square_dict = defaultdict(set)\\n\\n for row in range(9): #recall prop of range: stops at last index\\n for column in range(9):\\n if board[row][column] == '.':\\n continue\\n \\n if (board[row][column] in row_dict[row] or\\n board[row][column] in column_dict[column] or \\n board[row][column] in square_dict[(row//3, column//3)]):\\n return False\\n\\n else:\\n # WE want to add to the individual sets attached to the keys here..\\n row_dict[row].add(board[row][column])\\n column_dict[column].add(board[row][column])\\n square_dict[(row//3, column//3)].add(board[row][column])\\n return True\\n\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n inputs = map(loads, stdin)\\n for board in inputs:\\n print(\\\"true\\\" if bool(Solution().isValidSudoku(board)) else \\\"false\\\", file=f)\\nexit(0)\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n dic_save = {**{\\\"row\\\"+str(i): [] for i in range(9)},**{\\\"col\\\"+str(i): [] for i in range(9)},**{\\\"grid\\\"+str(i): [] for i in range(9)}}\\n for r in range(9):\\n for c in range(9):\\n grid_index = (r // 3) * 3 + (c // 3)\\n if board[r][c] != \\\".\\\":\\n dic_save[\\\"grid\\\" + str(grid_index)] += board[r][c]\\n dic_save[\\\"row\\\" + str(r)] += board[r][c]\\n dic_save[\\\"col\\\" + str(c)] += board[r][c]\\n return all(len(set(values)) == len(values) for values in dic_save.values())\\n\\n\\nimport sys\\nimport json\\n\\ndef kdsmain():\\n input_data = sys.stdin.read().strip()\\n lines = input_data.splitlines()\\n\\n num_test_cases = len(lines) # Number of test cases\\n results = []\\n\\n solution = Solution() # Create the Solution object once\\n for i in range(num_test_cases):\\n board = json.loads(lines[i].strip()) # Parse each Sudoku board (in JSON format)\\n result = solution.isValidSudoku(board) # Call isValidSudoku method\\n results.append(json.dumps(result)) # Store result (True/False) in JSON format\\n\\n with open('user.out', 'w') as f: # Write all results to 'user.out'\\n f.write(\\\"\\\\n\\\".join(results) + \\\"\\\\n\\\")\\n\\nif __name__ == \\\"__main__\\\":\\n kdsmain()\\n exit(0)\\n\\n\\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n d = defaultdict(set)\\n\\n for row in range(len(board)):\\n for column, square in enumerate(board[row]):\\n if square != \\\".\\\":\\n if square in d[row + 9] or square in d[column + 18] or square in d[(row // 3) * 3 + (column // 3)]:\\n return False\\n\\n d[(row // 3) * 3 + (column // 3)].add(square) # square\\n d[row + 9].add(square) # row\\n d[column + 18].add(square) # column\\n return True\\n\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as f:\\n inputs = map(loads, stdin)\\n for board in inputs:\\n print(\\\"true\\\" if bool(Solution().isValidSudoku(board)) else \\\"false\\\", file=f)\\nexit(0)\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(board: List[List[str]]) -> bool:\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [[set() for _ in range(3)] for _ in range(3)]\\n\\n def check(num, *sets):\\n for s in sets:\\n if num not in s:\\n s.add(num)\\n else:\\n return False\\n return True\\n\\n for i in range(9):\\n for j in range(9):\\n num = board[i][j]\\n\\n if num == \\\".\\\":\\n continue\\n\\n if not check(num, rows[i], cols[j], boxes[i//3][j//3]):\\n print(i, j)\\n return False\\n \\n return True\\n \\n with open('user.out', 'w') as f:\\n for case in map(loads, stdin):\\n f.write(f'{str(isValidSudoku(case)).lower()}\\\\n')\\n exit()\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"\\ndef isValidSudoku(board: List[List[str]]) -> bool:\\n blocks = {(i, j): [] for i in range(3) for j in range(3)}\\n for i in range(9):\\n row = []\\n column = []\\n for j in range(9):\\n if (board[i][j] != '.') and (board[i][j] not in row):\\n row.append(board[i][j])\\n elif (board[i][j] in row):return False\\n \\n if (board[j][i] != '.') and (board[j][i] not in column):\\n column.append(board[j][i])\\n elif (board[j][i] in column):return False\\n \\n if (board[i][j] != '.') and (board[i][j] not in blocks[(i//3, j//3)]):\\n blocks[(i//3, j//3)].append(board[i][j])\\n elif (board[i][j] in blocks[(i//3, j//3)]):return False\\n return True\\n\\nwith open('user.out', 'w') as f:\\n for c in map(loads, stdin):\\n f.write(f\\\"{str(isValidSudoku(c)).lower()}\\\\n\\\")\\nexit(0)\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # Edge Cases:\\n # Non-digits are used (in the constraints)\\n # Different board sizes (in the constraints)\\n # Whole board is empty\\n\\n # Create sets of each of the rows, columns, and sub-boxes\\n # Check if the number is in the set before you place it\\n # 27 sets total\\n # Can check as you're running over the board\\n # Will return false if one is already in a set\\n\\n # Runtime: O(n) - time it takes to loop over the whole board, Set retrieval/setting time is O(1)\\n\\n # Define list of row_sets List[set]\\n row_sets = [set() for i in range (len(board))]\\n # Define list of col_sets List[set]\\n col_sets = [set() for i in range (len(board))]\\n # Define list of sub_sets List[set]\\n sub_sets = [set() for i in range (len(board))]\\n\\n # Loop through all of the rows\\n for row in range(len(board)):\\n # Loop through all of the columns \\n for col in range(len(board[0])):\\n curr_num = board[row][col]\\n if curr_num != \\\".\\\":\\n # Add to rows set and check if already in set\\n if curr_num in row_sets[row]:\\n return False\\n row_sets[row].add(curr_num)\\n # Add to columns set and check if already in set\\n if curr_num in col_sets[col]:\\n return False\\n col_sets[col].add(curr_num)\\n # Get sub-box idx\\n sub_box_idx = col//3+3*(row//3)\\n # Add to sub-box set (will be in 3x3 sections)\\n if curr_num in sub_sets[sub_box_idx]:\\n return False\\n sub_sets[sub_box_idx].add(curr_num)\\n\\n return True\\n\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n h = [set() for _ in range(9)]\\n v = [set() for _ in range(9)]\\n b = [set() for _ in range(9)]\\n\\n for r in range(9):\\n for c in range(9):\\n val = board[r][c]\\n if val == \\\".\\\":\\n continue\\n if val in h[r]:\\n return False\\n h[r].add(val)\\n if val in v[c]:\\n return False\\n v[c].add(val)\\n box = (r//3) * 3 + (c//3)\\n if val in b[box]:\\n return False\\n b[box].add(val)\\n return True\\n \\\"\\\"\\\"#determine if it is valid\\n #horizontal\\n #vertical\\n #box (3x3)\\n h = [set() for _ in range(9)]\\n v = [set() for _ in range(9)]\\n b = [set() for _ in range(9)]\\n\\n for r in range(9):\\n for c in range(9):\\n val = board[r][c]\\n if val == \\\".\\\":\\n continue\\n if val in h[r]:\\n return False\\n h[r].add(val)\\n if val in v[c]:\\n return False\\n v[c].add(val)\\n box = (r//3) * 3 + (c//3)\\n if val in b[box]:\\n return False\\n b[box].add(val)\\n\\n return True\\\"\\\"\\\"\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # we will need a hash map for every row, and a hashmap for every column\\n rows = {}\\n columns = {}\\n # we will also need a hash map foe each square of 3*3\\n # we can identify each square bu dividing indexes of the lines and columns to 3\\n squares = {}\\n for i in range(3):\\n squares[i] = {}\\n for j in range(3):\\n squares[i][j]= {}\\n\\n # now we go through the matrix:\\n for line in range(len(board)):\\n rows.clear()\\n columns.clear()\\n lineIndex = line//3\\n for column in range(len(board[line])):\\n if board[line][column] != '.':\\n columnIndex = column//3\\n # first we check if the element is unique in its square\\n if board[line][column] not in squares[lineIndex][columnIndex]:\\n squares[lineIndex][columnIndex][board[line][column]] = True\\n else:\\n return False\\n # then we check if the element is unique on its row\\n if board[line][column] not in rows:\\n rows[board[line][column]] = True\\n else:\\n return False\\n \\n if board[column][line] != '.':\\n # lastly, we check is the element is unoque on its column\\n if board[column][line] not in columns:\\n columns[board[column][line]] = True\\n else:\\n return False\\n\\n # now for the squares\\n\\n return True\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"def check_cell(board, i,j,checker):\\n c = board[i][j]\\n if c == \\\".\\\":\\n return True\\n idx = int(c) - 1\\n if checker[idx]:\\n return False\\n checker[idx] = 1\\n return True\\n\\n\\nclass Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n for row in board:\\n checker = [0] * 9\\n for c in row:\\n if c == \\\".\\\":\\n continue\\n idx = int(c) - 1\\n if checker[idx]:\\n return False\\n checker[idx] = 1\\n \\n for column in range(9):\\n checker = [0] * 9\\n for r in range(9):\\n if not check_cell(board, r, column, checker):\\n return False\\n \\n for i,j in [(0,0), (0,3), (0,6),(3,0), (3,3), (3,6),(6,0), (6,3), (6,6)]:\\n checker = [0] * 9\\n \\n if not check_cell(board, i, j, checker):\\n return False\\n \\n if not check_cell(board, i, j + 1, checker):\\n return False\\n \\n if not check_cell(board, i, j + 2, checker):\\n return False\\n \\n if not check_cell(board, i + 1, j, checker):\\n return False\\n \\n if not check_cell(board, i + 1, j + 1, checker):\\n return False\\n \\n if not check_cell(board, i + 1, j + 2, checker):\\n return False\\n \\n if not check_cell(board, i + 2, j, checker):\\n return False\\n \\n if not check_cell(board, i + 2, j + 1, checker):\\n return False\\n \\n if not check_cell(board, i + 2, j + 2, checker):\\n return False\\n \\n return True\\n \\n\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n N = 9\\n\\n # Use hash set to record the status\\n rows = [set() for _ in range(N)]\\n cols = [set() for _ in range(N)]\\n boxes = [set() for _ in range(N)]\\n\\n for i in range(N):\\n for j in range(N):\\n val = board[i][j]\\n\\n if val == \\\".\\\":\\n continue\\n \\n if val in rows[i]:\\n return False\\n rows[i].add(val)\\n\\n if val in cols[j]:\\n return False\\n cols[j].add(val)\\n\\n boxindex = (i//3) + (j//3)*3\\n if val in boxes[boxindex]:\\n return False\\n boxes[boxindex].add(val)\\n \\n return True\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: list[list[str]]) -> bool:\\n seen = set()\\n\\n for i in range(9):\\n for j in range(9):\\n c = board[i][j]\\n if c == '.':\\n continue\\n if (c + '@row ' + str(i) in seen or\\n c + '@col ' + str(j) in seen or\\n c + '@box ' + str(i // 3) + str(j // 3) in seen):\\n return False\\n seen.add(c + '@row ' + str(i))\\n seen.add(c + '@col ' + str(j))\\n seen.add(c + '@box ' + str(i // 3) + str(j // 3))\\n\\n return True\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # Create sets to track seen numbers for rows, columns, and subgrids\\n rows = [set() for _ in range(9)]\\n columns = [set() for _ in range(9)]\\n subgrids = [set() for _ in range(9)]\\n\\n # Iterate over each cell in the board\\n for row in range(9):\\n for col in range(9):\\n num = board[row][col]\\n \\n if num != '.':\\n # Determine the subgrid index\\n subgrid_index = (row // 3) * 3 + (col // 3)\\n \\n # Check if the number is already in the row, column, or subgrid\\n if num in rows[row] or num in columns[col] or num in subgrids[subgrid_index]:\\n return False\\n \\n # Add the number to the respective sets\\n rows[row].add(num)\\n columns[col].add(num)\\n subgrids[subgrid_index].add(num)\\n \\n # If no duplicates are found, the Sudoku is valid\\n return True\\n\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n n = len(board)\\n rows = [set() for i in range(n)]\\n cols = [set() for i in range(n)]\\n boxes = defaultdict(set)\\n\\n for r in range(n):\\n for c in range(n):\\n val = board[r][c]\\n if val == \\\".\\\":\\n continue\\n if val in rows[r] or val in cols[c] or val in boxes[(r // 3, c // 3)]:\\n return False\\n rows[r].add(val)\\n cols[c].add(val)\\n boxes[(r // 3, c // 3)].add(val)\\n\\n return True\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n squares = defaultdict(set)\\n\\n for r in range(len(board)):\\n for c in range(len(board[0])):\\n if board[r][c] == \\\".\\\":\\n continue\\n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in squares[(r//3, c//3)]:\\n return False\\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n squares[(r//3, c//3)].add(board[r][c])\\n \\n return True\\n\\n\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n grid = defaultdict(set)\\n\\n for i in range(len(board)):\\n for j in range(len(board[0])):\\n if board[i][j] == \\\".\\\":\\n continue\\n else:\\n if board[i][j] in rows[i] or board[i][j] in cols[j] or board[i][j] in grid[(i//3,j//3)]:\\n return False\\n rows[i].add(board[i][j])\\n cols[j].add(board[i][j])\\n grid[(i//3,j//3)].add(board[i][j])\\n \\n return True\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\\"\\\"\\\"col = collections.defaultdict(set)\\n row = collections.defaultdict(set)\\n grid = collections.defaultdict(set)\\n\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n continue\\n if (board[i][j] in row[i] or board[i][j] in col[j] or board[i][j] in grid[(i//3,j//3)]):\\n return False\\n \\n col[j].add(board[i][j])\\n row[i].add(board[i][j])\\n grid[(i//3,j//3)].add(board[i][j])\\n \\n return True\\n\\\"\\\"\\\"\\n \\n\\n\\n \\n \",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n #check row\\n for i in range(9):\\n check = [0]*10\\n for j in range(9):\\n if board[i][j] == \\\".\\\": continue\\n n = int(board[i][j])\\n if check[n]: return False\\n else: check[n] = 1\\n\\n #check col\\n for i in range(9):\\n check = [0]*10\\n for j in range(9):\\n if board[j][i] == \\\".\\\": continue\\n n = int(board[j][i])\\n if check[n]: return False\\n else: check[n] = 1\\n \\n #check 3x3 grid\\n for R in range(3):\\n for C in range(3):\\n check = [0]*10\\n for i in range(R*3, R*3+3):\\n for j in range(C*3, C*3+3):\\n if board[i][j] == \\\".\\\": continue\\n n = int(board[i][j])\\n if check[n]: return False\\n else: check[n] = 1\\n return True\",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n n = 9\\n rows = []\\n cols = []\\n cells = []\\n\\n for i in range(9):\\n rows.append(set())\\n cols.append(set())\\n cells.append(set())\\n\\n\\n for i in range(9):\\n for j in range(9):\\n val = board[i][j]\\n if val == \\\".\\\":\\n continue\\n cell = 3 * (i // 3) + j // 3\\n if val in rows[i] or val in cols[j] or val in cells[cell]:\\n return False\\n rows[i].add(val)\\n cols[j].add(val)\\n cells[cell].add(val)\\n\\n return True\\n\",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n row = [set() for _ in range(9)]\\n col = [set() for _ in range(9)]\\n box = [set() for _ in range(9)]\\n\\n for i in range(9):\\n for j in range(9):\\n num = board[i][j]\\n if num == '.':\\n continue\\n box_index = (i//3)*3 + (j//3)\\n\\n if num in row[i]:\\n return False\\n row[i].add(num)\\n if num in col[j]:\\n return False\\n col[j].add(num)\\n if num in box[box_index]:\\n return False\\n box[box_index].add(num)\\n return True\\n\\n\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n\\n def check_square(top_left_r: int, top_left_c: int) -> bool:\\n track = set()\\n for i in range(top_left_r, top_left_r + 3):\\n for j in range(top_left_c, top_left_c + 3):\\n if board[i][j] == \\\".\\\":\\n continue\\n if board[i][j] in track:\\n return False\\n track.add(board[i][j])\\n return True\\n\\n for row in board:\\n track = set()\\n for num in row:\\n if num == \\\".\\\":\\n continue\\n if num in track:\\n return False\\n track.add(num)\\n \\n for r in range(len(board[0])):\\n track = set()\\n for c in range(len(board)):\\n if board[c][r] == \\\".\\\":\\n continue\\n if board[c][r] in track:\\n return False\\n track.add(board[c][r])\\n\\n for r in range(0, 9, 3):\\n for c in range(0, 9, 3):\\n if not check_square(top_left_r=r, top_left_c=c):\\n return False\\n\\n return True\\n \\n \",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [set() for _ in range(9)]\\n for i in range(9):\\n for j in range(9):\\n num = board[i][j]\\n if num == '.':\\n continue\\n if num in rows[i]:\\n return False\\n rows[i].add(num)\\n if num in cols[j]:\\n return False\\n cols[j].add(num)\\n box_index = (i // 3) * 3 + (j // 3)\\n if num in boxes[box_index]:\\n return False\\n boxes[box_index].add(num)\\n return True\\n \",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = {0 : [False] * 9, 1 : [False] * 9, 2 : [False] * 9, 3 : [False] * 9, 4 : [False] * 9, 5 : [False] * 9, 6 : [False] * 9, 7 : [False] * 9, 8 : [False] * 9}\\n columns = {0 : [False] * 9, 1 : [False] * 9, 2 : [False] * 9, 3 : [False] * 9, 4 : [False] * 9, 5 : [False] * 9, 6 : [False] * 9, 7 : [False] * 9, 8 : [False] * 9}\\n boxes = {0 : [False] * 9, 1 : [False] * 9, 2 : [False] * 9, 3 : [False] * 9, 4 : [False] * 9, 5 : [False] * 9, 6 : [False] * 9, 7 : [False] * 9, 8 : [False] * 9}\\n\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n continue\\n # square in the ith row and jth column\\n curr = int(board[i][j])\\n box = None\\n if 0 <= i <= 2 and 0 <= j <= 2:\\n box = 0\\n elif 3 <= i <= 5 and 0 <= j <= 2:\\n box = 1\\n elif 6 <= i <= 8 and 0 <= j <= 2:\\n box = 2\\n elif 0 <= i <= 2 and 3 <= j <= 5:\\n box = 3\\n elif 3 <= i <= 5 and 3 <= j <= 5:\\n box = 4\\n elif 6 <= i <= 8 and 3 <= j <= 5:\\n box = 5\\n elif 0 <= i <= 2 and 6 <= j <= 8:\\n box = 6\\n elif 3 <= i <= 5 and 6 <= j <= 8:\\n box = 7\\n elif 6 <= i <= 8 and 6 <= j <= 8:\\n box = 8\\n\\n if rows[i][curr-1]:\\n return False\\n if columns[j][curr-1]:\\n return False\\n if boxes[box][curr-1]:\\n return False\\n \\n rows[i][curr-1] = True\\n columns[j][curr-1] = True\\n boxes[box][curr-1] = True\\n return True\\n \",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = collections.defaultdict(set)\\n cols = collections.defaultdict(set)\\n squares = collections.defaultdict(set)\\n\\n \\n\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == '.':\\n continue\\n \\n if ( \\n board[r][c] in rows[r] or\\n board[r][c] in cols[c] or\\n board[r][c] in squares[(r//3, c//3)]\\n ):\\n return False\\n \\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n squares[(r//3, c//3)].add(board[r][c])\\n \\n\\n return True\\n\\n \\n\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n arr = []\\n for i in range(9):\\n for j in range(9):\\n ele = board[i][j]\\n if ele != '.':\\n arr += [(i,ele),(ele,j),(i//3,j//3,ele)]\\n return len(arr) == len(set(arr))\\n\\n \",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n boxes = defaultdict(set)\\n\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] != \\\".\\\":\\n if board[i][j] in rows[i] or board[i][j] in cols[j] or board[i][j] in boxes[i // 3, j // 3]:\\n return False\\n else:\\n rows[i].add(board[i][j])\\n cols[j].add(board[i][j])\\n boxes[i // 3, j // 3].add(board[i][j])\\n \\n return True\\n\\n\\n\\n\\n \",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n col=[ [] for _ in range(9) ]\\n square=[ [ [] for _ in range(3) ] for _ in range(3) ]\\n \\n for x,r in enumerate(board):\\n row=set()\\n for y,n in enumerate(r):\\n if n!=\\\".\\\":\\n \\n if n in row:return False\\n else:row.add(n)\\n\\n if n in col[y]:return False\\n else:col[y].append(n)\\n\\n if n in square[x//3][y//3]:return False\\n else: square[x//3][y//3].append(n)\\n \\n return True\\n\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rowsMap = defaultdict(set)\\n columnsMap = defaultdict(set)\\n boxMap = defaultdict(set)\\n\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\":\\n continue\\n if board[r][c] in rowsMap[r]:\\n return False\\n\\n if board[r][c] in columnsMap[c]:\\n return False\\n\\n if board[r][c] in boxMap[(r//3, c//3)]:\\n return False\\n\\n rowsMap[r].add(board[r][c])\\n columnsMap[c].add(board[r][c])\\n boxMap[(r//3, c//3)].add(board[r][c])\\n return True\\n \",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: list[list[str]]) -> bool:\\n seen = set()\\n\\n for i in range(9):\\n for j in range(9):\\n c = board[i][j]\\n if c == '.':\\n continue\\n if (c + '@row ' + str(i) in seen or\\n c + '@col ' + str(j) in seen or\\n c + '@box ' + str(i // 3) + str(j // 3) in seen):\\n return False\\n seen.add(c + '@row ' + str(i))\\n seen.add(c + '@col ' + str(j))\\n seen.add(c + '@box ' + str(i // 3) + str(j // 3))\\n\\n return True\",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [set() for _ in range(9)] \\n for r in range(9):\\n for c in range(9):\\n num = board[r][c]\\n if num == \\\".\\\":\\n continue\\n box_index = (r // 3) * 3 + (c // 3)\\n if num in rows[r] or num in cols[c] or num in boxes[box_index]:\\n return False\\n rows[r].add(num)\\n cols[c].add(num)\\n boxes[box_index].add(num)\\n return True\",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"# class Solution:\\n# def isValidSudoku(self, board: list[list[str]]) -> bool:\\n# hold = [0,0,0,0,0,0,0,0,0]\\n# for i in range(0,9):\\n# for j in range(0,9):\\n# try:\\n# board[i][j] = int(board[i][j])\\n# except ValueError:\\n# board[i][j] = 0\\n# for i in range(0,9):\\n# reset = hold.copy()\\n# for j in range(0,9):\\n# if board[j][i] > 0 :\\n# if board[j][i] == reset[board[j][i]-1]:\\n# return False\\n# reset[board[j][i]-1] = board[j][i]\\n# for k in range(0,9,3):\\n# for l in range(0,9,3):\\n# reset = hold.copy()\\n# for i in range(k,k+3):\\n# for j in range(l,l+3):\\n# if board[i][j] > 0:\\n# if board[i][j] == reset[board[i][j]-1]:\\n# return False\\n# reset[board[i][j]-1] = board[i][j]\\n# for i in range(0,9):\\n# reset = hold.copy()\\n# for j in board[i]:\\n# if j > 0:\\n# if j == reset[j-1]:\\n# return False\\n# reset[j-1] = j\\n# return True\\nclass Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n boxes = defaultdict(set)\\n \\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\":\\n continue\\n \\n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in boxes[(r // 3, c // 3)]:\\n return False\\n \\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n boxes[(r // 3, c // 3)].add(board[r][c])\\n \\n return True\",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board):\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n boxes = defaultdict(set)\\n \\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\":\\n continue\\n \\n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in boxes[(r // 3, c // 3)]:\\n return False\\n \\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n boxes[(r // 3, c // 3)].add(board[r][c])\\n return True\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # for row in board:\\n # print(*row)\\n for row in range(9):\\n seen = [False] * 10\\n for col in range(9):\\n if board[row][col] == '.':\\n continue\\n val = int(board[row][col])\\n if seen[val]:\\n return False\\n seen[val] = True\\n for row in range(9):\\n seen = [False] * 10\\n for col in range(9):\\n if board[col][row] == '.':\\n continue\\n val = int(board[col][row])\\n if seen[val]:\\n return False\\n seen[val] = True\\n for sr in range(0, 9, 3):\\n for sc in range(0, 9, 3):\\n seen = [False] * 10\\n for i in range(3):\\n for j in range(3):\\n if board[sr+i][sc+j] == '.':\\n continue\\n val = int(board[sr+i][sc+j])\\n if seen[val]:\\n return False\\n seen[val] = True\\n return True\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n boxes = defaultdict(set)\\n\\n for r in range(9):\\n for c in range(9):\\n curr_num = board[r][c]\\n\\n if curr_num == '.':\\n continue\\n \\n if curr_num in rows[r] or curr_num in cols[c] or curr_num in boxes[(r//3, c//3)]:\\n return False\\n\\n rows[r].add(curr_num)\\n cols[c].add(curr_num)\\n boxes[(r//3, c//3)].add(curr_num)\\n\\n return True\",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n cols = defaultdict(set)\\n rows = defaultdict(set)\\n sqrs = defaultdict(set) \\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n continue\\n num = board[i][j]\\n if num in rows[i] or num in cols[j] or num in sqrs[(i//3, j//3)]:\\n return False\\n rows[i].add(num)\\n cols[j].add(num)\\n sqrs[(i//3, j//3)].add(num)\\n return True\",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n\\n def printBoard(board):\\n for row in board:\\n print(row)\\n printBoard(board)\\n\\n squares=[(0,0), (0, 3), (0, 6),(3,0), (3, 3), (3, 6),(6,0), (6, 3), (6, 6)]\\n \\n def isRowValid(i):\\n seen = [0] * 10\\n for j in range(len(board[i])):\\n if board[i][j] == \\\".\\\":\\n continue\\n if seen[int(board[i][j])]:\\n return False\\n seen[int(board[i][j])] = 1\\n return True\\n\\n def isColValid(j):\\n seen = [0] * 10\\n for i in range(len(board)):\\n if board[i][j] == \\\".\\\":\\n continue\\n if seen[int(board[i][j])]:\\n return False\\n seen[int(board[i][j])] = 1\\n return True\\n\\n def isSquareValid(i, j):\\n seen = [0] * 10\\n for y in range(3):\\n for x in range(3):\\n if board[i + y][j + x] == \\\".\\\":\\n continue\\n if seen[int(board[i + y][j + x])]:\\n return False\\n seen[int(board[i + y][j + x])] = 1\\n\\n return True\\n\\n for row in range(len(board)):\\n if not isRowValid(row):\\n return False\\n for col in range(len(board)):\\n if not isColValid(col):\\n return False\\n for square in squares:\\n i, j = square\\n if not isSquareValid(i, j):\\n return False\\n return True\",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n flag=True\\n sub1=[]\\n sub2=[]\\n sub3=[]\\n for i in range(9):\\n rows_list=[]\\n columns_list=[]\\n for j in range(9):\\n if board[i][j]!=\\\".\\\":\\n rows_list.append(board[i][j])\\n if board[j][i]!=\\\".\\\":\\n columns_list.append(board[j][i])\\n #Append in Sub-Box\\n if j==0: \\n if board[i][j]!=\\\".\\\": \\n sub1.append(board[i][j])\\n if board[i][j+1]!=\\\".\\\": \\n sub1.append(board[i][j+1])\\n if board[i][j+2]!=\\\".\\\": \\n sub1.append(board[i][j+2])\\n elif j==3: \\n if board[i][j]!=\\\".\\\": \\n sub2.append(board[i][j])\\n if board[i][j+1]!=\\\".\\\": \\n sub2.append(board[i][j+1])\\n if board[i][j+2]!=\\\".\\\": \\n sub2.append(board[i][j+2])\\n elif j==6: \\n if board[i][j]!=\\\".\\\": \\n sub3.append(board[i][j])\\n if board[i][j+1]!=\\\".\\\": \\n sub3.append(board[i][j+1])\\n if board[i][j+2]!=\\\".\\\": \\n sub3.append(board[i][j+2]) \\n # print(f\\\"For row i={i} the Sub boxes are {sub1} \\\\n {sub2} \\\\n {sub3}\\\")\\n #check unique row\\n if len(rows_list)!=len(set(rows_list)):\\n #duplicate present\\n # print(f\\\"Duplicate found on ROW {rows_list}\\\")\\n flag=False\\n break\\n #check unique column\\n if len(columns_list)!=len(set(columns_list)):\\n #duplicate present\\n # print(f\\\"Duplicate found on Column {columns_list}\\\")\\n flag=False\\n break\\n #\\n if i==2 or i==5 or i==8:\\n #check unique Sub-Box\\n if len(sub1)!=len(set(sub1)):\\n #duplicate present\\n # print(f\\\"Duplicate found on Sub Box 1 {sub1}\\\")\\n flag=False\\n break\\n if len(sub2)!=len(set(sub2)):\\n #duplicate present\\n # print(f\\\"Duplicate found on Sub Box 2 {sub2}\\\")\\n flag=False\\n break\\n if len(sub3)!=len(set(sub3)):\\n #duplicate present\\n # print(f\\\"Duplicate found on Sub Box 3 {sub3}\\\")\\n flag=False\\n break\\n sub1=[]\\n sub2=[]\\n sub3=[]\\n return flag\\n\\n\\n \",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n squares = defaultdict(set)\\n\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\":\\n continue\\n if (board[r][c] in rows[r] or\\n board[r][c] in cols[c] or\\n board[r][c] in squares[(r//3, c//3)]):\\n return False\\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n squares[(r//3, c//3)].add(board[r][c])\\n return True\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # row key [idx] -> Set()\\n # col key [idx] -> Set()\\n # Box key c // 3 - r // 3 -> Set()\\n\\n rows, cols, boxes = {}, {}, {}\\n\\n for r in range(len(board)):\\n for c in range(len(board[0])):\\n value = board[r][c]\\n if value == '.':\\n continue\\n \\n current_box = f'{r // 3} - {c // 3}'\\n if r not in rows:\\n rows[r] = set()\\n if c not in cols:\\n cols[c] = set()\\n if current_box not in boxes:\\n boxes[current_box] = set()\\n \\n if value in rows[r] or value in cols[c] or value in boxes[current_box]:\\n return False\\n \\n rows[r].add(value)\\n cols[c].add(value)\\n boxes[current_box].add(value)\\n\\n return True\\n\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n for i in range(9):\\n row_visited = set()\\n for j in range(9):\\n if i % 3 == 0 and j % 3 == 0:\\n if not self.subBoxes(board, i, j):\\n return False\\n cell = board[i][j]\\n if cell != '.':\\n if cell in row_visited:\\n return False\\n row_visited.add(cell)\\n \\n for i in range(9):\\n col_visited = set()\\n for j in range(9):\\n cell = board[j][i]\\n if cell != '.':\\n if cell in col_visited:\\n return False\\n col_visited.add(cell)\\n \\n return True\\n \\n def subBoxes(self, board: List[List[str]], x: int, y: int) -> bool:\\n visited = set()\\n for i in range(x, x + 3):\\n for j in range(y, y + 3):\\n cell = board[i][j]\\n if cell != '.':\\n if cell in visited:\\n return False\\n visited.add(cell)\\n return True\",\n \"runtime\": \"89\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # Initialize sets to keep track of seen digits\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [set() for _ in range(9)]\\n\\n for i in range(9):\\n for j in range(9):\\n num = board[i][j]\\n if num == '.':\\n continue\\n \\n # Check the row\\n if num in rows[i]:\\n return False\\n rows[i].add(num)\\n \\n # Check the column\\n if num in cols[j]:\\n return False\\n cols[j].add(num)\\n \\n # Check the 3x3 sub-box\\n box_index = (i // 3) * 3 + (j // 3)\\n if num in boxes[box_index]:\\n return False\\n boxes[box_index].add(num)\\n \\n return True\\n\\n \",\n \"runtime\": \"89\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # Check rows and columns\\n for i in range(9):\\n row_set = set()\\n col_set = set()\\n for j in range(9):\\n # Check row\\n if board[i][j] != '.':\\n if board[i][j] in row_set:\\n return False\\n row_set.add(board[i][j])\\n\\n # Check column\\n if board[j][i] != '.':\\n if board[j][i] in col_set:\\n return False\\n col_set.add(board[j][i])\\n\\n # Check 3x3 subgrids\\n for i in range(0, 9, 3):\\n for j in range(0, 9, 3):\\n block_set = set()\\n for u in range(3):\\n for v in range(3):\\n cell_value = board[i + u][j + v]\\n if cell_value != '.':\\n if cell_value in block_set:\\n return False\\n block_set.add(cell_value)\\n \\n return True\\n\",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = {}\\n columns = {}\\n boxes = {}\\n\\n i = 0\\n j = 0\\n \\n for i in range(len(board)):\\n for j in range(len(board)):\\n cur = board[i][j]\\n\\n if cur == \\\".\\\":\\n continue\\n\\n if i not in rows:\\n rows[i] = set()\\n if j not in columns:\\n columns[j] = set()\\n if (i//3, j//3) not in boxes:\\n boxes[(i//3, j//3)] = set()\\n\\n if (cur in rows[i]) or (cur in columns[j]) or (cur in boxes[(i//3, j//3)]):\\n return False\\n \\n rows[i].add(cur)\\n columns[j].add(cur)\\n boxes[(i//3, j//3)].add(cur)\\n\\n return True\",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"from itertools import product\\n\\nclass Solution:\\n def is_valid(self, coords, board):\\n seen = set()\\n for i, j in coords:\\n val = board[i][j]\\n if val in seen:\\n return False\\n elif val != \\\".\\\":\\n seen.add(val)\\n\\n return True\\n\\n\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # Check rows.\\n for i in range(9):\\n if not self.is_valid(product([i], range(9)), board):\\n return False\\n\\n # Check columns.\\n for j in range(9):\\n if not self.is_valid(product(range(9), [j]), board):\\n return False\\n\\n # Check subgrids.\\n for subgrid in range(9):\\n # Get rows.\\n if subgrid < 3:\\n rows = [0, 1, 2]\\n elif subgrid < 6:\\n rows = [3, 4, 5]\\n else:\\n rows = [6, 7, 8]\\n\\n # Get cols.\\n if subgrid % 3 == 0:\\n cols = [0, 1, 2]\\n elif subgrid % 3 == 1:\\n cols = [3, 4, 5]\\n else:\\n cols = [6, 7, 8]\\n\\n if not self.is_valid(product(rows, cols), board):\\n return False\\n\\n return True\",\n \"runtime\": \"91\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n \\n for line in board:\\n if not self.isLineValid(line):\\n return False\\n \\n for i in range(len(board)):\\n if not self.isLineValid([line[i] for line in board]):\\n return False \\n \\n return self.isSquareValid(board)\\n \\n def isLineValid(self, line: list[str]) -> bool:\\n int_line = [int(i) for i in line if i.isdigit()]\\n return len(int_line) == len(set(int_line))\\n \\n def isSquareValid(self, square: list[list[str]]) -> bool:\\n for offset in range(0, 7, 3):\\n rect = square[offset: offset + 3]\\n for inner_offset in range(0, 7, 3):\\n sq = []\\n for i in rect:\\n sq.extend(i[inner_offset: inner_offset + 3])\\n \\n if not self.isLineValid(sq):\\n return False\\n return True\",\n \"runtime\": \"91\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n def check_array(arr):\\n arr = [item for item in arr if item != \\\".\\\"]\\n return len(set(arr)) == len(arr)\\n \\n lines = defaultdict(list)\\n sub_boxes = [[[], [], [],], [[], [], []], [[], [], []]]\\n \\n curr_row_sub_boxes = 0\\n for i in range(len(board)):\\n \\n if not check_array(board[i]):\\n return False\\n \\n curr_line_sub_boxes = 0\\n \\n for j in range(len(board[i])):\\n lines[j].append(board[i][j])\\n sub_boxes[curr_row_sub_boxes][curr_line_sub_boxes].append(board[i][j])\\n if j in [2, 5]:\\n curr_line_sub_boxes += 1\\n if i in [2, 5]:\\n curr_row_sub_boxes += 1\\n\\n for arrays in sub_boxes:\\n for a in arrays:\\n if not check_array(a):\\n return False\\n \\n for arr in lines.values():\\n if not check_array(arr):\\n return False\\n \\n return True\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n hashmap = {}\\n\\n #check rows\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] in hashmap and board[i][j] != '.':\\n # print(i,j,\\\"rows\\\")\\n return False\\n else:\\n hashmap[board[i][j]] = 1 \\n hashmap = {}\\n \\n hashmap = {}\\n \\n \\n #check columns\\n for i in range(9):\\n for j in range(9):\\n if board[j][i] in hashmap and board[j][i] != '.':\\n # print(j, i, \\\"cols\\\")\\n return False\\n else:\\n hashmap[board[j][i]] = 1 \\n hashmap = {}\\n \\n hashmap = {}\\n\\n #check squares\\n for m in range(0,9,3):\\n for k in range(0,9,3):\\n # print(k,k+3)\\n for i in range(k, k+3):\\n # print(i)\\n # for l in range(0,9,3):\\n for j in range(m,m+3):\\n print(i,j)\\n if board[i][j] in hashmap and board[i][j] != '.':\\n # print(i, j, \\\"err\\\")\\n return False\\n else:\\n hashmap[board[i][j]] = 1 \\n # print(\\\"reset\\\")\\n # hashmap = {}\\n # print(\\\"bigreset\\\")\\n hashmap = {}\\n \\n \\n # [[\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"5\\\",\\\".\\\",\\\".\\\",\\\"1\\\",\\\".\\\"],\\n # [\\\".\\\",\\\"4\\\",\\\".\\\",\\\"3\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\"],\\n # [\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"3\\\",\\\".\\\",\\\".\\\",\\\"1\\\"],\\n # [\\\"8\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"2\\\",\\\".\\\"],\\n # [\\\".\\\",\\\".\\\",\\\"2\\\",\\\".\\\",\\\"7\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\"],\\n # [\\\".\\\",\\\"1\\\",\\\"5\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\"],\\n # [\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"2\\\",\\\".\\\",\\\".\\\",\\\".\\\"],\\n # [\\\".\\\",\\\"2\\\",\\\".\\\",\\\"9\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\"],\\n # [\\\".\\\",\\\".\\\",\\\"4\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\"]]\\n\\n \\n return True\\n\\n \",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n res = []\\n for i in range(9):\\n for j in range(9):\\n element = board[i][j]\\n if element != '.':\\n res += [(i, element), (element, j), (i // 3, j // 3, element)]\\n return len(res) == len(set(res))\\n \",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"class Solution:\\n \\n # # 1: check duplicates in each row, col and quadrat\\n # def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # for r in range(9):\\n # row = [el for el in board[r] if el != \\\".\\\"]\\n # if len(set(row)) != len(row):\\n # return False\\n # for c in range(9):\\n # col = [row[c] for row in board if row[c] != \\\".\\\"]\\n # if len(set(col)) != len(col):\\n # return False\\n # for q_r in range(3):\\n # for q_c in range(3):\\n # quad = []\\n # for r in range(q_r*3, q_r*3+3):\\n # for c in range(q_c*3, q_c*3+3):\\n # el = board[r][c]\\n # if el != \\\".\\\":\\n # quad.append(el)\\n # if len(set(quad)) != len(quad):\\n # return False\\n # return True\\n \\n # 2: hashset\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n N = 9\\n rows = [set() for _ in range(N)]\\n cols = [set() for _ in range(N)]\\n quads = [set() for _ in range(N)]\\n \\n for r in range(9):\\n for c in range(9):\\n val = board[r][c]\\n if val == '.':\\n continue\\n \\n if val in rows[r]:\\n return False\\n else:\\n rows[r].add(val)\\n \\n if val in cols[c]:\\n return False\\n else:\\n cols[c].add(val)\\n \\n idx = r//3*3+c//3\\n if val in quads[idx]:\\n return False\\n else:\\n quads[idx].add(val)\\n \\n return True\\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n for i in range(9):\\n row_visited = set()\\n for j in range(9):\\n if i % 3 == 0 and j % 3 == 0:\\n if not self.subBoxes(board, i, j):\\n return False\\n cell = board[i][j]\\n if cell != '.':\\n if cell in row_visited:\\n return False\\n row_visited.add(cell)\\n \\n for i in range(9):\\n col_visited = set()\\n for j in range(9):\\n cell = board[j][i]\\n if cell != '.':\\n if cell in col_visited:\\n return False\\n col_visited.add(cell)\\n \\n return True\\n \\n def subBoxes(self, board: List[List[str]], x: int, y: int) -> bool:\\n visited = set()\\n for i in range(x, x + 3):\\n for j in range(y, y + 3):\\n cell = board[i][j]\\n if cell != '.':\\n if cell in visited:\\n return False\\n visited.add(cell)\\n return True\",\n \"runtime\": \"94\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = [set() for x in range(9)] # a set for each row\\n cols = [set() for x in range(9)]\\n sqrs = [set() for x in range(9)]\\n for i in range(9):\\n for j in range(9):\\n cell = board[i][j]\\n k = i//3*3 + j//3\\n if cell == \\\".\\\":\\n continue\\n elif cell in rows[i] or cell in cols[j] or cell in sqrs[k]:\\n return False \\n rows[i].add(cell)\\n cols[j].add(cell)\\n sqrs[k].add(cell)\\n return True\\n\",\n \"runtime\": \"94\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows=collections.defaultdict(set)\\n cols=collections.defaultdict(set)\\n squares=collections.defaultdict(set)\\n\\n for r in range(9):\\n for c in range(9):\\n if board[r][c]==\\\".\\\":\\n continue\\n if (board[r][c] in rows[r] or\\n board[r][c] in cols[c] or\\n board[r][c] in squares[(r//3,c//3)]):\\n return False\\n \\n cols[c].add(board[r][c])\\n rows[r].add(board[r][c])\\n squares[(r//3,c//3)].add(board[r][c])\\n\\n return True\\n \",\n \"runtime\": \"95\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = defaultdict(set) # make a dict for each row and their values\\n cols = defaultdict(set)\\n subgrid = defaultdict(set)\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == '.':\\n continue\\n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in subgrid[(r//3, c//3)]:\\n return False\\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n subgrid[(r//3, c//3)].add(board[r][c])\\n return True\\n \\n\\n\",\n \"runtime\": \"95\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n flag=True\\n sub1=[]\\n sub2=[]\\n sub3=[]\\n for i in range(9):\\n rows_list=[]\\n columns_list=[]\\n for j in range(9):\\n if board[i][j]!=\\\".\\\":\\n rows_list.append(board[i][j])\\n if board[j][i]!=\\\".\\\":\\n columns_list.append(board[j][i])\\n #Append in Sub-Box\\n if j==0: \\n if board[i][j]!=\\\".\\\": \\n sub1.append(board[i][j])\\n if board[i][j+1]!=\\\".\\\": \\n sub1.append(board[i][j+1])\\n if board[i][j+2]!=\\\".\\\": \\n sub1.append(board[i][j+2])\\n elif j==3: \\n if board[i][j]!=\\\".\\\": \\n sub2.append(board[i][j])\\n if board[i][j+1]!=\\\".\\\": \\n sub2.append(board[i][j+1])\\n if board[i][j+2]!=\\\".\\\": \\n sub2.append(board[i][j+2])\\n elif j==6: \\n if board[i][j]!=\\\".\\\": \\n sub3.append(board[i][j])\\n if board[i][j+1]!=\\\".\\\": \\n sub3.append(board[i][j+1])\\n if board[i][j+2]!=\\\".\\\": \\n sub3.append(board[i][j+2]) \\n # print(f\\\"For row i={i} the Sub boxes are {sub1} \\\\n {sub2} \\\\n {sub3}\\\")\\n #check unique row\\n if len(rows_list)!=len(set(rows_list)):\\n #duplicate present\\n print(f\\\"Duplicate found on ROW {rows_list}\\\")\\n flag=False\\n break\\n #check unique column\\n if len(columns_list)!=len(set(columns_list)):\\n #duplicate present\\n print(f\\\"Duplicate found on Column {columns_list}\\\")\\n flag=False\\n break\\n #\\n if i==2 or i==5 or i==8:\\n #check unique Sub-Box\\n if len(sub1)!=len(set(sub1)):\\n #duplicate present\\n print(f\\\"Duplicate found on Sub Box 1 {sub1}\\\")\\n flag=False\\n break\\n if len(sub2)!=len(set(sub2)):\\n #duplicate present\\n print(f\\\"Duplicate found on Sub Box 2 {sub2}\\\")\\n flag=False\\n break\\n if len(sub3)!=len(set(sub3)):\\n #duplicate present\\n print(f\\\"Duplicate found on Sub Box 3 {sub3}\\\")\\n flag=False\\n break\\n sub1=[]\\n sub2=[]\\n sub3=[]\\n return flag\\n\\n\\n \",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n SIZE = len(board)\\n\\n #BOX CHECK\\n for block_hor in range(3):\\n for block_ver in range(3):\\n num_set = set()\\n for i in range(3):\\n for j in range(3):\\n num = board[block_hor * 3 + i][block_ver * 3 + j]\\n if num in num_set:\\n return False\\n if num != \\\".\\\":\\n num_set.add(num)\\n \\n\\n\\n #row and col check\\n for i in range(SIZE):\\n colset = set()\\n rowset = set()\\n for j in range(SIZE):\\n if board[i][j] in colset or board[j][i] in rowset:\\n return False\\n if board[i][j] != \\\".\\\":\\n colset.add(board[i][j])\\n if board[j][i] != \\\".\\\":\\n rowset.add(board[j][i])\\n print(colset, rowset)\\n return True\\n\\n\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n row = [[] for _ in range(9)]\\n col = [ [] for _ in range(9)]\\n sub_box = [[[] for i in range(3)] for _ in range(3)]\\n for i in range(9):\\n for j in range(9):\\n val = board[i][j]\\n if val == '.':\\n continue\\n curr_row = row[i]\\n curr_col = col[j]\\n curr_sub_box = sub_box[i//3][j//3]\\n if val in curr_row or val in curr_col or val in curr_sub_box:\\n print(i,j)\\n print(val)\\n print(curr_col)\\n print(curr_row)\\n print(curr_sub_box)\\n return False\\n curr_row.append(val)\\n curr_col.append(val)\\n curr_sub_box.append(val)\\n return True\\n\\\"\\\"\\\"\\n[\\n[\\\"5\\\",\\\"3\\\",\\\".\\\",\\\".\\\",\\\"7\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\"],\\n[\\\"6\\\",\\\".\\\",\\\".\\\",\\\"1\\\",\\\"9\\\",\\\"5\\\",\\\".\\\",\\\".\\\",\\\".\\\"],\\n[\\\".\\\",\\\"9\\\",\\\"8\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"6\\\",\\\".\\\"],\\n[\\\"8\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"6\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"3\\\"],\\n[\\\"4\\\",\\\".\\\",\\\".\\\",\\\"8\\\",\\\".\\\",\\\"3\\\",\\\".\\\",\\\".\\\",\\\"1\\\"],\\n[\\\"7\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"2\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"6\\\"],\\n[\\\".\\\",\\\"6\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"2\\\",\\\"8\\\",\\\".\\\"],\\n[\\\".\\\",\\\".\\\",\\\".\\\",\\\"4\\\",\\\"1\\\",\\\"9\\\",\\\".\\\",\\\".\\\",\\\"5\\\"],\\n[\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"8\\\",\\\".\\\",\\\".\\\",\\\"7\\\",\\\"9\\\"]]\\n\\\"\\\"\\\"\",\n \"runtime\": \"97\"\n },\n {\n \"code\": \"class Solution:\\n def checkRow(self, board: List[List[str]]) -> bool:\\n for row in board:\\n appared = set()\\n for n in row:\\n if n is not \\\".\\\" and n in appared:\\n return False\\n appared.add(n)\\n return True\\n def checkColumn(self, board: List[List[str]]) -> bool:\\n for col_i in range(0, 9):\\n appared = set()\\n for row in board:\\n n = row[col_i]\\n if n is not \\\".\\\" and n in appared:\\n return False\\n appared.add(n)\\n return True\\n def checkSquare(self, board: List[List[str]]) -> bool:\\n leftTops = [[0,0], [0,3], [0,6], [3,0], [3,3], [3,6],[6,0],[6,3],[6,6]]\\n for leftTop in leftTops:\\n [leftTopRow, leftTopCol] = leftTop\\n appared = set()\\n for row in range(leftTopRow, leftTopRow+3):\\n for col in range(leftTopCol, leftTopCol+3):\\n n = board[row][col]\\n if n is not \\\".\\\" and n in appared:\\n return False\\n appared.add(n)\\n return True\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n return self.checkRow(board) and self.checkColumn(board) and self.checkSquare(board)\",\n \"runtime\": \"97\"\n },\n {\n \"code\": \"# class Solution:\\n# def isValidSudoku(self, board: list[list[str]]) -> bool:\\n# hold = [0,0,0,0,0,0,0,0,0]\\n# for i in range(0,9):\\n# for j in range(0,9):\\n# try:\\n# board[i][j] = int(board[i][j])\\n# except ValueError:\\n# board[i][j] = 0\\n# for i in range(0,9):\\n# reset = hold.copy()\\n# for j in range(0,9):\\n# if board[j][i] > 0 :\\n# if board[j][i] == reset[board[j][i]-1]:\\n# return False\\n# reset[board[j][i]-1] = board[j][i]\\n# for k in range(0,9,3):\\n# for l in range(0,9,3):\\n# reset = hold.copy()\\n# for i in range(k,k+3):\\n# for j in range(l,l+3):\\n# if board[i][j] > 0:\\n# if board[i][j] == reset[board[i][j]-1]:\\n# return False\\n# reset[board[i][j]-1] = board[i][j]\\n# for i in range(0,9):\\n# reset = hold.copy()\\n# for j in board[i]:\\n# if j > 0:\\n# if j == reset[j-1]:\\n# return False\\n# reset[j-1] = j\\n# return True\\nclass Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n boxes = defaultdict(set)\\n \\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\":\\n continue\\n \\n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in boxes[(r // 3, c // 3)]:\\n return False\\n \\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n boxes[(r // 3, c // 3)].add(board[r][c])\\n \\n return True\",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rowCheck = [set() for _ in range(9)]\\n colCheck = [set() for _ in range(9)]\\n threeCheck = {((i//3, j//3)): set() for i in range(9) for j in range(9)}\\n\\n for i in range(len(board)):\\n for j in range(len(board[0])):\\n if board[i][j] != \\\".\\\":\\n if board[i][j] not in rowCheck[i]:\\n rowCheck[i].add(board[i][j])\\n else:\\n return False\\n if board[i][j] not in colCheck[j]:\\n colCheck[j].add(board[i][j])\\n else:\\n return False\\n if board[i][j] not in threeCheck[(i//3, j//3)]:\\n threeCheck[(i//3, j//3)].add(board[i][j])\\n else:\\n return False\\n return True\\n\",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n\\n \\\"\\\"\\\"\\n 9x9 2D array - partially or fully filled\\n\\n every row unique 1-9\\n every column unique 1-9\\n \\n each 9 3x3 boxes unique 1-9\\n\\n empty cells '.'\\n\\n\\n 8-> 2,2\\n\\n 2/3, 2/3--> 0,0\\n\\n 8,8---> 8/3,8/3-->2,2\\n\\n \\\"\\\"\\\"\\n\\n row=collections.defaultdict(set)\\n col=collections.defaultdict(set)\\n\\n subbox=collections.defaultdict(set)\\n\\n for r in range(9):\\n for c in range(9):\\n\\n if board[r][c]=='.':\\n continue\\n\\n else:\\n if (board[r][c] in row[r]) or (board[r][c] in col[c]) or (board[r][c] in subbox[(r//3,c//3)]):\\n\\n return False\\n\\n row[r].add(board[r][c])\\n col[c].add(board[r][c])\\n subbox[(r//3,c//3)].add(board[r][c])\\n \\n return True\\n\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"99\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n for r in range(1,9,3):\\n for c in range(1,9,3):\\n seen = set()\\n for i in range(r-1,r+2):\\n for j in range(c-1,c+2):\\n if board[i][j] in seen:\\n return False\\n if board[i][j] != '.': \\n seen.add(board[i][j])\\n\\n for c in range(9):\\n seen = set()\\n for r in range(9):\\n if board[r][c] in seen:\\n return False\\n if board[r][c] != '.':\\n seen.add(board[r][c])\\n \\n for r in range(9):\\n seen = set()\\n for c in range(9):\\n if board[r][c] in seen:\\n return False\\n if board[r][c] != '.':\\n seen.add(board[r][c])\\n\\n return True\",\n \"runtime\": \"99\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n\\n # 使用三个字典分别存储行、列和3x3子方块中的数字情况\\n rows = [{} for _ in range(9)]\\n cols = [{} for _ in range(9)]\\n boxes = [{} for _ in range(9)]\\n\\n # 遍历数独棋盘\\n for i in range(9):\\n \\n for j in range(9):\\n num = board[i][j]\\n if num != '.': # 只处理填充的数字\\n num = int(num)\\n box_index = (i // 3) * 3 + j // 3 # 计算当前数字属于哪个3x3子方块\\n \\n # 检查行、列和子方块中是否已经存在当前数字\\n rows[i][num] = rows[i].get(num, 0) + 1\\n cols[j][num] = cols[j].get(num, 0) + 1\\n boxes[box_index][num] = boxes[box_index].get(num, 0) + 1\\n \\n # 如果当前数字在行、列或子方块中重复出现，数独无效\\n if rows[i][num] > 1 or cols[j][num] > 1 or boxes[box_index][num] > 1:\\n return False\\n return True\",\n \"runtime\": \"100\"\n },\n {\n \"code\": \"class Solution:\\n def checkRow(self, board: List[List[str]]) -> bool:\\n for row in board:\\n appared = set()\\n for n in row:\\n if n is not \\\".\\\" and n in appared:\\n return False\\n appared.add(n)\\n return True\\n def checkColumn(self, board: List[List[str]]) -> bool:\\n for col_i in range(0, 9):\\n appared = set()\\n for row in board:\\n n = row[col_i]\\n if n is not \\\".\\\" and n in appared:\\n return False\\n appared.add(n)\\n return True\\n def checkSquare(self, board: List[List[str]]) -> bool:\\n leftTops = [[0,0], [0,3], [0,6], [3,0], [3,3], [3,6],[6,0],[6,3],[6,6]]\\n for leftTop in leftTops:\\n [leftTopRow, leftTopCol] = leftTop\\n appared = set()\\n for row in range(leftTopRow, leftTopRow+3):\\n for col in range(leftTopCol, leftTopCol+3):\\n n = board[row][col]\\n if n is not \\\".\\\" and n in appared:\\n return False\\n appared.add(n)\\n return True\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n return self.checkRow(board) and self.checkColumn(board) and self.checkSquare(board)\",\n \"runtime\": \"100\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n\\n def printBoard(board):\\n for row in board:\\n print(row)\\n printBoard(board)\\n\\n squares=[(0,0), (0, 3), (0, 6),(3,0), (3, 3), (3, 6),(6,0), (6, 3), (6, 6)]\\n \\n def isRowValid(i):\\n seen = [0] * 10\\n for j in range(len(board[i])):\\n if board[i][j] == \\\".\\\":\\n continue\\n if seen[int(board[i][j])]:\\n return False\\n seen[int(board[i][j])] = 1\\n return True\\n\\n def isColValid(j):\\n seen = [0] * 10\\n for i in range(len(board)):\\n if board[i][j] == \\\".\\\":\\n continue\\n if seen[int(board[i][j])]:\\n return False\\n seen[int(board[i][j])] = 1\\n return True\\n\\n def isSquareValid(i, j):\\n seen = [0] * 10\\n for y in range(3):\\n for x in range(3):\\n if board[i + y][j + x] == \\\".\\\":\\n continue\\n if seen[int(board[i + y][j + x])]:\\n return False\\n seen[int(board[i + y][j + x])] = 1\\n\\n return True\\n\\n for row in range(len(board)):\\n if not isRowValid(row):\\n return False\\n for col in range(len(board)):\\n if not isColValid(col):\\n return False\\n for square in squares:\\n i, j = square\\n if not isSquareValid(i, j):\\n return False\\n return True\",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = self.getRows(board)\\n cols = self.getCols(board)\\n boxes = self.getBoxes(board)\\n\\n return self.isUnique(rows) and self.isUnique(cols) and self.isUnique(boxes)\\n\\n @staticmethod\\n def isUnique(numbers: List[List[str]]) -> bool:\\n for group in numbers:\\n if len(set(group)) != len(group): return False\\n else:\\n return True\\n\\n @staticmethod\\n def getRows(board: List[List[str]]) -> List[List[str]]:\\n return [[x for x in row if x != '.'] for row in board]\\n\\n @staticmethod\\n def getCols(board: List[List[str]]) -> List[List[str]]:\\n cols = [[row[i] for row in board] for i in range(9)]\\n return [[x for x in col if x != '.'] for col in cols]\\n\\n @staticmethod\\n def getBoxes(board: List[List[str]]) -> List[List[str]]:\\n boxes = [[] for _ in range(9)]\\n for i, row in enumerate(board):\\n for j, col in enumerate(row):\\n if board[i][j] == '.': continue\\n\\n idx = 3 * (i // 3) + j // 3\\n boxes[idx].append(board[i][j])\\n\\n return boxes\\n \",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = collections.defaultdict(set)\\n cols = collections.defaultdict(set)\\n grid = collections.defaultdict(set) #key = (r/3, c/3)\\n\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\": continue\\n n = int(board[r][c])\\n if n in rows[r] or n in cols[c] or n in grid[(r//3, c//3)]: return False\\n\\n rows[r].add(n)\\n cols[c].add(n)\\n grid[(r//3, c//3)].add(n)\\n return True\",\n \"runtime\": \"102\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: list[list[str]]) -> bool:\\n seen = set()\\n\\n for i in range(9):\\n for j in range(9):\\n c = board[i][j]\\n if c == '.':\\n continue\\n if (c + '@row ' + str(i) in seen or\\n c + '@col ' + str(j) in seen or\\n c + '@box ' + str(i // 3) + str(j // 3) in seen):\\n return False\\n seen.add(c + '@row ' + str(i))\\n seen.add(c + '@col ' + str(j))\\n seen.add(c + '@box ' + str(i // 3) + str(j // 3))\\n\\n return True\",\n \"runtime\": \"102\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n l = 9 # length\\n for i in range(l):\\n row = set()\\n col = set()\\n box = set()\\n for j in range(l):\\n a, b, c = board[i][j], board[j][i], board[i-i%3+j//3][(i%3)*3+j%3]\\n if a != \\\".\\\" and a in row:\\n return False\\n if b != \\\".\\\" and b in col:\\n return False\\n if c != \\\".\\\" and c in box:\\n return False\\n row.update(a)\\n col.update(b)\\n box.update(c)\\n \\n return True\",\n \"runtime\": \"105\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # Checking the rows.\\n for i in range(9):\\n row_map = {}\\n for j in range(9):\\n if board[i][j] != \\\".\\\" and board[i][j] in row_map:\\n return False\\n elif board[i][j] not in row_map:\\n row_map[board[i][j]] = 0\\n row_map[board[i][j]] += 1\\n\\n # Checking the columns.\\n for i in range(9):\\n col_map = {}\\n for j in range(9):\\n if board[j][i] != \\\".\\\" and board[j][i] in col_map:\\n return False\\n elif board[j][i] not in col_map:\\n col_map[board[j][i]] = 0\\n col_map[board[j][i]] += 1\\n\\n # Checking the squares.\\n curr_square = 0\\n curr_row_level = 0\\n curr_col_level = 0\\n while curr_square <= 8:\\n square_map = {}\\n for i in range(3):\\n for j in range(3):\\n if (board[i + (3 * curr_row_level)][j + (3 * curr_col_level)] != \\\".\\\" and \\n board[i + (3 * curr_row_level)][j + (3 * curr_col_level)] in square_map):\\n return False\\n elif (board[i + (3 * curr_row_level)][j + (3 * curr_col_level)] not in square_map):\\n square_map[board[i + (3 * curr_row_level)][j + (3 * curr_col_level)]] = 0\\n square_map[board[i + (3 * curr_row_level)][j + (3 * curr_col_level)]] += 1\\n curr_square += 1\\n curr_col_level += 1\\n if curr_square % 3 == 0:\\n curr_row_level += 1\\n curr_col_level = 0\\n \\n return True\",\n \"runtime\": \"105\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":86,"string":"86"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n #create 3 hashmaps\n #2 of which are for col and row where key is the col or row index and val is a set of values\n #1 of which is for the squares where key is the (r//3, c//3) and value is the set of values\n\n rows = collections.defaultdict(set)\n cols = collections.defaultdict(set)\n squares = collections.defaultdict(set)\n\n for r in range(9):\n for c in range(9):\n if(board[r][c] == \".\"):\n continue\n if(board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in squares[(r//3,c//3)]):\n return False\n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n squares[(r//3,c//3)].add(board[r][c])\n return True","memory":"16000"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n n = len(board)\n rows = [set() for _ in range(n)]\n cols = [set() for _ in range(n)]\n sqrs = [[[] for _ in range(n//3)] for _ in range(n//3)]\n\n for row_index, row in enumerate(board):\n for col_index, value in enumerate(row):\n if value == \".\":\n continue\n elif value in rows[row_index] or value in cols[col_index] or value in sqrs[row_index//3][col_index//3]:\n return False\n rows[row_index].add(value)\n cols[col_index].add(value)\n sqrs[row_index//3][col_index//3].append(value)\n \n return True","memory":"16100"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n res = []\n for i in range(9):\n for j in range(9):\n element = board[i][j]\n if element != '.':\n res += [(i, element), (element, j), (i//3, j//3, element)]\n return len(res) == len(set(res))","memory":"16200"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n for i in range(9):\n nums = set()\n rows = set()\n for j in range(9):\n if board[i][j] != '.':\n if board[i][j] in nums:\n return False\n nums.add(board[i][j])\n if board[j][i] != '.':\n if board[j][i] in rows:\n return False\n rows.add(board[j][i])\n\n directions = [(0,1),(0,0),(1,0),(1,1),(-1,0),(-1,-1),(0,-1),(1,-1),(-1,1)]\n for i in range(1, 9, 3):\n for j in range(1, 9, 3):\n nums = set()\n for x,y in directions:\n dx,dy = i+x, j+y\n if board[dx][dy] != '.':\n if board[dx][dy] in nums:\n return False\n nums.add(board[dx][dy])\n\n return True\n\n\n \n \n\n\n ","memory":"16300"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n # hashmap/set for each scenario: rows, columns, sub-boxes\n\n rows = defaultdict(list)\n columns = defaultdict(list)\n subboxes = defaultdict(list)\n\n # go through and add to according ones\n for row in range(len(board)):\n for col in range(len(board[row])):\n number = board[row][col]\n\n if not number.isdigit():\n continue\n\n subbox = (row // 3, col // 3)\n\n if number in rows[row] or number in columns[col] or number in subboxes[subbox]:\n return False\n \n else:\n rows[row].append(number)\n columns[col].append(number)\n subboxes[subbox].append(number)\n \n return True\n\n\n \n\n\n \n ","memory":"16300"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [set() for _ in range(9)]\n\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n continue\n \n # check the row\n if board[i][j] in rows[i]:\n return False\n rows[i].add(board[i][j])\n\n #check the col\n if board[i][j] in cols[j]:\n return False\n cols[j].add(board[i][j])\n\n #check the box\n idx = 3 * (i // 3) + j // 3\n if board[i][j] in boxes[idx]:\n return False\n boxes[idx].add(board[i][j])\n return True\n","memory":"16400"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = defaultdict(set)\n cols = defaultdict(set)\n boxes = defaultdict(set)\n \n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\":\n continue\n \n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in boxes[(r // 3, c // 3)]:\n return False\n \n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n boxes[(r // 3, c // 3)].add(board[r][c])\n \n return True","memory":"16400"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n cols = collections.defaultdict(set)\n rows = collections.defaultdict(set)\n squares = collections.defaultdict(set)\n\n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\":\n continue\n if (board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in squares[r//3, c//3]):\n return False\n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n squares[r//3, c//3].add(board[r][c])\n \n return True","memory":"16500"},{"code":"class Solution:\n def isValidSudoku(self, arr: List[List[str]]) -> bool:\n rows, cols, squares =defaultdict(list), defaultdict(list), defaultdict(list), \n\n for i in range(9):\n for j in range(9):\n\n\n if arr[i][j]=='.':\n continue\n elif (arr[i][j] in rows[i]) or (arr[i][j] in cols[j]) or (arr[i][j] in squares[(i//3,j//3)]):\n return False\n \n else:\n rows[i].append(arr[i][j])\n cols[j].append(arr[i][j])\n squares[(i//3,j//3)].append(arr[i][j])\n \n\n return True\n ","memory":"16500"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [[set() for _ in range(3)] for _ in range(3)]\n\n for r in range(9):\n for c in range(9):\n e = board[r][c]\n if e == \".\":\n continue\n if e in rows[r] or e in cols[c] or e in boxes[r // 3][c // 3]:\n return False\n else:\n rows[r].add(e)\n cols[c].add(e)\n boxes[r // 3][c // 3].add(e)\n \n return True","memory":"16600"},{"code":"class Solution:\n def isValidSudoku(self, board: List[List[str]]) -> bool:\n n = len(board)\n for i in range(n):\n row_visited = [False] * 10\n col_visited = [False] * 10\n for j in range(n):\n num1 = board[i][j]\n num2 = board[j][i]\n if num1 != \".\":\n if row_visited[int(num1)]:\n return False\n row_visited[int(num1)] = True\n if num2 != \".\":\n if col_visited[int(num2)]:\n return False\n col_visited[int(num2)] = True\n \n for i in range(0, 9, 3):\n for j in range(0, 9, 3):\n visited = [False] * 10\n for di in range(3):\n for dj in range(3):\n num = board[i + di][j + dj]\n if num != \".\":\n if visited[int(num)]:\n return False\n visited[int(num)] = True\n \n return True","memory":"16600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n #create 3 hashmaps\\n #2 of which are for col and row where key is the col or row index and val is a set of values\\n #1 of which is for the squares where key is the (r//3, c//3) and value is the set of values\\n\\n rows = collections.defaultdict(set)\\n cols = collections.defaultdict(set)\\n squares = collections.defaultdict(set)\\n\\n for r in range(9):\\n for c in range(9):\\n if(board[r][c] == \\\".\\\"):\\n continue\\n if(board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in squares[(r//3,c//3)]):\\n return False\\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n squares[(r//3,c//3)].add(board[r][c])\\n return True\",\n \"memory\": \"16000\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n n = len(board)\\n rows = [set() for _ in range(n)]\\n cols = [set() for _ in range(n)]\\n sqrs = [[[] for _ in range(n//3)] for _ in range(n//3)]\\n\\n for row_index, row in enumerate(board):\\n for col_index, value in enumerate(row):\\n if value == \\\".\\\":\\n continue\\n elif value in rows[row_index] or value in cols[col_index] or value in sqrs[row_index//3][col_index//3]:\\n return False\\n rows[row_index].add(value)\\n cols[col_index].add(value)\\n sqrs[row_index//3][col_index//3].append(value)\\n \\n return True\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n res = []\\n for i in range(9):\\n for j in range(9):\\n element = board[i][j]\\n if element != '.':\\n res += [(i, element), (element, j), (i//3, j//3, element)]\\n return len(res) == len(set(res))\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n for i in range(9):\\n nums = set()\\n rows = set()\\n for j in range(9):\\n if board[i][j] != '.':\\n if board[i][j] in nums:\\n return False\\n nums.add(board[i][j])\\n if board[j][i] != '.':\\n if board[j][i] in rows:\\n return False\\n rows.add(board[j][i])\\n\\n directions = [(0,1),(0,0),(1,0),(1,1),(-1,0),(-1,-1),(0,-1),(1,-1),(-1,1)]\\n for i in range(1, 9, 3):\\n for j in range(1, 9, 3):\\n nums = set()\\n for x,y in directions:\\n dx,dy = i+x, j+y\\n if board[dx][dy] != '.':\\n if board[dx][dy] in nums:\\n return False\\n nums.add(board[dx][dy])\\n\\n return True\\n\\n\\n \\n \\n\\n\\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n # hashmap/set for each scenario: rows, columns, sub-boxes\\n\\n rows = defaultdict(list)\\n columns = defaultdict(list)\\n subboxes = defaultdict(list)\\n\\n # go through and add to according ones\\n for row in range(len(board)):\\n for col in range(len(board[row])):\\n number = board[row][col]\\n\\n if not number.isdigit():\\n continue\\n\\n subbox = (row // 3, col // 3)\\n\\n if number in rows[row] or number in columns[col] or number in subboxes[subbox]:\\n return False\\n \\n else:\\n rows[row].append(number)\\n columns[col].append(number)\\n subboxes[subbox].append(number)\\n \\n return True\\n\\n\\n \\n\\n\\n \\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [set() for _ in range(9)]\\n\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n continue\\n \\n # check the row\\n if board[i][j] in rows[i]:\\n return False\\n rows[i].add(board[i][j])\\n\\n #check the col\\n if board[i][j] in cols[j]:\\n return False\\n cols[j].add(board[i][j])\\n\\n #check the box\\n idx = 3 * (i // 3) + j // 3\\n if board[i][j] in boxes[idx]:\\n return False\\n boxes[idx].add(board[i][j])\\n return True\\n\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n boxes = defaultdict(set)\\n \\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\":\\n continue\\n \\n if board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in boxes[(r // 3, c // 3)]:\\n return False\\n \\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n boxes[(r // 3, c // 3)].add(board[r][c])\\n \\n return True\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n cols = collections.defaultdict(set)\\n rows = collections.defaultdict(set)\\n squares = collections.defaultdict(set)\\n\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\":\\n continue\\n if (board[r][c] in rows[r] or board[r][c] in cols[c] or board[r][c] in squares[r//3, c//3]):\\n return False\\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n squares[r//3, c//3].add(board[r][c])\\n \\n return True\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, arr: List[List[str]]) -> bool:\\n rows, cols, squares =defaultdict(list), defaultdict(list), defaultdict(list), \\n\\n for i in range(9):\\n for j in range(9):\\n\\n\\n if arr[i][j]=='.':\\n continue\\n elif (arr[i][j] in rows[i]) or (arr[i][j] in cols[j]) or (arr[i][j] in squares[(i//3,j//3)]):\\n return False\\n \\n else:\\n rows[i].append(arr[i][j])\\n cols[j].append(arr[i][j])\\n squares[(i//3,j//3)].append(arr[i][j])\\n \\n\\n return True\\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [[set() for _ in range(3)] for _ in range(3)]\\n\\n for r in range(9):\\n for c in range(9):\\n e = board[r][c]\\n if e == \\\".\\\":\\n continue\\n if e in rows[r] or e in cols[c] or e in boxes[r // 3][c // 3]:\\n return False\\n else:\\n rows[r].add(e)\\n cols[c].add(e)\\n boxes[r // 3][c // 3].add(e)\\n \\n return True\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def isValidSudoku(self, board: List[List[str]]) -> bool:\\n n = len(board)\\n for i in range(n):\\n row_visited = [False] * 10\\n col_visited = [False] * 10\\n for j in range(n):\\n num1 = board[i][j]\\n num2 = board[j][i]\\n if num1 != \\\".\\\":\\n if row_visited[int(num1)]:\\n return False\\n row_visited[int(num1)] = True\\n if num2 != \\\".\\\":\\n if col_visited[int(num2)]:\\n return False\\n col_visited[int(num2)] = True\\n \\n for i in range(0, 9, 3):\\n for j in range(0, 9, 3):\\n visited = [False] * 10\\n for di in range(3):\\n for dj in range(3):\\n num = board[i + di][j + dj]\\n if num != \\\".\\\":\\n if visited[int(num)]:\\n return False\\n visited[int(num)] = True\\n \\n return True\",\n \"memory\": \"16600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":11,"string":"11"}}},{"rowIdx":73,"cells":{"question_id":{"kind":"number","value":37,"string":"37"},"name":{"kind":"string","value":"sudoku-solver"},"content":{"kind":"string","value":"<p>Write a program to solve a Sudoku puzzle by filling the empty cells.</p>\n\n<p>A sudoku solution must satisfy <strong>all of the following rules</strong>:</p>\n\n<ol>\n\t<li>Each of the digits <code>1-9</code> must occur exactly once in each row.</li>\n\t<li>Each of the digits <code>1-9</code> must occur exactly once in each column.</li>\n\t<li>Each of the digits <code>1-9</code> must occur exactly once in each of the 9 <code>3x3</code> sub-boxes of the grid.</li>\n</ol>\n\n<p>The <code>'.'</code> character indicates empty cells.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Sudoku-by-L2G-20050714.svg/250px-Sudoku-by-L2G-20050714.svg.png\" style=\"height:250px; width:250px\" />\n<pre>\n<strong>Input:</strong> board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]\n<strong>Output:</strong> [["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]\n<strong>Explanation:</strong> The input board is shown above and the only valid solution is shown below:\n\n<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/Sudoku-by-L2G-20050714_solution.svg/250px-Sudoku-by-L2G-20050714_solution.svg.png\" style=\"height:250px; width:250px\" />\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>board.length == 9</code></li>\n\t<li><code>board[i].length == 9</code></li>\n\t<li><code>board[i][j]</code> is a digit or <code>'.'</code>.</li>\n\t<li>It is <strong>guaranteed</strong> that the input board has only one solution.</li>\n</ul>\n"},"acRate":{"kind":"number","value":62.8183480052662,"string":"62.818348"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","hash-table","backtracking","matrix"],"string":"[\n \"array\",\n \"hash-table\",\n \"backtracking\",\n \"matrix\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"29\", 0.184], [\"35\", 1.1541000000000001], [\"40\", 1.3715], [\"46\", 1.7896], [\"51\", 1.0203], [\"57\", 0.853], [\"63\", 0.6356], [\"68\", 1.4049], [\"74\", 1.405], [\"79\", 2.0239], [\"85\", 2.5257], [\"90\", 1.6726999999999999], [\"96\", 2.6593], [\"101\", 1.9904], [\"107\", 2.0740000000000003], [\"113\", 1.6056000000000001], [\"118\", 1.5890999999999997], [\"124\", 1.4552], [\"129\", 1.3882], [\"135\", 1.221], [\"140\", 1.037], [\"146\", 1.0203], [\"151\", 1.0706], [\"157\", 0.9198999999999999], [\"162\", 0.7193], [\"168\", 0.6021000000000001], [\"174\", 0.4516], [\"179\", 0.5853999999999999], [\"185\", 0.6524000000000001], [\"190\", 0.4349], [\"196\", 0.6522999999999999], [\"201\", 0.3513], [\"207\", 0.7024], [\"212\", 0.4516], [\"218\", 0.7359], [\"224\", 1.3380999999999998], [\"229\", 2.2412], [\"235\", 2.258], [\"240\", 1.7896], [\"246\", 1.2042000000000002], [\"251\", 1.3881000000000001], [\"257\", 1.7730000000000001], [\"262\", 1.4049999999999998], [\"268\", 2.5423], [\"273\", 2.5255], [\"279\", 3.3449999999999998], [\"285\", 2.3082], [\"290\", 2.3583], [\"296\", 1.9903999999999997], [\"301\", 2.9436], [\"307\", 3.1109], [\"312\", 2.1744], [\"318\", 2.7931000000000004], [\"323\", 2.0071], [\"329\", 2.0405], [\"335\", 1.5221], [\"340\", 1.4050000000000002], [\"346\", 1.1206], [\"351\", 0.8698], [\"357\", 0.5353], [\"362\", 0.552], [\"368\", 0.4516], [\"373\", 0.30110000000000003], [\"379\", 0.2844], [\"384\", 0.31790000000000007], [\"390\", 0.3512], [\"396\", 0.4182], [\"401\", 0.2677], [\"407\", 0.3011], [\"412\", 0.2676], [\"418\", 0.251], [\"423\", 0.23420000000000002], [\"429\", 0.2677], [\"434\", 0.3012], [\"440\", 0.1674], [\"446\", 0.2343], [\"451\", 0.2509], [\"457\", 0.1507], [\"462\", 0.1507], [\"468\", 0.0502]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16000\", 0.0167], [\"16100\", 0.0167], [\"16200\", 0.0502], [\"16300\", 0.4516], [\"16400\", 5.5862], [\"16500\", 17.4109], [\"16600\", 31.7946], [\"16700\", 22.4787], [\"16800\", 10.8379], [\"16900\", 5.3855]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n# def solveSudoku(self, board: List[List[str]]) -> None:\n def solveSudoku(self, board):\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # store possible values\n sets = [set(range(1,10)) for _ in range(81)]\n\n candidates = []\n \n\n for i, row in enumerate(board):\n for j, square in enumerate(row):\n if square != \".\":\n\n n = int(square)\n sets[9*i+j] = set([n])\n\n candidates.append((i,j))\n\n\n\n self.solve(sets, candidates)\n\n for i in range(9):\n for j in range(9):\n [n] = sets[9*i+j]\n board[i][j] = str(n)\n\n # print(\"DONE\")\n \n def solve(self, sets, candidates):\n if not self.reduceSets(sets, candidates):\n return False\n \n # pick a set with more than 1 to branch\n minLen = 10 # needs to be >9\n minIdx =-1\n for idx, s in enumerate(sets):\n if len(s) >1 and len(s)<minLen:\n minLen = len(s)\n minIdx = idx\n \n if minIdx == -1:\n return True\n\n i,j = minIdx//9, minIdx%9\n # print(f\"branching on {i},{j} {sets[minIdx]}\")\n for possibleN in sets[minIdx]:\n # print(f\"{i},{j} trying {possibleN}\")\n setsCopy= [s.copy() for s in sets]\n setsCopy[minIdx] = set([possibleN])\n if self.solve(setsCopy, [(i,j)]):\n # no contradiction\n # manually replace sets to pass result up recursion stack\n for i in range(81):\n sets[i] = setsCopy[i]\n return True\n # else:\n # print(f\"{i},{j} trying {possibleN} failed\")\n return False\n\n\n \n def reduceSets(self, sets, candidates): \n def remove(i,j,n):\n s = sets[9*i+j]\n\n if n in s:\n s.remove(n)\n if len(s) == 0:\n return False\n elif len(s) ==1:\n candidates.append((i, j))\n return True\n\n \n while len(candidates) > 0:\n i,j = candidates.pop()\n\n # self.printSudoku(sets)\n # print(\"candidate\", i, j)\n\n [n] = sets[9*i+j]\n \n # reduce sets\n for other in range(9):\n # row\n if other != i:\n # print(f\"removing {n} from row {other},{j}\")\n if not remove(other, j, n):\n return False\n \n # column\n if other != j:\n # print(f\"removing {n} from col {i},{other}\")\n if not remove(i, other, n):\n return False\n\n \n # square\n \n y = (i//3)*3 + other % 3\n x = (j//3)*3 + other // 3\n if y!=i or x!=j:\n # print(f\"removing {n} from square {y},{x}\")\n if not remove(y,x,n):\n return False\n\n # print(\"DONE\")\n # self.printSudoku(sets)\n return True\n \n\n \n\n \n","runtime":"29"},{"code":"class SudokuSolver:\n def __init__(self, board):\n self._complete_domain = \"123456789\"\n self._width = 9\n self._cells = [[self._complete_domain if v == '.' else v for v in row] for row in board]\n self.board = board\n\n def is_solved(self):\n for i in range(self._width):\n for j in range(self._width):\n if len(self._cells[i][j]) != 1 or not self.is_value_consistent(self._cells[i][j], i, j):\n return False\n return True\n\n def is_value_consistent(self, value, row, column):\n cells = self._cells\n width = self._width\n\n # Check row consistency\n for j in range(width):\n if j != column and cells[row][j] == value:\n return False\n\n # Check column consistency\n for i in range(width):\n if i != row and cells[i][column] == value:\n return False\n\n # Check 3x3 unit consistency\n row_init = (row // 3) * 3\n col_init = (column // 3) * 3\n for i in range(row_init, row_init + 3):\n for j in range(col_init, col_init + 3):\n if (i != row or j != column) and cells[i][j] == value:\n return False\n\n return True\n\n def select_variable(self):\n min_domain_size = 10 # Start with a number larger than any possible domain size (which is 9)\n selected_cell = None\n cells = self._cells\n\n for i in range(self._width):\n for j in range(self._width):\n domain_size = len(cells[i][j])\n if 1 < domain_size < min_domain_size: # Skip cells that are already solved (domain size 1)\n min_domain_size = domain_size\n selected_cell = (i, j)\n if min_domain_size == 2: # Early exit if the minimum possible domain size is found\n return selected_cell\n\n return selected_cell\n\n def remove_domain_row(self, row, column):\n value = self._cells[row][column]\n row_cells = self._cells[row]\n variables_assigned = []\n\n for j in range(self._width):\n if j != column and len(row_cells[j]) > 1:\n if value in row_cells[j]:\n new_domain = row_cells[j].replace(value, '')\n row_cells[j] = new_domain\n if len(new_domain) == 0:\n return None, True # Early exit if the domain is empty\n if len(new_domain) == 1:\n variables_assigned.append((row, j))\n\n return variables_assigned, False\n\n def remove_domain_column(self, row, column):\n value = self._cells[row][column]\n variables_assigned = []\n\n for i in range(self._width):\n if i != row and len(self._cells[i][column]) > 1:\n if value in self._cells[i][column]:\n new_domain = self._cells[i][column].replace(value, '')\n self._cells[i][column] = new_domain\n if len(new_domain) == 0:\n return None, True\n if len(new_domain) == 1:\n variables_assigned.append((i, column))\n\n return variables_assigned, False\n\n def remove_domain_unit(self, row, column):\n value = self._cells[row][column]\n row_init, col_init = (row // 3) * 3, (column // 3) * 3\n variables_assigned = []\n\n for i in range(row_init, row_init + 3):\n for j in range(col_init, col_init + 3):\n if (i != row or j != column) and len(self._cells[i][j]) > 1:\n if value in self._cells[i][j]:\n new_domain = self._cells[i][j].replace(value, '')\n self._cells[i][j] = new_domain\n if len(new_domain) == 0:\n return None, True\n if len(new_domain) == 1:\n variables_assigned.append((i, j))\n\n return variables_assigned, False\n\n\n def pre_process_consistency(self):\n Q = [(i, j) for i in range(self._width) for j in range(self._width) if len(self._cells[i][j]) == 1]\n self.consistency(Q)\n\n def consistency(self, Q):\n while Q:\n row, col = Q.pop()\n value = self._cells[row][col]\n\n for method in [self.remove_domain_row, self.remove_domain_column, self.remove_domain_unit]:\n variables_assigned, conflict = method(row, col)\n if conflict:\n return True\n Q.extend(variables_assigned)\n\n return False\n\n def search(self):\n if self.is_solved():\n return self\n\n domain = self.select_variable()\n if not domain:\n return None\n\n row, col = domain\n original = self._cells[row][col]\n for value in original:\n backup = [row[:] for row in self._cells] # Backup grid state\n self._cells[row][col] = value\n\n if not self.consistency([(row, col)]):\n result = self.search()\n if result is not None:\n return result\n\n self._cells = backup # Revert to backup if search fails\n\n return None\n\n def solve(self):\n self.pre_process_consistency()\n solution = self.search()\n if solution:\n self.update_board()\n\n def update_board(self):\n for i in range(9):\n for j in range(9):\n self.board[i][j] = self._cells[i][j][0] # Take the first character which is the solved value\n\nclass Solution:\n def solveSudoku(self, board: list[list[str]]) -> None:\n solver = SudokuSolver(board)\n solver.solve()","runtime":"29"},{"code":"from dataclasses import dataclass\nfrom typing import List, Set, Tuple, Optional\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # First initialize our solve state\n row_sets, col_sets, box_sets = init_group_sets(board)\n\n board_candidates, is_finalized = init_board_candidates(board, row_sets, col_sets, box_sets)\n\n state = SolveState(board_candidates, is_finalized)\n # Solve\n solved_state = solve(state)\n\n # Finally copy everything over to the original board and return.\n for row in range(9):\n for col in range(9):\n assert solved_state.is_finalized[row][col]\n assert len(solved_state.board_candidates[row][col]) == 1\n if board[row][col] == \".\":\n entry = next(iter(solved_state.board_candidates[row][col]))\n board[row][col] = entry\n\n@dataclass\nclass SolveState:\n board_candidates: List[List[Set[str]]]\n is_finalized: List[List[bool]]\n\n def clone(self):\n board_candidates = [ [ set(cand_set) for cand_set in row] for row in self.board_candidates ]\n is_finalized = [ [ fn for fn in row] for row in self.is_finalized ]\n return SolveState(board_candidates, is_finalized)\n\n\ndef get_box_idx(row: int, col: int) -> int:\n return 3 * (row // 3) + col // 3\n\ndef init_group_sets(board: List[List[str]]):\n row_sets = [set() for i in range(9)]\n col_sets = [set() for i in range(9)]\n box_sets = [set() for i in range(9)]\n for row in range(9):\n for col in range(9):\n cur_cell = board[row][col]\n if cur_cell == \".\":\n continue\n for group_set in [ row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)]]:\n if cur_cell in group_set:\n raise Exception(\"Invalid initial board\")\n group_set.add(cur_cell)\n\n return row_sets, col_sets, box_sets\n\ndef init_board_candidates(board, row_sets, col_sets, box_sets):\n board_candidates = [ [None for col in range(9)] for row in range(9)]\n is_finalized = [ [False for col in range(9)] for row in range(9)]\n\n for row in range(9):\n for col in range(9):\n # Simple case: board has this already defined.\n cur_entry = board[row][col]\n if cur_entry != \".\":\n board_candidates[row][col] = { cur_entry }\n is_finalized[row][col] = True\n else:\n board_candidates[row][col] = get_candidates([\n row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)] ])\n is_finalized[row][col] = False # Set to false even if there's only one candidate.\n \n return board_candidates, is_finalized\n\ndef get_candidates(cand_sets: List[Set[str]]):\n candidates = set(map(str, range(1, 10)))\n for cand_set in cand_sets:\n candidates = candidates - cand_set\n return candidates\n\ndef solve(state: SolveState) -> Optional[SolveState]:\n debug = False\n # Level 2 solve algorithm: \n # apply the winnow algorithm to remove deterministic candidates. \n # then, select the cell with the smallest number of remaining candidates.\n # Guess one of the candidates, then re-apply the solve algorithm. If the\n # guess is correct, the solve algorithm will find a correct solution and return it.\n # Return that solution up the chain.\n # If the guess is incorrect, change your guess and repeat until you find the correct\n # value.\n is_valid, return_code = winnow(state)\n if debug:\n print(\"winnow return: \", return_code)\n print_board(state)\n if not is_valid:\n return None\n\n # Find the cell with the smallest number of candidates, unless this board is finalized.\n min_candidate_cell = None\n min_candidates = float('inf')\n is_finalized = True\n for row in range(9):\n for col in range(9):\n if state.is_finalized[row][col]:\n assert len(state.board_candidates[row][col]) == 1\n else:\n is_finalized = False\n if len(state.board_candidates[row][col]) < min_candidates:\n min_candidates = len(state.board_candidates[row][col])\n min_candidate_cell = (row, col)\n\n # If we've finalized this board, return immediately\n if is_finalized:\n return state\n \n # Else there must have been some min_candidate_cell.\n assert min_candidate_cell != None\n min_cand_row, min_cand_col = min_candidate_cell\n\n for candidate_val in state.board_candidates[min_cand_row][min_cand_col]:\n # Duplicate the solve state and re-apply the winnow algorithm.\n guess_state = state.clone()\n guess_state.board_candidates[min_cand_row][min_cand_col] = { candidate_val }\n maybe_solved_state = solve(guess_state)\n if maybe_solved_state:\n return maybe_solved_state\n\n # If we reach this state the board is invalid\n return None\n\ndef winnow(state: SolveState) -> Tuple[bool, int]:\n # Simple solve algorithm:\n # Loop over the board and collect all non-finalized cells that have only\n # one candidate. Store them in a queue. \n # While the queue is not empty, pop an entry off, finalize it, and \n # remove it as a candidate for all squares in the same row, column, and box.\n # When removing, if any corresponding non-finalized cell has only one remaining\n # entry, add it to the queue. \n # Once the queue is empty, check if everything is finalized. If not we'll need\n # to make some guesses... just throw for now and we can revisit.\n # Return True if the board remains in a valid state after winnowing, otherwise\n # return False. If this returns False, the winnowing process ends and the board\n # will be in an inconsistent state.\n single_candidate_cells = []\n for r in range(9):\n for c in range(9):\n if not state.is_finalized[r][c] and len(state.board_candidates[r][c]) == 1:\n single_candidate_cells.append((r, c))\n\n while len(single_candidate_cells) > 0:\n cur_row, cur_col = single_candidate_cells.pop()\n assert len(state.board_candidates[cur_row][cur_col]) == 1\n cur_val = next(iter(state.board_candidates[cur_row][cur_col]))\n\n state.is_finalized[cur_row][cur_col] = True\n\n # Remove cur_val as a candidate everywhere.\n # Remove from everything in this row\n for col in range(9):\n if state.is_finalized[cur_row][col]:\n continue\n if not maybe_remove_candidate_and_enqueue(cur_val, cur_row, col, state, single_candidate_cells):\n return False, 1\n \n # Remove from everything in this col\n for row in range(9):\n if state.is_finalized[row][cur_col]:\n continue\n if not maybe_remove_candidate_and_enqueue(cur_val, row, cur_col, state, single_candidate_cells):\n return False, 2\n\n # Remove from everything in this box\n for row, col in get_box_coords(cur_row, cur_col):\n if state.is_finalized[row][col]:\n continue\n if not maybe_remove_candidate_and_enqueue(cur_val, row, col, state, single_candidate_cells):\n return False, 3\n\n return True, 4\n\n\ndef maybe_remove_candidate_and_enqueue(cur_val: str, row: int, col: int, \n state: SolveState, single_candidate_cells: List[Tuple[int, int]]) -> bool:\n '''\n Remove the current value from the candidates for the given cell, and append this cell to the single_candidates\n list if removing this value reduces the number of candidates to one.\n If removing this value reduces the number of candidates to zero, return False, as this means we've entered\n an invalid board state. Otherwise return True\n '''\n cur_candidates = state.board_candidates[row][col]\n if cur_val in cur_candidates:\n cur_candidates.remove(cur_val)\n if len(cur_candidates) == 1:\n single_candidate_cells.append((row, col))\n elif len(cur_candidates) == 0:\n return False\n return True\n\ndef get_box_coords(row: int, col: int):\n base_row = 3 * (row // 3) # 0, 3, 6\n base_col = 3 * (col // 3) # 0, 3, 6\n for r in range(base_row, base_row+3):\n for c in range(base_col, base_col+3):\n yield r, c\n\ndef print_n_candidates(board_candidate: List[List[Set[str]]]):\n for row in board_candidate:\n for candidates in row:\n print(len(candidates), end=\", \")\n print()\n\ndef print_board(state: SolveState):\n for row in range(9):\n for col in range(9):\n if state.is_finalized[row][col]:\n cur_val = next(iter(state.board_candidates[row][col]))\n disp = \" \" + cur_val\n else:\n n_cand = len(state.board_candidates[row][col])\n disp = f\"n{n_cand}\"\n \n print(disp, end=\", \")\n print()","runtime":"35"},{"code":"class Solution:\n def solveSudoku(self, board):\n rows, cols, triples, visit = collections.defaultdict(set), collections.defaultdict(set), collections.defaultdict(set), collections.deque([])\n for r in range(9):\n for c in range(9):\n if board[r][c] != \".\":\n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n triples[(r // 3, c // 3)].add(board[r][c])\n else:\n visit.append((r, c))\n def dfs():\n if not visit:\n return True\n r, c = visit[0]\n t = (r // 3, c // 3)\n for dig in {\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"}:\n if dig not in rows[r] and dig not in cols[c] and dig not in triples[t]:\n board[r][c] = dig\n rows[r].add(dig)\n cols[c].add(dig)\n triples[t].add(dig)\n visit.popleft()\n if dfs():\n return True\n else:\n board[r][c] = \".\"\n rows[r].discard(dig)\n cols[c].discard(dig)\n triples[t].discard(dig)\n visit.appendleft((r, c))\n return False\n dfs()","runtime":"35"},{"code":"from dataclasses import dataclass\nfrom typing import List, Set, Tuple, Optional\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # First initialize our solve state\n row_sets, col_sets, box_sets = init_group_sets(board)\n\n board_candidates, is_finalized = init_board_candidates(board, row_sets, col_sets, box_sets)\n\n state = SolveState(board_candidates, is_finalized)\n # Solve\n solved_state = solve(state)\n\n # Finally copy everything over to the original board and return.\n for row in range(9):\n for col in range(9):\n assert solved_state.is_finalized[row][col]\n assert len(solved_state.board_candidates[row][col]) == 1\n if board[row][col] == \".\":\n entry = next(iter(solved_state.board_candidates[row][col]))\n board[row][col] = entry\n\n@dataclass\nclass SolveState:\n board_candidates: List[List[Set[str]]]\n is_finalized: List[List[bool]]\n\n def clone(self):\n board_candidates = [ [ set(cand_set) for cand_set in row] for row in self.board_candidates ]\n is_finalized = [ [ fn for fn in row] for row in self.is_finalized ]\n return SolveState(board_candidates, is_finalized)\n\n\ndef get_box_idx(row: int, col: int) -> int:\n return 3 * (row // 3) + col // 3\n\ndef init_group_sets(board: List[List[str]]):\n row_sets = [set() for i in range(9)]\n col_sets = [set() for i in range(9)]\n box_sets = [set() for i in range(9)]\n for row in range(9):\n for col in range(9):\n cur_cell = board[row][col]\n if cur_cell == \".\":\n continue\n for group_set in [ row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)]]:\n if cur_cell in group_set:\n raise Exception(\"Invalid initial board\")\n group_set.add(cur_cell)\n\n return row_sets, col_sets, box_sets\n\ndef init_board_candidates(board, row_sets, col_sets, box_sets):\n board_candidates = [ [None for col in range(9)] for row in range(9)]\n is_finalized = [ [False for col in range(9)] for row in range(9)]\n\n for row in range(9):\n for col in range(9):\n # Simple case: board has this already defined.\n cur_entry = board[row][col]\n if cur_entry != \".\":\n board_candidates[row][col] = { cur_entry }\n is_finalized[row][col] = True\n else:\n board_candidates[row][col] = get_candidates([\n row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)] ])\n is_finalized[row][col] = False # Set to false even if there's only one candidate.\n \n return board_candidates, is_finalized\n\ndef get_candidates(cand_sets: List[Set[str]]):\n candidates = set(map(str, range(1, 10)))\n for cand_set in cand_sets:\n candidates = candidates - cand_set\n return candidates\n\ndef solve(state: SolveState) -> Optional[SolveState]:\n debug = False\n # Level 2 solve algorithm: \n # apply the winnow algorithm to remove deterministic candidates. \n # then, select the cell with the smallest number of remaining candidates.\n # Guess one of the candidates, then re-apply the solve algorithm. If the\n # guess is correct, the solve algorithm will find a correct solution and return it.\n # Return that solution up the chain.\n # If the guess is incorrect, change your guess and repeat until you find the correct\n # value.\n is_valid, return_code = winnow(state)\n if debug:\n print(\"winnow return: \", return_code)\n print_board(state)\n if not is_valid:\n return None\n\n # Find the cell with the smallest number of candidates, unless this board is finalized.\n min_candidate_cell = None\n min_candidates = float('inf')\n is_finalized = True\n for row in range(9):\n for col in range(9):\n if state.is_finalized[row][col]:\n assert len(state.board_candidates[row][col]) == 1\n else:\n is_finalized = False\n if len(state.board_candidates[row][col]) < min_candidates:\n min_candidates = len(state.board_candidates[row][col])\n min_candidate_cell = (row, col)\n\n # If we've finalized this board, return immediately\n if is_finalized:\n return state\n \n # Else there must have been some min_candidate_cell.\n assert min_candidate_cell != None\n min_cand_row, min_cand_col = min_candidate_cell\n\n for candidate_val in state.board_candidates[min_cand_row][min_cand_col]:\n # Duplicate the solve state and re-apply the winnow algorithm.\n guess_state = state.clone()\n guess_state.board_candidates[min_cand_row][min_cand_col] = { candidate_val }\n maybe_solved_state = solve(guess_state)\n if maybe_solved_state:\n return maybe_solved_state\n\n # If we reach this state the board is invalid\n return None\n\ndef winnow(state: SolveState) -> Tuple[bool, int]:\n # Simple solve algorithm:\n # Loop over the board and collect all non-finalized cells that have only\n # one candidate. Store them in a queue. \n # While the queue is not empty, pop an entry off, finalize it, and \n # remove it as a candidate for all squares in the same row, column, and box.\n # When removing, if any corresponding non-finalized cell has only one remaining\n # entry, add it to the queue. \n # Once the queue is empty, check if everything is finalized. If not we'll need\n # to make some guesses... just throw for now and we can revisit.\n # Return True if the board remains in a valid state after winnowing, otherwise\n # return False. If this returns False, the winnowing process ends and the board\n # will be in an inconsistent state.\n single_candidate_cells = []\n for r in range(9):\n for c in range(9):\n if not state.is_finalized[r][c] and len(state.board_candidates[r][c]) == 1:\n single_candidate_cells.append((r, c))\n\n while len(single_candidate_cells) > 0:\n cur_row, cur_col = single_candidate_cells.pop()\n assert len(state.board_candidates[cur_row][cur_col]) == 1\n cur_val = next(iter(state.board_candidates[cur_row][cur_col]))\n\n state.is_finalized[cur_row][cur_col] = True\n\n # Remove cur_val as a candidate everywhere.\n # Remove from everything in this row\n for col in range(9):\n if state.is_finalized[cur_row][col]:\n continue\n if not maybe_remove_candidate_and_enqueue(cur_val, cur_row, col, state, single_candidate_cells):\n return False, 1\n \n # Remove from everything in this col\n for row in range(9):\n if state.is_finalized[row][cur_col]:\n continue\n if not maybe_remove_candidate_and_enqueue(cur_val, row, cur_col, state, single_candidate_cells):\n return False, 2\n\n # Remove from everything in this box\n for row, col in get_box_coords(cur_row, cur_col):\n if state.is_finalized[row][col]:\n continue\n if not maybe_remove_candidate_and_enqueue(cur_val, row, col, state, single_candidate_cells):\n return False, 3\n\n return True, 4\n\n\ndef maybe_remove_candidate_and_enqueue(cur_val: str, row: int, col: int, \n state: SolveState, single_candidate_cells: List[Tuple[int, int]]) -> bool:\n '''\n Remove the current value from the candidates for the given cell, and append this cell to the single_candidates\n list if removing this value reduces the number of candidates to one.\n If removing this value reduces the number of candidates to zero, return False, as this means we've entered\n an invalid board state. Otherwise return True\n '''\n cur_candidates = state.board_candidates[row][col]\n if cur_val in cur_candidates:\n cur_candidates.remove(cur_val)\n if len(cur_candidates) == 1:\n single_candidate_cells.append((row, col))\n elif len(cur_candidates) == 0:\n return False\n return True\n\ndef get_box_coords(row: int, col: int):\n base_row = 3 * (row // 3) # 0, 3, 6\n base_col = 3 * (col // 3) # 0, 3, 6\n for r in range(base_row, base_row+3):\n for c in range(base_col, base_col+3):\n yield r, c\n\ndef print_n_candidates(board_candidate: List[List[Set[str]]]):\n for row in board_candidate:\n for candidates in row:\n print(len(candidates), end=\", \")\n print()\n\ndef print_board(state: SolveState):\n for row in range(9):\n for col in range(9):\n if state.is_finalized[row][col]:\n cur_val = next(iter(state.board_candidates[row][col]))\n disp = \" \" + cur_val\n else:\n n_cand = len(state.board_candidates[row][col])\n disp = f\"n{n_cand}\"\n \n print(disp, end=\", \")\n print()","runtime":"40"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # Precompute the rows, columns, and boxes\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [set() for _ in range(9)]\n empties = []\n\n # Initialize the sets and list of empty cells\n for i in range(9):\n for j in range(9):\n if board[i][j] != '.':\n num = board[i][j]\n rows[i].add(num)\n cols[j].add(num)\n boxes[(i // 3) * 3 + j // 3].add(num)\n else:\n empties.append((i, j))\n\n # Function to find the empty cell with the minimum remaining values\n def select_next_cell():\n min_options = 10 # Start with a value greater than the maximum possible options\n min_cell = None\n for i, j in empties:\n options = 0\n for num in map(str, range(1, 10)):\n if is_valid(num, i, j):\n options += 1\n if options < min_options:\n min_options = options\n min_cell = (i, j)\n if min_options == 1:\n break # Can't get fewer than one option\n return min_cell\n\n # Function to check if placing num at (i, j) is valid\n def is_valid(num, i, j):\n return (\n num not in rows[i] and\n num not in cols[j] and\n num not in boxes[(i // 3) * 3 + j // 3]\n )\n\n def solve():\n if not empties:\n return True # Puzzle solved\n\n # Select the next cell with the fewest options\n i, j = select_next_cell()\n empties.remove((i, j))\n\n for num in map(str, range(1, 10)):\n if is_valid(num, i, j):\n # Place the number\n board[i][j] = num\n rows[i].add(num)\n cols[j].add(num)\n boxes[(i // 3) * 3 + j // 3].add(num)\n\n if solve():\n return True # If the puzzle is solved, return True\n\n # Backtrack\n board[i][j] = '.'\n rows[i].remove(num)\n cols[j].remove(num)\n boxes[(i // 3) * 3 + j // 3].remove(num)\n\n # If no valid number is found, add the cell back to empties and backtrack\n empties.append((i, j))\n return False\n\n solve()\n","runtime":"40"},{"code":"from dataclasses import dataclass\nfrom typing import List, Set, Tuple, Optional\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # First initialize our solve state\n row_sets, col_sets, box_sets = init_group_sets(board)\n\n board_candidates, is_finalized = init_board_candidates(board, row_sets, col_sets, box_sets)\n\n state = SolveState(board_candidates, is_finalized)\n # Solve\n solved_state = solve(state)\n\n # Finally copy everything over to the original board and return.\n for row in range(9):\n for col in range(9):\n assert solved_state.is_finalized[row][col]\n assert len(solved_state.board_candidates[row][col]) == 1\n if board[row][col] == \".\":\n entry = next(iter(solved_state.board_candidates[row][col]))\n board[row][col] = entry\n\n@dataclass\nclass SolveState:\n board_candidates: List[List[Set[str]]]\n is_finalized: List[List[bool]]\n\n def clone(self):\n board_candidates = [ [ set(cand_set) for cand_set in row] for row in self.board_candidates ]\n is_finalized = [ [ fn for fn in row] for row in self.is_finalized ]\n return SolveState(board_candidates, is_finalized)\n\n\ndef get_box_idx(row: int, col: int) -> int:\n return 3 * (row // 3) + col // 3\n\ndef init_group_sets(board: List[List[str]]):\n row_sets = [set() for i in range(9)]\n col_sets = [set() for i in range(9)]\n box_sets = [set() for i in range(9)]\n for row in range(9):\n for col in range(9):\n cur_cell = board[row][col]\n if cur_cell == \".\":\n continue\n for group_set in [ row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)]]:\n if cur_cell in group_set:\n raise Exception(\"Invalid initial board\")\n group_set.add(cur_cell)\n\n return row_sets, col_sets, box_sets\n\ndef init_board_candidates(board, row_sets, col_sets, box_sets):\n board_candidates = [ [None for col in range(9)] for row in range(9)]\n is_finalized = [ [False for col in range(9)] for row in range(9)]\n\n for row in range(9):\n for col in range(9):\n # Simple case: board has this already defined.\n cur_entry = board[row][col]\n if cur_entry != \".\":\n board_candidates[row][col] = { cur_entry }\n is_finalized[row][col] = True\n else:\n board_candidates[row][col] = get_candidates([\n row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)] ])\n is_finalized[row][col] = False # Set to false even if there's only one candidate.\n \n return board_candidates, is_finalized\n\ndef get_candidates(cand_sets: List[Set[str]]):\n candidates = set(map(str, range(1, 10)))\n for cand_set in cand_sets:\n candidates = candidates - cand_set\n return candidates\n\ndef solve(state: SolveState) -> Optional[SolveState]:\n debug = False\n # Level 2 solve algorithm: \n # apply the winnow algorithm to remove deterministic candidates. \n # then, select the cell with the smallest number of remaining candidates.\n # Guess one of the candidates, then re-apply the solve algorithm. If the\n # guess is correct, the solve algorithm will find a correct solution and return it.\n # Return that solution up the chain.\n # If the guess is incorrect, change your guess and repeat until you find the correct\n # value.\n is_valid, return_code = winnow(state)\n if debug:\n print(\"winnow return: \", return_code)\n print_board(state)\n if not is_valid:\n return None\n\n # Find the cell with the smallest number of candidates, unless this board is finalized.\n min_candidate_cell = None\n min_candidates = float('inf')\n is_finalized = True\n for row in range(9):\n for col in range(9):\n if state.is_finalized[row][col]:\n assert len(state.board_candidates[row][col]) == 1\n else:\n is_finalized = False\n if len(state.board_candidates[row][col]) < min_candidates:\n min_candidates = len(state.board_candidates[row][col])\n min_candidate_cell = (row, col)\n\n # If we've finalized this board, return immediately\n if is_finalized:\n return state\n \n # Else there must have been some min_candidate_cell.\n assert min_candidate_cell != None\n min_cand_row, min_cand_col = min_candidate_cell\n\n for candidate_val in state.board_candidates[min_cand_row][min_cand_col]:\n # Duplicate the solve state and re-apply the winnow algorithm.\n guess_state = state.clone()\n guess_state.board_candidates[min_cand_row][min_cand_col] = { candidate_val }\n maybe_solved_state = solve(guess_state)\n if maybe_solved_state:\n return maybe_solved_state\n\n # If we reach this state the board is invalid\n return None\n\ndef winnow(state: SolveState) -> Tuple[bool, int]:\n # Simple solve algorithm:\n # Loop over the board and collect all non-finalized cells that have only\n # one candidate. Store them in a queue. \n # While the queue is not empty, pop an entry off, finalize it, and \n # remove it as a candidate for all squares in the same row, column, and box.\n # When removing, if any corresponding non-finalized cell has only one remaining\n # entry, add it to the queue. \n # Once the queue is empty, check if everything is finalized. If not we'll need\n # to make some guesses... just throw for now and we can revisit.\n # Return True if the board remains in a valid state after winnowing, otherwise\n # return False. If this returns False, the winnowing process ends and the board\n # will be in an inconsistent state.\n single_candidate_cells = []\n for r in range(9):\n for c in range(9):\n if not state.is_finalized[r][c] and len(state.board_candidates[r][c]) == 1:\n single_candidate_cells.append((r, c))\n\n while len(single_candidate_cells) > 0:\n cur_row, cur_col = single_candidate_cells.pop()\n assert len(state.board_candidates[cur_row][cur_col]) == 1\n cur_val = next(iter(state.board_candidates[cur_row][cur_col]))\n\n state.is_finalized[cur_row][cur_col] = True\n\n # Remove cur_val as a candidate everywhere.\n # Remove from everything in this row\n for col in range(9):\n if state.is_finalized[cur_row][col]:\n continue\n if not maybe_remove_candidate_and_enqueue(cur_val, cur_row, col, state, single_candidate_cells):\n return False, 1\n \n # Remove from everything in this col\n for row in range(9):\n if state.is_finalized[row][cur_col]:\n continue\n if not maybe_remove_candidate_and_enqueue(cur_val, row, cur_col, state, single_candidate_cells):\n return False, 2\n\n # Remove from everything in this box\n for row, col in get_box_coords(cur_row, cur_col):\n if state.is_finalized[row][col]:\n continue\n if not maybe_remove_candidate_and_enqueue(cur_val, row, col, state, single_candidate_cells):\n return False, 3\n\n return True, 4\n\n\ndef maybe_remove_candidate_and_enqueue(cur_val: str, row: int, col: int, \n state: SolveState, single_candidate_cells: List[Tuple[int, int]]) -> bool:\n '''\n Remove the current value from the candidates for the given cell, and append this cell to the single_candidates\n list if removing this value reduces the number of candidates to one.\n If removing this value reduces the number of candidates to zero, return False, as this means we've entered\n an invalid board state. Otherwise return True\n '''\n cur_candidates = state.board_candidates[row][col]\n if cur_val in cur_candidates:\n cur_candidates.remove(cur_val)\n if len(cur_candidates) == 1:\n single_candidate_cells.append((row, col))\n elif len(cur_candidates) == 0:\n return False\n return True\n\ndef get_box_coords(row: int, col: int):\n base_row = 3 * (row // 3) # 0, 3, 6\n base_col = 3 * (col // 3) # 0, 3, 6\n for r in range(base_row, base_row+3):\n for c in range(base_col, base_col+3):\n yield r, c\n\ndef print_n_candidates(board_candidate: List[List[Set[str]]]):\n for row in board_candidate:\n for candidates in row:\n print(len(candidates), end=\", \")\n print()\n\ndef print_board(state: SolveState):\n for row in range(9):\n for col in range(9):\n if state.is_finalized[row][col]:\n cur_val = next(iter(state.board_candidates[row][col]))\n disp = \" \" + cur_val\n else:\n n_cand = len(state.board_candidates[row][col])\n disp = f\"n{n_cand}\"\n \n print(disp, end=\", \")\n print()","runtime":"46"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n def get_nigh(x, y):\n s = set()\n for i in range(x): # vertical - \n yield (i,y)\n for i in range(x+1,9):\n yield (i,y)\n for j in range(y): # horizontal |\n yield (x,j)\n for j in range(y+1,9):\n yield (x,j)\n xbx, ybx = x // 3 * 3, y // 3 * 3\n for i in range(x % 3):\n for j in range(y % 3):\n yield (xbx+i,ybx+j)\n for j in range(y % 3+1, 3):\n yield (xbx+i,ybx+j)\n for i in range(x % 3+1,3):\n for j in range(y % 3):\n yield (xbx+i,ybx+j)\n for j in range(y % 3+1, 3):\n yield (xbx+i,ybx+j)\n # xbx, ybx = x // 3 * 3, y // 3 * 3\n # return {(i,y) for i in range(9)}.union( \n # {(x,j) for j in range(9)}).union( \n # {(xbx, ybx+j) for j in range(3)}).union( # box\n # {(xbx+1, ybx+j) for j in range(3)}).union(\n # {(xbx+2, ybx+j) for j in range(3)})\n nums = {'1','2','3','4','5','6','7','8','9'}\n for x,y in itertools.product(range(9), range(9)):\n if board[x][y] == '.':\n board[x][y] = nums - {board[i][j] for i,j in get_nigh(x,y) if type(board[i][j]) == str}\n def dfs():\n x,y = min(((len(board[i][j]),i,j) for i,j in itertools.product(range(9), range(9)) if type(board[i][j]) == set), default=(123))[1:]\n vals = board[x][y]\n for val in vals:\n updated = []\n board[x][y] = val\n for i,j in get_nigh(x,y):\n if type(board[i][j]) == set and val in board[i][j]:\n board[i][j] -= {val}\n updated.append((i,j))\n dfs() # recursive call\n for i,j in updated:\n print(board[i][j])\n board[i][j].add(val)\n board[x][y] = vals\n try: dfs()\n except TypeError: pass\n","runtime":"46"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n usedRows = [set() for _ in range(9)]\n usedCols = [set() for _ in range(9)]\n usedBoxes = [[set() for _ in range(3)] for _ in range(3)]\n\n for i in range(81):\n row = i // 9\n col = i % 9\n val = board[row][col]\n if val != \".\":\n usedRows[row].add(val)\n usedCols[col].add(val)\n usedBoxes[row // 3][col // 3].add(val)\n\n # print(usedRows)\n # print(usedCols)\n # print(usedBoxes)\n\n allNums = set([str(num) for num in range(1, 10)])\n availableRows = [set() for _ in range(9)]\n availableCols = [set() for _ in range(9)]\n availableBoxes = [[set() for _ in range(3)] for _ in range(3)]\n\n for i in range(81):\n row = i // 9\n col = i % 9\n availableRows[row] = allNums.difference(usedRows[row])\n availableCols[col] = allNums - usedCols[col]\n availableBoxes[row // 3][col // 3] = allNums - usedBoxes[row // 3][col // 3]\n\n \n def backtrack(n, availableRows, availableCols, availableBoxes):\n # print(n)\n row = n // 9\n col = n % 9\n\n if row == 9:\n # print(\"solved\")\n return True\n\n # if already a number, move on\n if board[row][col] == \".\":\n posNums = set(availableRows[row] & availableCols[col] & availableBoxes[row // 3][col // 3])\n # print(\"pos\", n, posNums)\n for num in posNums:\n # print(\"try\", n, num)\n # place\n board[row][col] = num\n # usedRows[row].add(num)\n # usedCols[col].add(num)\n # usedBoxes[row // 3][col // 3].add(num)\n availableRows[row].remove(num)\n availableCols[col].remove(num)\n availableBoxes[row // 3][col // 3].remove(num)\n\n # recurse\n if backtrack(n + 1, availableRows, availableCols, availableBoxes):\n return True\n\n else:\n # remove\n board[row][col] = \".\"\n # usedRows[row].remove(num)\n # usedCols[col].remove(num)\n # usedBoxes[row // 3][col // 3].remove(num)\n availableRows[row].add(num)\n availableCols[col].add(num)\n availableBoxes[row // 3][col // 3].add(num)\n \n return False\n else:\n # print(\"skip\", n)\n if backtrack(n + 1, availableRows, availableCols, availableBoxes):\n return True\n\n return False\n\n \n print(backtrack(0, availableRows, availableCols, availableBoxes))","runtime":"51"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n usedRows = [set() for _ in range(9)]\n usedCols = [set() for _ in range(9)]\n usedBoxes = [[set() for _ in range(3)] for _ in range(3)]\n\n for i in range(81):\n row = i // 9\n col = i % 9\n val = board[row][col]\n if val != \".\":\n usedRows[row].add(val)\n usedCols[col].add(val)\n usedBoxes[row // 3][col // 3].add(val)\n\n allNums = set([str(num) for num in range(1, 10)])\n availableRows = [set() for _ in range(9)]\n availableCols = [set() for _ in range(9)]\n availableBoxes = [[set() for _ in range(3)] for _ in range(3)]\n\n for i in range(81):\n row = i // 9\n col = i % 9\n availableRows[row] = allNums.difference(usedRows[row])\n availableCols[col] = allNums - usedCols[col]\n availableBoxes[row // 3][col // 3] = allNums - usedBoxes[row // 3][col // 3]\n\n \n def backtrack(n):\n row = n // 9\n col = n % 9\n\n if row == 9:\n return True\n\n # if already a number, move on\n if board[row][col] == \".\":\n posNums = set(availableRows[row] & availableCols[col] & availableBoxes[row // 3][col // 3])\n for num in posNums:\n # place\n board[row][col] = num\n availableRows[row].remove(num)\n availableCols[col].remove(num)\n availableBoxes[row // 3][col // 3].remove(num)\n\n # recurse\n if backtrack(n + 1):\n return True\n\n else:\n # remove\n board[row][col] = \".\"\n availableRows[row].add(num)\n availableCols[col].add(num)\n availableBoxes[row // 3][col // 3].add(num)\n \n return False\n else:\n if backtrack(n + 1):\n return True\n\n return False\n\n \n print(backtrack(0))","runtime":"51"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def nextdot(i, j, board):\n for k in range(j,9):\n if board[i][k] == \".\":\n return i, k\n for k in range(i+1, 9):\n for l in range(9):\n if board[k][l] == \".\":\n return k, l\n return -1, -1\n\n def putnumber(i, j, board, r_sets, c_sets, b_sets):\n checklist = set(map(str, range(1, 10))) - r_sets[i] - c_sets[j] - b_sets[3*(i//3)+(j//3)]\n for a in checklist:\n board[i][j] = a\n r_sets[i].add(a)\n c_sets[j].add(a)\n b_sets[3*(i//3)+(j//3)].add(a)\n n_i, n_j = nextdot(i, j, board)\n if n_i == -1:\n return True\n if putnumber(n_i, n_j, board, r_sets, c_sets, b_sets):\n return True\n board[i][j] = \".\"\n r_sets[i].remove(a)\n c_sets[j].remove(a)\n b_sets[3*(i//3)+(j//3)].remove(a)\n return False\n\n r_sets = []\n c_sets = []\n b_sets = []\n for i in range(9):\n r_sets.append(set())\n c_sets.append(set())\n b_sets.append(set())\n \n for i in range(9):\n for j in range(9):\n a = board[i][j]\n if a!=\".\":\n r_sets[i].add(a)\n c_sets[j].add(a)\n b_sets[3*(i//3)+(j//3)].add(a)\n \n i, j = nextdot(0, 0, board)\n if i == -1:\n return\n putnumber(i, j, board, r_sets, c_sets, b_sets)","runtime":"57"},{"code":"import copy\n\n\nclass Board:\n def __init__(self, board):\n self.board = [\n [set(range(1, 10)) if v is None else {v} for v in r] for r in board\n ]\n\n def solve(self):\n if not self.constrain():\n return False\n\n if self.isSolved():\n return True\n\n # Pick location with least possibilities.\n best_idx = (0, 0)\n num_pos = 9\n for i, r in enumerate(self.board):\n for j, c in enumerate(r):\n if len(c) > 1 and len(c) < num_pos:\n # New better location\n best_idx = (i, j)\n num_pos = len(c)\n # Make a guess\n i, j = best_idx\n old = copy.deepcopy(self.board)\n posibilities = list(self.board[i][j])\n for p in posibilities:\n self.board[i][j] = {p}\n if self.solve():\n return True\n # Restore\n self.board = old\n return False\n\n def performSolve(self, to_update):\n assert self.solve()\n\n # Update results\n for i, r in enumerate(self.board):\n for j, c in enumerate(r):\n to_update[i][j] = str(min(c))\n\n def isSolved(self):\n for r in self.board:\n for e in r:\n if len(e) != 1:\n return False\n return True\n\n # Returns true if valid solution.\n def constrain(self):\n updated = False\n # Clean rows\n for i, r in enumerate(self.board):\n used = set()\n for j, x in enumerate(r):\n if len(x) == 0:\n return False # Invalid.\n if len(x) == 1:\n if x.issubset(used):\n return False # invalid\n used.update(x)\n for x in r:\n if len(x) > 1:\n size_before = len(x)\n x.difference_update(used)\n updated |= size_before != len(x)\n if len(x) == 1:\n used.update(x)\n\n # Clean columns\n for c in range(9):\n used = set()\n for r in self.board:\n if len(r[c]) == 1:\n if r[c].issubset(used):\n return False # invalid\n used.update(r[c])\n for r in self.board:\n if len(r[c]) > 1:\n size_before = len(r[c])\n r[c].difference_update(used)\n updated |= size_before != len(r[c])\n if len(r[c]) == 1:\n used.update(r[c])\n\n # Clean tiles.\n for t in range(9):\n c_start = 3 * (t % 3)\n r_start = 3 * (t // 3)\n used = set()\n for r in range(3):\n for c in range(3):\n elem = self.board[r_start + r][c_start + c]\n if len(elem) == 1:\n if elem.issubset(used):\n return False # invalid\n used.update(self.board[r_start + r][c_start + c])\n for r in range(3):\n for c in range(3):\n elem = self.board[r_start + r][c_start + c]\n if len(elem) > 1:\n size_before = len(elem)\n elem.difference_update(used)\n updated |= size_before != len(elem)\n if len(elem) == 1:\n used.update(elem)\n\n if updated:\n # Recurse\n return self.constrain()\n\n return True\n\n def __str__(self):\n return \"\\n\".join([\",\".join([str(x) for x in r]) for r in self.board])\n\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # Convert to sensible.\n board_proc = [[int(v) if v != \".\" else None for v in row] for row in board]\n b = Board(board_proc)\n b.performSolve(board)\n","runtime":"57"},{"code":"import copy\nclass Board:\n def __init__(self, board):\n self.board = [[set(range(1, 10)) if v is None else {v} for v in r] for r in board]\n \n def solve(self):\n if not self.constrain():\n return False\n \n if self.isSolved():\n return True\n\n # Pick location with least possibilities.\n best_idx = (0, 0)\n num_pos = 9\n for i, r in enumerate(self.board):\n for j, c in enumerate(r):\n if len(c) > 1 and len(c) < num_pos:\n # New better location\n best_idx = (i, j)\n num_pos = len(c)\n # Make a guess\n i, j = best_idx\n old = copy.deepcopy(self.board)\n posibilities = list(self.board[i][j])\n for p in posibilities:\n print(\"Guessing {} for ({}, {})\".format(p, i, j))\n self.board[i][j] = {p}\n if self.solve():\n return True\n # Restore\n self.board = old\n return False\n \n\n def performSolve(self, to_update):\n assert(self.solve())\n\n # Update results\n for i, r in enumerate(self.board):\n for j, c in enumerate(r):\n to_update[i][j] = str(min(c))\n\n def isSolved(self):\n for r in self.board:\n for e in r:\n if len(e) != 1:\n return False\n return True\n \n # Returns true if valid solution.\n def constrain(self):\n print(self)\n print(\"\\n\")\n\n updated = False\n # Clean rows\n for i, r in enumerate(self.board):\n used = set()\n for j, x in enumerate(r):\n if len(x) == 0:\n print(\"({}, {}) invalid\".format(i, j))\n return False # Invalid.\n if len(x) == 1:\n if x.issubset(used):\n return False # invalid\n used.update(x)\n for x in r:\n if len(x) > 1:\n size_before = len(x)\n x.difference_update(used)\n updated |= size_before != len(x)\n if len(x) == 1:\n used.update(x)\n \n # Clean columns\n for c in range(9):\n used = set()\n for r in self.board:\n if len(r[c]) == 1:\n if r[c].issubset(used):\n return False # invalid\n used.update(r[c])\n for r in self.board:\n if len(r[c]) > 1:\n size_before = len(r[c])\n r[c].difference_update(used)\n updated |= size_before != len(r[c])\n if len(r[c]) == 1:\n used.update(r[c])\n\n # Clean tiles.\n for t in range(9):\n c_start = 3*(t % 3)\n r_start = 3*(t // 3)\n used = set()\n for r in range(3):\n for c in range(3):\n elem = self.board[r_start + r][c_start + c]\n if len(elem) == 1:\n if elem.issubset(used):\n return False # invalid\n used.update(self.board[r_start + r][c_start + c])\n for r in range(3):\n for c in range(3):\n elem = self.board[r_start + r][c_start + c]\n if len(elem) > 1:\n size_before = len(elem)\n elem.difference_update(used)\n updated |= size_before != len(elem)\n if len(elem) == 1:\n used.update(elem)\n\n if updated:\n # Recurse\n return self.constrain()\n \n return True\n \n\n def __str__(self):\n return \"\\n\".join([','.join([str(x) for x in r]) for r in self.board])\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # Convert to sensible.\n board_proc = [[int(v) if v != '.' else None for v in row] for row in board]\n b = Board(board_proc)\n b.performSolve(board)\n # print(b)\n ","runtime":"63"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n rows,cols,block,seen = defaultdict(set),defaultdict(set),defaultdict(set),deque([])\n for i in range(9):\n for j in range(9):\n if board[i][j]!=\".\":\n rows[i].add(board[i][j])\n cols[j].add(board[i][j])\n block[(i//3,j//3)].add(board[i][j])\n else:\n seen.append((i,j))\n \n def dfs():\n if not seen:\n return True\n \n r,c = seen[0]\n t = (r//3,c//3)\n for n in {'1','2','3','4','5','6','7','8','9'}:\n if n not in rows[r] and n not in cols[c] and n not in block[t]:\n board[r][c]=n\n rows[r].add(n)\n cols[c].add(n)\n block[t].add(n)\n seen.popleft()\n if dfs():\n return True\n else:\n board[r][c]=\".\"\n rows[r].discard(n)\n cols[c].discard(n)\n block[t].discard(n)\n seen.appendleft((r,c))\n return False\n \n dfs()\n\n \n\n","runtime":"63"},{"code":"from collections import defaultdict\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\" \n\n def dfs(row, col, left_row, left_col, left_square):\n\n possible_digits = set(['1','2','3','4','5','6','7','8','9']) - used_row[row] - used_col[col] - used_square[(row//3, col//3)]\n\n for possible_digit in possible_digits:\n\n board[row][col] = possible_digit\n\n \n used_row[row].add(possible_digit)\n used_col[col].add(possible_digit)\n used_square[(row//3, col//3)].add(possible_digit)\n\n # go to next open space\n next_row, next_col = row, col\n while board[next_row][next_col] != '.':\n next_row = next_row + 1 if next_col + 1 == 9 else next_row\n next_col = 0 if next_col + 1 == 9 else next_col + 1\n \n\n if next_row == 9: # we are outside the board\n return True\n\n if dfs(next_row, next_col, used_row, used_col, used_square):\n return True\n\n board[row][col] = '.'\n\n used_row[row].remove(possible_digit)\n used_col[col].remove(possible_digit)\n used_square[(row//3, col//3)].remove(possible_digit)\n\n return False\n\n used_row = defaultdict(set)\n used_col = defaultdict(set)\n used_square = defaultdict(set)\n\n\n first_dot = True\n for row in range(len(board)):\n for col in range(len(board[0])):\n\n if board[row][col] != '.':\n used_row[row].add(board[row][col])\n used_col[col].add(board[row][col])\n used_square[(row//3, col//3)].add(board[row][col])\n else:\n if first_dot:\n start_row = row\n start_col = col\n first_dot = False\n\n dfs(start_row, start_col, used_row, used_col, used_square)","runtime":"68"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n rows = defaultdict(set)\n cols = defaultdict(set)\n region = defaultdict(set)\n f = lambda r, c : 3 * (r // 3) + (c // 3)\n \n def append(r, c, x):\n rows[r].add(x)\n cols[c].add(x)\n region[f(r, c)].add(x)\n board[r][c] = str(x)\n \n def pop(r, c, x):\n rows[r].remove(x)\n cols[c].remove(x)\n region[f(r, c)].remove(x)\n board[r][c] = '.'\n \n def neighbors(r, c):\n for val in range(1, 10):\n if all((\n val not in rows[r],\n val not in cols[c],\n val not in region[f(r, c)],\n )):\n yield val\n \n def cost(r, c):\n return sum(1 for _ in neighbors(r, c))\n \n def solve(coords):\n if len(coords) == 0:\n return True\n \n _, r, c = heapq.heappop(queue)\n for val in neighbors(r, c):\n append(r, c, val)\n if solve(coords):\n return True\n pop(r, c, val)\n \n heapq.heappush(queue, (cost(r, c), r, c))\n return False\n \n empties = []\n for r, c in product(range(9), repeat=2):\n if board[r][c] == '.':\n empties.append((r, c))\n else:\n append(r, c, int(board[r][c]))\n \n queue = [(cost(r, c), r, c) for r, c in empties]\n heapq.heapify(queue)\n solve(queue)\n return board","runtime":"68"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n rows,cols,block,seen = defaultdict(set),defaultdict(set),defaultdict(set),deque([])\n for i in range(9):\n for j in range(9):\n if board[i][j]!=\".\":\n rows[i].add(board[i][j])\n cols[j].add(board[i][j])\n block[(i//3,j//3)].add(board[i][j])\n else:\n seen.append((i,j))\n \n def dfs():\n if not seen:\n return True\n \n r,c = seen[0]\n t = (r//3,c//3)\n for n in {'1','2','3','4','5','6','7','8','9'}:\n if n not in rows[r] and n not in cols[c] and n not in block[t]:\n board[r][c]=n\n rows[r].add(n)\n cols[c].add(n)\n block[t].add(n)\n seen.popleft()\n if dfs():\n return True\n else:\n board[r][c]=\".\"\n rows[r].discard(n)\n cols[c].discard(n)\n block[t].discard(n)\n seen.appendleft((r,c))\n return False\n \n dfs()","runtime":"74"},{"code":"class Solution:\n # def solveSudoku(self, board: List[List[str]]) -> None:\n # \"\"\"\n # Do not return anything, modify board in-place instead.\n # \"\"\"\n # def is_valid(board, row, col, num):\n # for i in range(9):\n # if board[row][i] == num:\n # return False\n \n # for i in range(9):\n # if board[i][col] == num:\n # return False\n \n # startRow = (row // 3) * 3\n # startCol = (col // 3)* 3\n # for i in range(3):\n # for j in range(3):\n # if board[startRow + i][startCol + j] == num:\n # return False\n # return True\n \n # def solve(board):\n # for row in range(9):\n # for col in range(9):\n # if board[row][col] == '.':\n # for num in '123456789':\n # if is_valid(board, row, col, num):\n # board[row][col] = num\n # if solve(board):\n # return True\n # # back track\n # board[row][col] = '.'\n # return False\n # return True\n \n # solve(board)\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [set() for _ in range(9)]\n\n for i in range(9):\n for j in range(9):\n if board[i][j] != \".\":\n num = int(board[i][j])\n rows[i].add(num)\n cols[j].add(num)\n\n box_id = i // 3 * 3 + j // 3\n boxes[box_id].add(num)\n\n def backTrack(i, j) -> None:\n nonlocal solved\n if i == 9:\n solved = True\n return\n \n new_i = i + (j + 1) // 9\n new_j = (j + 1) % 9\n\n if board[i][j] != \".\":\n backTrack(new_i, new_j)\n else:\n box_id = i // 3 * 3 + j // 3\n for n in range(1, 10):\n if n not in rows[i] and n not in cols[j] and n not in boxes[box_id]:\n rows[i].add(n)\n cols[j].add(n)\n boxes[box_id].add(n)\n board[i][j] = str(n)\n\n backTrack(new_i, new_j)\n if solved:\n break\n\n rows[i].remove(n)\n cols[j].remove(n)\n boxes[box_id].remove(n)\n board[i][j] = \".\"\n\n solved = False\n backTrack(0, 0)","runtime":"74"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n r = [[0]*9 for _ in range(9)]\n c = [[0]*9 for _ in range(9)]\n d = [[0]*9 for _ in range(9)]\n visit = []\n for i in range(9):\n for j in range(9):\n if board[i][j] != '.':\n num = int(board[i][j]) - 1\n k = i//3 * 3 + j//3;\n r[i][num] = 1\n c[j][num] = 1\n d[k][num] = 1\n else:\n visit.append((i,j))\n def dfs():\n if not visit:\n return True\n i, j = visit.pop()\n for num in range(9):\n if r[i][num]==0 and c[j][num]==0 and d[i//3*3+j//3][num]==0:\n board[i][j] = str(num+1)\n r[i][num] = c[j][num] = d[i//3*3+j//3][num] = 1\n if dfs():\n return True\n board[i][j] = '.'\n r[i][num] = c[j][num] = d[i//3*3+j//3][num] = 0\n visit.append((i,j))\n return False\n\n dfs()\n \n","runtime":"79"},{"code":"class Solution:\n # The time complexity can be improved by using more space (dict or set) and pre-processing the input to save non-empty and empty cells and put into 3 separate dict for its row/col/cube-box.\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # pre-processing input board to store index for\n rows, cols, triples = defaultdict(set), defaultdict(set), defaultdict(set)\n empties = deque()\n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\": \n empties.append((r, c))\n else:\n rows[r].add(board[r][c])\n cols[c].add(board[r][c])\n triples[(r // 3, c // 3)].add(board[r][c])\n\n def backtrack():\n if not empties: \n return True\n r, c = empties[0] # row, col index\n t = (r // 3, c // 3)\n for num in (\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"):\n if num in rows[r] or num in cols[c] or num in triples[t]:\n continue\n board[r][c] = num\n rows[r].add(num)\n cols[c].add(num)\n triples[t].add(num)\n empties.popleft()\n if backtrack(): \n return True\n # backtrack\n board[r][c] = \".\"\n rows[r].discard(num)\n cols[c].discard(num)\n triples[t].discard(num)\n empties.appendleft((r, c))\n return False\n \n backtrack()","runtime":"79"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.row = [[False for _ in range(9+1)] for _ in range(9)]\n self.col = [[False for _ in range(9+1)] for _ in range(9)]\n self.box = [[[False for _ in range(9+1)] for _ in range(3)] for _ in range(3)]\n self.ans = False \n for i in range(9):\n for j in range(9):\n if board[i][j] != '.':\n val = int(board[i][j])\n self.row[i][val] = self.col[j][val] = \\\n self.box[i//3][j//3][val] = True \n self.dfs(board, 0, 0)\n print(board)\n \n def dfs(self, grid, i, j):\n if i == 9:\n self.ans = True \n return \n if j == 9:\n self.dfs(grid, i+1, 0)\n return \n if grid[i][j] != '.':\n self.dfs(grid, i, j+1)\n return \n for val in range(1, 10):\n if not self.row[i][val] and not self.col[j][val] and \\\n not self.box[i//3][j//3][val]:\n self.row[i][val] = self.col[j][val] = \\\n self.box[i//3][j//3][val] = True \n grid[i][j] = str(val)\n self.dfs(grid, i, j+1)\n if self.ans:\n return \n grid[i][j] = '.'\n self.row[i][val] = self.col[j][val] = \\\n self.box[i//3][j//3][val] = False","runtime":"85"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n def dfs(k):\n nonlocal ok\n if k == len(t):\n ok = True\n return\n i, j = t[k]\n for v in range(9):\n if row[i][v] == col[j][v] == block[i // 3][j // 3][v] == False:\n row[i][v] = col[j][v] = block[i // 3][j // 3][v] = True\n board[i][j] = str(v + 1)\n dfs(k + 1)\n row[i][v] = col[j][v] = block[i // 3][j // 3][v] = False\n if ok:\n return\n\n row = [[False] * 9 for _ in range(9)]\n col = [[False] * 9 for _ in range(9)]\n block = [[[False] * 9 for _ in range(3)] for _ in range(3)]\n t = []\n ok = False\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n t.append((i, j))\n else:\n v = int(board[i][j]) - 1\n row[i][v] = col[j][v] = block[i // 3][j // 3][v] = True\n dfs(0)","runtime":"85"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n solved = False\n\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n grids = [[set() for _ in range(3)] for _ in range(3)]\n\n # Set the current board\n for i in range(9):\n for j in range(9):\n if board[i][j] != '.':\n rows[i].add(int(board[i][j]))\n cols[j].add(int(board[i][j]))\n grids[i//3][j//3].add(int(board[i][j]))\n\n def solver(i,j):\n nonlocal solved\n\n if i == 9:\n solved = True\n return\n \n i_new = i if j<8 else i+1\n j_new = j+1 if j<8 else 0\n\n if board[i][j] != '.':\n solver(i_new,j_new)\n else:\n for k in range(1,10):\n if k not in rows[i] and k not in cols[j] and k not in grids[i//3][j//3]:\n board[i][j] = str(k)\n rows[i].add(k)\n cols[j].add(k)\n grids[i//3][j//3].add(k)\n\n solver(i_new,j_new)\n\n if not solved:\n board[i][j] = '.'\n rows[i].remove(k)\n cols[j].remove(k)\n grids[i//3][j//3].remove(k)\n\n solver(0,0)\n\n\n ","runtime":"90"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # self.found = False\n used_row, used_col, used_mat = [set() for i in range(9)], [set() for i in range(9)], [set() for i in range(9)]\n loc = []\n for i in range(len(board)):\n for j in range(len(board)):\n if board[i][j] == '.':\n loc.append((i, j))\n else:\n used_row[i].add(board[i][j])\n used_col[j].add(board[i][j])\n used_mat[i // 3 * 3 + j // 3].add(board[i][j])\n\n\n # print(used_row)\n # print(used_col)\n # print(used_mat)\n ans = []\n\n \n\n \n def back_track(k):\n if k == len(loc):\n for row in range(len(board)):\n ans.append(list(board[row]))\n # self.ans = copy.deepcopy(board)\n return\n \n if ans:\n return\n \n i, j = loc[k]\n\n for n in range(1, 10):\n s = f'{n}'\n if s not in used_row[i] and s not in used_col[j] and s not in used_mat[i // 3 * 3 + j // 3]:\n board[i][j] = s\n used_row[i].add(s)\n used_col[j].add(s)\n used_mat[i // 3 * 3 + j // 3].add(s)\n back_track(k + 1)\n board[i][j] = '.'\n used_row[i].remove(s)\n used_col[j].remove(s)\n used_mat[i // 3 * 3 + j // 3].remove(s)\n \n back_track(0)\n\n for i in range(len(board)):\n for j in range(len(board)):\n board[i][j] = ans[i][j]\n \n","runtime":"90"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anithing, modifi board in-place instead.\n \"\"\"\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxs = [set() for _ in range(9)]\n\n \"\"\"\"These loops are just for us to find and record the preexisting numbers in the sudoku board\"\"\"\n for i in range(9):\n for j, val in enumerate(board[i]):\n if board[i][j] != '.':\n rows[i].add(int(val))\n cols[j].add(int(val))\n box_idx = i // 3 * 3 + j // 3 #this will make it so the boxs are labeled 1-8\n boxs[box_idx].add(int(val))\n\n def backTrack(i, j):\n nonlocal solved\n if i == 9:\n solved = True\n return\n\n # These 2 lines are a calculation trick to make sure that i is increased if j is at the 9th\n # position and j is increases until it reaches 9 and then becomes 0 again \n new_i = i + (j+1) // 9 \n new_j = (j+1) % 9\n\n if board[i][j] != '.':\n backTrack(new_i, new_j)\n else:\n for num in range(1, 10):\n box_idx = i // 3 * 3 + j // 3\n if num not in rows[i] and num not in cols[j] and num not in boxs[box_idx]:\n rows[i].add(num)\n cols[j].add(num)\n boxs[box_idx].add(num)\n board[i][j] = str(num)\n\n backTrack(new_i, new_j)\n \n if not solved:\n rows[i].remove(num)\n cols[j].remove(num)\n boxs[box_idx].remove(num)\n board[i][j] = '.'\n\n\n solved = False\n backTrack(0, 0)","runtime":"96"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n rows = [set() for _ in range(9)]\n columns = [set() for _ in range(9)]\n buckets = [set() for _ in range(9)]\n empty_cells = []\n\n # Preprocess the board to initialize sets and collect empty cells\n for r in range(9):\n for c in range(9):\n if board[r][c] == '.':\n empty_cells.append((r, c))\n else:\n rows[r].add(board[r][c])\n columns[c].add(board[r][c])\n bucket_index = (r // 3) * 3 + c // 3\n buckets[bucket_index].add(board[r][c])\n\n # Check if placing number 'n' at position (r, c) is valid\n def is_valid(r, c, n):\n bucket_index = (r // 3) * 3 + c // 3\n if n in rows[r] or n in columns[c] or n in buckets[bucket_index]:\n return False\n return True\n\n # Recursive backtracking function to solve the Sudoku\n def solve(index=0):\n if index == len(empty_cells):\n return True # Puzzle is solved\n\n r, c = empty_cells[index]\n \n for n in '123456789':\n if is_valid(r, c, n):\n bucket_index = (r // 3) * 3 + c // 3\n\n # Update the sets\n rows[r].add(n)\n columns[c].add(n)\n buckets[bucket_index].add(n)\n \n # Update the board\n board[r][c] = n\n\n # Proceed with recursion\n if solve(index + 1):\n return True\n\n # Backtrack if needed\n rows[r].discard(n)\n columns[c].discard(n)\n buckets[bucket_index].discard(n)\n board[r][c] = '.'\n\n return False\n\n # Start solving the Sudoku\n solve()","runtime":"96"},{"code":"import collections\nclass Solution:\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n rows, cols, squares = self.createSet(board)\n solved = False\n \n def backtrack(r, c):\n nonlocal solved\n\n if r == 9:\n solved = True\n return \n\n R = r+((c+1)//9)\n C = (c+1) % 9\n \n # has a numer \n if board[r][c] != '.': \n backtrack(R, C)\n\n # empty\n else:\n for i in range(1,10):\n if i not in rows[r] and i not in cols[c] and i not in squares[(r//3, c//3)]:\n rows[r].add(i)\n cols[c].add(i)\n squares[(r//3, c//3)].add(i)\n board[r][c] = str(i)\n \n backtrack(R, C)\n \n if solved == False:\n rows[r].remove(i)\n cols[c].remove(i)\n squares[(r//3, c//3)].remove(i)\n board[r][c] = '.'\n\n backtrack(0,0) \n\n def createSet(self, board):\n rows = collections.defaultdict(set)\n cols = collections.defaultdict(set)\n squares = collections.defaultdict(set)\n \n for r in range(9):\n for c in range(9):\n if board[r][c] != '.':\n num = int(board[r][c])\n rows[r].add(num)\n cols[c].add(num)\n squares[(r//3, c//3)].add(num)\n \n return rows, cols, squares\n\n \n \n ","runtime":"101"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n col_sets = [set() for j in range(len(board[0]))]\n row_sets = [set() for i in range(len(board))]\n box_sets = [set() for i in range(9)]\n\n def helper(ind):\n if ind == len(board[0]) * len(board):\n return True\n \n i, j = ind // len(board[0]), ind % len(board[0])\n box = 3 * (i // 3) + (j // 3)\n if board[i][j] != \".\":\n return helper(ind + 1)\n \n # we can fill in the dot\n for choice in range(1,10):\n choice = str(choice)\n if choice in row_sets[i] or choice in col_sets[j] or choice in box_sets[box]:\n continue\n board[i][j] = str(choice)\n row_sets[i].add(choice)\n col_sets[j].add(choice)\n box_sets[box].add(choice)\n if helper(ind+1):\n return True\n row_sets[i].remove(choice)\n col_sets[j].remove(choice)\n box_sets[box].remove(choice)\n board[i][j] = \".\"\n return False\n \n for i in range(len(board)):\n for j in range(len(board[i])):\n x = board[i][j]\n box = 3 * (i // 3) + (j // 3)\n if board[i][j] != \".\":\n col_sets[j].add(x)\n row_sets[i].add(x)\n box_sets[box].add(x)\n \n helper(0)\n return board\n ","runtime":"101"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n sub_boxes = [[set() for _ in range(3)] for _ in range(3)]\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n\n for i in range(9):\n for j in range(9):\n num = board[i][j]\n if num == \".\":\n continue\n\n sub_boxes[i // 3][j // 3].add(num)\n rows[i].add(num)\n cols[j].add(num)\n\n def solve(row, col) -> bool:\n if row == 9:\n return True\n if col == 9:\n return solve(row + 1, 0)\n if board[row][col] != \".\":\n return solve(row, col + 1)\n\n for num in range(1, 10):\n num = str(num)\n if (\n num in sub_boxes[row // 3][col // 3]\n or num in rows[row]\n or num in cols[col]\n ):\n continue\n\n board[row][col] = num\n sub_boxes[row // 3][col // 3].add(num)\n rows[row].add(num)\n cols[col].add(num)\n\n if solve(row, col + 1):\n return True\n\n board[row][col] = \".\"\n sub_boxes[row // 3][col // 3].remove(num)\n rows[row].remove(num)\n cols[col].remove(num)\n\n return False\n\n return solve(0, 0)\n ","runtime":"107"},{"code":"import collections\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # Track numbers in rows, columns, and subgrids (3x3)\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n subs = [[set() for _ in range(3)] for _ in range(3)]\n\n # Use deque for storing empty cells (gaps) as a stack\n gaps = collections.deque()\n for i in range(9):\n for j in range(9):\n tile = board[i][j]\n if tile != \".\":\n rows[i].add(tile)\n cols[j].add(tile)\n subs[i // 3][j // 3].add(tile)\n else:\n gaps.append((i, j))\n\n # Recursive backtracking using gaps as a stack (deque)\n def solve(rows, cols, subs):\n nonlocal board\n nonlocal gaps\n\n # Base case: all gaps filled\n if not gaps:\n return True # Puzzle solved\n\n # Pop the last gap from the stack\n i, j = gaps.pop()\n\n # Try placing numbers 1-9 in the current gap\n for n in map(str, range(1, 10)):\n if n not in rows[i] and n not in cols[j] and n not in subs[i // 3][j // 3]:\n # Place the number and update tracking sets\n board[i][j] = n\n rows[i].add(n)\n cols[j].add(n)\n subs[i // 3][j // 3].add(n)\n\n # Recur to the next gap\n if solve(rows, cols, subs):\n return True # Puzzle is solved\n\n # Backtrack if this placement doesn't lead to a solution\n board[i][j] = \".\"\n rows[i].remove(n)\n cols[j].remove(n)\n subs[i // 3][j // 3].remove(n)\n\n # No valid number found, push the gap back (restore it)\n gaps.append((i, j))\n return False # Trigger backtracking\n\n # Start solving from the first gap\n solve(rows, cols, subs)","runtime":"107"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n rows = defaultdict(set)\n cols = defaultdict(set)\n cells = defaultdict(set)\n\n for i in range(9):\n for j in range(9):\n if board[i][j] != \".\":\n rows[i].add(board[i][j])\n cols[j].add(board[i][j])\n c_i = i // 3\n c_j = j // 3\n cells[c_i*3+c_j].add(board[i][j])\n \n found = False\n print(cells)\n\n def backtrack(i, j):\n nonlocal rows, cols, cells, found\n if found:\n return\n\n if j == 9:\n i = i+1\n j = 0\n \n if i == 9:\n found = True\n return\n\n # if the current (i, j) is empty, try to put a number from 1 to 9 that is valid to it and continue to the next pos; and if the current (i, j) is not empty, continue to the next pos directly.\n if board[i][j] == \".\":\n c_i = i // 3\n c_j = j // 3\n for d in range(1, 10):\n d = str(d)\n if d not in rows[i] and d not in cols[j] and d not in cells[c_i*3+c_j]:\n rows[i].add(d)\n cols[j].add(d)\n cells[c_i*3+c_j].add(d)\n board[i][j] = d\n backtrack(i, j+1)\n if found:\n return\n board[i][j] = \".\"\n rows[i].remove(d)\n cols[j].remove(d)\n cells[c_i*3+c_j].remove(d)\n\n else:\n backtrack(i, j+1)\n \n backtrack(0, 0)","runtime":"113"},{"code":"from collections import defaultdict\n\nclass Solution:\n def getSubBoxIndex(self, rowIndex, colIndex):\n return (rowIndex // 3) * 3 + colIndex // 3\n \n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n rowDct = defaultdict(set)\n colDct = defaultdict(set)\n subBoxDct = defaultdict(set)\n toFill = []\n \n for i in range(9):\n for j in range(9):\n if board[i][j].isdigit():\n subBoxIndex = self.getSubBoxIndex(i, j)\n rowDct[i].add(board[i][j])\n colDct[j].add(board[i][j])\n subBoxDct[subBoxIndex].add(board[i][j])\n else:\n subBoxIndex = self.getSubBoxIndex(i, j)\n toFill.append((i, j, subBoxIndex))\n \n \n def fill():\n if not toFill:\n return True\n rowIndex, colIndex, subBoxIndex = toFill.pop()\n for num in map(str, range(1, 10)):\n if num in rowDct[rowIndex] or num in colDct[colIndex] or num in subBoxDct[subBoxIndex]:\n continue\n rowDct[rowIndex].add(num)\n colDct[colIndex].add(num)\n subBoxDct[subBoxIndex].add(num)\n board[rowIndex][colIndex] = num\n res = fill()\n if res:\n return True\n board[rowIndex][colIndex] = \".\"\n rowDct[rowIndex].discard(num)\n colDct[colIndex].discard(num)\n subBoxDct[subBoxIndex].discard(num)\n toFill.append((rowIndex, colIndex, subBoxIndex))\n \n fill()\n \n \n ","runtime":"113"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n def getBoxIndex(r, c):\n r //= 3\n c //= 3\n return r * 3 + c\n\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [set() for _ in range(9)] # row-major\n\n for r in range(9):\n for c in range(9):\n if board[r][c] != '.':\n num = int(board[r][c])\n rows[r].add(num)\n cols[c].add(num)\n boxes[getBoxIndex(r, c)].add(num)\n \n def placeNumber(num, r, c):\n board[r][c] = str(num)\n rows[r].add(num)\n cols[c].add(num)\n boxes[getBoxIndex(r, c)].add(num)\n \n def removeNumber(num, r, c):\n board[r][c] = '.'\n rows[r].remove(num)\n cols[c].remove(num)\n boxes[getBoxIndex(r, c)].remove(num)\n \n def canPlace(num, r, c):\n return num not in rows[r] and num not in cols[c] and num not in boxes[getBoxIndex(r, c)]\n \n self.done = False\n\n def dfs(r, c):\n if board[r][c] != '.':\n if r == 8 and c == 8:\n self.done = True\n return\n elif c < 8:\n return dfs(r, c + 1)\n else:\n return dfs(r + 1, 0)\n\n for num in range(1, 10):\n if canPlace(num, r, c):\n placeNumber(num, r, c)\n \n if r == 8 and c == 8:\n self.done = True\n return\n elif c < 8:\n dfs(r, c + 1)\n else:\n dfs(r + 1, 0)\n \n if self.done:\n return\n \n removeNumber(num, r, c)\n \n dfs(0, 0)","runtime":"118"},{"code":"#\n# @lc app=leetcode id=37 lang=python3\n#\n# [37] Sudoku Solver\n#\nfrom typing import *\n# @lc code=start\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n rows: List[set[str]] = [set() for _ in range(9)]\n cols: List[set[str]] = [set() for _ in range(9)]\n boxes: List[set[str]] = [set() for _ in range(9)]\n get_box_index: Callable[[int, int], int] = lambda row, col: (row // 3) * 3 + (col // 3)\n finished: bool = False\n \n def place_num(num: str, row: int, col: int):\n rows[row].add(num)\n cols[col].add(num)\n boxes[get_box_index(row, col)].add(num)\n board[row][col] = num\n \n def remove_num(num: str, row: int, col: int):\n rows[row].remove(num)\n cols[col].remove(num)\n boxes[get_box_index(row, col)].remove(num)\n board[row][col] = \".\"\n \n def can_place(num: str, row: int, col: int):\n return not num in rows[row] and \\\n not num in cols[col] and \\\n not num in boxes[get_box_index(row, col)]\n\n \n def place_next(row: int, col: int):\n nonlocal finished\n if row == 8 and col == 8:\n finished = True\n return\n if col == 8:\n return backtrack(row + 1, 0)\n \n return backtrack(row, col + 1)\n \n def backtrack(row: int, col: int):\n if board[row][col] == \".\":\n for val in range(1, 10):\n num = str(val)\n if can_place(num, row, col):\n place_num(num, row, col)\n place_next(row, col)\n \n if finished:\n return\n remove_num(num, row, col)\n else:\n place_next(row, col)\n \n for row in range(9):\n for col in range(9):\n val = board[row][col]\n if val != \".\":\n place_num(val, row, col)\n\n backtrack(0, 0)\n ","runtime":"118"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n BS = 9\n SQBS = int(BS ** 0.5)\n\n def extract_row(i):\n return board[i]\n\n def extract_col(i):\n return [board[j][i] for j in range(len(board))]\n\n def extract_box(k):\n res = list()\n for i in range((k // SQBS) * SQBS, (k // SQBS) * SQBS + SQBS):\n for j in range((k % SQBS) * SQBS, (k % SQBS) * SQBS + SQBS):\n res.append(board[i][j])\n return res\n\n def get_options(i, j):\n r = set([x for x in extract_row(i) if x != '.'])\n c = set([x for x in extract_col(j) if x != '.'])\n b = set([x for x in extract_box((i // SQBS) * SQBS + (j // SQBS)) if x != '.'])\n all_digits = r.union(c).union(b)\n options = [str(i) for i in range(1, BS + 1) if str(i) not in all_digits]\n return options\n\n min_sugg_cell = None\n min_sugg = None\n\n for i in range(BS):\n for j in range(BS):\n if board[i][j] == '.':\n curr_sugg = get_options(i, j)\n print(i, j, curr_sugg)\n if len(curr_sugg) == 0:\n return False\n if len(curr_sugg) > 0 and (min_sugg is None or len(curr_sugg) < len(min_sugg)):\n min_sugg = curr_sugg\n min_sugg_cell = (i, j)\n \n if min_sugg_cell is None:\n return True\n \n for o in min_sugg:\n board[min_sugg_cell[0]][min_sugg_cell[1]] = str(o)\n if self.solveSudoku(board):\n return True\n board[min_sugg_cell[0]][min_sugg_cell[1]] = '.'\n\n \n ","runtime":"124"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n \n rows=9\n cols=9\n\n rowset=defaultdict(set)\n colset=defaultdict(set)\n boxset=defaultdict(set)\n\n for i in range(rows):\n\n for j in range(cols):\n \n if board[i][j].isdigit():\n rowset[i].add(board[i][j])\n colset[j].add(board[i][j])\n boxset[(i//3,j//3)].add(board[i][j])\n \n print(rowset)\n print(colset)\n print(boxset)\n def backtrack(i,j):\n\n if i==9:\n return True\n \n if j==9:\n return backtrack(i+1,0)\n \n if board[i][j].isdigit():\n return backtrack(i,j+1)\n \n for num in range(1,10):\n num=str(num)\n if num not in colset[j] and num not in rowset[i] and num not in boxset[(i//3,j//3)]:\n rowset[i].add(num)\n colset[j].add(num)\n boxset[(i//3,j//3)].add(num)\n board[i][j]=num\n if backtrack(i,j+1):\n return True\n board[i][j]=\".\"\n rowset[i].remove(num)\n colset[j].remove(num)\n boxset[(i//3,j//3)].remove(num)\n return False\n \n backtrack(0,0)","runtime":"124"},{"code":"import copy\nfrom typing import List\n\n\nclass Solution:\n def __init__(self):\n self.posibilities = [[set() for _ in range(9)] for _ in range(9)]\n \n def initPosibilities(self, board: List[List[str]]) -> None:\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n for value in range(1,10):\n self.posibilities[i][j].add(str(value))\n else:\n self.posibilities[i][j].add(board[i][j])\n board[i][j] = \".\"\n\n def removeValueFromCell(self,board,row:int,col:int,value:str)->None:\n try:\n self.posibilities[row][col].remove(value)\n except KeyError as e:\n return\n\n def setCell(self,board,row:int,col:int,value:str)->None:\n board[row][col] = value\n #on row\n for j in range(9):\n if(j==col):\n continue\n self.removeValueFromCell(board,row,j,value) \n #on col\n for i in range(9):\n if(i==row):\n continue\n self.removeValueFromCell(board,i,col,value)\n #on square\n for i in range(3):\n for j in range(3):\n if row-row%3+i==row and col-col%3+j==col:\n continue\n self.removeValueFromCell(board,row-row%3+i,col-col%3+j,value)\n\n def fillByEliminating(self,board):\n changeMade = True\n while changeMade:\n changeMade = False\n for i in range(9):\n for j in range(9):\n if(board[i][j] == \".\" and len(self.posibilities[i][j]) == 1):\n changeMade = True\n self.setCell(board,i,j,next(iter(self.posibilities[i][j]))) \n\n def isValid(self)->bool:\n for i in range(9):\n for j in range(9):\n if self.posibilities[i][j] == 0:\n return False\n return True\n \n def nextEmptySpace(self,board,row:int,col:int)->tuple[int,int]:\n while board[row][col] != \".\":\n col += 1\n if col>8:\n col=0\n row+=1\n if row == 9:\n return (-1,-1)\n return (row,col)\n\n def backtrackTheMdf(self,board: List[List[str]],row:int,col:int)->bool:\n #all empty cells were filled\n if row == -1:\n return True\n #trying the possible values\n oldPossibilities = copy.deepcopy(self.posibilities)\n oldBoard = copy.deepcopy(board)\n for value in oldPossibilities[row][col]:\n #filling the new guess\n self.setCell(board,row,col,value)\n self.fillByEliminating(board)\n nextRow,nextCol = self.nextEmptySpace(board,row,col)\n #restoring the sudoku in case of bad guess\n if (self.isValid() and self.backtrackTheMdf(board,nextRow,nextCol)):\n return True\n else:\n board = copy.deepcopy(oldBoard)\n self.posibilities = copy.deepcopy(oldPossibilities)\n \n return False \n\n def solveSudoku(self, board: List[List[str]]) -> None:\n self.initPosibilities(board)\n self.fillByEliminating(board)\n nextRow,nextCol = self.nextEmptySpace(board,0,0)\n self.backtrackTheMdf(board,nextRow,nextCol)\n for i in range(9):\n for j in range(9):\n board[i][j] = str(next(iter(self.posibilities[i][j]))) ","runtime":"129"},{"code":"class Solution:\n # The time complexity can be improved by using more space (dict and set) to save non-empty cells and their values.\n def solveSudoku(self, board):\n \"\"\"\n :type board: List[List[str]]\n :rtype: void Do not return anything, modify board in-place instead.\n \"\"\"\n\n def could_place(d, row, col):\n \"\"\"\n Check if one could place a number `d` in (row, col) cell\n \"\"\"\n return not (\n d in rows[row]\n or d in columns[col]\n or d in boxes[box_index(row, col)]\n )\n\n def place_number(d, row, col):\n \"\"\"\n Place a number `d` in (row, col) cell\n \"\"\"\n rows[row][d] += 1\n columns[col][d] += 1\n boxes[box_index(row, col)][d] += 1\n board[row][col] = str(d)\n\n def remove_number(d, row, col):\n \"\"\"\n Remove a number that didn't lead to a solution\n \"\"\"\n rows[row][d] -= 1\n columns[col][d] -= 1\n boxes[box_index(row, col)][d] -= 1\n if rows[row][d] == 0:\n del rows[row][d]\n if columns[col][d] == 0:\n del columns[col][d]\n if boxes[box_index(row, col)][d] == 0:\n del boxes[box_index(row, col)][d]\n board[row][col] = \".\"\n\n def place_next_numbers(row, col):\n \"\"\"\n Call backtrack function in recursion to continue to place numbers\n till the moment we have a solution (reached the bottom right)\n \"\"\"\n if col == N - 1 and row == N - 1:\n sudoku_solved[0] = True\n else: # place number row by row\n if col == N - 1:\n backtrack(row + 1, 0)\n else:\n backtrack(row, col + 1)\n\n def backtrack(row=0, col=0):\n \"\"\"\n Backtracking\n \"\"\"\n if board[row][col] == \".\":\n for d in range(1, 10):\n if could_place(d, row, col):\n place_number(d, row, col)\n place_next_numbers(row, col)\n if sudoku_solved[0]:\n return\n remove_number(d, row, col)\n else:\n place_next_numbers(row, col)\n\n\n n = 3\n N = n * n\n box_index = lambda row, col: (row // n) * n + col // n\n\n rows = [defaultdict(int) for _ in range(N)]\n columns = [defaultdict(int) for _ in range(N)]\n boxes = [defaultdict(int) for _ in range(N)]\n for i in range(N):\n for j in range(N):\n if board[i][j] != \".\":\n d = int(board[i][j])\n place_number(d, i, j)\n\n sudoku_solved = [False]\n backtrack()","runtime":"129"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def could_place(d, row, col):\n return not (d in rows[row] or d in cols[col] or d in boxes[box_id(row, col)])\n def place_number(d, row, col):\n rows[row][d] += 1\n cols[col][d] += 1\n boxes[box_id(row, col)][d] += 1\n board[row][col] = str(d)\n def remove_number(d, row, col):\n del rows[row][d]\n del cols[col][d]\n del boxes[box_id(row, col)][d]\n board[row][col] = '.'\n def place_next(row, col):\n if row == N - 1 and col == N - 1:\n nonlocal solved\n solved = True\n else:\n if col == N - 1:\n backtrack(row + 1, 0)\n else:\n backtrack(row, col + 1)\n def backtrack(row, col):\n if board[row][col] == '.':\n for d in range(1, 10):\n if could_place(d, row, col):\n place_number(d, row, col)\n place_next(row, col)\n if not solved:\n remove_number(d, row, col)\n else:\n place_next(row, col)\n N = 9\n rows = [defaultdict(int) for i in range(N)]\n cols = [defaultdict(int) for i in range(N)]\n boxes = [defaultdict(int) for i in range(N)]\n box_id = lambda row, col: (row // 3) * 3 + col // 3\n for row in range(N):\n for col in range(N):\n if board[row][col] != '.':\n d = int(board[row][col])\n place_number(d, row, col)\n solved = False\n backtrack(0, 0)","runtime":"135"},{"code":"class N:\n def __init__(s):\n s.L = s.R = s.U = s.D = s.C = s\n \ndef S(g):\n N9, N81 = 9, 81\n H = N()\n C = [N() for _ in range(324)]\n for i in range(324):\n H.L.R = C[i]\n C[i].R = H\n C[i].L = H.L\n H.L = C[i]\n C[i].U = C[i].D = C[i]\n C[i].C = C[i]\n def ci(r, c, n):\n return [r * 9 + c, 81 + r * 9 + n, 162 + c * 9 + n, 243 + ((r // 3) * 3 + (c // 3)) * 9 + n]\n for r in range(9):\n for c in range(9):\n n = g[r][c]\n if n:\n n -= 1\n cols = ci(r, c, n)\n R = []\n for col in cols:\n node = N()\n node.C = C[col]\n node.U = C[col].U\n node.D = C[col]\n C[col].U.D = node\n C[col].U = node\n node.N = (r, c, n)\n R.append(node)\n for i in range(4):\n R[i].R = R[(i + 1) % 4]\n R[i].L = R[(i - 1) % 4]\n else:\n for n in range(9):\n cols = ci(r, c, n)\n R = []\n for col in cols:\n node = N()\n node.C = C[col]\n node.U = C[col].U\n node.D = C[col]\n C[col].U.D = node\n C[col].U = node\n node.N = (r, c, n)\n R.append(node)\n for i in range(4):\n R[i].R = R[(i + 1) % 4]\n R[i].L = R[(i - 1) % 4]\n R = []\n def Cc(c):\n c.R.L = c.L\n c.L.R = c.R\n for i in I(c.D, lambda x: x != c, lambda x: x.D):\n for j in I(i.R, lambda x: x != i, lambda x: x.R):\n j.D.U = j.U\n j.U.D = j.D\n def Uc(c):\n for i in I(c.U, lambda x: x != c, lambda x: x.U):\n for j in I(i.L, lambda x: x != i, lambda x: x.L):\n j.D.U = j\n j.U.D = j\n c.R.L = c\n c.L.R = c\n def I(s, c, m):\n x = s\n while c(x):\n yield x\n x = m(x)\n def Sx(k):\n if H.R == H:\n return True\n c = min(I(H.R, lambda x: x != H, lambda x: x.R), key=lambda c: sum(1 for _ in I(c.D, lambda x: x != c, lambda x: x.D)))\n Cc(c)\n for r in I(c.D, lambda x: x != c, lambda x: x.D):\n R.append(r)\n for j in I(r.R, lambda x: x != r, lambda x: x.R):\n Cc(j.C)\n if Sx(k + 1):\n return True\n for j in I(r.L, lambda x: x != r, lambda x: x.L):\n Uc(j.C)\n R.pop()\n Uc(c)\n return False\n Sx(0)\n for n in R:\n r, c, v = n.N\n g[r][c] = v + 1\n return g\n \nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n p = []\n for row in board:\n new_row = []\n for char in row:\n if char == \".\":\n new_row.append(0)\n else:\n new_row.append(int(char))\n p.append(new_row)\n \n s = S(p)\n for ri, row in enumerate(s):\n for ci, val in enumerate(row):\n board[ri][ci] = str(val)\n \n","runtime":"135"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def get_matrix_number(row, col):\n return 3 * (row // 3) + (col // 3)\n\n def can_place(row, col, num):\n return (num, row) not in rows_used and (num, col) not in cols_used and (num, get_matrix_number(row, col)) not in matrices_used\n\n def backtrack(row, col):\n if row == ROWS - 1 and col == COLS:\n return True\n\n if col == COLS:\n row += 1\n col = 0\n\n if board[row][col] != \".\":\n return backtrack(row, col + 1)\n\n for i in range(1, 10):\n num = str(i)\n if can_place(row, col, num):\n board[row][col] = num\n rows_used.add((num, row))\n cols_used.add((num, col))\n matrices_used.add((num, get_matrix_number(row, col)))\n\n if backtrack(row, col + 1):\n return True\n\n board[row][col] = \".\"\n rows_used.remove((num, row))\n cols_used.remove((num, col))\n matrices_used.remove((num, get_matrix_number(row, col)))\n\n return False\n\n\n # Sets of tuples, (number, row/col/matrix number)\n ROWS = len(board)\n COLS = len(board[0])\n rows_used = set()\n cols_used = set()\n matrices_used = set()\n\n for row in range(ROWS):\n for col in range(COLS):\n num = board[row][col]\n if num != \".\":\n rows_used.add((num, row))\n cols_used.add((num, col))\n matrices_used.add((num, get_matrix_number(row, col)))\n\n backtrack(0, 0)","runtime":"140"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n count = defaultdict(set)\n for i in range(9):\n for j in range(9):\n if board[i][j] != '.':\n count[(i, -1)].add(board[i][j])\n count[(-1, j)].add(board[i][j])\n count[i // 3 * 3 + j // 3].add(board[i][j])\n\n def backtrack(board, count, x):\n i, j = x // 9, x % 9\n if x >= 81:\n return True\n if board[i][j] == '.':\n for k in set(str(m) for m in range(1, 10)) - count[(i, -1)] - count[(-1, j)] - count[i // 3 * 3 + j // 3]:\n count[(i, -1)].add(k)\n count[(-1, j)].add(k)\n count[i // 3 * 3 + j // 3].add(k)\n board[i][j] = k\n if backtrack(board, count, x + 1):\n return True\n board[i][j] = '.'\n count[(i, -1)].remove(k)\n count[(-1, j)].remove(k)\n count[i // 3 * 3 + j // 3].remove(k)\n else:\n return backtrack(board, count, x + 1)\n\n backtrack(board, count, 0)\n","runtime":"140"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n rowSets = collections.defaultdict(set)\n colSets = collections.defaultdict(set)\n boxSets = collections.defaultdict(set)\n\n def populateSets():\n for r in range(9):\n for c in range(9):\n if board[r][c] != \".\":\n rowSets[r].add(board[r][c])\n colSets[c].add(board[r][c])\n boxSets[(r // 3, c // 3)].add(board[r][c])\n\n # def findEmptySpace():\n # for r in range(9):\n # for c in range(9):\n # if board[r][c] == \".\":\n # return (r, c)\n # return None\n\n def isValid(digit, r, c):\n return (\n digit not in rowSets[r] and\n digit not in colSets[c] and\n digit not in boxSets[(r // 3, c // 3)]\n )\n \n def solve(r, c):\n nonlocal solved\n\n if solved:\n return\n \n if r == 9:\n solved = True\n return\n\n nextR, nextC = r + ((c + 1) // 9), (c + 1) % 9\n\n if board[r][c] != \".\":\n solve(nextR, nextC)\n else:\n for digit in range(1, 10):\n if isValid(str(digit), r, c):\n\n rowSets[r].add(str(digit))\n colSets[c].add(str(digit))\n boxSets[(r // 3, c // 3)].add(str(digit))\n board[r][c] = str(digit)\n solve(nextR, nextC)\n\n if not solved:\n rowSets[r].remove(str(digit))\n colSets[c].remove(str(digit))\n boxSets[(r // 3, c // 3)].remove(str(digit))\n board[r][c] = \".\"\n \n solved = False\n populateSets()\n solve(0, 0)\n","runtime":"146"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def find_existing_numbers(x, y):\n seen_numbers = set()\n\n for i in range(9):\n if board[i][y] != '.':\n seen_numbers.add(board[i][y])\n \n for j in range(9):\n if board[x][j] != '.':\n seen_numbers.add(board[x][j])\n \n x = (x // 3) * 3\n y = (y // 3) * 3\n for i in range(0, 3):\n for j in range(0, 3):\n if board[x + i][y + j] != '.':\n seen_numbers.add(board[x + i][y + j])\n \n return seen_numbers\n\n def find_candidates(x, y):\n seen_numbers = find_existing_numbers(x, y)\n \n result = set()\n for num in range(1,10):\n if str(num) not in seen_numbers:\n result.add(str(num))\n \n return result\n \n def is_valid(x, y, num):\n seen_numbers = find_existing_numbers(x, y)\n\n return num not in seen_numbers\n \n def explore(x, y):\n print(x, y, board[x][y])\n # move on to next since the spot is already filled\n if board[x][y] != '.':\n if x == 8 and y == 8:\n return True\n \n if y < 8:\n return explore(x, y + 1)\n else:\n return explore(x + 1, 0)\n\n candidates = find_candidates(x, y)\n\n # spot is not filled but there are no possible candidates\n if len(candidates) == 0:\n return False\n\n # explore each candidate\n for candidate in candidates:\n \n # set the current candidate\n board[x][y] = candidate\n\n if x == 8 and y == 8:\n return True\n \n if y < 8:\n result = explore(x, y + 1)\n\n if result:\n return True\n else:\n result = explore(x + 1, 0)\n\n if result:\n return True\n \n board[x][y] = '.'\n \n return False\n \n explore(0, 0)","runtime":"146"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \n rows=[set() for _ in range(9)]\n cols=[set() for _ in range(9)]\n boxs=[set() for _ in range(9)]\n \n for i in range(9):\n for j in range(9):\n if board[i][j]!=\".\":\n num= board[i][j]\n rows[i].add(num)\n cols[j].add(num)\n boxs[(i//3)*3+(j//3)].add(num)\n\n def backtrack():\n for i in range(9):\n for j in range(9):\n if board[i][j] ==\".\":\n for num in \"123456789\":\n box_num= (i//3)*3 + (j//3)\n\n if num not in rows[i] and num not in cols[j] and num not in boxs[box_num]:\n board[i][j]= num\n rows[i].add(num)\n cols[j].add(num)\n boxs[box_num].add(num)\n\n if backtrack():\n return True\n board[i][j]= \".\"\n rows[i].remove(num)\n cols[j].remove(num)\n boxs[box_num].remove(num)\n\n return False\n return True \n \n\n backtrack()\n\n\n \n ","runtime":"151"},{"code":"class Solution:\n # The time complexity can be improved by using more space (dict and set) to save non-empty cells and put into 3 separate dict for its row/col/cube-box.\n def solveSudoku(self, board):\n \"\"\"\n :type board: List[List[str]]\n :rtype: void Do not return anything, modify board in-place instead.\n \"\"\"\n\n def could_place(d, row, col):\n \"\"\"\n Check if one could place a number `d` in (row, col) cell\n \"\"\"\n return not (\n d in rows[row]\n or d in columns[col]\n or d in cubes[cube_index(row, col)]\n )\n\n def place_number(d, row, col):\n \"\"\"\n Place a number `d` in (row, col) cell\n \"\"\"\n rows[row][d] += 1\n columns[col][d] += 1\n cubes[cube_index(row, col)][d] += 1\n board[row][col] = str(d)\n\n def remove_number(d, row, col):\n \"\"\"\n Remove a number that didn't lead to a solution\n \"\"\"\n rows[row][d] -= 1\n columns[col][d] -= 1\n cubes[cube_index(row, col)][d] -= 1\n if rows[row][d] == 0:\n del rows[row][d]\n if columns[col][d] == 0:\n del columns[col][d]\n if cubes[cube_index(row, col)][d] == 0:\n del cubes[cube_index(row, col)][d]\n board[row][col] = \".\"\n\n def place_next_numbers(row, col):\n \"\"\"\n Call backtrack function in recursion to continue to place numbers\n till the moment we have a solution (reached the bottom right)\n \"\"\"\n if col == N - 1 and row == N - 1:\n sudoku_solved[0] = True\n else: # place number row by row\n if col == N - 1:\n backtrack(row + 1, 0)\n else:\n backtrack(row, col + 1)\n\n def backtrack(row=0, col=0):\n \"\"\"\n Backtracking\n \"\"\"\n if board[row][col] == \".\":\n for d in range(1, 10):\n if could_place(d, row, col):\n place_number(d, row, col)\n place_next_numbers(row, col)\n if sudoku_solved[0]:\n return\n remove_number(d, row, col)\n else:\n place_next_numbers(row, col)\n\n\n n = 3\n N = n * n\n cube_index = lambda row, col: (row // n) * n + col // n\n\n rows = [defaultdict(int) for _ in range(N)]\n columns = [defaultdict(int) for _ in range(N)]\n cubes = [defaultdict(int) for _ in range(N)]\n for i in range(N):\n for j in range(N):\n if board[i][j] != \".\":\n d = int(board[i][j])\n place_number(d, i, j)\n\n sudoku_solved = [False]\n backtrack()","runtime":"151"},{"code":"from collections import defaultdict\nclass Solution:\n BOARD_SIZE = 9\n GRID_SIZE = 3\n DIGITS = set([str(num) for num in range(1, BOARD_SIZE + 1)])\n EMPTY_CELL = \".\"\n \n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n \n self.grids = defaultdict(list)\n for row in range(self.BOARD_SIZE):\n for col in range(self.BOARD_SIZE):\n self.grids[self.get_grid_index(row, col)].append((row, col))\n\n self.backtrack(board)\n \n \n def is_valid_state(self, board):\n # check rows\n for row in self.get_rows(board):\n if set(row) != self.DIGITS:\n return False\n \n # check columns\n for column in self.get_columns(board):\n if set(column) != self.DIGITS:\n return False\n \n # check sub-boxes\n for grid in self.get_grids(board):\n if set(grid) != self.DIGITS:\n return False\n \n return True\n \n def get_rows(self, board):\n for row in board:\n yield row\n \n def get_columns(self, board):\n for col in range(self.BOARD_SIZE):\n yield [ \n board[row][col]\n for row in range(self.BOARD_SIZE)\n ]\n \n def get_grids(self, board):\n for rows_and_cols in self.grids.values():\n yield [\n board[row][col] for (row, col) in rows_and_cols\n ]\n\n def get_kth_row(self, board, k):\n return board[k]\n \n def get_kth_col(self, board, k):\n return [\n board[row][k]\n for row in range(self.BOARD_SIZE)\n ]\n \n def get_grid_at(self, board, row, col):\n rows_and_cols = self.grids[self.get_grid_index(row, col)]\n return set([\n board[row][col] for (row, col) in rows_and_cols\n ])\n \n \n def get_grid_index(self, row, col):\n return row // self.GRID_SIZE * 3 + col // self.GRID_SIZE\n \n\n def get_candidates(self, board, row, col):\n used_digits = set()\n # remove used digits used by the same row\n used_digits.update(self.get_kth_row(board, row))\n \n # remove used digits from the same column\n used_digits.update(self.get_kth_col(board, col))\n \n # remove used digits from the same 3x3 sub-box\n used_digits.update(self.get_grid_at(board, row, col))\n \n used_digits.remove(self.EMPTY_CELL)\n \n return self.DIGITS - used_digits\n \n \n def backtrack(self, board):\n if self.is_valid_state(board):\n return True\n \n # find the next empty spot and take a guess\n for row in range(self.BOARD_SIZE):\n for col in range(self.BOARD_SIZE):\n if board[row][col] == self.EMPTY_CELL:\n for candidate in self.get_candidates(board, row, col):\n board[row][col] = candidate\n is_solved = self.backtrack(board)\n if is_solved:\n return True\n else:\n board[row][col] = self.EMPTY_CELL\n \n return False\n # no empty spot\n return True\n ","runtime":"162"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n if board[0][0] != \".\":\n has_next = _find_next(board, 0, 0)\n if has_next is not None:\n row_idx, col_idx = has_next\n else:\n row_idx, col_idx = 0, 0\n\n _solve(board, row_idx=row_idx, col_idx=col_idx)\n\nref_set = set(\"123456789\")\ndef _find_next(board, row_idx, col_idx):\n row = board[row_idx]\n for _col_idx in range(col_idx + 1, 9):\n if row[_col_idx] == \".\":\n return row_idx, _col_idx\n for _row_idx in range(row_idx + 1, 9):\n row = board[_row_idx]\n for _col_idx in range(9):\n if row[_col_idx] == \".\":\n return _row_idx, _col_idx\n return None\n\n\ndef _solve(board, row_idx=0, col_idx=0):\n # print(f\"Called, row = {row_idx}, col = {col_idx}\")\n # if board[row_idx][col_idx] != \".\":\n # has_next = _find_next(board, row_idx, col_idx)\n # if has_next is None:\n # return _check(board)\n # row_idx, col_idx = has_next\n # # print(f\"Updated, row = {row_idx}, col = {col_idx}\")\n\n choices = (\n ref_set\n - set(board[row_idx])\n - {board[_row_idx][col_idx] for _row_idx in range(9)}\n )\n block_row_idx = row_idx // 3\n block_col_idx = col_idx // 3\n choices = choices - {\n board[block_row_idx * 3 + _row_idx][block_col_idx * 3 + _col_idx]\n for _row_idx in range(3)\n for _col_idx in range(3)\n }\n if len(choices) == 0:\n return False\n\n has_next = _find_next(board, row_idx, col_idx)\n if has_next is None:\n # for choice in choices:\n if len(choices) == 1:\n board[row_idx][col_idx] = choices.pop()\n # if _check(board):\n return True\n return False\n nex_row_idx, next_col_idx = has_next\n for choice in choices:\n board[row_idx][col_idx] = choice\n if _solve(board, row_idx=nex_row_idx, col_idx=next_col_idx):\n return True\n board[row_idx][col_idx] = \".\"\n return False ","runtime":"162"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def place_number(d, row, col):\n rows[row][d] += 1\n columns[col][d] += 1\n boxes[box_index(row, col)][d] += 1\n board[row][col] = str(d)\n def could_place(d, row, col):\n return not (d in rows[row] or d in columns[col] or d in boxes[box_index(row, col)])\n def place_next_numbers(row, col):\n if col == N - 1 and row == N - 1:\n sudoku_solved[0] = True\n else:\n if col == N - 1:\n backtrack(row + 1, 0)\n else:\n backtrack(row, col + 1)\n def remove_number(d, row, col):\n rows[row][d] -= 1\n columns[col][d] -= 1\n boxes[box_index(row, col)][d] -= 1\n if rows[row][d] == 0:\n del rows[row][d]\n if columns[col][d] == 0:\n del columns[col][d]\n if boxes[box_index(row, col)][d] == 0:\n del boxes[box_index(row, col)][d]\n board[row][col] = \".\"\n def backtrack(row=0, col=0):\n if board[row][col] == \".\":\n for d in range(1, 10):\n if could_place(d, row, col):\n place_number(d, row, col)\n place_next_numbers(row, col)\n if sudoku_solved[0]:\n return\n remove_number(d, row, col)\n else:\n place_next_numbers(row, col)\n n = 3\n N = n * n\n box_index = lambda row, col: (row // n) * n + col // n\n rows = [defaultdict(int) for _ in range(N)]\n columns = [defaultdict(int) for _ in range(N)]\n boxes = [defaultdict(int) for _ in range(N)]\n for i in range(N):\n for j in range(N):\n if board[i][j] != \".\":\n d = int(board[i][j])\n place_number(d, i, j)\n sudoku_solved = [False]\n backtrack()","runtime":"168"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Modify board in-place to solve the Sudoku puzzle.\n \"\"\"\n # Initialize sets to track numbers in rows, columns, and sub-boxes\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [set() for _ in range(9)]\n \n # Fill the sets with existing numbers from the board\n for i in range(9):\n for j in range(9):\n num = board[i][j]\n if num != '.':\n box_index = (i // 3) * 3 + (j // 3)\n rows[i].add(num)\n cols[j].add(num)\n boxes[box_index].add(num)\n\n def is_valid(num, row, col):\n \"\"\"\n Check if placing 'num' in board[row][col] is valid.\n \"\"\"\n box_index = (row // 3) * 3 + (col // 3)\n if num in rows[row] or num in cols[col] or num in boxes[box_index]:\n return False\n return True\n \n def solve():\n \"\"\"\n Recursive backtracking function to solve the board.\n \"\"\"\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n for num in '123456789':\n if is_valid(num, i, j):\n # Place the number and update the sets\n board[i][j] = num\n rows[i].add(num)\n cols[j].add(num)\n boxes[(i // 3) * 3 + (j // 3)].add(num)\n \n # Recur to solve the rest of the board\n if solve():\n return True\n \n # Undo the move (backtrack)\n board[i][j] = '.'\n rows[i].remove(num)\n cols[j].remove(num)\n boxes[(i // 3) * 3 + (j // 3)].remove(num)\n return False\n return True\n \n solve()\n","runtime":"168"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Modify board in-place to solve the Sudoku puzzle.\n \"\"\"\n # Initialize sets to track numbers in rows, columns, and sub-boxes\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [set() for _ in range(9)]\n \n # Fill the sets with existing numbers from the board\n for i in range(9):\n for j in range(9):\n num = board[i][j]\n if num != '.':\n box_index = (i // 3) * 3 + (j // 3)\n rows[i].add(num)\n cols[j].add(num)\n boxes[box_index].add(num)\n\n def is_valid(num, row, col):\n \"\"\"\n Check if placing 'num' in board[row][col] is valid.\n \"\"\"\n box_index = (row // 3) * 3 + (col // 3)\n if num in rows[row] or num in cols[col] or num in boxes[box_index]:\n return False\n return True\n \n def solve():\n \"\"\"\n Recursive backtracking function to solve the board.\n \"\"\"\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n for num in '123456789':\n if is_valid(num, i, j):\n # Place the number and update the sets\n board[i][j] = num\n rows[i].add(num)\n cols[j].add(num)\n boxes[(i // 3) * 3 + (j // 3)].add(num)\n \n # Recur to solve the rest of the board\n if solve():\n return True\n \n # Undo the move (backtrack)\n board[i][j] = '.'\n rows[i].remove(num)\n cols[j].remove(num)\n boxes[(i // 3) * 3 + (j // 3)].remove(num)\n return False\n return True\n \n solve()\n","runtime":"174"},{"code":"class Solution:\n row_dict = {}\n col_dict = {}\n box_dict = {}\n goal_set = set([1, 2, 3, 4, 5, 6, 7, 8, 9])\n grid = []\n \n def fill_dict_with_null(self):\n for i in range(9):\n self.row_dict[i] = set()\n self.col_dict[i] = set()\n self.box_dict[i] = set()\n\n def fill_initial_values(self, board):\n for i in range(len(board)):\n for j in range(len(board[i])):\n if(board[i][j] != \".\"):\n self.row_dict[i].add(board[i][j])\n if(board[j][i] != \".\"):\n self.col_dict[i].add(board[j][i])\n self.box_traversal(board)\n\n def box_traversal(self, board):\n for i in range(3):\n for j in range(3):\n for x in range(3*i, 3*(i+1)):\n for y in range(3*j, 3*(j+1)):\n if(board[x][y] != 0):\n self.box_dict[3*i +j].add(board[x][y])\n\n def get_box_num(self, x, y):\n return (3*(x//3) + y//3)\n\n def get_next_empty_cell(self, board):\n for i in range(9):\n for j in range(9):\n if(board[i][j] == 0):\n return i,j\n return -1, -1\n\n def check_if_num_can_fit_in_cell(self, num, row, col):\n if num in self.row_dict[row]:\n return False\n elif num in self.col_dict[col]:\n return False\n elif num in self.box_dict[self.get_box_num(row, col)]:\n return False\n return True\n \n def assign_val_to_cell(self, val, row, col):\n self.row_dict[row].add(val)\n self.col_dict[col].add(val)\n self.box_dict[self.get_box_num(row, col)].add(val)\n\n def remove_val_from_cell(self, val, row, col):\n self.row_dict[row].remove(val)\n self.col_dict[col].remove(val)\n self.box_dict[self.get_box_num(row, col)].remove(val)\n\n def backtracker(self):\n x, y = self.get_next_empty_cell(self.grid)\n if(x == -1 and y == -1):\n return True\n for i in range(1,10):\n if (self.check_if_num_can_fit_in_cell(i, x, y)):\n self.assign_val_to_cell(i, x, y)\n self.grid[x][y] = i\n if(self.backtracker()):\n return True\n self.remove_val_from_cell(i, x, y)\n self.grid[x][y] = 0\n return False \n\n def convert_board_to_int(self, board):\n self.grid = board\n for row in range(len(self.grid)):\n for col in range(len(self.grid[row])):\n if self.grid[row][col] == '.':\n self.grid[row][col] = '0'\n self.grid[row][col] = int(self.grid[row][col])\n\n def format_output(self):\n for row in range(len(self.grid)):\n for col in range(len(self.grid[row])):\n self.grid[row][col] = str(self.grid[row][col])\n\n def solveSudoku(self, board):\n self.convert_board_to_int(board)\n self.fill_dict_with_null()\n self.fill_initial_values(self.grid)\n\n self.backtracker()\n self.format_output()\n board = self.grid","runtime":"174"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def check(i,j,num):\n if num in board[i]: \n return False\n for k in range(9):\n if board[k][j] == num:\n return False\n for l in range(i//3 * 3, i//3*3 + 3):\n for m in range(j//3 * 3, j//3*3 + 3):\n if board[l][m] == num:\n return False\n return True\n\n def backtrack(i,j):\n if j == 9:\n i,j = i+1,0\n if i == 9:\n return True\n if board[i][j] == '.':\n for cur in range(1,10):\n if check(i, j, str(cur)):\n board[i][j] = str(cur)\n if backtrack(i,j+1):\n return True\n board[i][j] = '.'\n return False\n else:\n return backtrack(i, j+1)\n backtrack(0,0)\n","runtime":"179"},{"code":"class Solution:\n def solveSudoku(self, board):\n def find_candidates(board, r, c):\n if board[r][c] != \".\":\n return set()\n candidates = set(\"123456789\")\n # 检查行\n for num in board[r]:\n candidates.discard(num)\n # 检查列\n for i in range(9):\n candidates.discard(board[i][c])\n # 检查3x3子格\n start_row, start_col = 3 * (r // 3), 3 * (c // 3)\n for i in range(start_row, start_row + 3):\n for j in range(start_col, start_col + 3):\n candidates.discard(board[i][j])\n return candidates\n\n def find_next_empty(board):\n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\":\n return r, c\n return None # 棋盘已满\n\n def solve():\n next_pos = find_next_empty(board)\n if next_pos is None:\n return True # 棋盘已填满，解完成\n\n r, c = next_pos\n candidates = find_candidates(board, r, c)\n for cand in candidates:\n board[r][c] = cand\n if solve():\n return True # 递归成功，返回\n board[r][c] = \".\" # 回溯：撤销选择\n\n return False # 触发回溯\n\n solve()\n","runtime":"179"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n n = len(board)\n block_index_change = {0: [0, 1, 2], 1:[-1, 0, 1], 2:[-2, -1, 0]}\n \n def violate_numbers(row, col):\n rows_digit = [x for x in board[row] if x.isdigit()]\n cols_ditit = [x[col] for x in board if x[col].isdigit()]\n \n row_rank = row%3\n col_rank = col%3\n \n cube_digit = []\n rows_change = block_index_change[row_rank]\n cols_change = block_index_change[col_rank]\n for r in rows_change:\n for c in cols_change:\n if board[row+r][col+c].isdigit() and not (r==0 and c==0):\n cube_digit.append(board[row+r][col+c])\n cur_digit = set(cube_digit + cols_ditit + rows_digit)\n \n return cur_digit\n \n \n empty_list = []\n for i in range(n):\n for j in range(n):\n if board[i][j] == '.':\n empty_list.append([i,j])\n \n def dfs(idx):\n if idx == len(empty_list):\n return True\n \n e = empty_list[idx]\n\n vn = violate_numbers(e[0], e[1])\n valid_number = [x for x in range(1,10) if str(x) not in vn]\n # print(valid_number)\n for v in valid_number:\n board[e[0]][e[1]] = str(v)\n if dfs(idx+1):\n return True\n board[e[0]][e[1]] = '.'\n \n return False\n \n dfs(0)\n\n\n \n \n \n \n\n \n \n \n \n \n \n ","runtime":"185"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n rowHash = {}\n colHash = {}\n groupHash = {}\n cellGroupXref = {}\n\n group = 0\n prevGroup = 0\n for row in range(len(board)):\n if row % 3 == 0:\n prevGroup = group\n else:\n group = prevGroup\n if row not in rowHash:\n rowHash[row] = set()\n for col in range(len(board[0])):\n cellGroupXref[(row, col)] = group\n if group not in groupHash:\n groupHash[group] = set()\n if col not in colHash:\n colHash[col] = set()\n if board[row][col] != \".\":\n groupHash[group].add(board[row][col])\n rowHash[row].add(board[row][col])\n colHash[col].add(board[row][col])\n if (col + 1) % 3 == 0:\n group += 1\n\n def helperDfs():\n for row in range(len(board)):\n for col in range(len(board[0])):\n if board[row][col] == \".\":\n for cand in range (1, 10):\n cand = str(cand)\n if cand in rowHash[row] or cand in colHash[col] or cand in groupHash[cellGroupXref[(row, col)]]:\n continue\n board[row][col] = cand\n rowHash[row].add(cand)\n colHash[col].add(cand)\n groupHash[cellGroupXref[(row, col)]].add(cand)\n if helperDfs():\n return True\n board[row][col] = \".\"\n rowHash[row].remove(cand)\n colHash[col].remove(cand)\n groupHash[cellGroupXref[(row, col)]].remove(cand)\n return False\n return True\n\n helperDfs()\n \n \n\n","runtime":"185"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n squares_pos = [[[] for _ in range(3)] for _ in range(3)]\n for row in range(9):\n for col in range(9):\n squares_pos[row // 3][col // 3].append((row, col))\n\n def is_valid(row, col, num):\n for i in range(9):\n if board[row][i] == num:\n return False\n if board[i][col] == num:\n return False\n for i, j in squares_pos[row // 3][col // 3]:\n if board[i][j] == num:\n return False\n return True\n \n def dfs(row, col):\n if row == 9:\n return True\n if col == 9:\n return dfs(row+1, 0)\n\n if board[row][col] != '.':\n return dfs(row, col+1)\n \n for num in range(1, 10):\n if is_valid(row, col, str(num)):\n board[row][col] = str(num)\n if dfs(row, col+1):\n return True\n else:\n board[row][col] = '.'\n return False\n \n dfs(0, 0)","runtime":"190"},{"code":"class Solution:\n def solver(self, index, board, data):\n if index >= len(board) * len(board[0]):\n return True\n \n row = index // len(board[0])\n col = index - row * len(board[0])\n \n if board[row][col] == \".\":\n for digit in range(1, 10):\n if (\n f\"row_{row}_{digit}\" not in data and\n f\"col_{col}_{digit}\" not in data and\n f\"quad_{row // 3}_{col // 3}_{digit}\" not in data\n ):\n board[row][col] = str(digit)\n data.add(f\"row_{row}_{digit}\")\n data.add(f\"col_{col}_{digit}\")\n data.add(f\"quad_{row // 3}_{col // 3}_{digit}\")\n \n res = self.solver(index + 1, board, data)\n if res:\n return True\n \n board[row][col] = \".\"\n data.remove(f\"row_{row}_{digit}\")\n data.remove(f\"col_{col}_{digit}\")\n data.remove(f\"quad_{row // 3}_{col // 3}_{digit}\")\n \n return False\n else:\n return self.solver(index + 1, board, data)\n \n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n The time complexity should be 9 ^ m (m represents the number of blanks to be filled in), since each blank can have 9 choices.\n \"\"\"\n data = set()\n for i in range(len(board)):\n for j in range(len(board[0])):\n if board[i][j] != \".\":\n data.add(f\"row_{i}_{board[i][j]}\")\n data.add(f\"col_{j}_{board[i][j]}\")\n data.add(f\"quad_{i // 3}_{j // 3}_{board[i][j]}\")\n \n self.solver(0, board, data)","runtime":"190"},{"code":"class Solution:\n def find_possible_digits(self, board, row, col):\n possible_digits = {\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"}\n for i in range(9):\n for j in range(9):\n if i == row or j == col:\n if board[i][j] != \".\":\n possible_digits.discard(board[i][j])\n area_row = int(row / 3) * 3\n area_col = int(col / 3) * 3\n for i in range(area_row, area_row + 3):\n for j in range(area_col, area_col + 3):\n if board[i][j] != \".\":\n possible_digits.discard(board[i][j])\n return possible_digits\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def rec(b):\n row, col = -1, -1\n for i in range(9):\n break_flag = False\n for j in range(9):\n if b[i][j] == \".\":\n row = i\n col = j\n break_flag = True\n break\n if break_flag:\n break\n\n if row == -1:\n return b\n\n digits = self.find_possible_digits(b, row, col)\n\n for digit in digits:\n b[row][col] = digit\n ret = rec(b)\n if ret:\n return b\n b[row][col] = \".\"\n return None\n\n rec(board)\n","runtime":"196"},{"code":"class Solution:\n def canPlace(self, row, col, board, digit):\n for idx in range(9):\n if board[row][idx] == digit or board[idx][col] == digit:\n return False\n rstr = 3 * (row // 3)\n cstr = 3 * (col // 3)\n for r in range(rstr, rstr + 3):\n for c in range(cstr, cstr + 3):\n if board[r][c] == digit:\n return False\n return True\n\n def traverse(self, row, col, board):\n if row == 9:\n return True\n if col == 9:\n return self.traverse(row + 1, 0, board)\n if board[row][col] != \".\":\n return self.traverse(row, col + 1, board)\n for digit in \"123456789\":\n if self.canPlace(row, col, board, digit):\n board[row][col] = digit\n possible = self.traverse(row, col + 1, board)\n if possible:\n return True\n board[row][col] = \".\"\n return False\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.traverse(0, 0, board)\n return board\n ","runtime":"196"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n def isValid(i, j, num):\n # check row, col\n for x in range(9):\n if self.board[i][x] == num or self.board[x][j] == num:\n return False\n # check sub-box\n rstart, cstart = i//3*3, j//3*3\n for x in range(rstart, rstart+3):\n for y in range(cstart, cstart+3):\n if x == i or y == j:\n continue\n if self.board[x][y] == num:\n return False\n return True\n\n def backtracking(i, j):\n if i == 9:\n return True\n if j == 9:\n return backtracking(i + 1, 0)\n if self.board[i][j] != '.':\n return backtracking(i, j + 1)\n for n in \"123456789\":\n if not isValid(i, j, n):\n continue\n self.board[i][j] = n\n if backtracking(i, j + 1):\n return True\n self.board[i][j] = '.'\n return False\n\n self.board = board\n backtracking(0, 0)\n return board","runtime":"201"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n ROW_STATES = \"rowStates\"\n COL_STATES = \"colStates\"\n BOX_STATES = \"boxStates\"\n\n # Will contain state as set of values for each row, col, box\n states = {ROW_STATES: {}, COL_STATES: {}, BOX_STATES: {}}\n\n for i in range(9):\n states[ROW_STATES][i] = set()\n states[COL_STATES][i] = set()\n states[BOX_STATES][i] = set()\n\n def getBoxNumber(i: int, j: int) -> int:\n \"\"\"\n This function returns the box number for the given cell\n \"\"\"\n\n return int(i / 3) * 3 + int(j / 3)\n\n # Iterate through the cells in the sudoku board and update states\n for i in range(9):\n for j in range(9):\n\n if board[i][j] != \".\":\n\n numStr = board[i][j]\n # add to relevant board state\n states[ROW_STATES][i].add(numStr)\n states[COL_STATES][j].add(numStr)\n\n boxNum = getBoxNumber(i, j)\n states[BOX_STATES][boxNum].add(numStr)\n\n # for box in states[BOX_STATES]:\n # print(f\"Box {box} : {states[BOX_STATES][box]}\")\n\n def updateBoard(num_str: str, i: int, j: int):\n\n # update the board as well\n board[i][j] = num_str\n\n states[ROW_STATES][i].add(num_str)\n states[COL_STATES][j].add(num_str)\n\n boxNum = getBoxNumber(i, j)\n states[BOX_STATES][boxNum].add(num_str)\n\n def resetBoard(num_str: str, i, j):\n\n # remove from board\n board[i][j] = \".\"\n\n states[ROW_STATES][i].remove(num_str)\n states[COL_STATES][j].remove(num_str)\n\n boxNum = getBoxNumber(i, j)\n states[BOX_STATES][boxNum].remove(num_str)\n\n def findNextCell(i, j):\n if i == 8 and j == 8:\n solved[0] = True\n return\n\n if j == 8:\n fill(i + 1, 0)\n else:\n fill(i, j + 1)\n\n def canFillIn(numStr: str, i: int, j: int):\n boxNum = getBoxNumber(i, j)\n\n return (\n numStr not in states[ROW_STATES][i]\n and numStr not in states[COL_STATES][j]\n and numStr not in states[BOX_STATES][boxNum]\n )\n\n def fill(i, j):\n if board[i][j] != \".\":\n findNextCell(i, j)\n else:\n for num in range(1, 10):\n numStr = str(num)\n if canFillIn(numStr, i, j):\n updateBoard(numStr, i, j)\n findNextCell(i, j)\n if solved[0]:\n return\n resetBoard(numStr, i, j)\n\n solved = [False]\n fill(0, 0)\n","runtime":"201"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isValid(board, row, col, num):\n if num in board[row]:\n return False\n\n for r in range(9):\n if board[r][col] == num:\n return False\n\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\n for r in range(start_row, start_row + 3):\n for c in range(start_col, start_col + 3):\n if board[r][c] == num:\n return False\n return True\n \n\n def backtrack(board):\n for r in range(9):\n for c in range(9):\n if board[r][c] == '.':\n for num in '123456789':\n if isValid(board, r, c, num):\n board[r][c] = num\n if backtrack(board):\n return True\n board[r][c] = '.'\n return False\n return True \n\n backtrack(board)\n return board","runtime":"207"},{"code":"import copy\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n results = []\n\n traverse(board, 0, 0, results)\n print(\"results\",results)\n if len(results) > 0:\n for row in range(len(board)):\n for col in range(len(board[0])):\n board[row][col] = results[0][row][col]\n\ndef traverse(board, row, col, results):\n # print(\"row,col,board\",row,col,board)\n if row > 8 :\n if board[8][8] != '.':\n print(\"board\", board)\n newBoard = copy.deepcopy(board)\n results.append(newBoard)\n return\n \n nextRow = row\n nextCol = col + 1\n\n if nextCol == 9:\n nextRow += 1\n nextCol = 0\n # print(\"row, col\", row, col)\n\n if board[row][col] != '.': \n traverse(board, nextRow, nextCol, results)\n return\n \n units = findAvailableUnits(board, row, col)\n # print(\"row, col, units\",row, col, units)\n for unit in units:\n board[row][col] = unit\n traverse(board, nextRow, nextCol, results)\n board[row][col] = '.'\n\ndef findAvailableUnits(board, row, col):\n units = set(['1','2','3','4','5','6','7','8','9'])\n for iterCol in range(len(board[0])):\n if board[row][iterCol] != '.':\n units.discard(board[row][iterCol])\n\n for iterRow in range(len(board)):\n if board[iterRow][col] != '.':\n units.discard(board[iterRow][col])\n\n squareInitRow = row // 3 * 3\n squareInitCol= col // 3 * 3\n\n for i in range(3):\n for j in range(3):\n if board[squareInitRow + i][squareInitCol + j] != '.':\n units.discard(board[squareInitRow + i][squareInitCol + j])\n\n return units","runtime":"207"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n header_dict = dict()\n h = ColumnNode()\n size = len(board)\n solution = []\n\n def rowRange(cIndex):\n rows = [0] * size\n res = int(cIndex / size ** 2)\n if res == 0:\n column = cIndex % size\n row = int(cIndex / size)\n for i in range(0, size):\n rows[i] = row * size ** 2 + column * size + i\n elif res == 1:\n cIndex -= size ** 2\n row = int(cIndex / size)\n valueIndex = cIndex % size\n for c in range(0, size):\n rows[c] = row * size ** 2 + c * size + valueIndex\n elif res == 2:\n cIndex = cIndex - size ** 2 * 2\n column = int(cIndex / size)\n valueIndex = cIndex % size\n for r in range(0, size):\n rows[r] = r * size ** 2 + column * size + valueIndex\n else:\n cIndex = cIndex - size ** 2 * 3\n valueIndex = cIndex % size\n box = int(cIndex / size)\n boxsize = int(size ** 0.5)\n for r in range(int(box / boxsize) * boxsize, (int(box / boxsize) + 1) * boxsize):\n for c in range(box % boxsize * boxsize, (box % boxsize + 1) * boxsize):\n rows[(r - int(box / boxsize) * boxsize) * boxsize + (\n c - box % boxsize * boxsize)] = r * size ** 2 + c * size + valueIndex\n return rows\n\n def columnRange(rIndex):\n columns = [0] * 4\n row = int(rIndex / size ** 2)\n column = int(rIndex % (size ** 2) / len(board))\n valueIndex = int((rIndex % size ** 2) % len(board))\n columns[0] = row * size + column\n columns[1] = size ** 2 + row * size + valueIndex\n columns[2] = size ** 2 * 2 + column * size + valueIndex\n columns[3] = size ** 2 * 3 + (int(int(row / size ** 0.5) * size ** 0.5) + int(column / size ** 0.5)) * size + valueIndex\n return columns\n\n def findMinColumn():\n t = h.R\n min = h\n m = size + 1\n while t != h:\n if t.S == 0:\n min = h\n break\n if t.S < m:\n m = t.S\n min = t\n t = t.R\n return min\n\n def findNode(c, rIndex, cIndex):\n node = c.D\n for i in range(0, size):\n if (rowRange(cIndex)[i] == rIndex):\n break\n node = node.D\n return node\n\n def cover(c):\n c.removeH()\n i = c.D\n while i != c:\n j = i.R\n while j != i:\n j.removeV()\n j = j.R\n i = i.D\n\n def uncover(c):\n i = c.U\n while i != c:\n j = i.L\n while j != i:\n j.addV()\n j = j.L\n i = i.U\n c.addH()\n\n def solving():\n if h.R == h:\n for i in solution:\n while i.c.N >= size ** 2:\n i = i.L\n row = int(i.c.N / size)\n column = i.c.N % size\n valueIndex = i.R.c.N - size ** 2 - row * size\n board[row][column] = str(valueIndex + 1)\n return True\n c = findMinColumn()\n if c == h: return False\n r = c.D\n cover(c)\n while r != c:\n solution.append(r)\n j = r.R\n while j != r:\n cover(j.c)\n j = j.R\n\n if solving(): return True\n solution.remove(r)\n j = r.L\n while j != r:\n uncover(j.c)\n j = j.L\n r = r.D\n uncover(c)\n return False\n\n for i in range(0, len(board) ** 2 * 4):\n c = ColumnNode(i)\n header_dict[i] = c\n for j in range(0, len(board)):\n node = DancingNode(c)\n c.linkDown(node)\n if j == 0:\n node.D = c\n c.U = node\n if i == 0:\n h.linkRight(c)\n else:\n header_dict[i - 1].linkRight(c)\n if i == len(board) ** 2 * 4 - 1:\n c.R = h\n h.L = c\n\n for i in range(0, size ** 2):\n for j in range(0, size):\n rIndex = rowRange(i)[j]\n\n r = findNode(header_dict.get(columnRange(rIndex)[0]), rIndex, columnRange(rIndex)[0])\n for k in range(3, 0, -1):\n c = findNode(header_dict.get(columnRange(rIndex)[k]), rIndex, columnRange(rIndex)[k])\n r.linkRight(c)\n if k == 3:\n r.L = c\n c.R = r\n\n for r in range(0, size):\n for c in range(0, size):\n if board[r][c] != \".\":\n val = int(board[r][c])\n val -= 1\n rIndex = r * size ** 2 + c * size + val\n for k in range(0, 4):\n cover(header_dict[columnRange(rIndex)[k]])\n\n solving()\n return board\n\nclass DancingNode:\n def __init__(self, c=None):\n self.U = self.D = self.L = self.R = self\n self.c = c\n\n def linkRight(self, node):\n node.L = self\n node.R = self.R\n self.R.L = node\n self.R = node\n\n def linkDown(self, node):\n node.U = self\n self.D.U = node\n node.D = self.D\n self.D = node\n self.c.S += 1\n\n def removeH(self):\n self.L.R = self.R\n self.R.L = self.L\n\n def removeV(self):\n self.U.D = self.D\n self.D.U = self.U\n self.c.S -= 1\n\n def addH(self):\n self.L.R = self\n self.R.L = self\n\n def addV(self):\n self.U.D = self\n self.D.U = self\n self.c.S += 1\n\n\nclass ColumnNode(DancingNode):\n def __init__(self, N=None):\n super().__init__(self)\n # size\n self.S = 0\n # name\n self.N = N\n","runtime":"212"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # backtracking + pruning\n\n def possible_numbers(i,j,board):\n possibles = set([str(x) for x in range(1, 10)])\n \n # rows\n for x in board[i]:\n if x in possibles:\n possibles.remove(x)\n \n # cols\n for row in board:\n if row[j] in possibles:\n possibles.remove(row[j])\n \n # 3x3 square\n square_x = j//3\n square_y = i//3\n for y in range(square_x*3, square_x*3+3):\n for x in range(square_y*3, square_y*3+3):\n if board[x][y] in possibles:\n possibles.remove(board[x][y])\n \n return list(possibles)\n\n empties = []\n\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n empties.append((i,j))\n \n\n res = []\n # parameters: idx for empties, tuple of board\n def backtrack(idx, t_board):\n if idx == len(empties):\n for i in range(9):\n temp = []\n for j in range(9):\n temp.append(t_board[i][j])\n res.append(temp)\n return\n \n x, y = empties[idx][0], empties[idx][1]\n possibles = possible_numbers(x, y, t_board)\n \n if len(possibles) == 0:\n return\n \n for num in possibles:\n t_board[x][y] = num\n backtrack(idx+1, t_board)\n t_board[x][y] = \".\"\n \n backtrack(0, board)\n \n for i in range(9):\n for j in range(9):\n board[i][j] = res[i][j]\n \n\n\n \n \n\n ","runtime":"212"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n \n # for each cell, find the row, col, and 3x3's occurences of 1-9\n # find all possible cell vals\n # continue from each\n # \n\n def solve(i,j,num):\n # need to check also for square\n for k in range(9):\n if board[i][k]==num or board[k][j]==num:\n return False\n rs = (i//3)*3\n cs = (j//3)*3\n for k in range(rs,rs+3):\n for l in range(cs,cs+3):\n if board[k][l]==num:\n return False\n return True\n\n def backtrack(i,j):\n if i>8:\n return True\n if j>8:\n return backtrack(i+1,0)\n if board[i][j]==\".\":\n for num in range(1,10):\n if solve(i,j,str(num)):\n board[i][j]=str(num)\n if backtrack(i,j+1):\n return True\n board[i][j]=\".\"\n return False\n else:\n return backtrack(i,j+1)\n backtrack(0,0)","runtime":"218"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isValid(r, c, k):\n for i in range(9):\n if board[i][c] == k or board[r][i] == k:\n return False\n startRow = r - r % 3\n startCol = c - c % 3\n for i in range(3):\n for j in range(3):\n if board[i + startRow][j + startCol] == k:\n return False\n return True \n def backtrack(r, c):\n if r == 9:\n return True\n if c == 9:\n return backtrack(r + 1, 0)\n if board[r][c] == '.':\n for k in range(1, 10):\n if isValid(r, c, str(k)):\n board[r][c] = str(k)\n if backtrack(r, c + 1):\n return True\n board[r][c] = '.'\n return False\n return backtrack(r, c + 1)\n backtrack(0, 0)","runtime":"218"},{"code":"def fixedlocation(sud) -> list:\n fixed = []\n for row in range(len(sud)):\n for col in range(len(sud[row])):\n if sud[row][col] != \".\":\n fixed.append(str(row) + str(col))\n return fixed\n\ndef transpose(sud) -> list:\n transpose_sud = []\n for row in range(len(sud)):\n coln = []\n for col in range(len(sud[row])):\n coln.append(sud[col][row]) \n transpose_sud.append(coln)\n\n return transpose_sud\n\ndef blockerize(sud) -> list:\n blockerize_sud = []\n for row in range(len(sud)):\n block = []\n for col in range(len(sud[row])):\n block.append(sud[(row // 3)*3 + col // 3][col % 3 + (row % 3) * 3]) \n blockerize_sud.append(block) \n \n return blockerize_sud\n \nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n row, col = 0, 0\n beginning_coor = \"99\"\n fixed_sud = set(fixedlocation(board))\n row_backtrack, col_backtrack = False, False\n blockerize_sud = blockerize(board) \n transpose_sud = transpose(board)\n while -1 < row and row < 9:\n if row_backtrack and col == -1:\n col = 8\n else:\n col = 0\n\n while -1 < col and col < 9:\n if (str(row) + str(col)) in fixed_sud:\n if col_backtrack:\n col -=1\n if col < 0:\n row_backtrack = True\n continue\n else:\n col +=1\n continue\n sud_row = set(board[row])\n sud_col = set(transpose_sud[col])\n sud_block = set(blockerize_sud[(row // 3)*3 + col // 3])\n union = sud_row | sud_col | sud_block\n temp = board[row][col]\n start = 0 if board[row][col] == '.' else board[row][col]\n for i in range(int(start) + 1, 10):\n if str(i) not in union:\n if beginning_coor == \"99\":\n beginning_coor = str(col) + str(row)\n board[row][col] = str(i)\n col_backtrack = False\n row_backtrack = False\n break\n if board[row][col] == temp: #fail to find any number, start backtracking\n if board[row][col] != \".\":\n board[row][col] = \".\"\n col_backtrack = True\n\n transpose_sud[col][row] = board[row][col]\n blockerize_sud[(row // 3)*3 + col // 3][col % 3 + (row % 3) * 3] = board[row][col]\n\n if col_backtrack:\n col -=1\n if col < 0:\n row_backtrack = True\n else:\n col +=1\n \n if row_backtrack:\n row -=1\n else:\n row +=1\n ","runtime":"224"},{"code":"class Solution:\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n def isSafe(row, col, num):\n for i in range(9):\n if board[row][i] == num:\n return False\n if board[i][col] == num:\n return False\n startRow = row - row % 3\n startCol = col - col % 3\n for i in range(3):\n for j in range(3):\n if board[i + startRow][j+startCol] == num:\n return False\n return True\n \n def validSol(row, col):\n if row == 8 and col > 8:\n return True\n if col > 8:\n row += 1\n col = 0\n \n if board[row][col] != \".\":\n return validSol(row, col+1)\n \n for i in range(1,10):\n if isSafe(row, col, str(i)):\n board[row][col] = str(i)\n if validSol(row, col + 1):\n return True\n board[row][col] = \".\"\n \n return False\n \n validSol(0,0)","runtime":"224"},{"code":"def fixedlocation(sud) -> list:\n fixed = []\n for row in range(len(sud)):\n for col in range(len(sud[row])):\n if sud[row][col] != \".\":\n fixed.append(str(row) + str(col))\n return fixed\n\ndef transpose(sud) -> list:\n transpose_sud = []\n for row in range(len(sud)):\n coln = []\n for col in range(len(sud[row])):\n coln.append(sud[col][row]) \n transpose_sud.append(coln)\n\n return transpose_sud\n\ndef blockerize(sud) -> list:\n blockerize_sud = []\n for row in range(len(sud)):\n block = []\n for col in range(len(sud[row])):\n block.append(sud[(row // 3)*3 + col // 3][col % 3 + (row % 3) * 3]) \n blockerize_sud.append(block) \n \n return blockerize_sud\n \nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n row, col = 0, 0\n beginning_coor = \"99\"\n fixed_sud = set(fixedlocation(board))\n row_backtrack, col_backtrack = False, False\n blockerize_sud = blockerize(board) \n transpose_sud = transpose(board)\n while -1 < row and row < 9:\n if row_backtrack and col == -1:\n col = 8\n else:\n col = 0\n\n while -1 < col and col < 9:\n if (str(row) + str(col)) in fixed_sud:\n if col_backtrack:\n col -=1\n if col < 0:\n row_backtrack = True\n continue\n else:\n col +=1\n continue\n sud_row = set(board[row])\n sud_col = set(transpose_sud[col])\n sud_block = set(blockerize_sud[(row // 3)*3 + col // 3])\n union = sud_row | sud_col | sud_block\n temp = board[row][col]\n start = 0 if board[row][col] == '.' else board[row][col]\n for i in range(int(start) + 1, 10):\n if str(i) not in union:\n if beginning_coor == \"99\":\n beginning_coor = str(col) + str(row)\n board[row][col] = str(i)\n col_backtrack = False\n row_backtrack = False\n break\n if board[row][col] == temp: #fail to find any number, start backtracking\n if board[row][col] != \".\":\n board[row][col] = \".\"\n col_backtrack = True\n\n transpose_sud[col][row] = board[row][col]\n blockerize_sud[(row // 3)*3 + col // 3][col % 3 + (row % 3) * 3] = board[row][col]\n\n if col_backtrack:\n col -=1\n if col < 0:\n row_backtrack = True\n else:\n col +=1\n \n if row_backtrack:\n row -=1\n else:\n row +=1\n ","runtime":"229"},{"code":"from collections import defaultdict\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n n = len(board)\n rows = defaultdict(set)\n cols = defaultdict(set)\n squares = defaultdict(set)\n\n # add given numbers in original board\n for i in range(n):\n for j in range(n):\n if board[i][j] != '.':\n rows[i].add(board[i][j])\n cols[j].add(board[i][j])\n squares[(i//3,j//3)].add(board[i][j]) \n \n def valid():\n return (\n len(rows) == 9 and len(cols) == 9 and len(squares) == 9\n and all([True if len(rows[r]) == 9 else False for r in rows])\n and all([True if len(cols[c]) == 9 else False for c in cols])\n and all([True if len(squares[s]) == 9 else False for s in squares])\n )\n\n def solve(board, row, col):\n if valid():\n return True\n\n for i in range(n):\n for j in range(n):\n if board[i][j] == '.':\n for k in range(1, 10):\n k = str(k)\n if k not in rows[i] and k not in cols[j] and k not in squares[(i//3,j//3)]:\n # change\n rows[i].add(k)\n cols[j].add(k)\n squares[(i//3,j//3)].add(k)\n board[i][j] = str(k)\n\n # recurse\n if solve(board, i, j):\n return True\n\n # backtrack\n board[i][j] = '.'\n rows[i].remove(k)\n cols[j].remove(k)\n squares[(i//3,j//3)].remove(k)\n\n # no k exists that solves the board based on previous k's chosen\n return False\n\n return False\n\n solve(board, 0, 0)","runtime":"229"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n emptySpots = []\n for row in range(9):\n for col in range(9):\n if board[row][col] == \".\":\n emptySpots.append([row, col])\n\n def canInsert(row: int, col: int, num: str):\n # check 3 things to make sure it's ok to add current num\n # the row\n for _col in range(9):\n if board[row][_col] == num:\n return False\n\n # the column\n for _row in range(9):\n if board[_row][col] == num:\n return False\n\n # the 3 * 3 sub board\n subBoardStartRow = (row // 3) * 3\n subBoardStartCol = (col // 3) * 3\n\n for _row in range(subBoardStartRow, subBoardStartRow + 3):\n for _col in range(subBoardStartCol, subBoardStartCol + 3):\n if board[_row][_col] == num:\n return False\n\n return True\n\n def solve(currIdx: int = 0) -> None:\n # all empty spots are filled with a valid number\n if currIdx == len(emptySpots):\n return True\n\n row, col = emptySpots[currIdx]\n for candidateNum in range(1, 10):\n if canInsert(row, col, str(candidateNum)):\n board[row][col] = str(candidateNum)\n\n # try current number\n if solve(currIdx + 1):\n return True\n\n # revert change and try out another number\n board[row][col] = \".\"\n\n return False\n\n solve()\n","runtime":"235"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n n = 9\n def solve(board):\n for i in range(n):\n for j in range(n):\n if board[i][j]==\".\":\n pos = set(map(str,range(1,10)))\n for k in range(n):\n if board[i][k].isdigit():\n pos.discard(board[i][k])\n if board[k][j].isdigit():\n pos.discard(board[k][j])\n for p,q in filter(\n lambda x:3*(i//3)+j//3==3*(x[0]//3)+x[1]//3,\n ((x,y) for x in range(9) for y in range(9))):\n if board[p][q].isdigit():\n pos.discard(board[p][q])\n if not pos: return False\n for k in pos:\n board[i][j] = k\n if solve(board):\n return True\n else:\n board[i][j] = \".\"\n return False\n return True\n solve(board)\n \n ","runtime":"235"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n ROWS, COLS = len(board), len(board[0])\n\n def find_empty():\n for r in range(ROWS):\n for c in range(COLS):\n if board[r][c] == '.':\n return (r, c)\n \n return None\n\n\n colset, rowset, gridset = collections.defaultdict(set), collections.defaultdict(set), collections.defaultdict(set)\n\n def is_valid(r, c, val):\n # val = board[r][c]\n\n if val in colset[c] or val in rowset[r] or val in gridset[(r // 3, c // 3)]:\n return False\n print('colset', colset[c], 'rowset', rowset[r], 'gridset', gridset[(r // 3, c // 3)])\n return True\n \n def add_cell(r, c):\n val = board[r][c]\n\n colset[c].add(val)\n rowset[r].add(val)\n gridset[(r // 3, c // 3)].add(val)\n \n def remove_cell(r, c):\n val = board[r][c]\n\n colset[c].remove(val)\n rowset[r].remove(val)\n gridset[(r // 3, c // 3)].remove(val)\n\n\n def solve(r, c):\n if r == 9:\n return True\n if c == 9:\n return solve(r + 1, 0)\n \n if board[r][c] == '.':\n for i in range(1, 10):\n if is_valid(r, c, str(i)):\n board[r][c] = str(i)\n\n add_cell(r, c)\n\n if solve(r, c + 1):\n return True\n\n remove_cell(r, c) \n board[r][c] = '.'\n\n return False\n \n return solve(r, c + 1)\n\n # prepopulate sets\n for r in range(ROWS):\n for c in range(COLS):\n if board[r][c] != '.':\n add_cell(r, c)\n\n solve(0, 0)","runtime":"240"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n arr = []\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n arr.append([i,j])\n \n def safe(i,j,num):\n for x in range(9):\n if board[i][x] == num:\n return False\n for y in range(9):\n if board[y][j] == num:\n return False\n for x in range(3):\n for y in range(3):\n r = 3*(i//3) + x\n c = 3*(j//3) + y\n if board[r][c] == num:\n return False\n return True\n\n def solve(index):\n if index == len(arr):\n return True\n row, col = arr[index]\n for num in '123456789':\n if safe(row, col, num):\n board[row][col] = num\n if solve(index+1):\n return True\n board[row][col] = '.'\n return False\n solve(0)\n\n\n\n\n\n\n ","runtime":"240"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def find_existing_numbers(x, y):\n seen_numbers = set()\n\n for i in range(9):\n if board[i][y] != '.':\n seen_numbers.add(board[i][y])\n \n for j in range(9):\n if board[x][j] != '.':\n seen_numbers.add(board[x][j])\n \n x = (x // 3) * 3\n y = (y // 3) * 3\n for i in range(0, 3):\n for j in range(0, 3):\n if board[x + i][y + j] != '.':\n seen_numbers.add(board[x + i][y + j])\n \n return seen_numbers\n\n def find_candidates(x, y):\n seen_numbers = find_existing_numbers(x, y)\n \n result = set()\n for num in range(1,10):\n if str(num) not in seen_numbers:\n result.add(str(num))\n \n return result\n \n def is_valid(x, y, num):\n seen_numbers = find_existing_numbers(x, y)\n\n return num not in seen_numbers\n \n def explore(x, y):\n print(x, y, board[x][y])\n # move on to next since the spot is already filled\n if board[x][y] != '.':\n if x == 8 and y == 8:\n return True\n \n if y < 8:\n return explore(x, y + 1)\n else:\n return explore(x + 1, 0)\n\n candidates = find_candidates(x, y)\n\n # spot is not filled but there are no possible candidates\n if len(candidates) == 0:\n return False\n\n # explore each candidate\n for candidate in candidates:\n \n # set the current candidate\n board[x][y] = candidate\n\n if x == 8 and y == 8:\n return True\n \n if y < 8:\n result = explore(x, y + 1)\n\n if result:\n return True\n else:\n result = explore(x + 1, 0)\n\n if result:\n return True\n \n board[x][y] = '.'\n \n return False\n \n explore(0, 0)","runtime":"246"},{"code":"class Solution:\n def solveSudoku(self, board: list[list[str]]) -> None:\n def isValid(row: int, col: int, c: str) -> bool:\n for i in range(9):\n if (board[i][col] == c or\n board[row][i] == c or\n board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c):\n return False\n return True\n\n def solve(s: int) -> bool:\n if s == 81:\n return True\n\n i = s // 9\n j = s % 9\n\n if board[i][j] != '.':\n return solve(s + 1)\n\n for c in string.digits[1:]:\n if isValid(i, j, c):\n board[i][j] = c\n if solve(s + 1):\n return True\n board[i][j] = '.'\n\n return False\n\n solve(0)","runtime":"246"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def square(a,b):\n squares = [{(x+i,y+j) for i in range(-1,2) for j in range(-1,2)} for (x,y) in [(1,1),(1,4),(1,7),(4,1),(4,4),(4,7),(7,1),(7,4),(7,7)]] \n for s in squares:\n if (a,b) in s:\n return s\n def valid_numbers(x,y):\n return {'1','2','3','4','5','6','7','8','9'} - (set(board[x]) | set(board[i][y] for i in range(9)) | set(board[i][j] for (i,j) in square(x,y)))\n def solve(p):\n for s in range(p,81):\n i,j = s//9,s%9\n if board[i][j] == \".\":\n possibilities = valid_numbers(i,j)\n if not possibilities:\n return False\n for n in possibilities:\n board[i][j] = str(n)\n if solve(s+1):\n return True\n board[i][j] = \".\"\n return False\n return True\n solve(0)\n","runtime":"251"},{"code":"# 注意：python 代码由 chatGPT\\U0001f916 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。\n# 本代码已经通过力扣的测试用例，应该可直接成功提交。\n\nclass Solution:\n def solveSudoku(self, board):\n self.backtrack(board, 0, 0)\n\n def backtrack(self, board, i, j):\n m, n = 9, 9\n if j == n:\n # 穷举到最后一列的话就换到下一行重新开始。\n return self.backtrack(board, i + 1, 0)\n if i == m:\n # 找到一个可行解，触发 base case\n return True\n\n if board[i][j] != '.':\n # 如果有预设数字，不用我们穷举\n return self.backtrack(board, i, j + 1)\n\n for ch in '123456789': # Corrected range for '1' to '9'\n # 如果遇到不合法的数字，就跳过\n if not self.isValid(board, i, j, ch):\n continue\n\n board[i][j] = ch\n # 如果找到一个可行解，立即结束\n if self.backtrack(board, i, j + 1):\n return True\n board[i][j] = '.'\n\n # 穷举完 1~9，依然没有找到可行解，此路不通\n return False\n\n # 判断 board[i][j] 是否可以填入 n\n def isValid(self, board, r, c, n):\n for i in range(9):\n # 判断行是否存在重复\n if board[r][i] == n:\n return False\n # 判断列是否存在重复\n if board[i][c] == n:\n return False\n # 判断 3 x 3 方框是否存在重复\n if board[(r // 3) * 3 + i // 3][(c // 3) * 3 + i % 3] == n:\n return False\n return True\n# 详细解析参见：\n# https://labuladong.online/algo/practice-in-action/sudoku/\n","runtime":"251"},{"code":"class Solution:\n def solveSudoku(self, board: list[list[str]]) -> None:\n def isValid(row: int, col: int, c: str) -> bool:\n for i in range(9):\n if (board[i][col] == c or\n board[row][i] == c or\n board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c):\n return False\n return True\n\n def solve(s: int) -> bool:\n if s == 81:\n return True\n\n i = s // 9\n j = s % 9\n\n if board[i][j] != '.':\n return solve(s + 1)\n\n for c in string.digits[1:]:\n if isValid(i, j, c):\n board[i][j] = c\n if solve(s + 1):\n return True\n board[i][j] = '.'\n\n return False\n\n solve(0)","runtime":"257"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def is_valid(board, row, col, num):\n \"\"\"\n Check if it's valid to place `num` at board[row][col].\n \"\"\"\n # Check the row\n for c in range(9):\n if board[row][c] == num:\n return False\n \n # Check the column\n for r in range(9):\n if board[r][col] == num:\n return False\n \n # Check the 3x3 sub-box\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\n for r in range(start_row, start_row + 3):\n for c in range(start_col, start_col + 3):\n if board[r][c] == num:\n return False\n \n return True\n \n def solve(board):\n \"\"\"\n Use backtracking to solve the Sudoku board.\n \"\"\"\n for row in range(9):\n for col in range(9):\n if board[row][col] == '.':\n for num in '123456789':\n if is_valid(board, row, col, num):\n board[row][col] = num\n if solve(board):\n return True\n board[row][col] = '.' # Undo the move\n return False # Trigger backtracking\n return True\n \n solve(board)","runtime":"257"},{"code":"class Solution:\n def solveSudoku(self, board: list[list[str]]) -> None:\n def isValid(row: int, col: int, c: str) -> bool:\n for i in range(9):\n if (board[i][col] == c or\n board[row][i] == c or\n board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c):\n return False\n return True\n\n def solve(s: int) -> bool:\n if s == 81:\n return True\n\n i = s // 9\n j = s % 9\n\n if board[i][j] != '.':\n return solve(s + 1)\n\n for c in string.digits[1:]:\n if isValid(i, j, c):\n board[i][j] = c\n if solve(s + 1):\n return True\n board[i][j] = '.'\n\n return False\n\n solve(0)","runtime":"262"},{"code":"class Solution:\n def solveSudoku(self, board: list[list[str]]) -> None:\n def isValid(row: int, col: int, c: str) -> bool:\n for i in range(9):\n if (board[i][col] == c or\n board[row][i] == c or\n board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c):\n return False\n return True\n\n def solve(s: int) -> bool:\n if s == 81:\n return True\n\n i = s // 9\n j = s % 9\n\n if board[i][j] != '.':\n return solve(s + 1)\n\n for c in string.digits[1:]:\n if isValid(i, j, c):\n board[i][j] = c\n if solve(s + 1):\n return True\n board[i][j] = '.'\n\n return False\n\n solve(0)\n ","runtime":"262"},{"code":"class Solution:\n def solveSudoku(self, board):\n def is_valid(num, row, col):\n for i in range(9):\n if board[row][i] == num or board[i][col] == num:\n return False\n box_row, box_col = 3 * (row // 3), 3 * (col // 3)\n for i in range(box_row, box_row + 3):\n for j in range(box_col, box_col + 3):\n if board[i][j] == num:\n return False\n return True\n\n def backtrack():\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n for num in '123456789':\n if is_valid(num, i, j):\n board[i][j] = num\n if backtrack():\n return True\n board[i][j] = '.' # Reset on backtrack\n return False # Trigger backtrack if no number is valid\n return True # Solved\n\n backtrack()","runtime":"268"},{"code":"class Solution:\n def solveSudoku(self, board: list[list[str]]) -> None:\n def isValid(row: int, col: int, c: str) -> bool:\n for i in range(9):\n if (board[i][col] == c or\n board[row][i] == c or\n board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c):\n return False\n return True\n\n def solve(s: int) -> bool:\n if s == 81:\n return True\n\n i = s // 9\n j = s % 9\n\n if board[i][j] != '.':\n return solve(s + 1)\n\n for c in string.digits[1:]:\n if isValid(i, j, c):\n board[i][j] = c\n if solve(s + 1):\n return True\n board[i][j] = '.'\n\n return False\n\n solve(0)","runtime":"268"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n curr_pos = (0,0)\n from itertools import product, islice\n to_next = {x:y for x,y in zip(product(range(9),range(9)), islice(product(range(9),range(9)), 1, None))}\n to_next[(8,8)] = None\n def pos_to_row(pos):\n return pos[0]\n def pos_to_col(pos):\n return pos[1]\n def pos_to_block(pos):\n return (pos[0]//3) + 3 * (pos[1]//3)\n \n set_row = [ set() for _ in range(9)]\n set_col = [ set() for _ in range(9)]\n set_block = [ set() for _ in range(9)]\n f_and_s = ((pos_to_row, set_row), (pos_to_col, set_col), (pos_to_block, set_block))\n for pos in product(range(9), repeat = 2):\n if board[pos[0]][pos[1]] == '.':\n continue\n else:\n filling = int(board[pos[0]][pos[1]])\n for fun_, set_ in f_and_s:\n set_[fun_(pos)].add(filling)\n\n\n def search(pos):\n if pos is None:\n return True\n u, v = pos\n if board[u][v] != '.':\n if search(to_next[pos]):\n return True\n return False\n else:\n for i in range(1, 10):\n if any([i in set_[fun_(pos)] for fun_, set_ in f_and_s]):\n continue\n for fun_, set_ in f_and_s:\n set_[fun_(pos)].add(i)\n board[u][v] = str(i)\n if search(to_next[pos]):\n return True\n for fun_, set_ in f_and_s:\n set_[fun_(pos)].remove(i)\n board[u][v] = '.'\n search((0,0))\n \n ","runtime":"273"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n # Backtracking problem: simple in concept, but difficult in execution\n # Setup a method to check if value we want to add is valid or not\n # Use recursion to do the backtracking\n # Need to setup the end case for returning\n\n def isBoardValid():\n for i in range(len(board)):\n row = board[i]\n if len(set(row)) != 9:\n return False\n for j in range(len(board[0])):\n col = [i[j] for i in board]\n if len(set(col)) != 9:\n return False\n for box_row in range(3):\n for box_col in range(3):\n box_vals = []\n for i in range(box_row*3, (box_row+1)*3):\n for j in range(box_col*3, (box_col+1)*3):\n box_vals.append(board[i][j])\n if len(set(box_vals)) != 9:\n return False\n return True\n \n\n def isValid(row, col, val):\n # Check row\n # if val in board[row]:\n # return False\n # # Check col\n # col_vals = [i[col] for i in board]\n # if val in col_vals:\n # return False\n # # Check 3x3 box\n # box_vals = []\n # for i in range(row//3*3, (row//3+1)*3):\n # for j in range(col//3*3, (col//3+1)*3):\n # box_vals.append(board[i][j])\n # if val in box_vals:\n # return False\n # return True\n \n region_row = (row//3)*3\n region_col = (col//3)*3\n\n for col_check in range(9):\n if val in board[row][col_check]:\n return False\n for row_check in range(9):\n if val in board[row_check][col]:\n return False\n for row_check in range(region_row,region_row+3):\n for col_check in range(region_col,region_col+3):\n # print(row_check,col_check)\n if val in board[row_check][col_check]:\n return False\n return True\n \n \n soln_found = False\n def backtrack(start_row, start_col):\n nonlocal soln_found\n # if row == 1 and start_col == 1:\n # print(board)\n # return\n if start_col >= 9:\n start_row += 1\n start_col = 0\n if start_row >= 9:\n soln_found = True\n return\n if soln_found:\n return\n for i in range(start_row, 9):\n # start = start_col if i == row else 0\n if i != start_row:\n start_col = 0\n for j in range(start_col, 9):\n if board[i][j] == '.':\n for num in range(9):\n val = str(num+1)\n if isValid(i, j, val):\n board[i][j] = val\n backtrack(i,j+1)\n if not soln_found:\n board[i][j] = '.'\n else:\n return\n return\n soln_found = True\n # if isBoardValid():\n # soln_found = True\n \n # print(isValid(0,2,\"3\"))\n # print(isValid(0,2,\"1\"))\n # print(isValid(0,2,\"9\"))\n # print(isBoardValid())\n backtrack(0,0)\n print(soln_found)\n\n ","runtime":"273"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Solves the Sudoku puzzle in-place.\n \"\"\"\n # Helper function to check if placing num at board[row][col] is valid\n def is_valid(board, row, col, num):\n # Check row\n for i in range(9):\n if board[row][i] == num:\n return False\n \n # Check column\n for i in range(9):\n if board[i][col] == num:\n return False\n \n # Check 3x3 sub-grid\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\n for i in range(3):\n for j in range(3):\n if board[start_row + i][start_col + j] == num:\n return False\n \n return True\n \n # Helper function to solve the board using backtracking\n def backtrack(board):\n for row in range(9):\n for col in range(9):\n if board[row][col] == '.': # Found an empty space\n for num in '123456789': # Try placing numbers 1-9\n if is_valid(board, row, col, num):\n board[row][col] = num # Place the number\n \n if backtrack(board): # Recursively solve the next cell\n return True\n \n board[row][col] = '.' # Undo the move (backtrack)\n return False # No valid number was found for this cell\n return True # Solved the board\n \n # Call the backtracking function to solve the board\n backtrack(board)\n\n\n\n\n","runtime":"279"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n #这题类似N皇后 用dfs去生成每一行 在行里每个坐标填数字 \n #还需要一个check每行 每列 每3X3格子有效性的function 每3X3格子需要背 比任何东西都不直观\n self.fill(0, 0, board) #row, col, board\n \n def fill(self, row, col, board):\n #这里边fill的逻辑要非常清楚\n if row == 9: return True #填满所有行 就T\n if col == 9: return self.fill(row+1, 0, board) #填满当前行所有格子 就去下一行继续填 col初始化为0 从头开始走\n \n if board[row][col] == '.': #当前格子能填数字\n for i in range(1, 10):\n if self.isvalid(row, col, board, str(i)): #如果数字在当前格子valid\n board[row][col] = str(i)\n if self.fill(row, col+1, board): #就去同行下一个格子填\n return True #?T去哪里\n else:\n board[row][col] = '.' #如果下一个格子不行 就把这个当前格子改回‘.’ 回到for循环选一个新数字来填\n else:\n return self.fill(row, col+1, board) #如果当前格子不能填数字 就去下一个格子填\n\n def isvalid(self, row, col, board, letter):\n for i in range(9): #这里不能是(1,10) 因为i是0-index坐标\n if letter == board[i][col] or letter == board[row][i]:\n return False\n if letter == board[3*(row//3)+i//3][3*(col//3)+i%3]:\n return False\n return True","runtime":"279"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \n def is_valid(r,c,n):\n for i in range(9):\n if board[r][i]==n:\n return False\n for i in range(9):\n if board[i][c] == n:\n return False\n\n rs = (r//3)*3\n cs = (c//3)*3\n\n for i in range(rs,rs+3):\n for j in range(cs,cs+3):\n if board[i][j]==n:\n return False\n return True\n\n def solve():\n for r in range(0,9):\n for c in range(0,9):\n if board[r][c]=='.':\n for n in '123456789':\n if is_valid(r,c,n):\n board[r][c] = n\n if solve():\n return True\n else:\n board[r][c] = '.'\n return False\n return True\n solve() \n\n \n","runtime":"285"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isValid(r,c,k):\n for i in range(9):\n if board[i][c]==k or board[r][i]==k:\n return False\n subgrid_row = 3 * (r//3) + i//3\n subgrid_col = 3 * (c//3) + i%3\n if board[subgrid_row][subgrid_col]==k:\n return False\n return True\n\n def fill(r,c):\n if r==9:\n return True\n if c==9:\n return fill(r + 1, 0)\n if board[r][c]=='.':\n for k in range(1,10):\n if isValid(r,c,str(k)):\n board[r][c] = str(k)\n if fill(r,c+1):\n return True\n board[r][c] = '.'\n return False\n return fill(r,c+1)\n fill(0,0)","runtime":"285"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n # Check if placing 'k' at position (r, c) is valid\n def isValid(r, c, k):\n for i in range(9):\n # Check row and column\n if board[i][c] == k or board[r][i] == k:\n return False\n \n # Check the 3x3 subgrid\n subgrid_row = 3 * (r // 3) + i // 3\n subgrid_col = 3 * (c // 3) + i % 3\n if board[subgrid_row][subgrid_col] == k:\n return False\n return True \n\n # Recursively fill the board\n def fill(r, c):\n # If we reach the end of the board, the solution is found\n if r == 9:\n return True\n \n # Move to the next row if we reach the end of the current row\n if c == 9:\n return fill(r + 1, 0)\n \n # If the current cell is empty, try filling it\n if board[r][c] == '.':\n for k in range(1, 10):\n if isValid(r, c, str(k)):\n board[r][c] = str(k)\n \n # Recur for the next cell\n if fill(r, c + 1):\n return True\n \n # Backtrack if placing 'k' doesn't lead to a solution\n board[r][c] = '.'\n \n # Return False if no valid number can be placed\n return False\n \n # Move to the next cell if the current one is already filled\n return fill(r, c + 1)\n\n # Start solving from the top-left corner\n fill(0, 0)","runtime":"290"},{"code":"from typing import List\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Solves the Sudoku puzzle in-place.\n \"\"\"\n def is_safe(board, row, col, num) -> bool:\n # Check if 'num' is in the current row\n if num in board[row]:\n return False\n \n # Check if 'num' is in the current column\n if num in [board[i][col] for i in range(9)]:\n return False\n \n # Check the 3x3 sub-grid\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\n for i in range(start_row, start_row + 3):\n for j in range(start_col, start_col + 3):\n if board[i][j] == num:\n return False\n \n return True\n \n def solve(board):\n # Try to find an empty cell\n for row in range(9):\n for col in range(9):\n if board[row][col] == '.':\n # Try placing digits 1 to 9\n for num in map(str, range(1, 10)):\n if is_safe(board, row, col, num):\n board[row][col] = num # Place the number\n \n # Recursively try to solve the rest of the board\n if solve(board):\n return True\n \n # Backtrack if it didn't lead to a solution\n board[row][col] = '.' # Reset the cell\n return False\n return True\n \n # Start solving the board\n solve(board)\n","runtime":"290"},{"code":"from typing import List\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n def is_valid(num, row, col):\n # Check if 'num' is not in the current row\n for i in range(9):\n if board[row][i] == num:\n return False\n \n # Check if 'num' is not in the current column\n for i in range(9):\n if board[i][col] == num:\n return False\n \n # Check if 'num' is not in the current 3x3 grid\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\n for i in range(3):\n for j in range(3):\n if board[start_row + i][start_col + j] == num:\n return False\n \n return True\n \n def solve():\n for row in range(9):\n for col in range(9):\n if board[row][col] == '.':\n for num in '123456789':\n if is_valid(num, row, col):\n board[row][col] = num # Place the number\n if solve(): # Recursively call solve\n return True\n board[row][col] = '.' # Backtrack\n return False # If no number is valid, return False\n return True # All cells filled successfully\n \n solve()","runtime":"296"},{"code":"class Solution:\n def is_valid(self, val, row, col, board):\n if val in board[row]:\n return False\n\n if val in [board[j][col] for j in range(len(board))]:\n return False\n\n ri, ci = (row // 3)*3, (col//3) * 3\n if val in [board[i][j] for i in range(ri, ri+3) for j in range(ci, ci+3)]:\n return False\n\n return True\n \n def solve(self, board):\n n = len(board)\n for i in range(n):\n for j in range(n):\n if board[i][j] != \".\":\n continue\n for val in range(1,10):\n if self.is_valid(str(val), i, j, board):\n board[i][j] = str(val)\n status = self.solve(board)\n if status:\n return True\n else:\n board[i][j] = \".\"\n return False\n return True\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.solve(board)\n ","runtime":"296"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def solve(row, col):\n if row == 9 :\n return True\n if col == 9:\n return solve(row+1, 0)\n if board[row][col] == '.':\n for k in range(1,10):\n if isValid(row, col, str(k)):\n board[row][col] = str(k)\n res = solve(row, col+1)\n if res == True:\n return True\n board[row][col] = '.'\n return False\n return solve(row, col+1)\n \n def isValid(r, c, k):\n for i in range(9):\n # Check row and column\n if board[i][c] == k or board[r][i] == k:\n return False\n \n # Check the 3x3 subgrid\n subgrid_row = 3 * (r // 3) + i // 3\n subgrid_col = 3 * (c // 3) + i % 3\n if board[subgrid_row][subgrid_col] == k:\n return False\n return True \n \n solve(0,0)\n \n\n\n ","runtime":"301"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.solve(board)\n \n def solve(self, board):\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n for num in '123456789':\n if self.is_valid(board, i, j, num):\n board[i][j] = num\n if self.solve(board):\n return True\n board[i][j] = '.'\n return False\n return True\n \n def is_valid(self, board, i, j, num):\n box_base_row = (i // 3) * 3\n box_base_col = (j // 3) * 3\n for k in range(9):\n if board[i][k] == num:\n return False\n if board[k][j] == num:\n return False\n if board[box_base_row + k // 3][box_base_col + k % 3] == num:\n return False\n return True ","runtime":"301"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.backtracking(board)\n \n def backtracking(self, board: List[List[str]]) -> bool:\n for r in range(9):\n for c in range(9):\n if board[r][c] == \".\":\n for num in range(1, 10):\n if self.isValid(board, r, c, str(num)):\n board[r][c] = str(num)\n res = self.backtracking(board) # 接住从下面返回上来的bool值\n if res: # 只要找到一个valid的叶子结点，就返回\n return True\n board[r][c] = \".\"\n return False # 如果1-9所有的数都尝试之后的棋盘也没填好，那就无解\n return True\n \n\n def isValid(self, board: List[List[str]], row: int, col: int, num: str):\n for c in range(9):\n if board[row][c] == num:\n return False\n for r in range(9):\n if board[r][col] == num:\n return False\n start_r, start_c = row // 3 * 3, col // 3 * 3\n for r in range(start_r, start_r + 3):\n for c in range(start_c, start_c + 3):\n if board[r][c] == num:\n return False\n return True\n\n ","runtime":"307"},{"code":"class Solution:\n def solveSudoku(self, board):\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def is_valid(board, row, col, num):\n # Check if the number is not in the current row\n for x in range(9):\n if board[row][x] == num:\n return False\n\n # Check if the number is not in the current column\n for x in range(9):\n if board[x][col] == num:\n return False\n\n # Check if the number is not in the current 3x3 sub-box\n startRow = row - row % 3\n startCol = col - col % 3\n for i in range(3):\n for j in range(3):\n if board[i + startRow][j + startCol] == num:\n return False\n\n return True\n\n def solve(board):\n empty = find_empty_location(board)\n if not empty:\n return True # Puzzle solved\n\n row, col = empty\n\n for num in \"123456789\":\n if is_valid(board, row, col, num):\n board[row][col] = num\n\n if solve(board):\n return True\n\n board[row][col] = '.'\n\n return False\n\n def find_empty_location(board):\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n return i, j\n return None\n\n solve(board)\n\n# Example usage:\nsolution = Solution()\nboard = [[\"5\",\"3\",\".\",\".\",\"7\",\".\",\".\",\".\",\".\"],\n [\"6\",\".\",\".\",\"1\",\"9\",\"5\",\".\",\".\",\".\"],\n [\".\",\"9\",\"8\",\".\",\".\",\".\",\".\",\"6\",\".\"],\n [\"8\",\".\",\".\",\".\",\"6\",\".\",\".\",\".\",\"3\"],\n [\"4\",\".\",\".\",\"8\",\".\",\"3\",\".\",\".\",\"1\"],\n [\"7\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\",\"6\"],\n [\".\",\"6\",\".\",\".\",\".\",\".\",\"2\",\"8\",\".\"],\n [\".\",\".\",\".\",\"4\",\"1\",\"9\",\".\",\".\",\"5\"],\n [\".\",\".\",\".\",\".\",\"8\",\".\",\".\",\"7\",\"9\"]]\n\nsolution.solveSudoku(board)\n\n# Print the solved board\nfor row in board:\n print(' '.join(row))","runtime":"307"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n from typing import List\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # Function to check if placing num at board[row][col] is valid\n def is_valid(board, row, col, num):\n # Check row\n for i in range(9):\n if board[row][i] == num:\n return False\n # Check column\n for i in range(9):\n if board[i][col] == num:\n return False\n # Check 3x3 sub-box\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\n for i in range(3):\n for j in range(3):\n if board[start_row + i][start_col + j] == num:\n return False\n return True\n\n # Recursive backtracking function to solve the board\n def solve():\n for row in range(9):\n for col in range(9):\n if board[row][col] == '.':\n # Try placing digits 1 to 9\n for num in '123456789':\n if is_valid(board, row, col, num):\n board[row][col] = num # Place the digit\n if solve(): # Recursively solve the next cell\n return True\n board[row][col] = '.' # Backtrack if not solvable\n return False # No valid number was found, return False\n return True # All cells are filled correctly\n\n solve()\n","runtime":"312"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isvalid(board,row,col,num):\n for i in range(9):\n if board[i][col]==num:\n return False\n for i in range(9):\n if board[row][i]==num:\n return False\n start_row=3*(row//3)\n start_col=3*(col//3)\n for i in range(start_row,start_row+3):\n for j in range(start_col,start_col+3):\n if board[i][j]==num:\n return False\n return True\n def solve(board):\n for i in range(9):\n for j in range(9):\n if board[i][j]=='.':\n for num in map(str,range(1,10)):\n if isvalid(board,i,j,num):\n board[i][j]=num\n if solve(board):\n return True\n board[i][j]='.'\n return False\n return True\n solve(board)\n return board\n \n\n ","runtime":"312"},{"code":"from functools import cmp_to_key\n\nclass Solution:\n def isValid(self, board: List[List[str]], x:int, y:int, val: int) -> None:\n for j, cell in enumerate(board[x]):\n if j!=y and cell == val:\n return False\n for i, row in enumerate(board):\n if i!=x and row[y] == val:\n return False\n x_range = list(range((x // 3) * 3, (x // 3 + 1) * 3))\n y_range = list(range((y // 3) * 3, (y // 3 + 1) * 3))\n for i in x_range:\n for j in y_range:\n if board[i][j] == val and not (i == x and j == y):\n return False\n return True\n \n def helper(self, board: List[List[str]]) -> bool:\n for x in range(9):\n for y in range(9):\n if board[x][y] == '.':\n for val in range(1, 10):\n if self.isValid(board, x, y, str(val)):\n board[x][y] = str(val)\n retval = self.helper(board)\n if retval: return retval\n else: board[x][y] = '.'\n if board[x][y] == '.':\n return False\n return True\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.helper(board)\n\n ","runtime":"318"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n def isgood(board,row,col,i):\n for j in board[row]:\n if j == str(i):\n return False\n \n for j in range(9):\n if board[j][col] == str(i):\n return False\n \n temprow = (row//3)*3\n tempcol = (col//3)*3\n\n for a in range(temprow , temprow+3):\n for b in range(tempcol , tempcol+3):\n if board[a][b] == str(i):\n return False\n \n return True\n \n def help(board,row,col):\n if row == 9:\n return True\n if col == 9:\n return help(board,row+1,0)\n \n if board[row][col] != \".\" :\n return help(board,row,col+1)\n \n for i in range(1,10):\n if isgood(board,row,col,i):\n board[row][col] = str(i)\n if(help(board,row,col)):\n return True\n else:\n board[row][col] = \".\"\n \n help(board,0,0)\n\n ","runtime":"318"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Solves the Sudoku puzzle in-place.\n \"\"\"\n self.solve(board)\n\n def solve(self, board) -> bool:\n # Try to find an empty cell\n for row in range(9):\n for col in range(9):\n if board[row][col] == '.':\n # Try placing digits 1-9\n for num in '123456789':\n if self.isValid(board, row, col, num):\n board[row][col] = num\n \n # Recursively try to solve the board\n if self.solve(board):\n return True\n \n # If it doesn't lead to a solution, backtrack\n board[row][col] = '.'\n return False # If no number fits, backtrack\n return True # Puzzle is solved when no empty cell is left\n\n def isValid(self, board, row, col, num) -> bool:\n # Check if 'num' is not present in the current row, column, and 3x3 sub-grid\n for i in range(9):\n # Check row and column\n if board[row][i] == num or board[i][col] == num:\n return False\n \n # Check the 3x3 sub-box\n boxRow = 3 * (row // 3) + i // 3\n boxCol = 3 * (col // 3) + i % 3\n if board[boxRow][boxCol] == num:\n return False\n\n return True","runtime":"323"},{"code":"class Solution:\n def findUnassigned(self):\n\n for row in range(9):\n for col in range(9):\n if self.board[row][col] == '.':\n return row, col\n return -1, -1\n\n def solve(self):\n row, col = self.findUnassigned()\n if row == -1 and col == -1:\n return True\n \n for num in [\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"]:\n if self.isValid(row, col, num):\n self.board[row][col] = num\n if self.solve():\n return True\n self.board[row][col] = '.'\n return False\n \n def isValid(self, row, col, num):\n boxRow = row - row % 3\n boxCol = col - col % 3\n\n if self.isRowValid(row, num) and self.isColValid(col, num) and self.isSquareValid(boxRow, boxCol, num):\n return True\n return False\n\n def isRowValid(self, row, num):\n for col in range(9):\n if self.board[row][col] == num:\n return False\n return True\n \n def isColValid(self, col, num):\n for row in range(9):\n if self.board[row][col] == num:\n return False\n return True\n \n def isSquareValid(self, row, col, num):\n for r in range(row, row + 3):\n for c in range(col, col + 3):\n if self.board[r][c] == num:\n return False\n return True\n \n\n \n\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.board = board\n self.solve()\n \n ","runtime":"323"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def check_number(x,y, cur_nb):\n # check row and column\n # for i in range (9):\n # if y == i or x == i:\n # continue\n # if board[x][i] == cur_nb or board[i][y] == cur_nb:\n # return False\n \n for i in range(9):\n if y != i and board[x][i] == cur_nb:\n return False\n if x != i and board[i][y] == cur_nb:\n return False\n \n # check small square\n index_x = x // 3 * 3\n index_y = y // 3 * 3\n \n \n for i in range(0, 3):\n for j in range(0, 3):\n if index_x + i == x and index_y + j == y:\n continue\n if(board[index_x + i][index_y + j] == cur_nb):\n return False\n return True\n \n \n \n def is_solved():\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n return False, (i, j)\n return True, (0,0)\n \n \n def backtrack():\n solved, coord = is_solved()\n x, y = coord\n if solved:\n return True\n \n for i in range(1, 10):\n if check_number(x, y, str(i)):\n board[x][y] = str(i)\n if(backtrack()):\n return True\n board[x][y] = '.'\n \n backtrack()\n ","runtime":"335"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isValidPlacement(board: List[List[str]], row: int, col: int, num: str) -> bool:\n\n for i in range(9):\n if board[row][i] == num: \n return False\n if board[i][col] == num: \n return False\n if board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == num:\n return False\n return True\n \n def solve() -> bool:\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n for num in \"123456789\":\n if isValidPlacement(board, i, j, num):\n board[i][j] = num\n if solve():\n return True\n board[i][j] = \".\"\n return False\n return True\n \n solve()\n","runtime":"335"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \n \"\"\"\n Do not return anything, modify board in-place instead. \"\"\"\n \n def check (board, row, col, val):\n for i in range(0, 9):\n if board[i][col] == val :\n return False\n if board[row][i] == val : \n return False \n if board[3*(row//3)+(i//3)][3*(col//3)+i%3]== val: \n return False\n return True \n def solve(board): \n for a in range(9):\n for b in range(9):\n if board[a][b]=='.' : \n for z in range(1, 10):\n z=str(z)\n if check(board, a, b, z) :\n board[a][b]=z\n if solve(board):\n return True\n else:\n board[a][b]='.'\n \n return False\n return True \n \n\n solve(board)\n return board\n","runtime":"340"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n def f(board):\n for i in range(9):\n for j in range(9):\n if board[i][j]=='.':\n for c in range(1,10):\n if isvalid(i,j,str(c)):\n board[i][j]=str(c)\n if f(board):\n return True\n board[i][j]='.'\n return False\n return True\n def isvalid(row,col,k):\n for i in range(9):\n if board[i][col]==k:\n return False\n if board[row][i]==k:\n return False\n if board[3*(row//3)+i//3][3*(col//3)+i%3]==k:\n return False\n return True\n f(board)\n","runtime":"340"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isvalid(num,row,col):\n for i in range(9):\n if board[i][col] == num:\n return False\n if board[row][i] == num:\n return False\n r = 3*(row//3) + i//3\n c = 3*(col//3) + i%3\n if board[r][c]==num:\n return False\n return True\n def fillboard():\n for row in range(9):\n for col in range(9):\n if board[row][col] == '.':\n for num in \"123456789\":\n if isvalid(num,row,col):\n board[row][col] = num\n if fillboard() : return True\n board[row][col] = \".\"\n return False\n return True\n fillboard()","runtime":"346"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isPossible(board, row, col, value):\n for i in range(9):\n if board[i][col] == value:\n return False\n\n if board[row][i] == value:\n return False\n\n if board[3*(row//3) + i//3][3*(col//3) + i%3] == value:\n return False\n return True\n\n\n def solve(board):\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n for val in range(1, 10):\n if isPossible(board, i, j, str(val)):\n board[i][j] = str(val)\n if solve(board):\n return True\n else:\n board[i][j] = \".\"\n return False\n return True\n \n \n solve(board)","runtime":"346"},{"code":"from typing import List\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def is_valid(row, col, num):\n for i in range(9):\n # Check row and column\n if board[row][i] == num or board[i][col] == num:\n return False\n # Check 3x3 subgrid\n subgrid_row = 3 * (row // 3) + i // 3\n subgrid_col = 3 * (col // 3) + i % 3\n if board[subgrid_row][subgrid_col] == num:\n return False\n return True\n\n def solve():\n for row in range(9):\n for col in range(9):\n if board[row][col] == '.':\n for num in '123456789':\n if is_valid(row, col, num):\n board[row][col] = num\n if solve():\n return True\n board[row][col] = '.' # Backtrack\n return False # Trigger backtracking\n return True # Puzzle solved\n\n solve()\n","runtime":"351"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isValid(board,i, j, k):\n for row in range(len(board)):\n if board[row][j] == k:\n return False\n\n if board[i][row] == k:\n return False\n\n if board[3*(i//3) + row//3][3*(j//3) + row%3] == k:\n return False\n\n return True\n\n\n def solve(board):\n for i in range(len(board)):\n for j in range(len(board)):\n if board[i][j] == \".\":\n for k in range(1, 10):\n if isValid(board, i, j, str(k)):\n board[i][j] = str(k)\n if solve(board) == True:\n return True\n board[i][j] = \".\"\n\n return False\n \n \n return True\n\n solve(board)\n \n\n\n \n\n\n ","runtime":"351"},{"code":"class Solution:\n def isPossible(self, board, x, y, value):\n # Same row checking \n for col in range(9):\n if board[x][col] == str(value):\n return False\n \n # Same col checking\n for row in range(9):\n if board[row][y] == str(value):\n return False\n \n # Same 3 * 3 matrix checking \n topRow = (x // 3) * 3 \n topCol = (y // 3) * 3 \n \n for i in range(3):\n for j in range(3):\n if board[topRow + i][topCol + j] == str(value):\n return False\n return True\n\n def solveThis(self, x, y, board):\n #print(x, y, board)\n if x == 9:\n return True\n \n nextX, nextY = -1, -1 \n \n if y == 8:\n nextX = x + 1 \n nextY = 0 \n else:\n nextX = x \n nextY = y + 1\n \n if board[x][y] != \".\":\n return self.solveThis(nextX, nextY, board)\n \n \n for value in range(1, 10):\n if self.isPossible(board, x, y, value) == True:\n board[x][y] = str(value)\n result = self.solveThis(nextX, nextY, board)\n if result == True:\n return True\n board[x][y] = \".\"\n \n return False\n\n def solveSudoku(self, board):\n self.solveThis(0, 0, board)","runtime":"357"},{"code":"def ac3(board:List[List[str]],domain:List[List[List[int]]],rowStart:int,rowEnd:int,colStart:int,colEnd:int)->None:\n ##Row Constraints;\n for i in range(rowStart,rowEnd):\n for j in range(9):\n if board[i][j] != '.':\n domain[i][j]=['-1']\n continue\n revised=reviseRow(board,domain,i,j)\n if revised:\n ac3(board,domain,i,i+1,j,j+1)\n revised = False\n for j in range(colStart,colEnd):\n for i in range(9):\n if board[i][j] !='.':\n continue\n revised = reviseCol(board,domain,i,j)\n if revised:\n ac3(board,domain,i,i+1,j,j+1)\n revised = False\n for i in range(rowStart,rowEnd):\n for j in range(colStart,colEnd):\n if board[i][j] != '.':\n continue\n revised = reviseSubGrid(board,domain,i,j)\n if revised:\n ac3(board,domain,i,i+1,j,j+1)\n \n\ndef reviseRow(board,domain,i,j):\n revised = False\n for k in range(9):\n if k == j:\n continue\n val = board[i][k]\n \n if val != '.':\n if val in domain[i][j]:\n if(len(domain[i][j])>1):\n domain[i][j].remove(val)\n else:\n domain[i][j]=['-1']\n revised = True\n\n return revised\n\ndef reviseCol(board,domain,i,j):\n revised = False\n for k in range(9):\n if k==i:\n continue\n val = board[k][j]\n if val !='.':\n if val in domain[i][j]:\n if(len(domain[i][j])>1):\n domain[i][j].remove(val)\n else:\n domain[i][j]=['-1']\n revised = True\n return revised\n\ndef reviseSubGrid(board,domain,i,j):\n revised = False\n for k in range(int(i/3)*3,int((i+3)/3)*3):\n for l in range(int(j/3)*3,int((j+3)/3)*3):\n if i==k and j==l:\n continue\n val = board[k][l]\n if val != '.':\n if val in domain[i][j]:\n if(len(domain[i][j])>1):\n domain[i][j].remove(val)\n else:\n domain[i][j]=['-1']\n revised = True\n return revised\n\n \n# Function to Find the entry in \n# the Grid that is still not used\n# Searches the grid to find an \n# entry that is still unassigned. If\n# found, the reference parameters \n# row, col will be set the location\n# that is unassigned, and true is \n# returned. If no unassigned entries\n# remains, false is returned.\n# 'l' is a list variable that has \n# been passed from the solve_sudoku function\n# to keep track of incrementation \n# of Rows and Columns\ndef find_empty_location(board, l):\n for row in range(9):\n for col in range(9):\n if(board[row][col]== '.'):\n l[0]= row\n l[1]= col\n return True\n return False\n\n# Returns a boolean which indicates \n# whether any assigned entry\n# in the specified row matches \n# the given number.\ndef used_in_row(board, row, num):\n for i in range(9):\n if(board[row][i] == num):\n return True\n return False\n\n# Returns a boolean which indicates \n# whether any assigned entry\n# in the specified column matches \n# the given number.\ndef used_in_col(board, col, num):\n for i in range(9):\n if(board[i][col] == num):\n return True\n return False\n\n# Returns a boolean which indicates \n# whether any assigned entry\n# within the specified 3x3 box \n# matches the given number\ndef used_in_box(board, row, col, num):\n for i in range(3):\n for j in range(3):\n if(board[i + row][j + col] == num):\n return True\n return False\n\n# Checks whether it will be legal \n# to assign num to the given row, col\n# Returns a boolean which indicates \n# whether it will be legal to assign\n# num to the given row, col location.\ndef check_location_is_safe(board, row, col, num):\n \n # Check if 'num' is not already \n # placed in current row,\n # current column and current 3x3 box\n return (not used_in_row(board, row, num) and \n (not used_in_col(board, col, num) and \n (not used_in_box(board, row - row % 3,col - col % 3, num)))) \n \n\ndef printSubgrid(board,i,j):\n for k in range(int(i/3)*3,int((i+3)/3)*3):\n for l in range(int(j/3)*3,int((j+3)/3)*3):\n if i==k and j==l:\n continue\n print(board[k][l])\n\ndef solve_sudoku(board: List[List[str]],domain) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # 'l' is a list variable that keeps the \n # record of row and col in \n # find_empty_location Function \n l = [0, 0]\n \n # If there is no unassigned \n # location, we are done \n if(not find_empty_location(board, l)):\n return True\n \n # Assigning list values to row and col \n # that we got from the above Function \n row = l[0]\n col = l[1]\n \n # consider digits 1 to 9\n for num in range(1,10):\n num = str(num)\n # if looks promising\n if(check_location_is_safe(board, \n row, col, num)):\n print(\"IN !\")\n # make tentative assignment\n board[row][col]= num\n\n # return, if success, \n # ya ! \n if(solve_sudoku(board,domain)):\n return True\n\n # failure, unmake & try again\n board[row][col] = '.'\n print(\"backtracked\")\n \n # this triggers backtracking \n return False\n \n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \n #printSubgrid(board,0,8)\n domain = []\n\n for i in range(9):\n a = []\n for j in range(9):\n a.append([])\n for l in range(1,10):\n a[j].append(str(l))\n domain.append(a)\n ac3(board,domain,0,9,0,9)\n for i in range(9):\n print(i)\n print(domain[i])\n print('-'*30)\n \n print(solve_sudoku(board,domain))\n ","runtime":"357"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def validPlacement(i, j, val):\n # returns true if placing val at i,j is valid\n baseI, baseJ = 3 * (i // 3), 3 * (j // 3)\n for m in range(baseI, baseI + 3):\n for n in range(baseJ, baseJ + 3):\n if board[m][n] == val:\n return False\n for k in range(9):\n if board[i][k] == val or board[k][j] == val:\n return False\n return True\n\n nums = [str(i) for i in range(1, 10)]\n def dfs():\n for m in range(9):\n for n in range(9):\n if board[m][n] == '.': # only test if it's possible to fill this square\n for test in nums:\n if validPlacement(m, n, test):\n board[m][n] = test\n if dfs():\n return True\n board[m][n] = '.'\n return False\n return True # base case: only return True if no '.' characters were found this call, meaning the board is solved.\n \n dfs()\n \n\n\n \n\n \n","runtime":"362"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n def is_valid(num : int,pos: List[int])-> bool:\n #row\n for j in range(9):\n if board[pos[0]][j] == num and pos[1] != j:\n return False\n #col \n for i in range(9):\n if board[i][pos[1]] == num and pos[0] != i:\n return False\n\n box_x,box_y= (pos[1]//3),(pos[0]//3)\n for i in range(box_y*3,(box_y*3)+3):\n for j in range(box_x*3,(box_x*3)+3):\n if board[i][j] == num and (i,j) != pos:\n return False\n\n return True\n\n def solve():\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\": \n for num in \"123456789\":\n if is_valid(num,[i,j]):\n board[i][j]= num\n if solve():\n return True\n board[i][j]= \".\"\n return False\n return True \n\n solve() \n\n \n\n\n \n ","runtime":"362"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n nrows = len(board)\n ncols = len(board[0])\n\n def isValid(row,col, num):\n sbox_l_boundary = col//3\n sbox_r_boundary = col//3+1\n sbox_u_boundary = row//3\n sbox_d_boundary = row//3+1\n for x in range(sbox_u_boundary * 3, sbox_d_boundary * 3):\n for y in range(sbox_l_boundary* 3, sbox_r_boundary*3):\n if board[x][y] == num:\n return False\n if num in board[row]:\n return False\n if num in [board[_][col] for _ in range(nrows)]:\n return False\n return True\n\n\n def backtracking(r_start, c_start) -> bool:\n for row in range(r_start, 9): \n c_s = 0\n if row == r_start:\n c_s = c_start\n for col in range(c_s, 9): \n if board[row][col] == '.':\n for n in range(1,10):\n num = str(n)\n # check if we can place the number in the grid\n if isValid(row, col, num):\n board[row][col] = num\n if backtracking(row,col+1):\n return True\n board[row][col] = '.'\n return False\n return True\n \n return backtracking(0,0)\n","runtime":"368"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n nrows = len(board)\n ncols = len(board[0])\n\n def isValid(row,col, num):\n sbox_l_boundary = col//3\n sbox_r_boundary = col//3+1\n sbox_u_boundary = row//3\n sbox_d_boundary = row//3+1\n for x in range(sbox_u_boundary * 3, sbox_d_boundary * 3):\n for y in range(sbox_l_boundary* 3, sbox_r_boundary*3):\n if board[x][y] == num:\n return False\n if num in board[row]:\n return False\n if num in [board[_][col] for _ in range(nrows)]:\n return False\n return True\n\n\n def backtracking(rStart, cStart) -> bool:\n for row in range(rStart, 9): \n cS = 0\n if row == rStart:\n cS = cStart\n for col in range(cS, 9): \n if board[row][col] == '.':\n for n in range(1,10):\n num = str(n)\n # check if we can place the number in the grid\n if isValid(row, col, num):\n board[row][col] = num\n if backtracking(row,col+1):\n return True\n board[row][col] = '.'\n return False\n return True\n \n return backtracking(0,0)\n","runtime":"368"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n import collections\n n, occupied, empties = 9, collections.defaultdict(set), []\n for i in range(n):\n for j in range(n):\n if board[i][j] == '.': empties.append((i, j))\n else:\n v = board[i][j]\n occupied[(i, -1)].add(v)\n occupied[(-1, j)].add(v)\n occupied[(i // 3, j // 3)].add(v)\n\n def dfs():\n if not empties: return True\n i, j = empties.pop()\n for v in map(str, range(1, 10)):\n keys = ((i, -1), (-1, j), (i // 3, j // 3))\n if any(tuple(v in occupied[e] for e in keys)): continue\n board[i][j] = v\n for e in keys: occupied[e].add(v)\n if dfs(): return True\n for e in keys: occupied[e].remove(v)\n empties.append((i, j))\n return False\n \n dfs()","runtime":"373"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n def is_valid(x, y, num):\n for i in range(9):\n if board[x][i] == str(num) or board[i][y] == str(num):\n return False\n x_start = (x // 3) * 3\n y_start = (y // 3) * 3\n for i in range(3):\n for j in range(3):\n if board[x_start + i][y_start + j] == str(num):\n return False\n return True\n \n def dfs(board):\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n for num in range(1, 10):\n if is_valid(i, j, num):\n board[i][j] = str(num)\n if dfs(board):\n return True\n board[i][j] = \".\"\n return False\n return True\n \n dfs(board)\n ","runtime":"373"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n result=[]\n self.backtrack(0,board,result)\n print(board)\n\n def backtrack(self,start,board,result):\n if start==len(board)**2:\n return True\n row=start//len(board)\n column=start%len(board)\n if board[row][column]==\".\":\n for num in range(1,10):\n if self.checker(start,num,board):\n board[row][column]=str(num)\n if self.backtrack(start+1,board,result) : return True\n board[row][column]=\".\"\n return False\n else:\n return self.backtrack(start+1,board,result)\n def checker(self,start,num,board):\n\n #row\n row=start//len(board)\n for i in range(len(board)):\n if board[row][i]==str(num):\n return False\n #column\n column=start%len(board)\n for i in range(len(board)):\n if board[i][column]==str(num):\n return False\n \n\n #boxa\n start_row=0\n end_row=0\n start_col=0\n end_col=0\n if row>=0 and row<=2:\n start_row=0\n end_row=2\n elif row>=3 and row<=5:\n start_row=3\n end_row=5\n elif row>=6 and row<=8:\n start_row=6\n end_row=8\n\n if column>=0 and column<=2:\n start_col=0\n end_col=2\n\n elif column>=3 and column<=5:\n start_col=3\n end_col=5\n elif column>=6 and column<=8:\n start_col=6\n end_col=8\n\n \n for i in range(start_row,end_row+1):\n for j in range(start_col,end_col+1):\n if board[i][j]==str(num):\n return False\n\n return True\n\n\n \n\n\n\n\n\n\n\n\n ","runtime":"379"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isValid(row: int, col: int, num: str) -> bool:\n for i in range(9):\n # Check in row\n if board[row][i] == num: return False\n\n # Check in col\n if board[i][col] == num: return False\n\n # Check in sub-square\n subRow = 3 * (row // 3) + (i // 3)\n subCol = 3 * (col // 3) + (i % 3)\n if board[subRow][subCol] == num: return False\n return True\n\n def solve() -> bool:\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n for num in \"123456789\":\n if isValid(i, j, num):\n board[i][j] = num\n if solve() == True: return True\n else:\n board[i][j] = \".\"\n return False\n return True\n\n solve()\n ","runtime":"379"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def square(a,b):\n squares = [{(x+i,y+j) for i in range(-1,2) for j in range(-1,2)} for (x,y) in [(1,1),(1,4),(1,7),(4,1),(4,4),(4,7),(7,1),(7,4),(7,7)]] \n for s in squares:\n if (a,b) in s:\n return s\n def valid_numbers(x,y):\n return {'1','2','3','4','5','6','7','8','9'} - (set(board[x]) | set(board[i][y] for i in range(9)) | set(board[i][j] for (i,j) in square(x,y)))\n def solve(p):\n for s in range(p,81):\n i,j = s//9,s%9\n if board[i][j] == \".\":\n possibilities = valid_numbers(i,j)\n if not possibilities:\n return False\n for n in possibilities:\n board[i][j] = str(n)\n if solve(s+1):\n return True\n board[i][j] = \".\"\n return False\n return True\n solve(0)\n","runtime":"384"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Solution from:\n https://leetcode.com/problems/sudoku-solver/solutions/1947604/python-easiest-recursive-solution/\n \"\"\"\n\n def isValid(row, col, ch):\n for i in range(9):\n if board[i][col] == str(ch):\n return False\n if board[row][i] == str(ch):\n return False\n if board[3*(row//3) + i//3][3*(col//3) + i%3] == str(ch):\n return False\n return True\n \n def solve(row, col):\n if row == 9:\n return True\n if col == 9:\n return solve(row+1, 0)\n if board[row][col] == \".\":\n for i in range(1, 10):\n if isValid(row, col, i):\n board[row][col] = str(i)\n if solve(row, col + 1):\n return True\n else:\n board[row][col] = \".\"\n return False\n else:\n return solve(row, col + 1)\n solve(0, 0)","runtime":"384"},{"code":"class Solution:\n def is_valid(self, board, i, j, number):\n\n cubeX, cubeY = j // 3, i // 3\n\n # First we check if the number is in the same cube\n\n for row in range(3):\n\n for col in range(3):\n\n if board[cubeY * 3 + row][cubeX * 3 + col] == number:\n return False\n\n # Secondly we will check if the number is in the same line - horitzontal and diognal\n\n for line in range(9):\n \n if (line != j and board[i][line] == number) or (line != i and board[line][j] == number):\n return False\n \n # Passed all checks then it is true\n\n return True\n \n def solve(self, board, row, col):\n for i in range(row, 9):\n\n for j in range(col, 9):\n\n if board[i][j] == \".\":\n\n for chance in range(1,10):\n chance = str(chance)\n if self.is_valid(board, i, j, chance):\n board[i][j] = chance\n if not self.solve(board, i, j):\n board[i][j] = \".\"\n \n else:\n return True\n \n return False\n \n col = 0\n\n return True\n\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n self.solve(board, 0, 0)","runtime":"390"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n if not board: return\n self.sudoku(board)\n\n def sudoku(self, board: List[List[str]]) -> bool:\n if not board: return True\n\n m = len(board)\n n = len(board[0])\n\n for i in range(m):\n for j in range(n):\n if board[i][j] == '.': # empty spot to fill\n for k in range(1, 10):\n if self.isValidToPutNum(board, k, i, j):\n board[i][j] = str(k)\n if self.sudoku(board):\n return True # trim 1: don't need to try other numbers\n board[i][j] = '.'\n return False # trim2: tried all numbers, none works\n return True\n\n def isValidToPutNum(self, board: List[List[int]], num: int, i: int, j:int) -> bool:\n for n in range(0, 9):\n if board[i][n] == str(num):\n return False\n \n for n in range(0, 9):\n if board[n][j] == str(num):\n return False\n\n cuberow = 3 * (i // 3)\n cubecol = 3 * (j // 3)\n\n for a in range(cuberow, cuberow + 3):\n for b in range(cubecol, cubecol + 3):\n if board[a][b] == str(num):\n return False\n \n return True\n","runtime":"390"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def is_valid(row, col, num):\n for i in range(0, 9):\n if board[row][i] == str(num):\n return False\n if board[i][col] == str(num):\n return False\n \n start_row = 3 * (row // 3)\n start_col = 3 * (col // 3)\n for i in range(3):\n for j in range(3):\n if board[start_row + i][start_col + j] == str(num):\n return False\n \n return True\n\n def backtrack(board):\n for row in range(len(board)):\n for col in range(len(board)):\n if board[row][col] == '.':\n for i in range(1, 10):\n if is_valid(row, col, i):\n board[row][col] = str(i)\n if backtrack(board):\n return True\n board[row][col] = '.'\n return False\n return True\n \n if backtrack(board):\n return board","runtime":"396"},{"code":"class Solution:\n def isValid(self, board,row,col,num):\n for i in range(9):\n if board[row][i] == str(num):\n return False\n for j in range(9):\n if board[j][col] == str(num):\n return False\n start_row = (row // 3) * 3\n start_col = (col // 3) * 3\n for i in range(start_row, start_row+3):\n for j in range(start_col,start_col+3):\n if board[i][j] == str(num):\n return False\n return True\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n length = len(board)\n def backtracking(board)->bool:\n for i in range(length):\n for j in range(length):\n if board[i][j] != \".\":\n continue\n else :\n for num in range(1,10):\n if self.isValid(board,i,j,num) :\n board[i][j] = str(num)\n if backtracking(board):\n return True\n board[i][j] = '.'\n return False\n return True\n backtracking(board) \n","runtime":"396"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n if board is None or len(board) == 0: return\n self.helper(board)\n\n def helper(self, board):\n for row in range(9):\n for col in range(9):\n if board[row][col] == '.':\n for i in range(1, 10):\n char = str(i)\n if self.valid(board, row, col, char):\n board[row][col] = char\n if self.helper(board): return True\n board[row][col] = '.'\n return False\n return True\n\n def valid(self, board, row, col, char):\n for i in range(9):\n if board[i][col] != '.' and board[i][col] == char: return False\n if board[row][i] != '.' and board[row][i] == char: return False\n r = 3 * (row // 3) + i // 3\n c = 3 * (col // 3) + i % 3\n if board[r][c] != '.' and board[r][c] == char: return False\n return True\n\n ","runtime":"401"},{"code":"class Solution:\n def isValid(self,board: List[List[str]], row: int, col: int, c: str) -> bool:\n for i in range(9):\n if board[i][col] == c:\n return False\n if board[row][i] == c:\n return False\n if board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c:\n return False\n return True\n def solveSudoku(self,board: List[List[str]]) -> bool:\n for i in range(len(board)):\n for j in range(len(board[0])):\n if board[i][j] == \".\":\n for c in \"123456789\":\n if self.isValid(board, i, j, c):\n board[i][j] = c\n if self.solveSudoku(board):\n return True\n else:\n board[i][j] = \".\"\n return False\n return True\n ","runtime":"401"},{"code":"class Solution:\n def isValid(self, board, row, col, num):\n # check if the number is already in the row or column\n for i in range(9):\n if board[i][col] == str(num):\n return False\n if board[row][i] == str(num):\n return False\n # check if the number is in the 3x3 box\n box_row_start = (row//3)*3\n box_row_end = box_row_start + 3\n box_col_start = (col//3)*3\n box_col_end = box_col_start + 3\n for i in range(box_row_start, box_row_end):\n for j in range(box_col_start, box_col_end):\n if board[i][j] == str(num):\n return False\n return True\n def solveSudoku(self, board: List[List[str]]) -> None:\n def solve_backtrack(board):\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n for num in range(1, 10):\n if self.isValid(board, i, j, num):\n board[i][j] = str(num)\n if solve_backtrack(board):\n return True\n else:\n board[i][j] = \".\"\n return False \n return True \n\n solve_backtrack(board)","runtime":"407"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.backtracking(board)\n\n def backtracking(self, board: List[List[str]]) -> bool:\n # 若有解，返回True；若无解，返回False\n for i in range(len(board)): # 遍历行\n for j in range(len(board[0])): # 遍历列\n # 若空格内已有数字，跳过\n if board[i][j] != '.': continue\n for k in range(1, 10):\n if self.is_valid(i, j, k, board):\n board[i][j] = str(k)\n if self.backtracking(board): return True\n board[i][j] = '.'\n # 若数字1-9都不能成功填入空格，返回False无解\n return False\n return True # 有解\n\n def is_valid(self, row: int, col: int, val: int, board: List[List[str]]) -> bool:\n # 判断同一行是否冲突\n for i in range(9):\n if board[row][i] == str(val):\n return False\n # 判断同一列是否冲突\n for j in range(9):\n if board[j][col] == str(val):\n return False\n # 判断同一九宫格是否有冲突\n start_row = (row // 3) * 3\n start_col = (col // 3) * 3\n for i in range(start_row, start_row + 3):\n for j in range(start_col, start_col + 3):\n if board[i][j] == str(val):\n return False\n return True\n ","runtime":"407"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def backtracking(board):\n for i in range(len(board)):\n for j in range(len(board[0])):\n if board[i][j] == '.':\n for k in range(1, 10):\n if isValid(i, j, k, board):\n board[i][j] = str(k)\n if backtracking(board):\n return True\n board[i][j] = '.'\n return False\n return True\n\n def isValid(row, col, k, board):\n for i in range(9):\n if board[i][col] == str(k):\n return False\n for j in range(9):\n if board[row][j] == str(k):\n return False \n startRowIdx, startColIdx = (row//3) *3, (col//3)*3\n for i in range(startRowIdx, startRowIdx+3):\n for j in range(startColIdx, startColIdx+3):\n if board[i][j] == str(k):\n return False\n return True\n\n\n \n backtracking(board)","runtime":"412"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n def checkValid(row,col,board,k):\n for i in range(0,9):\n if board[i][col] == str(k):\n if i==row:\n continue\n #print(\"Returning false \",board[i], k)\n return False\n if board[row][i]== str(k):\n if i==col:\n continue\n return False\n start_row = row//3\n start_col = col//3\n for i in range(start_row*3,start_row*3+3):\n for j in range(start_col*3, start_col*3 + 3):\n if i==row and j==col:\n continue\n if board[i][j] == str(k):\n return False\n #print(\"returning true\")\n return True\n\n def dfs(board):\n filled = 0\n for i in range(0,9):\n for j in range(0,9):\n if board[i][j] == '.':\n for k in range(1,10):\n if(checkValid(i,j,board,k)):\n \n board[i][j] = str(k)\n if(dfs(board)):\n return True\n else:\n board[i][j]= '.'\n return False\n else:\n filled += 1\n if filled == 81:\n #print(filled) \n return True\n return False\n dfs(board)\n","runtime":"412"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n ## Initialize board with nums that cannot be backtracked on\n row_set = set()\n col_set = set()\n square_set = set()\n\n for r in range(9):\n for c in range(9):\n if board[r][c] != \".\":\n num = board[r][c]\n row_set.add((r,num))\n col_set.add((c,num))\n square_set.add((r//3,c//3,num))\n \n def is_valid(r,c,num):\n if (r,num) in row_set or (c,num) in col_set or (r//3, c//3, num) in square_set:\n return False\n else:\n row_set.add((r,num))\n col_set.add((c,num))\n square_set.add((r//3,c//3,num))\n return True\n \n def remove(r,c,num):\n row_set.remove((r,num))\n col_set.remove((c,num))\n square_set.remove((r//3,c//3,num))\n\n def solve(r,c):\n if r == 9:\n return True\n if c == 9:\n return solve(r+1, 0)\n \n if board[r][c] != \".\":\n return solve(r, c+1)\n \n for num in range(1,10):\n print(board[0])\n num = str(num)\n if is_valid(r,c,num):\n board[r][c] = num\n if solve(r, c+1):\n return True\n board[r][c] = \".\"\n remove(r,c,num)\n\n\n return solve(0,0)","runtime":"418"},{"code":"from collections import defaultdict\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n def is_valid(row: int, col: int, val: int, board: List[List[str]]) -> bool:\n # 判断同一行是否冲突\n for i in range(9):\n if board[row][i] == str(val):\n return False\n # 判断同一列是否冲突\n for j in range(9):\n if board[j][col] == str(val):\n return False\n # 判断同一九宫格是否有冲突\n start_row = (row // 3) * 3\n start_col = (col // 3) * 3\n for i in range(start_row, start_row + 3):\n for j in range(start_col, start_col + 3):\n if board[i][j] == str(val):\n return False\n return True\n \n def backtracking(board):\n for i in range(9):\n for j in range(9):\n cur_num = board[i][j]\n if cur_num != \".\":\n continue\n for k in range(1, 10):\n if is_valid(i,j,k, board):\n board[i][j] = str(k)\n if backtracking(board): return True\n board[i][j] = \".\"\n return False\n return True\n\n backtracking(board)\n\n \n\n\n ","runtime":"418"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n n = len(board)\n \n def backtracking(board):\n for i in range(n):\n for j in range(n):\n if board[i][j] != '.': continue\n for v in range(1, 10):\n if isValid(i, j, v, board):\n board[i][j] = str(v)\n if backtracking(board): return True\n board[i][j] = '.'\n return False\n return True\n \n def isValid(x, y, v, board):\n for i in range(n):\n if board[x][i] == str(v): return False\n for i in range(n):\n if board[i][y] == str(v): return False\n r = (x // 3) * 3\n c = (y // 3) * 3\n for i in range(r, r + 3):\n for j in range(c, c + 3):\n if board[i][j] == str(v): return False\n return True\n \n backtracking(board)","runtime":"423"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def backtracking(board):\n for i in range(len(board)):\n for j in range(len(board[0])):\n if board[i][j] == '.':\n for k in range(1, 10):\n if isValid(i, j, k, board):\n board[i][j] = str(k)\n if backtracking(board):\n return True\n board[i][j] = '.'\n return False\n return True\n\n def isValid(row, col, k, board):\n for i in range(9):\n if board[i][col] == str(k):\n return False\n for j in range(9):\n if board[row][j] == str(k):\n return False \n startRowIdx, startColIdx = (row//3) *3, (col//3)*3\n for i in range(startRowIdx, startRowIdx+3):\n for j in range(startColIdx, startColIdx+3):\n if board[i][j] == str(k):\n return False\n return True\n\n\n \n backtracking(board)","runtime":"423"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n rows,cols=len(board),len(board[0])\n self.result=[]\n self.board=board\n self.backtracking(rows)\n # return self.result[0]\n \n def backtracking(self,n):\n for i in range(n): #rows\n for j in range(n): #cols\n if self.board[i][j]=='.' :\n for num in range(1,10):\n if self.isValid(j,i,n,num):\n self.board[i][j]=str(num)\n if self.backtracking(n): return True\n self.board[i][j]='.'\n return False\n return True\n \n def isValid(self,currentcol,currentrow,n,num):\n for i in range(9):\n if str(num)==self.board[i][currentcol]:\n return False\n for i in range(9):\n if str(num)==self.board[currentrow][i]:\n return False\n \n startrow=(currentrow//3)*3\n startcol=(currentcol//3)*3\n\n for i in range(startrow,startrow+3):\n for j in range(startcol,startcol+3):\n if str(num)==self.board[i][j]:\n return False\n \n return True\n\n\n\n","runtime":"429"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def valid(row, col, num):\n for i in range(9):\n if board[i][col] == str(num):\n return False\n for i in range(9):\n if board[row][i] == str(num):\n return False\n sr, sc = row // 3 * 3, col // 3 * 3\n for i in range(sr, sr+3):\n for j in range(sc, sc+3):\n if board[i][j] == str(num):\n return False\n return True\n \n def backtrack(board):\n for i in range(len(board)):\n for j in range(len(board[0])):\n if board[i][j] != '.': \n continue\n for k in range(1, 10):\n if valid(i, j, k):\n board[i][j] = str(k)\n if backtrack(board):\n return True\n board[i][j] = '.'\n return False\n return True\n\n backtrack(board)","runtime":"429"},{"code":"from random import choice, random\n\nimport numpy as np\n\n\n# Setup masks for each tile\ntarget_set = set([str(s) for s in range(1, 10)])\n\nmasks = np.zeros((9, 9, 9, 9), dtype=bool)\nfor i in range(9):\n for j in range(9):\n masks[i, j, i, :] = True\n masks[i, j, :, j] = True\n\n # All members in same box\n iboxx = 3 * (i // 3)\n iboxy = 3 * (j // 3)\n masks[i, j, iboxx:iboxx + 3,iboxy:iboxy + 3] = True\n\n masks[i, j, i, j] = False\n\n\ndef do_exclusion(board_np: np.array):\n '''\n Try to solve sudoku board by exclusion:\n Check if any of the squares has to be a specific digit.\n '''\n for i in range(16):\n if not np.isin(\".\", board_np):\n print(\"Finished board!\")\n return True\n\n found_exclusion = False\n\n for irow in range(9):\n for icol in range(9):\n if board_np[irow, icol] != \".\":\n continue\n\n digits = np.unique(board_np[masks[irow, icol]])\n remaining = target_set.difference(set(digits))\n\n num_remaining = len(remaining)\n if num_remaining == 0:\n return False # Due to heuristics we could encounter invalid --> End immediately\n \n elif len(remaining) == 1:\n found_exclusion = True\n board_np[irow, icol] = list(remaining)[0]\n\n if not found_exclusion:\n return False\n \n raise Exception(\"INCREASE DEPTH\")\n return False\n\n\ndef get_heuristic_candidates(board_np: np.array):\n '''\n Produce a list of candidates for heuristics to check.\n Sorted by their probability.\n '''\n\n candidates = []\n\n for irow in range(9):\n for icol in range(9):\n if board_np[irow, icol] != \".\":\n continue\n mask = masks[irow, icol]\n\n digits = np.unique(board_np[mask])\n possible = target_set.difference(set(digits))\n\n candidates.append((list(possible), (irow, icol)))\n\n candidates.sort(key=lambda x: len(x[0]))\n\n return candidates\n\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n board_np = np.array(board)\n\n success = do_exclusion(board_np)\n\n if success:\n print(\"Found using initial exclusion!\")\n for x in range(9):\n board[x] = board_np[x].tolist()\n return\n\n # Now we start brute-force heuristics\n candidates = get_heuristic_candidates(board_np)\n\n count = 0\n\n for digits, (x, y) in candidates:\n for digit in digits:\n count += 1\n board_copy = board_np.copy()\n board_copy[x, y] = digit\n\n success = do_exclusion(board_copy)\n\n if success:\n print(f\"Found using brute-force in {count} tries!\")\n for x in range(9):\n board[x] = board_copy[x].tolist()\n return\n\n\n ","runtime":"434"},{"code":"class Solution(object):\n def solveSudoku(self, board):\n \n \"\"\"\n Solves the Sudoku puzzle by modifying the board in-place.\n :type board: List[List[str]]\n :rtype: None\n \"\"\"\n def isvalid(row, col, k):\n k = str(k)\n for i in range(9):\n if board[row][i] == k:\n return False\n for i in range(9):\n if board[i][col] == k:\n return False\n curRow = row//3\n curCol = col//3\n\n for i in range(9):\n for j in range(9):\n if i //3 == curRow and j //3 == curCol and board[i][j] == k:\n return False\n return True\n \n def backtrack():\n\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n for k in range(1, 10):\n if isvalid(i, j, k):\n board[i][j] = str(k)\n\n if backtrack():\n return True\n \n board[i][j] = \".\"\n return False\n return True\n \n backtrack()\n","runtime":"434"},{"code":"import threading\nfrom concurrent.futures import ThreadPoolExecutor, as_completed\nfrom typing import List\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def solve(local_board: List[List[str]]) -> List[List[str]]:\n for i in range(len(local_board)):\n for j in range(len(local_board[0])):\n if local_board[i][j] == '.':\n for num in range(1, 10):\n c = str(num)\n if isValid(local_board, i, j, c):\n local_board[i][j] = c\n if solve(local_board):\n return local_board\n local_board[i][j] = '.'\n return None\n return local_board\n\n def isValid(board, row, col, c):\n for i in range(9):\n if board[row][i] == c:\n return False \n if board[i][col] == c:\n return False\n if board[3*(row//3) + i//3][3*(col//3)+i%3] == c:\n return False\n return True\n\n def solve_with_starting_point(start_row, start_col, num):\n local_board = [row[:] for row in board]\n if isValid(local_board, start_row, start_col, str(num)):\n local_board[start_row][start_col] = str(num)\n result = solve(local_board)\n if result:\n return result\n return None\n\n # Find the first empty cell\n start_row, start_col = next((i, j) for i in range(9) for j in range(9) if board[i][j] == '.')\n\n # Create a thread pool\n with ThreadPoolExecutor(max_workers=9) as executor:\n # Submit tasks for each possible starting number\n futures = [executor.submit(solve_with_starting_point, start_row, start_col, num) for num in range(1, 10)]\n\n # Wait for the first successful result\n for future in as_completed(futures):\n result = future.result()\n if result:\n # Copy the solution back to the original board\n for i in range(9):\n for j in range(9):\n board[i][j] = result[i][j]\n return\n\n # If no solution found\n raise ValueError(\"No solution exists\")","runtime":"440"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def find_empty_location():\n for i in range(9):\n for j in range(9):\n if(board[i][j] == '.'):\n return [i, j]\n return [-1, -1]\n def is_valid(row, col, num):\n # check direct duplicates\n for i in range(9):\n if(board[i][col] == str(num)):\n return False\n for j in range(9):\n if(board[row][j] == str(num)):\n return False\n x, y = int(row / 3), int(col / 3)\n for i in range(3 * x, 3 * x + 3):\n for j in range(3 * y, 3 * y + 3):\n if(board[i][j] == str(num)):\n return False\n return True\n \n row, col = find_empty_location()\n if(row == -1 and col == -1):\n return True\n\n for num in range(1, 10):\n if(is_valid(row, col, num)):\n board[row][col] = str(num)\n if(Solution.solveSudoku(self, board)):\n return True\n board[row][col] = '.'\n \n return False\n \n\n ","runtime":"440"},{"code":"class Solution:\n def solve(self,board):\n for i in range(len(board)):\n for j in range(len(board[0])):\n if(board[i][j]=='.'):\n for c in range(1,10):\n if(self.valid(board,i,j,c)):\n board[i][j]=str(c)\n if(self.solve(board)==True):\n return True\n else:\n board[i][j]='.'\n return False\n\n return True\n def valid(self,board,row,col,c):\n for i in range(9):\n if(board[row][i]==str(c)):\n return False\n if(board[i][col]==str(c)):\n return False\n if(board[3*(row//3)+(i//3)][3*(col//3)+(i%3)]==str(c)):\n return False\n return True\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.solve(board)","runtime":"446"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def validPlacement(i, j, val):\n # returns true if placing val at i,j is valid\n baseI, baseJ = 3 * (i // 3), 3 * (j // 3)\n square = []\n for m in range(baseI, baseI + 3):\n for n in range(baseJ, baseJ + 3):\n if board[m][n] == val:\n return False\n valInRow = val in board[i]\n valInCol = val in [board[x][j] for x in range(len(board))]\n return not valInRow and not valInCol\n\n nums = [str(i) for i in range(1, 10)]\n def dfs():\n for m in range(9):\n for n in range(9):\n if board[m][n] == '.': # only test if it's possible to fill this square\n for test in nums:\n if validPlacement(m, n, test):\n board[m][n] = test\n if dfs():\n return True\n board[m][n] = '.'\n return False\n return True # base case: only return True if no '.' characters were found this call, meaning the board is solved.\n \n for i in range(9):\n for j in range(9):\n if dfs():\n return\n print('oops')\n \n\n\n \n\n \n","runtime":"446"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n def isValid(board, row, col, num):\n for i in range(9):\n if board[row][i] == str(num):\n return False\n if board[i][col] == str(num):\n return False\n if board[3 * (row//3) +i//3][3 * (col//3) + i%3] == str(num):\n return False\n return True\n\n def tryAndPlace(board):\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n for num in range(1,10):\n if isValid(board, i, j, num):\n board[i][j] = str(num)\n if tryAndPlace(board):\n return True\n\n board[i][j] = \".\"\n\n return False\n\n return True\n\n tryAndPlace(board)\n \n\n \n\n \n ","runtime":"451"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n N = len(board)\n UNIT = N // 3\n\n\n def validate(r: int, c: int, target: str) -> bool:\n if any(board[r][j] == target for j in range(9)):\n return False\n if any(board[i][c] == target for i in range(9)):\n return False\n \n x, y = (r // 3) * 3, (c // 3) * 3\n if any(board[i][j] == target \n for i in range(x, x + 3) \n for j in range(y, y + 3)):\n return False\n return True\n \n\n\n\n def backtrace(r: int, c: int) -> bool:\n if r >= 9:\n return True\n if c >= 9:\n return backtrace(r + 1, 0)\n if board[r][c] != '.':\n return backtrace(r, c + 1)\n\n for char in '123456789':\n if not validate(r, c, char):\n continue\n \n board[r][c] = char\n if backtrace(r, c + 1):\n return True\n board[r][c] = '.'\n return False\n\n backtrace(0, 0)\n\n","runtime":"451"},{"code":"class Solution:\n\n def isValid(self, i, j, n, board):\n for k in range(9):\n if board[i][k] == str(n):\n return False\n if board[k][j] == str(n):\n return False\n if board[3 * (i//3) + k//3][3 * (j//3) + k % 3] == str(n):\n return False\n return True\n\n def solve(self, board):\n for i in range(len(board)):\n for j in range(len(board)):\n if board[i][j] == \".\":\n for n in range(1, 10):\n if self.isValid(i, j, n, board):\n board[i][j] = str(n)\n if self.solve(board):\n return True\n board[i][j] = \".\"\n\n return False\n return True\n\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.solve(board)","runtime":"457"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # Backtracking\n # Try 1 through 9 for each cell. The time complexity should be 9 ^ m \n # (m represents the number of blanks to be filled in), since each blank can have 9 choices.\n\n if len(board) == 0: return\n self.solve(board)\n\n def solve(self, board):\n for i in range(len(board)):\n for j in range(len(board[0])):\n if board[i][j] == '.':\n for c in range(1, 10):\n ch = str(c)\n if self.is_valid(board, i, j, ch):\n board[i][j] = ch\n if self.solve(board):\n return True\n else:\n board[i][j] = '.'\n return False\n return True\n \n def is_valid(self, board, row, col, c):\n for i in range(9):\n if board[i][col] != '.' and board[i][col] == c: return False\n if board[row][i] != '.' and board[row][i] == c: return False\n if board[3*(row//3)+i//3][3*(col//3)+i%3] != '.' and board[3*(row//3)+i//3][3*(col//3)+i%3] == c: return False\n \n return True\n","runtime":"457"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n \n\n def isValidBoard(board,row,col,val):\n\n for i in range(9):\n\n if board[row][i] == str(val):\n return False\n \n if board[i][col] == str(val):\n return False\n \n if board[3*(row//3)+i//3][3*(col//3)+i%3] == str(val):\n return False\n return True\n\n def solve(board):\n\n for i in range(9):\n for j in range(9):\n\n if board[i][j]=='.':\n\n for c in range(1,10):\n\n if isValidBoard(board,i,j,c):\n board[i][j] = str(c)\n if solve(board):\n return True\n else:\n board[i][j] = \".\"\n return False\n return True\n solve(board)\n ","runtime":"462"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def solve(board):\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n for c in range(1, 10):\n if isValid(i, j, c):\n board[i][j] = str(c)\n if solve(board):\n return True\n board[i][j] = \".\"\n return False\n return True\n\n def isValid(row, col, c):\n for i in range(9):\n if board[i][col] == str(c):\n return False\n if board[row][i] == str(c):\n return False\n if board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == str(c):\n return False\n return True\n\n solve(board)\n ","runtime":"462"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isValid(board,r,c,l):\n for i in range(9):\n if board[i][c]==str(l):\n return False\n elif board[r][i]==str(l):\n return False\n elif board[(3*(r//3))+i//3][(3*(c//3))+i%3]==str(l):\n return False\n return True\n def solve(board):\n for r in range(9):\n for c in range(9):\n if board[r][c]=='.':\n for l in range(1,10):\n if isValid(board,r,c,l):\n board[r][c]=str(l)\n if solve(board):\n return True\n else:\n board[r][c]='.'\n return False\n return True\n solve(board)\n return board\n","runtime":"468"},{"code":"class Solution:\n def is_valid(self, board, row, col, digit):\n for i in range(9):\n if board[row][i] == str(digit): return False\n\n if board[i][col] == str(digit): return False\n\n if board[3*(row//3)+(i//3)][3*(col//3)+(i%3)] == str(digit): return False\n return True\n\n def solve(self, board):\n for row in range(len(board)):\n for col in range(len(board[0])):\n if board[row][col] == '.':\n for digit in range(1, 10):\n if self.is_valid(board, row, col, digit):\n board[row][col] = str(digit)\n if self.solve(board): return True\n else:\n board[row][col] = '.'\n return False\n return True\n\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.solve(board)\n ","runtime":"468"}],"string":"[\n {\n \"code\": \"class Solution:\\n# def solveSudoku(self, board: List[List[str]]) -> None:\\n def solveSudoku(self, board):\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # store possible values\\n sets = [set(range(1,10)) for _ in range(81)]\\n\\n candidates = []\\n \\n\\n for i, row in enumerate(board):\\n for j, square in enumerate(row):\\n if square != \\\".\\\":\\n\\n n = int(square)\\n sets[9*i+j] = set([n])\\n\\n candidates.append((i,j))\\n\\n\\n\\n self.solve(sets, candidates)\\n\\n for i in range(9):\\n for j in range(9):\\n [n] = sets[9*i+j]\\n board[i][j] = str(n)\\n\\n # print(\\\"DONE\\\")\\n \\n def solve(self, sets, candidates):\\n if not self.reduceSets(sets, candidates):\\n return False\\n \\n # pick a set with more than 1 to branch\\n minLen = 10 # needs to be >9\\n minIdx =-1\\n for idx, s in enumerate(sets):\\n if len(s) >1 and len(s)<minLen:\\n minLen = len(s)\\n minIdx = idx\\n \\n if minIdx == -1:\\n return True\\n\\n i,j = minIdx//9, minIdx%9\\n # print(f\\\"branching on {i},{j} {sets[minIdx]}\\\")\\n for possibleN in sets[minIdx]:\\n # print(f\\\"{i},{j} trying {possibleN}\\\")\\n setsCopy= [s.copy() for s in sets]\\n setsCopy[minIdx] = set([possibleN])\\n if self.solve(setsCopy, [(i,j)]):\\n # no contradiction\\n # manually replace sets to pass result up recursion stack\\n for i in range(81):\\n sets[i] = setsCopy[i]\\n return True\\n # else:\\n # print(f\\\"{i},{j} trying {possibleN} failed\\\")\\n return False\\n\\n\\n \\n def reduceSets(self, sets, candidates): \\n def remove(i,j,n):\\n s = sets[9*i+j]\\n\\n if n in s:\\n s.remove(n)\\n if len(s) == 0:\\n return False\\n elif len(s) ==1:\\n candidates.append((i, j))\\n return True\\n\\n \\n while len(candidates) > 0:\\n i,j = candidates.pop()\\n\\n # self.printSudoku(sets)\\n # print(\\\"candidate\\\", i, j)\\n\\n [n] = sets[9*i+j]\\n \\n # reduce sets\\n for other in range(9):\\n # row\\n if other != i:\\n # print(f\\\"removing {n} from row {other},{j}\\\")\\n if not remove(other, j, n):\\n return False\\n \\n # column\\n if other != j:\\n # print(f\\\"removing {n} from col {i},{other}\\\")\\n if not remove(i, other, n):\\n return False\\n\\n \\n # square\\n \\n y = (i//3)*3 + other % 3\\n x = (j//3)*3 + other // 3\\n if y!=i or x!=j:\\n # print(f\\\"removing {n} from square {y},{x}\\\")\\n if not remove(y,x,n):\\n return False\\n\\n # print(\\\"DONE\\\")\\n # self.printSudoku(sets)\\n return True\\n \\n\\n \\n\\n \\n\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class SudokuSolver:\\n def __init__(self, board):\\n self._complete_domain = \\\"123456789\\\"\\n self._width = 9\\n self._cells = [[self._complete_domain if v == '.' else v for v in row] for row in board]\\n self.board = board\\n\\n def is_solved(self):\\n for i in range(self._width):\\n for j in range(self._width):\\n if len(self._cells[i][j]) != 1 or not self.is_value_consistent(self._cells[i][j], i, j):\\n return False\\n return True\\n\\n def is_value_consistent(self, value, row, column):\\n cells = self._cells\\n width = self._width\\n\\n # Check row consistency\\n for j in range(width):\\n if j != column and cells[row][j] == value:\\n return False\\n\\n # Check column consistency\\n for i in range(width):\\n if i != row and cells[i][column] == value:\\n return False\\n\\n # Check 3x3 unit consistency\\n row_init = (row // 3) * 3\\n col_init = (column // 3) * 3\\n for i in range(row_init, row_init + 3):\\n for j in range(col_init, col_init + 3):\\n if (i != row or j != column) and cells[i][j] == value:\\n return False\\n\\n return True\\n\\n def select_variable(self):\\n min_domain_size = 10 # Start with a number larger than any possible domain size (which is 9)\\n selected_cell = None\\n cells = self._cells\\n\\n for i in range(self._width):\\n for j in range(self._width):\\n domain_size = len(cells[i][j])\\n if 1 < domain_size < min_domain_size: # Skip cells that are already solved (domain size 1)\\n min_domain_size = domain_size\\n selected_cell = (i, j)\\n if min_domain_size == 2: # Early exit if the minimum possible domain size is found\\n return selected_cell\\n\\n return selected_cell\\n\\n def remove_domain_row(self, row, column):\\n value = self._cells[row][column]\\n row_cells = self._cells[row]\\n variables_assigned = []\\n\\n for j in range(self._width):\\n if j != column and len(row_cells[j]) > 1:\\n if value in row_cells[j]:\\n new_domain = row_cells[j].replace(value, '')\\n row_cells[j] = new_domain\\n if len(new_domain) == 0:\\n return None, True # Early exit if the domain is empty\\n if len(new_domain) == 1:\\n variables_assigned.append((row, j))\\n\\n return variables_assigned, False\\n\\n def remove_domain_column(self, row, column):\\n value = self._cells[row][column]\\n variables_assigned = []\\n\\n for i in range(self._width):\\n if i != row and len(self._cells[i][column]) > 1:\\n if value in self._cells[i][column]:\\n new_domain = self._cells[i][column].replace(value, '')\\n self._cells[i][column] = new_domain\\n if len(new_domain) == 0:\\n return None, True\\n if len(new_domain) == 1:\\n variables_assigned.append((i, column))\\n\\n return variables_assigned, False\\n\\n def remove_domain_unit(self, row, column):\\n value = self._cells[row][column]\\n row_init, col_init = (row // 3) * 3, (column // 3) * 3\\n variables_assigned = []\\n\\n for i in range(row_init, row_init + 3):\\n for j in range(col_init, col_init + 3):\\n if (i != row or j != column) and len(self._cells[i][j]) > 1:\\n if value in self._cells[i][j]:\\n new_domain = self._cells[i][j].replace(value, '')\\n self._cells[i][j] = new_domain\\n if len(new_domain) == 0:\\n return None, True\\n if len(new_domain) == 1:\\n variables_assigned.append((i, j))\\n\\n return variables_assigned, False\\n\\n\\n def pre_process_consistency(self):\\n Q = [(i, j) for i in range(self._width) for j in range(self._width) if len(self._cells[i][j]) == 1]\\n self.consistency(Q)\\n\\n def consistency(self, Q):\\n while Q:\\n row, col = Q.pop()\\n value = self._cells[row][col]\\n\\n for method in [self.remove_domain_row, self.remove_domain_column, self.remove_domain_unit]:\\n variables_assigned, conflict = method(row, col)\\n if conflict:\\n return True\\n Q.extend(variables_assigned)\\n\\n return False\\n\\n def search(self):\\n if self.is_solved():\\n return self\\n\\n domain = self.select_variable()\\n if not domain:\\n return None\\n\\n row, col = domain\\n original = self._cells[row][col]\\n for value in original:\\n backup = [row[:] for row in self._cells] # Backup grid state\\n self._cells[row][col] = value\\n\\n if not self.consistency([(row, col)]):\\n result = self.search()\\n if result is not None:\\n return result\\n\\n self._cells = backup # Revert to backup if search fails\\n\\n return None\\n\\n def solve(self):\\n self.pre_process_consistency()\\n solution = self.search()\\n if solution:\\n self.update_board()\\n\\n def update_board(self):\\n for i in range(9):\\n for j in range(9):\\n self.board[i][j] = self._cells[i][j][0] # Take the first character which is the solved value\\n\\nclass Solution:\\n def solveSudoku(self, board: list[list[str]]) -> None:\\n solver = SudokuSolver(board)\\n solver.solve()\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"from dataclasses import dataclass\\nfrom typing import List, Set, Tuple, Optional\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # First initialize our solve state\\n row_sets, col_sets, box_sets = init_group_sets(board)\\n\\n board_candidates, is_finalized = init_board_candidates(board, row_sets, col_sets, box_sets)\\n\\n state = SolveState(board_candidates, is_finalized)\\n # Solve\\n solved_state = solve(state)\\n\\n # Finally copy everything over to the original board and return.\\n for row in range(9):\\n for col in range(9):\\n assert solved_state.is_finalized[row][col]\\n assert len(solved_state.board_candidates[row][col]) == 1\\n if board[row][col] == \\\".\\\":\\n entry = next(iter(solved_state.board_candidates[row][col]))\\n board[row][col] = entry\\n\\n@dataclass\\nclass SolveState:\\n board_candidates: List[List[Set[str]]]\\n is_finalized: List[List[bool]]\\n\\n def clone(self):\\n board_candidates = [ [ set(cand_set) for cand_set in row] for row in self.board_candidates ]\\n is_finalized = [ [ fn for fn in row] for row in self.is_finalized ]\\n return SolveState(board_candidates, is_finalized)\\n\\n\\ndef get_box_idx(row: int, col: int) -> int:\\n return 3 * (row // 3) + col // 3\\n\\ndef init_group_sets(board: List[List[str]]):\\n row_sets = [set() for i in range(9)]\\n col_sets = [set() for i in range(9)]\\n box_sets = [set() for i in range(9)]\\n for row in range(9):\\n for col in range(9):\\n cur_cell = board[row][col]\\n if cur_cell == \\\".\\\":\\n continue\\n for group_set in [ row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)]]:\\n if cur_cell in group_set:\\n raise Exception(\\\"Invalid initial board\\\")\\n group_set.add(cur_cell)\\n\\n return row_sets, col_sets, box_sets\\n\\ndef init_board_candidates(board, row_sets, col_sets, box_sets):\\n board_candidates = [ [None for col in range(9)] for row in range(9)]\\n is_finalized = [ [False for col in range(9)] for row in range(9)]\\n\\n for row in range(9):\\n for col in range(9):\\n # Simple case: board has this already defined.\\n cur_entry = board[row][col]\\n if cur_entry != \\\".\\\":\\n board_candidates[row][col] = { cur_entry }\\n is_finalized[row][col] = True\\n else:\\n board_candidates[row][col] = get_candidates([\\n row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)] ])\\n is_finalized[row][col] = False # Set to false even if there's only one candidate.\\n \\n return board_candidates, is_finalized\\n\\ndef get_candidates(cand_sets: List[Set[str]]):\\n candidates = set(map(str, range(1, 10)))\\n for cand_set in cand_sets:\\n candidates = candidates - cand_set\\n return candidates\\n\\ndef solve(state: SolveState) -> Optional[SolveState]:\\n debug = False\\n # Level 2 solve algorithm: \\n # apply the winnow algorithm to remove deterministic candidates. \\n # then, select the cell with the smallest number of remaining candidates.\\n # Guess one of the candidates, then re-apply the solve algorithm. If the\\n # guess is correct, the solve algorithm will find a correct solution and return it.\\n # Return that solution up the chain.\\n # If the guess is incorrect, change your guess and repeat until you find the correct\\n # value.\\n is_valid, return_code = winnow(state)\\n if debug:\\n print(\\\"winnow return: \\\", return_code)\\n print_board(state)\\n if not is_valid:\\n return None\\n\\n # Find the cell with the smallest number of candidates, unless this board is finalized.\\n min_candidate_cell = None\\n min_candidates = float('inf')\\n is_finalized = True\\n for row in range(9):\\n for col in range(9):\\n if state.is_finalized[row][col]:\\n assert len(state.board_candidates[row][col]) == 1\\n else:\\n is_finalized = False\\n if len(state.board_candidates[row][col]) < min_candidates:\\n min_candidates = len(state.board_candidates[row][col])\\n min_candidate_cell = (row, col)\\n\\n # If we've finalized this board, return immediately\\n if is_finalized:\\n return state\\n \\n # Else there must have been some min_candidate_cell.\\n assert min_candidate_cell != None\\n min_cand_row, min_cand_col = min_candidate_cell\\n\\n for candidate_val in state.board_candidates[min_cand_row][min_cand_col]:\\n # Duplicate the solve state and re-apply the winnow algorithm.\\n guess_state = state.clone()\\n guess_state.board_candidates[min_cand_row][min_cand_col] = { candidate_val }\\n maybe_solved_state = solve(guess_state)\\n if maybe_solved_state:\\n return maybe_solved_state\\n\\n # If we reach this state the board is invalid\\n return None\\n\\ndef winnow(state: SolveState) -> Tuple[bool, int]:\\n # Simple solve algorithm:\\n # Loop over the board and collect all non-finalized cells that have only\\n # one candidate. Store them in a queue. \\n # While the queue is not empty, pop an entry off, finalize it, and \\n # remove it as a candidate for all squares in the same row, column, and box.\\n # When removing, if any corresponding non-finalized cell has only one remaining\\n # entry, add it to the queue. \\n # Once the queue is empty, check if everything is finalized. If not we'll need\\n # to make some guesses... just throw for now and we can revisit.\\n # Return True if the board remains in a valid state after winnowing, otherwise\\n # return False. If this returns False, the winnowing process ends and the board\\n # will be in an inconsistent state.\\n single_candidate_cells = []\\n for r in range(9):\\n for c in range(9):\\n if not state.is_finalized[r][c] and len(state.board_candidates[r][c]) == 1:\\n single_candidate_cells.append((r, c))\\n\\n while len(single_candidate_cells) > 0:\\n cur_row, cur_col = single_candidate_cells.pop()\\n assert len(state.board_candidates[cur_row][cur_col]) == 1\\n cur_val = next(iter(state.board_candidates[cur_row][cur_col]))\\n\\n state.is_finalized[cur_row][cur_col] = True\\n\\n # Remove cur_val as a candidate everywhere.\\n # Remove from everything in this row\\n for col in range(9):\\n if state.is_finalized[cur_row][col]:\\n continue\\n if not maybe_remove_candidate_and_enqueue(cur_val, cur_row, col, state, single_candidate_cells):\\n return False, 1\\n \\n # Remove from everything in this col\\n for row in range(9):\\n if state.is_finalized[row][cur_col]:\\n continue\\n if not maybe_remove_candidate_and_enqueue(cur_val, row, cur_col, state, single_candidate_cells):\\n return False, 2\\n\\n # Remove from everything in this box\\n for row, col in get_box_coords(cur_row, cur_col):\\n if state.is_finalized[row][col]:\\n continue\\n if not maybe_remove_candidate_and_enqueue(cur_val, row, col, state, single_candidate_cells):\\n return False, 3\\n\\n return True, 4\\n\\n\\ndef maybe_remove_candidate_and_enqueue(cur_val: str, row: int, col: int, \\n state: SolveState, single_candidate_cells: List[Tuple[int, int]]) -> bool:\\n '''\\n Remove the current value from the candidates for the given cell, and append this cell to the single_candidates\\n list if removing this value reduces the number of candidates to one.\\n If removing this value reduces the number of candidates to zero, return False, as this means we've entered\\n an invalid board state. Otherwise return True\\n '''\\n cur_candidates = state.board_candidates[row][col]\\n if cur_val in cur_candidates:\\n cur_candidates.remove(cur_val)\\n if len(cur_candidates) == 1:\\n single_candidate_cells.append((row, col))\\n elif len(cur_candidates) == 0:\\n return False\\n return True\\n\\ndef get_box_coords(row: int, col: int):\\n base_row = 3 * (row // 3) # 0, 3, 6\\n base_col = 3 * (col // 3) # 0, 3, 6\\n for r in range(base_row, base_row+3):\\n for c in range(base_col, base_col+3):\\n yield r, c\\n\\ndef print_n_candidates(board_candidate: List[List[Set[str]]]):\\n for row in board_candidate:\\n for candidates in row:\\n print(len(candidates), end=\\\", \\\")\\n print()\\n\\ndef print_board(state: SolveState):\\n for row in range(9):\\n for col in range(9):\\n if state.is_finalized[row][col]:\\n cur_val = next(iter(state.board_candidates[row][col]))\\n disp = \\\" \\\" + cur_val\\n else:\\n n_cand = len(state.board_candidates[row][col])\\n disp = f\\\"n{n_cand}\\\"\\n \\n print(disp, end=\\\", \\\")\\n print()\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board):\\n rows, cols, triples, visit = collections.defaultdict(set), collections.defaultdict(set), collections.defaultdict(set), collections.deque([])\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] != \\\".\\\":\\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n triples[(r // 3, c // 3)].add(board[r][c])\\n else:\\n visit.append((r, c))\\n def dfs():\\n if not visit:\\n return True\\n r, c = visit[0]\\n t = (r // 3, c // 3)\\n for dig in {\\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\", \\\"5\\\", \\\"6\\\", \\\"7\\\", \\\"8\\\", \\\"9\\\"}:\\n if dig not in rows[r] and dig not in cols[c] and dig not in triples[t]:\\n board[r][c] = dig\\n rows[r].add(dig)\\n cols[c].add(dig)\\n triples[t].add(dig)\\n visit.popleft()\\n if dfs():\\n return True\\n else:\\n board[r][c] = \\\".\\\"\\n rows[r].discard(dig)\\n cols[c].discard(dig)\\n triples[t].discard(dig)\\n visit.appendleft((r, c))\\n return False\\n dfs()\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"from dataclasses import dataclass\\nfrom typing import List, Set, Tuple, Optional\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # First initialize our solve state\\n row_sets, col_sets, box_sets = init_group_sets(board)\\n\\n board_candidates, is_finalized = init_board_candidates(board, row_sets, col_sets, box_sets)\\n\\n state = SolveState(board_candidates, is_finalized)\\n # Solve\\n solved_state = solve(state)\\n\\n # Finally copy everything over to the original board and return.\\n for row in range(9):\\n for col in range(9):\\n assert solved_state.is_finalized[row][col]\\n assert len(solved_state.board_candidates[row][col]) == 1\\n if board[row][col] == \\\".\\\":\\n entry = next(iter(solved_state.board_candidates[row][col]))\\n board[row][col] = entry\\n\\n@dataclass\\nclass SolveState:\\n board_candidates: List[List[Set[str]]]\\n is_finalized: List[List[bool]]\\n\\n def clone(self):\\n board_candidates = [ [ set(cand_set) for cand_set in row] for row in self.board_candidates ]\\n is_finalized = [ [ fn for fn in row] for row in self.is_finalized ]\\n return SolveState(board_candidates, is_finalized)\\n\\n\\ndef get_box_idx(row: int, col: int) -> int:\\n return 3 * (row // 3) + col // 3\\n\\ndef init_group_sets(board: List[List[str]]):\\n row_sets = [set() for i in range(9)]\\n col_sets = [set() for i in range(9)]\\n box_sets = [set() for i in range(9)]\\n for row in range(9):\\n for col in range(9):\\n cur_cell = board[row][col]\\n if cur_cell == \\\".\\\":\\n continue\\n for group_set in [ row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)]]:\\n if cur_cell in group_set:\\n raise Exception(\\\"Invalid initial board\\\")\\n group_set.add(cur_cell)\\n\\n return row_sets, col_sets, box_sets\\n\\ndef init_board_candidates(board, row_sets, col_sets, box_sets):\\n board_candidates = [ [None for col in range(9)] for row in range(9)]\\n is_finalized = [ [False for col in range(9)] for row in range(9)]\\n\\n for row in range(9):\\n for col in range(9):\\n # Simple case: board has this already defined.\\n cur_entry = board[row][col]\\n if cur_entry != \\\".\\\":\\n board_candidates[row][col] = { cur_entry }\\n is_finalized[row][col] = True\\n else:\\n board_candidates[row][col] = get_candidates([\\n row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)] ])\\n is_finalized[row][col] = False # Set to false even if there's only one candidate.\\n \\n return board_candidates, is_finalized\\n\\ndef get_candidates(cand_sets: List[Set[str]]):\\n candidates = set(map(str, range(1, 10)))\\n for cand_set in cand_sets:\\n candidates = candidates - cand_set\\n return candidates\\n\\ndef solve(state: SolveState) -> Optional[SolveState]:\\n debug = False\\n # Level 2 solve algorithm: \\n # apply the winnow algorithm to remove deterministic candidates. \\n # then, select the cell with the smallest number of remaining candidates.\\n # Guess one of the candidates, then re-apply the solve algorithm. If the\\n # guess is correct, the solve algorithm will find a correct solution and return it.\\n # Return that solution up the chain.\\n # If the guess is incorrect, change your guess and repeat until you find the correct\\n # value.\\n is_valid, return_code = winnow(state)\\n if debug:\\n print(\\\"winnow return: \\\", return_code)\\n print_board(state)\\n if not is_valid:\\n return None\\n\\n # Find the cell with the smallest number of candidates, unless this board is finalized.\\n min_candidate_cell = None\\n min_candidates = float('inf')\\n is_finalized = True\\n for row in range(9):\\n for col in range(9):\\n if state.is_finalized[row][col]:\\n assert len(state.board_candidates[row][col]) == 1\\n else:\\n is_finalized = False\\n if len(state.board_candidates[row][col]) < min_candidates:\\n min_candidates = len(state.board_candidates[row][col])\\n min_candidate_cell = (row, col)\\n\\n # If we've finalized this board, return immediately\\n if is_finalized:\\n return state\\n \\n # Else there must have been some min_candidate_cell.\\n assert min_candidate_cell != None\\n min_cand_row, min_cand_col = min_candidate_cell\\n\\n for candidate_val in state.board_candidates[min_cand_row][min_cand_col]:\\n # Duplicate the solve state and re-apply the winnow algorithm.\\n guess_state = state.clone()\\n guess_state.board_candidates[min_cand_row][min_cand_col] = { candidate_val }\\n maybe_solved_state = solve(guess_state)\\n if maybe_solved_state:\\n return maybe_solved_state\\n\\n # If we reach this state the board is invalid\\n return None\\n\\ndef winnow(state: SolveState) -> Tuple[bool, int]:\\n # Simple solve algorithm:\\n # Loop over the board and collect all non-finalized cells that have only\\n # one candidate. Store them in a queue. \\n # While the queue is not empty, pop an entry off, finalize it, and \\n # remove it as a candidate for all squares in the same row, column, and box.\\n # When removing, if any corresponding non-finalized cell has only one remaining\\n # entry, add it to the queue. \\n # Once the queue is empty, check if everything is finalized. If not we'll need\\n # to make some guesses... just throw for now and we can revisit.\\n # Return True if the board remains in a valid state after winnowing, otherwise\\n # return False. If this returns False, the winnowing process ends and the board\\n # will be in an inconsistent state.\\n single_candidate_cells = []\\n for r in range(9):\\n for c in range(9):\\n if not state.is_finalized[r][c] and len(state.board_candidates[r][c]) == 1:\\n single_candidate_cells.append((r, c))\\n\\n while len(single_candidate_cells) > 0:\\n cur_row, cur_col = single_candidate_cells.pop()\\n assert len(state.board_candidates[cur_row][cur_col]) == 1\\n cur_val = next(iter(state.board_candidates[cur_row][cur_col]))\\n\\n state.is_finalized[cur_row][cur_col] = True\\n\\n # Remove cur_val as a candidate everywhere.\\n # Remove from everything in this row\\n for col in range(9):\\n if state.is_finalized[cur_row][col]:\\n continue\\n if not maybe_remove_candidate_and_enqueue(cur_val, cur_row, col, state, single_candidate_cells):\\n return False, 1\\n \\n # Remove from everything in this col\\n for row in range(9):\\n if state.is_finalized[row][cur_col]:\\n continue\\n if not maybe_remove_candidate_and_enqueue(cur_val, row, cur_col, state, single_candidate_cells):\\n return False, 2\\n\\n # Remove from everything in this box\\n for row, col in get_box_coords(cur_row, cur_col):\\n if state.is_finalized[row][col]:\\n continue\\n if not maybe_remove_candidate_and_enqueue(cur_val, row, col, state, single_candidate_cells):\\n return False, 3\\n\\n return True, 4\\n\\n\\ndef maybe_remove_candidate_and_enqueue(cur_val: str, row: int, col: int, \\n state: SolveState, single_candidate_cells: List[Tuple[int, int]]) -> bool:\\n '''\\n Remove the current value from the candidates for the given cell, and append this cell to the single_candidates\\n list if removing this value reduces the number of candidates to one.\\n If removing this value reduces the number of candidates to zero, return False, as this means we've entered\\n an invalid board state. Otherwise return True\\n '''\\n cur_candidates = state.board_candidates[row][col]\\n if cur_val in cur_candidates:\\n cur_candidates.remove(cur_val)\\n if len(cur_candidates) == 1:\\n single_candidate_cells.append((row, col))\\n elif len(cur_candidates) == 0:\\n return False\\n return True\\n\\ndef get_box_coords(row: int, col: int):\\n base_row = 3 * (row // 3) # 0, 3, 6\\n base_col = 3 * (col // 3) # 0, 3, 6\\n for r in range(base_row, base_row+3):\\n for c in range(base_col, base_col+3):\\n yield r, c\\n\\ndef print_n_candidates(board_candidate: List[List[Set[str]]]):\\n for row in board_candidate:\\n for candidates in row:\\n print(len(candidates), end=\\\", \\\")\\n print()\\n\\ndef print_board(state: SolveState):\\n for row in range(9):\\n for col in range(9):\\n if state.is_finalized[row][col]:\\n cur_val = next(iter(state.board_candidates[row][col]))\\n disp = \\\" \\\" + cur_val\\n else:\\n n_cand = len(state.board_candidates[row][col])\\n disp = f\\\"n{n_cand}\\\"\\n \\n print(disp, end=\\\", \\\")\\n print()\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # Precompute the rows, columns, and boxes\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [set() for _ in range(9)]\\n empties = []\\n\\n # Initialize the sets and list of empty cells\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] != '.':\\n num = board[i][j]\\n rows[i].add(num)\\n cols[j].add(num)\\n boxes[(i // 3) * 3 + j // 3].add(num)\\n else:\\n empties.append((i, j))\\n\\n # Function to find the empty cell with the minimum remaining values\\n def select_next_cell():\\n min_options = 10 # Start with a value greater than the maximum possible options\\n min_cell = None\\n for i, j in empties:\\n options = 0\\n for num in map(str, range(1, 10)):\\n if is_valid(num, i, j):\\n options += 1\\n if options < min_options:\\n min_options = options\\n min_cell = (i, j)\\n if min_options == 1:\\n break # Can't get fewer than one option\\n return min_cell\\n\\n # Function to check if placing num at (i, j) is valid\\n def is_valid(num, i, j):\\n return (\\n num not in rows[i] and\\n num not in cols[j] and\\n num not in boxes[(i // 3) * 3 + j // 3]\\n )\\n\\n def solve():\\n if not empties:\\n return True # Puzzle solved\\n\\n # Select the next cell with the fewest options\\n i, j = select_next_cell()\\n empties.remove((i, j))\\n\\n for num in map(str, range(1, 10)):\\n if is_valid(num, i, j):\\n # Place the number\\n board[i][j] = num\\n rows[i].add(num)\\n cols[j].add(num)\\n boxes[(i // 3) * 3 + j // 3].add(num)\\n\\n if solve():\\n return True # If the puzzle is solved, return True\\n\\n # Backtrack\\n board[i][j] = '.'\\n rows[i].remove(num)\\n cols[j].remove(num)\\n boxes[(i // 3) * 3 + j // 3].remove(num)\\n\\n # If no valid number is found, add the cell back to empties and backtrack\\n empties.append((i, j))\\n return False\\n\\n solve()\\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"from dataclasses import dataclass\\nfrom typing import List, Set, Tuple, Optional\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # First initialize our solve state\\n row_sets, col_sets, box_sets = init_group_sets(board)\\n\\n board_candidates, is_finalized = init_board_candidates(board, row_sets, col_sets, box_sets)\\n\\n state = SolveState(board_candidates, is_finalized)\\n # Solve\\n solved_state = solve(state)\\n\\n # Finally copy everything over to the original board and return.\\n for row in range(9):\\n for col in range(9):\\n assert solved_state.is_finalized[row][col]\\n assert len(solved_state.board_candidates[row][col]) == 1\\n if board[row][col] == \\\".\\\":\\n entry = next(iter(solved_state.board_candidates[row][col]))\\n board[row][col] = entry\\n\\n@dataclass\\nclass SolveState:\\n board_candidates: List[List[Set[str]]]\\n is_finalized: List[List[bool]]\\n\\n def clone(self):\\n board_candidates = [ [ set(cand_set) for cand_set in row] for row in self.board_candidates ]\\n is_finalized = [ [ fn for fn in row] for row in self.is_finalized ]\\n return SolveState(board_candidates, is_finalized)\\n\\n\\ndef get_box_idx(row: int, col: int) -> int:\\n return 3 * (row // 3) + col // 3\\n\\ndef init_group_sets(board: List[List[str]]):\\n row_sets = [set() for i in range(9)]\\n col_sets = [set() for i in range(9)]\\n box_sets = [set() for i in range(9)]\\n for row in range(9):\\n for col in range(9):\\n cur_cell = board[row][col]\\n if cur_cell == \\\".\\\":\\n continue\\n for group_set in [ row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)]]:\\n if cur_cell in group_set:\\n raise Exception(\\\"Invalid initial board\\\")\\n group_set.add(cur_cell)\\n\\n return row_sets, col_sets, box_sets\\n\\ndef init_board_candidates(board, row_sets, col_sets, box_sets):\\n board_candidates = [ [None for col in range(9)] for row in range(9)]\\n is_finalized = [ [False for col in range(9)] for row in range(9)]\\n\\n for row in range(9):\\n for col in range(9):\\n # Simple case: board has this already defined.\\n cur_entry = board[row][col]\\n if cur_entry != \\\".\\\":\\n board_candidates[row][col] = { cur_entry }\\n is_finalized[row][col] = True\\n else:\\n board_candidates[row][col] = get_candidates([\\n row_sets[row], col_sets[col], box_sets[get_box_idx(row, col)] ])\\n is_finalized[row][col] = False # Set to false even if there's only one candidate.\\n \\n return board_candidates, is_finalized\\n\\ndef get_candidates(cand_sets: List[Set[str]]):\\n candidates = set(map(str, range(1, 10)))\\n for cand_set in cand_sets:\\n candidates = candidates - cand_set\\n return candidates\\n\\ndef solve(state: SolveState) -> Optional[SolveState]:\\n debug = False\\n # Level 2 solve algorithm: \\n # apply the winnow algorithm to remove deterministic candidates. \\n # then, select the cell with the smallest number of remaining candidates.\\n # Guess one of the candidates, then re-apply the solve algorithm. If the\\n # guess is correct, the solve algorithm will find a correct solution and return it.\\n # Return that solution up the chain.\\n # If the guess is incorrect, change your guess and repeat until you find the correct\\n # value.\\n is_valid, return_code = winnow(state)\\n if debug:\\n print(\\\"winnow return: \\\", return_code)\\n print_board(state)\\n if not is_valid:\\n return None\\n\\n # Find the cell with the smallest number of candidates, unless this board is finalized.\\n min_candidate_cell = None\\n min_candidates = float('inf')\\n is_finalized = True\\n for row in range(9):\\n for col in range(9):\\n if state.is_finalized[row][col]:\\n assert len(state.board_candidates[row][col]) == 1\\n else:\\n is_finalized = False\\n if len(state.board_candidates[row][col]) < min_candidates:\\n min_candidates = len(state.board_candidates[row][col])\\n min_candidate_cell = (row, col)\\n\\n # If we've finalized this board, return immediately\\n if is_finalized:\\n return state\\n \\n # Else there must have been some min_candidate_cell.\\n assert min_candidate_cell != None\\n min_cand_row, min_cand_col = min_candidate_cell\\n\\n for candidate_val in state.board_candidates[min_cand_row][min_cand_col]:\\n # Duplicate the solve state and re-apply the winnow algorithm.\\n guess_state = state.clone()\\n guess_state.board_candidates[min_cand_row][min_cand_col] = { candidate_val }\\n maybe_solved_state = solve(guess_state)\\n if maybe_solved_state:\\n return maybe_solved_state\\n\\n # If we reach this state the board is invalid\\n return None\\n\\ndef winnow(state: SolveState) -> Tuple[bool, int]:\\n # Simple solve algorithm:\\n # Loop over the board and collect all non-finalized cells that have only\\n # one candidate. Store them in a queue. \\n # While the queue is not empty, pop an entry off, finalize it, and \\n # remove it as a candidate for all squares in the same row, column, and box.\\n # When removing, if any corresponding non-finalized cell has only one remaining\\n # entry, add it to the queue. \\n # Once the queue is empty, check if everything is finalized. If not we'll need\\n # to make some guesses... just throw for now and we can revisit.\\n # Return True if the board remains in a valid state after winnowing, otherwise\\n # return False. If this returns False, the winnowing process ends and the board\\n # will be in an inconsistent state.\\n single_candidate_cells = []\\n for r in range(9):\\n for c in range(9):\\n if not state.is_finalized[r][c] and len(state.board_candidates[r][c]) == 1:\\n single_candidate_cells.append((r, c))\\n\\n while len(single_candidate_cells) > 0:\\n cur_row, cur_col = single_candidate_cells.pop()\\n assert len(state.board_candidates[cur_row][cur_col]) == 1\\n cur_val = next(iter(state.board_candidates[cur_row][cur_col]))\\n\\n state.is_finalized[cur_row][cur_col] = True\\n\\n # Remove cur_val as a candidate everywhere.\\n # Remove from everything in this row\\n for col in range(9):\\n if state.is_finalized[cur_row][col]:\\n continue\\n if not maybe_remove_candidate_and_enqueue(cur_val, cur_row, col, state, single_candidate_cells):\\n return False, 1\\n \\n # Remove from everything in this col\\n for row in range(9):\\n if state.is_finalized[row][cur_col]:\\n continue\\n if not maybe_remove_candidate_and_enqueue(cur_val, row, cur_col, state, single_candidate_cells):\\n return False, 2\\n\\n # Remove from everything in this box\\n for row, col in get_box_coords(cur_row, cur_col):\\n if state.is_finalized[row][col]:\\n continue\\n if not maybe_remove_candidate_and_enqueue(cur_val, row, col, state, single_candidate_cells):\\n return False, 3\\n\\n return True, 4\\n\\n\\ndef maybe_remove_candidate_and_enqueue(cur_val: str, row: int, col: int, \\n state: SolveState, single_candidate_cells: List[Tuple[int, int]]) -> bool:\\n '''\\n Remove the current value from the candidates for the given cell, and append this cell to the single_candidates\\n list if removing this value reduces the number of candidates to one.\\n If removing this value reduces the number of candidates to zero, return False, as this means we've entered\\n an invalid board state. Otherwise return True\\n '''\\n cur_candidates = state.board_candidates[row][col]\\n if cur_val in cur_candidates:\\n cur_candidates.remove(cur_val)\\n if len(cur_candidates) == 1:\\n single_candidate_cells.append((row, col))\\n elif len(cur_candidates) == 0:\\n return False\\n return True\\n\\ndef get_box_coords(row: int, col: int):\\n base_row = 3 * (row // 3) # 0, 3, 6\\n base_col = 3 * (col // 3) # 0, 3, 6\\n for r in range(base_row, base_row+3):\\n for c in range(base_col, base_col+3):\\n yield r, c\\n\\ndef print_n_candidates(board_candidate: List[List[Set[str]]]):\\n for row in board_candidate:\\n for candidates in row:\\n print(len(candidates), end=\\\", \\\")\\n print()\\n\\ndef print_board(state: SolveState):\\n for row in range(9):\\n for col in range(9):\\n if state.is_finalized[row][col]:\\n cur_val = next(iter(state.board_candidates[row][col]))\\n disp = \\\" \\\" + cur_val\\n else:\\n n_cand = len(state.board_candidates[row][col])\\n disp = f\\\"n{n_cand}\\\"\\n \\n print(disp, end=\\\", \\\")\\n print()\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n def get_nigh(x, y):\\n s = set()\\n for i in range(x): # vertical - \\n yield (i,y)\\n for i in range(x+1,9):\\n yield (i,y)\\n for j in range(y): # horizontal |\\n yield (x,j)\\n for j in range(y+1,9):\\n yield (x,j)\\n xbx, ybx = x // 3 * 3, y // 3 * 3\\n for i in range(x % 3):\\n for j in range(y % 3):\\n yield (xbx+i,ybx+j)\\n for j in range(y % 3+1, 3):\\n yield (xbx+i,ybx+j)\\n for i in range(x % 3+1,3):\\n for j in range(y % 3):\\n yield (xbx+i,ybx+j)\\n for j in range(y % 3+1, 3):\\n yield (xbx+i,ybx+j)\\n # xbx, ybx = x // 3 * 3, y // 3 * 3\\n # return {(i,y) for i in range(9)}.union( \\n # {(x,j) for j in range(9)}).union( \\n # {(xbx, ybx+j) for j in range(3)}).union( # box\\n # {(xbx+1, ybx+j) for j in range(3)}).union(\\n # {(xbx+2, ybx+j) for j in range(3)})\\n nums = {'1','2','3','4','5','6','7','8','9'}\\n for x,y in itertools.product(range(9), range(9)):\\n if board[x][y] == '.':\\n board[x][y] = nums - {board[i][j] for i,j in get_nigh(x,y) if type(board[i][j]) == str}\\n def dfs():\\n x,y = min(((len(board[i][j]),i,j) for i,j in itertools.product(range(9), range(9)) if type(board[i][j]) == set), default=(123))[1:]\\n vals = board[x][y]\\n for val in vals:\\n updated = []\\n board[x][y] = val\\n for i,j in get_nigh(x,y):\\n if type(board[i][j]) == set and val in board[i][j]:\\n board[i][j] -= {val}\\n updated.append((i,j))\\n dfs() # recursive call\\n for i,j in updated:\\n print(board[i][j])\\n board[i][j].add(val)\\n board[x][y] = vals\\n try: dfs()\\n except TypeError: pass\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n usedRows = [set() for _ in range(9)]\\n usedCols = [set() for _ in range(9)]\\n usedBoxes = [[set() for _ in range(3)] for _ in range(3)]\\n\\n for i in range(81):\\n row = i // 9\\n col = i % 9\\n val = board[row][col]\\n if val != \\\".\\\":\\n usedRows[row].add(val)\\n usedCols[col].add(val)\\n usedBoxes[row // 3][col // 3].add(val)\\n\\n # print(usedRows)\\n # print(usedCols)\\n # print(usedBoxes)\\n\\n allNums = set([str(num) for num in range(1, 10)])\\n availableRows = [set() for _ in range(9)]\\n availableCols = [set() for _ in range(9)]\\n availableBoxes = [[set() for _ in range(3)] for _ in range(3)]\\n\\n for i in range(81):\\n row = i // 9\\n col = i % 9\\n availableRows[row] = allNums.difference(usedRows[row])\\n availableCols[col] = allNums - usedCols[col]\\n availableBoxes[row // 3][col // 3] = allNums - usedBoxes[row // 3][col // 3]\\n\\n \\n def backtrack(n, availableRows, availableCols, availableBoxes):\\n # print(n)\\n row = n // 9\\n col = n % 9\\n\\n if row == 9:\\n # print(\\\"solved\\\")\\n return True\\n\\n # if already a number, move on\\n if board[row][col] == \\\".\\\":\\n posNums = set(availableRows[row] & availableCols[col] & availableBoxes[row // 3][col // 3])\\n # print(\\\"pos\\\", n, posNums)\\n for num in posNums:\\n # print(\\\"try\\\", n, num)\\n # place\\n board[row][col] = num\\n # usedRows[row].add(num)\\n # usedCols[col].add(num)\\n # usedBoxes[row // 3][col // 3].add(num)\\n availableRows[row].remove(num)\\n availableCols[col].remove(num)\\n availableBoxes[row // 3][col // 3].remove(num)\\n\\n # recurse\\n if backtrack(n + 1, availableRows, availableCols, availableBoxes):\\n return True\\n\\n else:\\n # remove\\n board[row][col] = \\\".\\\"\\n # usedRows[row].remove(num)\\n # usedCols[col].remove(num)\\n # usedBoxes[row // 3][col // 3].remove(num)\\n availableRows[row].add(num)\\n availableCols[col].add(num)\\n availableBoxes[row // 3][col // 3].add(num)\\n \\n return False\\n else:\\n # print(\\\"skip\\\", n)\\n if backtrack(n + 1, availableRows, availableCols, availableBoxes):\\n return True\\n\\n return False\\n\\n \\n print(backtrack(0, availableRows, availableCols, availableBoxes))\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n usedRows = [set() for _ in range(9)]\\n usedCols = [set() for _ in range(9)]\\n usedBoxes = [[set() for _ in range(3)] for _ in range(3)]\\n\\n for i in range(81):\\n row = i // 9\\n col = i % 9\\n val = board[row][col]\\n if val != \\\".\\\":\\n usedRows[row].add(val)\\n usedCols[col].add(val)\\n usedBoxes[row // 3][col // 3].add(val)\\n\\n allNums = set([str(num) for num in range(1, 10)])\\n availableRows = [set() for _ in range(9)]\\n availableCols = [set() for _ in range(9)]\\n availableBoxes = [[set() for _ in range(3)] for _ in range(3)]\\n\\n for i in range(81):\\n row = i // 9\\n col = i % 9\\n availableRows[row] = allNums.difference(usedRows[row])\\n availableCols[col] = allNums - usedCols[col]\\n availableBoxes[row // 3][col // 3] = allNums - usedBoxes[row // 3][col // 3]\\n\\n \\n def backtrack(n):\\n row = n // 9\\n col = n % 9\\n\\n if row == 9:\\n return True\\n\\n # if already a number, move on\\n if board[row][col] == \\\".\\\":\\n posNums = set(availableRows[row] & availableCols[col] & availableBoxes[row // 3][col // 3])\\n for num in posNums:\\n # place\\n board[row][col] = num\\n availableRows[row].remove(num)\\n availableCols[col].remove(num)\\n availableBoxes[row // 3][col // 3].remove(num)\\n\\n # recurse\\n if backtrack(n + 1):\\n return True\\n\\n else:\\n # remove\\n board[row][col] = \\\".\\\"\\n availableRows[row].add(num)\\n availableCols[col].add(num)\\n availableBoxes[row // 3][col // 3].add(num)\\n \\n return False\\n else:\\n if backtrack(n + 1):\\n return True\\n\\n return False\\n\\n \\n print(backtrack(0))\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def nextdot(i, j, board):\\n for k in range(j,9):\\n if board[i][k] == \\\".\\\":\\n return i, k\\n for k in range(i+1, 9):\\n for l in range(9):\\n if board[k][l] == \\\".\\\":\\n return k, l\\n return -1, -1\\n\\n def putnumber(i, j, board, r_sets, c_sets, b_sets):\\n checklist = set(map(str, range(1, 10))) - r_sets[i] - c_sets[j] - b_sets[3*(i//3)+(j//3)]\\n for a in checklist:\\n board[i][j] = a\\n r_sets[i].add(a)\\n c_sets[j].add(a)\\n b_sets[3*(i//3)+(j//3)].add(a)\\n n_i, n_j = nextdot(i, j, board)\\n if n_i == -1:\\n return True\\n if putnumber(n_i, n_j, board, r_sets, c_sets, b_sets):\\n return True\\n board[i][j] = \\\".\\\"\\n r_sets[i].remove(a)\\n c_sets[j].remove(a)\\n b_sets[3*(i//3)+(j//3)].remove(a)\\n return False\\n\\n r_sets = []\\n c_sets = []\\n b_sets = []\\n for i in range(9):\\n r_sets.append(set())\\n c_sets.append(set())\\n b_sets.append(set())\\n \\n for i in range(9):\\n for j in range(9):\\n a = board[i][j]\\n if a!=\\\".\\\":\\n r_sets[i].add(a)\\n c_sets[j].add(a)\\n b_sets[3*(i//3)+(j//3)].add(a)\\n \\n i, j = nextdot(0, 0, board)\\n if i == -1:\\n return\\n putnumber(i, j, board, r_sets, c_sets, b_sets)\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"import copy\\n\\n\\nclass Board:\\n def __init__(self, board):\\n self.board = [\\n [set(range(1, 10)) if v is None else {v} for v in r] for r in board\\n ]\\n\\n def solve(self):\\n if not self.constrain():\\n return False\\n\\n if self.isSolved():\\n return True\\n\\n # Pick location with least possibilities.\\n best_idx = (0, 0)\\n num_pos = 9\\n for i, r in enumerate(self.board):\\n for j, c in enumerate(r):\\n if len(c) > 1 and len(c) < num_pos:\\n # New better location\\n best_idx = (i, j)\\n num_pos = len(c)\\n # Make a guess\\n i, j = best_idx\\n old = copy.deepcopy(self.board)\\n posibilities = list(self.board[i][j])\\n for p in posibilities:\\n self.board[i][j] = {p}\\n if self.solve():\\n return True\\n # Restore\\n self.board = old\\n return False\\n\\n def performSolve(self, to_update):\\n assert self.solve()\\n\\n # Update results\\n for i, r in enumerate(self.board):\\n for j, c in enumerate(r):\\n to_update[i][j] = str(min(c))\\n\\n def isSolved(self):\\n for r in self.board:\\n for e in r:\\n if len(e) != 1:\\n return False\\n return True\\n\\n # Returns true if valid solution.\\n def constrain(self):\\n updated = False\\n # Clean rows\\n for i, r in enumerate(self.board):\\n used = set()\\n for j, x in enumerate(r):\\n if len(x) == 0:\\n return False # Invalid.\\n if len(x) == 1:\\n if x.issubset(used):\\n return False # invalid\\n used.update(x)\\n for x in r:\\n if len(x) > 1:\\n size_before = len(x)\\n x.difference_update(used)\\n updated |= size_before != len(x)\\n if len(x) == 1:\\n used.update(x)\\n\\n # Clean columns\\n for c in range(9):\\n used = set()\\n for r in self.board:\\n if len(r[c]) == 1:\\n if r[c].issubset(used):\\n return False # invalid\\n used.update(r[c])\\n for r in self.board:\\n if len(r[c]) > 1:\\n size_before = len(r[c])\\n r[c].difference_update(used)\\n updated |= size_before != len(r[c])\\n if len(r[c]) == 1:\\n used.update(r[c])\\n\\n # Clean tiles.\\n for t in range(9):\\n c_start = 3 * (t % 3)\\n r_start = 3 * (t // 3)\\n used = set()\\n for r in range(3):\\n for c in range(3):\\n elem = self.board[r_start + r][c_start + c]\\n if len(elem) == 1:\\n if elem.issubset(used):\\n return False # invalid\\n used.update(self.board[r_start + r][c_start + c])\\n for r in range(3):\\n for c in range(3):\\n elem = self.board[r_start + r][c_start + c]\\n if len(elem) > 1:\\n size_before = len(elem)\\n elem.difference_update(used)\\n updated |= size_before != len(elem)\\n if len(elem) == 1:\\n used.update(elem)\\n\\n if updated:\\n # Recurse\\n return self.constrain()\\n\\n return True\\n\\n def __str__(self):\\n return \\\"\\\\n\\\".join([\\\",\\\".join([str(x) for x in r]) for r in self.board])\\n\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # Convert to sensible.\\n board_proc = [[int(v) if v != \\\".\\\" else None for v in row] for row in board]\\n b = Board(board_proc)\\n b.performSolve(board)\\n\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"import copy\\nclass Board:\\n def __init__(self, board):\\n self.board = [[set(range(1, 10)) if v is None else {v} for v in r] for r in board]\\n \\n def solve(self):\\n if not self.constrain():\\n return False\\n \\n if self.isSolved():\\n return True\\n\\n # Pick location with least possibilities.\\n best_idx = (0, 0)\\n num_pos = 9\\n for i, r in enumerate(self.board):\\n for j, c in enumerate(r):\\n if len(c) > 1 and len(c) < num_pos:\\n # New better location\\n best_idx = (i, j)\\n num_pos = len(c)\\n # Make a guess\\n i, j = best_idx\\n old = copy.deepcopy(self.board)\\n posibilities = list(self.board[i][j])\\n for p in posibilities:\\n print(\\\"Guessing {} for ({}, {})\\\".format(p, i, j))\\n self.board[i][j] = {p}\\n if self.solve():\\n return True\\n # Restore\\n self.board = old\\n return False\\n \\n\\n def performSolve(self, to_update):\\n assert(self.solve())\\n\\n # Update results\\n for i, r in enumerate(self.board):\\n for j, c in enumerate(r):\\n to_update[i][j] = str(min(c))\\n\\n def isSolved(self):\\n for r in self.board:\\n for e in r:\\n if len(e) != 1:\\n return False\\n return True\\n \\n # Returns true if valid solution.\\n def constrain(self):\\n print(self)\\n print(\\\"\\\\n\\\")\\n\\n updated = False\\n # Clean rows\\n for i, r in enumerate(self.board):\\n used = set()\\n for j, x in enumerate(r):\\n if len(x) == 0:\\n print(\\\"({}, {}) invalid\\\".format(i, j))\\n return False # Invalid.\\n if len(x) == 1:\\n if x.issubset(used):\\n return False # invalid\\n used.update(x)\\n for x in r:\\n if len(x) > 1:\\n size_before = len(x)\\n x.difference_update(used)\\n updated |= size_before != len(x)\\n if len(x) == 1:\\n used.update(x)\\n \\n # Clean columns\\n for c in range(9):\\n used = set()\\n for r in self.board:\\n if len(r[c]) == 1:\\n if r[c].issubset(used):\\n return False # invalid\\n used.update(r[c])\\n for r in self.board:\\n if len(r[c]) > 1:\\n size_before = len(r[c])\\n r[c].difference_update(used)\\n updated |= size_before != len(r[c])\\n if len(r[c]) == 1:\\n used.update(r[c])\\n\\n # Clean tiles.\\n for t in range(9):\\n c_start = 3*(t % 3)\\n r_start = 3*(t // 3)\\n used = set()\\n for r in range(3):\\n for c in range(3):\\n elem = self.board[r_start + r][c_start + c]\\n if len(elem) == 1:\\n if elem.issubset(used):\\n return False # invalid\\n used.update(self.board[r_start + r][c_start + c])\\n for r in range(3):\\n for c in range(3):\\n elem = self.board[r_start + r][c_start + c]\\n if len(elem) > 1:\\n size_before = len(elem)\\n elem.difference_update(used)\\n updated |= size_before != len(elem)\\n if len(elem) == 1:\\n used.update(elem)\\n\\n if updated:\\n # Recurse\\n return self.constrain()\\n \\n return True\\n \\n\\n def __str__(self):\\n return \\\"\\\\n\\\".join([','.join([str(x) for x in r]) for r in self.board])\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # Convert to sensible.\\n board_proc = [[int(v) if v != '.' else None for v in row] for row in board]\\n b = Board(board_proc)\\n b.performSolve(board)\\n # print(b)\\n \",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n rows,cols,block,seen = defaultdict(set),defaultdict(set),defaultdict(set),deque([])\\n for i in range(9):\\n for j in range(9):\\n if board[i][j]!=\\\".\\\":\\n rows[i].add(board[i][j])\\n cols[j].add(board[i][j])\\n block[(i//3,j//3)].add(board[i][j])\\n else:\\n seen.append((i,j))\\n \\n def dfs():\\n if not seen:\\n return True\\n \\n r,c = seen[0]\\n t = (r//3,c//3)\\n for n in {'1','2','3','4','5','6','7','8','9'}:\\n if n not in rows[r] and n not in cols[c] and n not in block[t]:\\n board[r][c]=n\\n rows[r].add(n)\\n cols[c].add(n)\\n block[t].add(n)\\n seen.popleft()\\n if dfs():\\n return True\\n else:\\n board[r][c]=\\\".\\\"\\n rows[r].discard(n)\\n cols[c].discard(n)\\n block[t].discard(n)\\n seen.appendleft((r,c))\\n return False\\n \\n dfs()\\n\\n \\n\\n\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\" \\n\\n def dfs(row, col, left_row, left_col, left_square):\\n\\n possible_digits = set(['1','2','3','4','5','6','7','8','9']) - used_row[row] - used_col[col] - used_square[(row//3, col//3)]\\n\\n for possible_digit in possible_digits:\\n\\n board[row][col] = possible_digit\\n\\n \\n used_row[row].add(possible_digit)\\n used_col[col].add(possible_digit)\\n used_square[(row//3, col//3)].add(possible_digit)\\n\\n # go to next open space\\n next_row, next_col = row, col\\n while board[next_row][next_col] != '.':\\n next_row = next_row + 1 if next_col + 1 == 9 else next_row\\n next_col = 0 if next_col + 1 == 9 else next_col + 1\\n \\n\\n if next_row == 9: # we are outside the board\\n return True\\n\\n if dfs(next_row, next_col, used_row, used_col, used_square):\\n return True\\n\\n board[row][col] = '.'\\n\\n used_row[row].remove(possible_digit)\\n used_col[col].remove(possible_digit)\\n used_square[(row//3, col//3)].remove(possible_digit)\\n\\n return False\\n\\n used_row = defaultdict(set)\\n used_col = defaultdict(set)\\n used_square = defaultdict(set)\\n\\n\\n first_dot = True\\n for row in range(len(board)):\\n for col in range(len(board[0])):\\n\\n if board[row][col] != '.':\\n used_row[row].add(board[row][col])\\n used_col[col].add(board[row][col])\\n used_square[(row//3, col//3)].add(board[row][col])\\n else:\\n if first_dot:\\n start_row = row\\n start_col = col\\n first_dot = False\\n\\n dfs(start_row, start_col, used_row, used_col, used_square)\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n region = defaultdict(set)\\n f = lambda r, c : 3 * (r // 3) + (c // 3)\\n \\n def append(r, c, x):\\n rows[r].add(x)\\n cols[c].add(x)\\n region[f(r, c)].add(x)\\n board[r][c] = str(x)\\n \\n def pop(r, c, x):\\n rows[r].remove(x)\\n cols[c].remove(x)\\n region[f(r, c)].remove(x)\\n board[r][c] = '.'\\n \\n def neighbors(r, c):\\n for val in range(1, 10):\\n if all((\\n val not in rows[r],\\n val not in cols[c],\\n val not in region[f(r, c)],\\n )):\\n yield val\\n \\n def cost(r, c):\\n return sum(1 for _ in neighbors(r, c))\\n \\n def solve(coords):\\n if len(coords) == 0:\\n return True\\n \\n _, r, c = heapq.heappop(queue)\\n for val in neighbors(r, c):\\n append(r, c, val)\\n if solve(coords):\\n return True\\n pop(r, c, val)\\n \\n heapq.heappush(queue, (cost(r, c), r, c))\\n return False\\n \\n empties = []\\n for r, c in product(range(9), repeat=2):\\n if board[r][c] == '.':\\n empties.append((r, c))\\n else:\\n append(r, c, int(board[r][c]))\\n \\n queue = [(cost(r, c), r, c) for r, c in empties]\\n heapq.heapify(queue)\\n solve(queue)\\n return board\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n rows,cols,block,seen = defaultdict(set),defaultdict(set),defaultdict(set),deque([])\\n for i in range(9):\\n for j in range(9):\\n if board[i][j]!=\\\".\\\":\\n rows[i].add(board[i][j])\\n cols[j].add(board[i][j])\\n block[(i//3,j//3)].add(board[i][j])\\n else:\\n seen.append((i,j))\\n \\n def dfs():\\n if not seen:\\n return True\\n \\n r,c = seen[0]\\n t = (r//3,c//3)\\n for n in {'1','2','3','4','5','6','7','8','9'}:\\n if n not in rows[r] and n not in cols[c] and n not in block[t]:\\n board[r][c]=n\\n rows[r].add(n)\\n cols[c].add(n)\\n block[t].add(n)\\n seen.popleft()\\n if dfs():\\n return True\\n else:\\n board[r][c]=\\\".\\\"\\n rows[r].discard(n)\\n cols[c].discard(n)\\n block[t].discard(n)\\n seen.appendleft((r,c))\\n return False\\n \\n dfs()\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n # def solveSudoku(self, board: List[List[str]]) -> None:\\n # \\\"\\\"\\\"\\n # Do not return anything, modify board in-place instead.\\n # \\\"\\\"\\\"\\n # def is_valid(board, row, col, num):\\n # for i in range(9):\\n # if board[row][i] == num:\\n # return False\\n \\n # for i in range(9):\\n # if board[i][col] == num:\\n # return False\\n \\n # startRow = (row // 3) * 3\\n # startCol = (col // 3)* 3\\n # for i in range(3):\\n # for j in range(3):\\n # if board[startRow + i][startCol + j] == num:\\n # return False\\n # return True\\n \\n # def solve(board):\\n # for row in range(9):\\n # for col in range(9):\\n # if board[row][col] == '.':\\n # for num in '123456789':\\n # if is_valid(board, row, col, num):\\n # board[row][col] = num\\n # if solve(board):\\n # return True\\n # # back track\\n # board[row][col] = '.'\\n # return False\\n # return True\\n \\n # solve(board)\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [set() for _ in range(9)]\\n\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] != \\\".\\\":\\n num = int(board[i][j])\\n rows[i].add(num)\\n cols[j].add(num)\\n\\n box_id = i // 3 * 3 + j // 3\\n boxes[box_id].add(num)\\n\\n def backTrack(i, j) -> None:\\n nonlocal solved\\n if i == 9:\\n solved = True\\n return\\n \\n new_i = i + (j + 1) // 9\\n new_j = (j + 1) % 9\\n\\n if board[i][j] != \\\".\\\":\\n backTrack(new_i, new_j)\\n else:\\n box_id = i // 3 * 3 + j // 3\\n for n in range(1, 10):\\n if n not in rows[i] and n not in cols[j] and n not in boxes[box_id]:\\n rows[i].add(n)\\n cols[j].add(n)\\n boxes[box_id].add(n)\\n board[i][j] = str(n)\\n\\n backTrack(new_i, new_j)\\n if solved:\\n break\\n\\n rows[i].remove(n)\\n cols[j].remove(n)\\n boxes[box_id].remove(n)\\n board[i][j] = \\\".\\\"\\n\\n solved = False\\n backTrack(0, 0)\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n r = [[0]*9 for _ in range(9)]\\n c = [[0]*9 for _ in range(9)]\\n d = [[0]*9 for _ in range(9)]\\n visit = []\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] != '.':\\n num = int(board[i][j]) - 1\\n k = i//3 * 3 + j//3;\\n r[i][num] = 1\\n c[j][num] = 1\\n d[k][num] = 1\\n else:\\n visit.append((i,j))\\n def dfs():\\n if not visit:\\n return True\\n i, j = visit.pop()\\n for num in range(9):\\n if r[i][num]==0 and c[j][num]==0 and d[i//3*3+j//3][num]==0:\\n board[i][j] = str(num+1)\\n r[i][num] = c[j][num] = d[i//3*3+j//3][num] = 1\\n if dfs():\\n return True\\n board[i][j] = '.'\\n r[i][num] = c[j][num] = d[i//3*3+j//3][num] = 0\\n visit.append((i,j))\\n return False\\n\\n dfs()\\n \\n\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n # The time complexity can be improved by using more space (dict or set) and pre-processing the input to save non-empty and empty cells and put into 3 separate dict for its row/col/cube-box.\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # pre-processing input board to store index for\\n rows, cols, triples = defaultdict(set), defaultdict(set), defaultdict(set)\\n empties = deque()\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\": \\n empties.append((r, c))\\n else:\\n rows[r].add(board[r][c])\\n cols[c].add(board[r][c])\\n triples[(r // 3, c // 3)].add(board[r][c])\\n\\n def backtrack():\\n if not empties: \\n return True\\n r, c = empties[0] # row, col index\\n t = (r // 3, c // 3)\\n for num in (\\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\", \\\"5\\\", \\\"6\\\", \\\"7\\\", \\\"8\\\", \\\"9\\\"):\\n if num in rows[r] or num in cols[c] or num in triples[t]:\\n continue\\n board[r][c] = num\\n rows[r].add(num)\\n cols[c].add(num)\\n triples[t].add(num)\\n empties.popleft()\\n if backtrack(): \\n return True\\n # backtrack\\n board[r][c] = \\\".\\\"\\n rows[r].discard(num)\\n cols[c].discard(num)\\n triples[t].discard(num)\\n empties.appendleft((r, c))\\n return False\\n \\n backtrack()\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.row = [[False for _ in range(9+1)] for _ in range(9)]\\n self.col = [[False for _ in range(9+1)] for _ in range(9)]\\n self.box = [[[False for _ in range(9+1)] for _ in range(3)] for _ in range(3)]\\n self.ans = False \\n for i in range(9):\\n for j in range(9):\\n if board[i][j] != '.':\\n val = int(board[i][j])\\n self.row[i][val] = self.col[j][val] = \\\\\\n self.box[i//3][j//3][val] = True \\n self.dfs(board, 0, 0)\\n print(board)\\n \\n def dfs(self, grid, i, j):\\n if i == 9:\\n self.ans = True \\n return \\n if j == 9:\\n self.dfs(grid, i+1, 0)\\n return \\n if grid[i][j] != '.':\\n self.dfs(grid, i, j+1)\\n return \\n for val in range(1, 10):\\n if not self.row[i][val] and not self.col[j][val] and \\\\\\n not self.box[i//3][j//3][val]:\\n self.row[i][val] = self.col[j][val] = \\\\\\n self.box[i//3][j//3][val] = True \\n grid[i][j] = str(val)\\n self.dfs(grid, i, j+1)\\n if self.ans:\\n return \\n grid[i][j] = '.'\\n self.row[i][val] = self.col[j][val] = \\\\\\n self.box[i//3][j//3][val] = False\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n def dfs(k):\\n nonlocal ok\\n if k == len(t):\\n ok = True\\n return\\n i, j = t[k]\\n for v in range(9):\\n if row[i][v] == col[j][v] == block[i // 3][j // 3][v] == False:\\n row[i][v] = col[j][v] = block[i // 3][j // 3][v] = True\\n board[i][j] = str(v + 1)\\n dfs(k + 1)\\n row[i][v] = col[j][v] = block[i // 3][j // 3][v] = False\\n if ok:\\n return\\n\\n row = [[False] * 9 for _ in range(9)]\\n col = [[False] * 9 for _ in range(9)]\\n block = [[[False] * 9 for _ in range(3)] for _ in range(3)]\\n t = []\\n ok = False\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n t.append((i, j))\\n else:\\n v = int(board[i][j]) - 1\\n row[i][v] = col[j][v] = block[i // 3][j // 3][v] = True\\n dfs(0)\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n solved = False\\n\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n grids = [[set() for _ in range(3)] for _ in range(3)]\\n\\n # Set the current board\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] != '.':\\n rows[i].add(int(board[i][j]))\\n cols[j].add(int(board[i][j]))\\n grids[i//3][j//3].add(int(board[i][j]))\\n\\n def solver(i,j):\\n nonlocal solved\\n\\n if i == 9:\\n solved = True\\n return\\n \\n i_new = i if j<8 else i+1\\n j_new = j+1 if j<8 else 0\\n\\n if board[i][j] != '.':\\n solver(i_new,j_new)\\n else:\\n for k in range(1,10):\\n if k not in rows[i] and k not in cols[j] and k not in grids[i//3][j//3]:\\n board[i][j] = str(k)\\n rows[i].add(k)\\n cols[j].add(k)\\n grids[i//3][j//3].add(k)\\n\\n solver(i_new,j_new)\\n\\n if not solved:\\n board[i][j] = '.'\\n rows[i].remove(k)\\n cols[j].remove(k)\\n grids[i//3][j//3].remove(k)\\n\\n solver(0,0)\\n\\n\\n \",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # self.found = False\\n used_row, used_col, used_mat = [set() for i in range(9)], [set() for i in range(9)], [set() for i in range(9)]\\n loc = []\\n for i in range(len(board)):\\n for j in range(len(board)):\\n if board[i][j] == '.':\\n loc.append((i, j))\\n else:\\n used_row[i].add(board[i][j])\\n used_col[j].add(board[i][j])\\n used_mat[i // 3 * 3 + j // 3].add(board[i][j])\\n\\n\\n # print(used_row)\\n # print(used_col)\\n # print(used_mat)\\n ans = []\\n\\n \\n\\n \\n def back_track(k):\\n if k == len(loc):\\n for row in range(len(board)):\\n ans.append(list(board[row]))\\n # self.ans = copy.deepcopy(board)\\n return\\n \\n if ans:\\n return\\n \\n i, j = loc[k]\\n\\n for n in range(1, 10):\\n s = f'{n}'\\n if s not in used_row[i] and s not in used_col[j] and s not in used_mat[i // 3 * 3 + j // 3]:\\n board[i][j] = s\\n used_row[i].add(s)\\n used_col[j].add(s)\\n used_mat[i // 3 * 3 + j // 3].add(s)\\n back_track(k + 1)\\n board[i][j] = '.'\\n used_row[i].remove(s)\\n used_col[j].remove(s)\\n used_mat[i // 3 * 3 + j // 3].remove(s)\\n \\n back_track(0)\\n\\n for i in range(len(board)):\\n for j in range(len(board)):\\n board[i][j] = ans[i][j]\\n \\n\",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anithing, modifi board in-place instead.\\n \\\"\\\"\\\"\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxs = [set() for _ in range(9)]\\n\\n \\\"\\\"\\\"\\\"These loops are just for us to find and record the preexisting numbers in the sudoku board\\\"\\\"\\\"\\n for i in range(9):\\n for j, val in enumerate(board[i]):\\n if board[i][j] != '.':\\n rows[i].add(int(val))\\n cols[j].add(int(val))\\n box_idx = i // 3 * 3 + j // 3 #this will make it so the boxs are labeled 1-8\\n boxs[box_idx].add(int(val))\\n\\n def backTrack(i, j):\\n nonlocal solved\\n if i == 9:\\n solved = True\\n return\\n\\n # These 2 lines are a calculation trick to make sure that i is increased if j is at the 9th\\n # position and j is increases until it reaches 9 and then becomes 0 again \\n new_i = i + (j+1) // 9 \\n new_j = (j+1) % 9\\n\\n if board[i][j] != '.':\\n backTrack(new_i, new_j)\\n else:\\n for num in range(1, 10):\\n box_idx = i // 3 * 3 + j // 3\\n if num not in rows[i] and num not in cols[j] and num not in boxs[box_idx]:\\n rows[i].add(num)\\n cols[j].add(num)\\n boxs[box_idx].add(num)\\n board[i][j] = str(num)\\n\\n backTrack(new_i, new_j)\\n \\n if not solved:\\n rows[i].remove(num)\\n cols[j].remove(num)\\n boxs[box_idx].remove(num)\\n board[i][j] = '.'\\n\\n\\n solved = False\\n backTrack(0, 0)\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n rows = [set() for _ in range(9)]\\n columns = [set() for _ in range(9)]\\n buckets = [set() for _ in range(9)]\\n empty_cells = []\\n\\n # Preprocess the board to initialize sets and collect empty cells\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == '.':\\n empty_cells.append((r, c))\\n else:\\n rows[r].add(board[r][c])\\n columns[c].add(board[r][c])\\n bucket_index = (r // 3) * 3 + c // 3\\n buckets[bucket_index].add(board[r][c])\\n\\n # Check if placing number 'n' at position (r, c) is valid\\n def is_valid(r, c, n):\\n bucket_index = (r // 3) * 3 + c // 3\\n if n in rows[r] or n in columns[c] or n in buckets[bucket_index]:\\n return False\\n return True\\n\\n # Recursive backtracking function to solve the Sudoku\\n def solve(index=0):\\n if index == len(empty_cells):\\n return True # Puzzle is solved\\n\\n r, c = empty_cells[index]\\n \\n for n in '123456789':\\n if is_valid(r, c, n):\\n bucket_index = (r // 3) * 3 + c // 3\\n\\n # Update the sets\\n rows[r].add(n)\\n columns[c].add(n)\\n buckets[bucket_index].add(n)\\n \\n # Update the board\\n board[r][c] = n\\n\\n # Proceed with recursion\\n if solve(index + 1):\\n return True\\n\\n # Backtrack if needed\\n rows[r].discard(n)\\n columns[c].discard(n)\\n buckets[bucket_index].discard(n)\\n board[r][c] = '.'\\n\\n return False\\n\\n # Start solving the Sudoku\\n solve()\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"import collections\\nclass Solution:\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n rows, cols, squares = self.createSet(board)\\n solved = False\\n \\n def backtrack(r, c):\\n nonlocal solved\\n\\n if r == 9:\\n solved = True\\n return \\n\\n R = r+((c+1)//9)\\n C = (c+1) % 9\\n \\n # has a numer \\n if board[r][c] != '.': \\n backtrack(R, C)\\n\\n # empty\\n else:\\n for i in range(1,10):\\n if i not in rows[r] and i not in cols[c] and i not in squares[(r//3, c//3)]:\\n rows[r].add(i)\\n cols[c].add(i)\\n squares[(r//3, c//3)].add(i)\\n board[r][c] = str(i)\\n \\n backtrack(R, C)\\n \\n if solved == False:\\n rows[r].remove(i)\\n cols[c].remove(i)\\n squares[(r//3, c//3)].remove(i)\\n board[r][c] = '.'\\n\\n backtrack(0,0) \\n\\n def createSet(self, board):\\n rows = collections.defaultdict(set)\\n cols = collections.defaultdict(set)\\n squares = collections.defaultdict(set)\\n \\n for r in range(9):\\n for c in range(9):\\n if board[r][c] != '.':\\n num = int(board[r][c])\\n rows[r].add(num)\\n cols[c].add(num)\\n squares[(r//3, c//3)].add(num)\\n \\n return rows, cols, squares\\n\\n \\n \\n \",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n col_sets = [set() for j in range(len(board[0]))]\\n row_sets = [set() for i in range(len(board))]\\n box_sets = [set() for i in range(9)]\\n\\n def helper(ind):\\n if ind == len(board[0]) * len(board):\\n return True\\n \\n i, j = ind // len(board[0]), ind % len(board[0])\\n box = 3 * (i // 3) + (j // 3)\\n if board[i][j] != \\\".\\\":\\n return helper(ind + 1)\\n \\n # we can fill in the dot\\n for choice in range(1,10):\\n choice = str(choice)\\n if choice in row_sets[i] or choice in col_sets[j] or choice in box_sets[box]:\\n continue\\n board[i][j] = str(choice)\\n row_sets[i].add(choice)\\n col_sets[j].add(choice)\\n box_sets[box].add(choice)\\n if helper(ind+1):\\n return True\\n row_sets[i].remove(choice)\\n col_sets[j].remove(choice)\\n box_sets[box].remove(choice)\\n board[i][j] = \\\".\\\"\\n return False\\n \\n for i in range(len(board)):\\n for j in range(len(board[i])):\\n x = board[i][j]\\n box = 3 * (i // 3) + (j // 3)\\n if board[i][j] != \\\".\\\":\\n col_sets[j].add(x)\\n row_sets[i].add(x)\\n box_sets[box].add(x)\\n \\n helper(0)\\n return board\\n \",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n sub_boxes = [[set() for _ in range(3)] for _ in range(3)]\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n\\n for i in range(9):\\n for j in range(9):\\n num = board[i][j]\\n if num == \\\".\\\":\\n continue\\n\\n sub_boxes[i // 3][j // 3].add(num)\\n rows[i].add(num)\\n cols[j].add(num)\\n\\n def solve(row, col) -> bool:\\n if row == 9:\\n return True\\n if col == 9:\\n return solve(row + 1, 0)\\n if board[row][col] != \\\".\\\":\\n return solve(row, col + 1)\\n\\n for num in range(1, 10):\\n num = str(num)\\n if (\\n num in sub_boxes[row // 3][col // 3]\\n or num in rows[row]\\n or num in cols[col]\\n ):\\n continue\\n\\n board[row][col] = num\\n sub_boxes[row // 3][col // 3].add(num)\\n rows[row].add(num)\\n cols[col].add(num)\\n\\n if solve(row, col + 1):\\n return True\\n\\n board[row][col] = \\\".\\\"\\n sub_boxes[row // 3][col // 3].remove(num)\\n rows[row].remove(num)\\n cols[col].remove(num)\\n\\n return False\\n\\n return solve(0, 0)\\n \",\n \"runtime\": \"107\"\n },\n {\n \"code\": \"import collections\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # Track numbers in rows, columns, and subgrids (3x3)\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n subs = [[set() for _ in range(3)] for _ in range(3)]\\n\\n # Use deque for storing empty cells (gaps) as a stack\\n gaps = collections.deque()\\n for i in range(9):\\n for j in range(9):\\n tile = board[i][j]\\n if tile != \\\".\\\":\\n rows[i].add(tile)\\n cols[j].add(tile)\\n subs[i // 3][j // 3].add(tile)\\n else:\\n gaps.append((i, j))\\n\\n # Recursive backtracking using gaps as a stack (deque)\\n def solve(rows, cols, subs):\\n nonlocal board\\n nonlocal gaps\\n\\n # Base case: all gaps filled\\n if not gaps:\\n return True # Puzzle solved\\n\\n # Pop the last gap from the stack\\n i, j = gaps.pop()\\n\\n # Try placing numbers 1-9 in the current gap\\n for n in map(str, range(1, 10)):\\n if n not in rows[i] and n not in cols[j] and n not in subs[i // 3][j // 3]:\\n # Place the number and update tracking sets\\n board[i][j] = n\\n rows[i].add(n)\\n cols[j].add(n)\\n subs[i // 3][j // 3].add(n)\\n\\n # Recur to the next gap\\n if solve(rows, cols, subs):\\n return True # Puzzle is solved\\n\\n # Backtrack if this placement doesn't lead to a solution\\n board[i][j] = \\\".\\\"\\n rows[i].remove(n)\\n cols[j].remove(n)\\n subs[i // 3][j // 3].remove(n)\\n\\n # No valid number found, push the gap back (restore it)\\n gaps.append((i, j))\\n return False # Trigger backtracking\\n\\n # Start solving from the first gap\\n solve(rows, cols, subs)\",\n \"runtime\": \"107\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n cells = defaultdict(set)\\n\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] != \\\".\\\":\\n rows[i].add(board[i][j])\\n cols[j].add(board[i][j])\\n c_i = i // 3\\n c_j = j // 3\\n cells[c_i*3+c_j].add(board[i][j])\\n \\n found = False\\n print(cells)\\n\\n def backtrack(i, j):\\n nonlocal rows, cols, cells, found\\n if found:\\n return\\n\\n if j == 9:\\n i = i+1\\n j = 0\\n \\n if i == 9:\\n found = True\\n return\\n\\n # if the current (i, j) is empty, try to put a number from 1 to 9 that is valid to it and continue to the next pos; and if the current (i, j) is not empty, continue to the next pos directly.\\n if board[i][j] == \\\".\\\":\\n c_i = i // 3\\n c_j = j // 3\\n for d in range(1, 10):\\n d = str(d)\\n if d not in rows[i] and d not in cols[j] and d not in cells[c_i*3+c_j]:\\n rows[i].add(d)\\n cols[j].add(d)\\n cells[c_i*3+c_j].add(d)\\n board[i][j] = d\\n backtrack(i, j+1)\\n if found:\\n return\\n board[i][j] = \\\".\\\"\\n rows[i].remove(d)\\n cols[j].remove(d)\\n cells[c_i*3+c_j].remove(d)\\n\\n else:\\n backtrack(i, j+1)\\n \\n backtrack(0, 0)\",\n \"runtime\": \"113\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def getSubBoxIndex(self, rowIndex, colIndex):\\n return (rowIndex // 3) * 3 + colIndex // 3\\n \\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n rowDct = defaultdict(set)\\n colDct = defaultdict(set)\\n subBoxDct = defaultdict(set)\\n toFill = []\\n \\n for i in range(9):\\n for j in range(9):\\n if board[i][j].isdigit():\\n subBoxIndex = self.getSubBoxIndex(i, j)\\n rowDct[i].add(board[i][j])\\n colDct[j].add(board[i][j])\\n subBoxDct[subBoxIndex].add(board[i][j])\\n else:\\n subBoxIndex = self.getSubBoxIndex(i, j)\\n toFill.append((i, j, subBoxIndex))\\n \\n \\n def fill():\\n if not toFill:\\n return True\\n rowIndex, colIndex, subBoxIndex = toFill.pop()\\n for num in map(str, range(1, 10)):\\n if num in rowDct[rowIndex] or num in colDct[colIndex] or num in subBoxDct[subBoxIndex]:\\n continue\\n rowDct[rowIndex].add(num)\\n colDct[colIndex].add(num)\\n subBoxDct[subBoxIndex].add(num)\\n board[rowIndex][colIndex] = num\\n res = fill()\\n if res:\\n return True\\n board[rowIndex][colIndex] = \\\".\\\"\\n rowDct[rowIndex].discard(num)\\n colDct[colIndex].discard(num)\\n subBoxDct[subBoxIndex].discard(num)\\n toFill.append((rowIndex, colIndex, subBoxIndex))\\n \\n fill()\\n \\n \\n \",\n \"runtime\": \"113\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n def getBoxIndex(r, c):\\n r //= 3\\n c //= 3\\n return r * 3 + c\\n\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [set() for _ in range(9)] # row-major\\n\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] != '.':\\n num = int(board[r][c])\\n rows[r].add(num)\\n cols[c].add(num)\\n boxes[getBoxIndex(r, c)].add(num)\\n \\n def placeNumber(num, r, c):\\n board[r][c] = str(num)\\n rows[r].add(num)\\n cols[c].add(num)\\n boxes[getBoxIndex(r, c)].add(num)\\n \\n def removeNumber(num, r, c):\\n board[r][c] = '.'\\n rows[r].remove(num)\\n cols[c].remove(num)\\n boxes[getBoxIndex(r, c)].remove(num)\\n \\n def canPlace(num, r, c):\\n return num not in rows[r] and num not in cols[c] and num not in boxes[getBoxIndex(r, c)]\\n \\n self.done = False\\n\\n def dfs(r, c):\\n if board[r][c] != '.':\\n if r == 8 and c == 8:\\n self.done = True\\n return\\n elif c < 8:\\n return dfs(r, c + 1)\\n else:\\n return dfs(r + 1, 0)\\n\\n for num in range(1, 10):\\n if canPlace(num, r, c):\\n placeNumber(num, r, c)\\n \\n if r == 8 and c == 8:\\n self.done = True\\n return\\n elif c < 8:\\n dfs(r, c + 1)\\n else:\\n dfs(r + 1, 0)\\n \\n if self.done:\\n return\\n \\n removeNumber(num, r, c)\\n \\n dfs(0, 0)\",\n \"runtime\": \"118\"\n },\n {\n \"code\": \"#\\n# @lc app=leetcode id=37 lang=python3\\n#\\n# [37] Sudoku Solver\\n#\\nfrom typing import *\\n# @lc code=start\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n rows: List[set[str]] = [set() for _ in range(9)]\\n cols: List[set[str]] = [set() for _ in range(9)]\\n boxes: List[set[str]] = [set() for _ in range(9)]\\n get_box_index: Callable[[int, int], int] = lambda row, col: (row // 3) * 3 + (col // 3)\\n finished: bool = False\\n \\n def place_num(num: str, row: int, col: int):\\n rows[row].add(num)\\n cols[col].add(num)\\n boxes[get_box_index(row, col)].add(num)\\n board[row][col] = num\\n \\n def remove_num(num: str, row: int, col: int):\\n rows[row].remove(num)\\n cols[col].remove(num)\\n boxes[get_box_index(row, col)].remove(num)\\n board[row][col] = \\\".\\\"\\n \\n def can_place(num: str, row: int, col: int):\\n return not num in rows[row] and \\\\\\n not num in cols[col] and \\\\\\n not num in boxes[get_box_index(row, col)]\\n\\n \\n def place_next(row: int, col: int):\\n nonlocal finished\\n if row == 8 and col == 8:\\n finished = True\\n return\\n if col == 8:\\n return backtrack(row + 1, 0)\\n \\n return backtrack(row, col + 1)\\n \\n def backtrack(row: int, col: int):\\n if board[row][col] == \\\".\\\":\\n for val in range(1, 10):\\n num = str(val)\\n if can_place(num, row, col):\\n place_num(num, row, col)\\n place_next(row, col)\\n \\n if finished:\\n return\\n remove_num(num, row, col)\\n else:\\n place_next(row, col)\\n \\n for row in range(9):\\n for col in range(9):\\n val = board[row][col]\\n if val != \\\".\\\":\\n place_num(val, row, col)\\n\\n backtrack(0, 0)\\n \",\n \"runtime\": \"118\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n BS = 9\\n SQBS = int(BS ** 0.5)\\n\\n def extract_row(i):\\n return board[i]\\n\\n def extract_col(i):\\n return [board[j][i] for j in range(len(board))]\\n\\n def extract_box(k):\\n res = list()\\n for i in range((k // SQBS) * SQBS, (k // SQBS) * SQBS + SQBS):\\n for j in range((k % SQBS) * SQBS, (k % SQBS) * SQBS + SQBS):\\n res.append(board[i][j])\\n return res\\n\\n def get_options(i, j):\\n r = set([x for x in extract_row(i) if x != '.'])\\n c = set([x for x in extract_col(j) if x != '.'])\\n b = set([x for x in extract_box((i // SQBS) * SQBS + (j // SQBS)) if x != '.'])\\n all_digits = r.union(c).union(b)\\n options = [str(i) for i in range(1, BS + 1) if str(i) not in all_digits]\\n return options\\n\\n min_sugg_cell = None\\n min_sugg = None\\n\\n for i in range(BS):\\n for j in range(BS):\\n if board[i][j] == '.':\\n curr_sugg = get_options(i, j)\\n print(i, j, curr_sugg)\\n if len(curr_sugg) == 0:\\n return False\\n if len(curr_sugg) > 0 and (min_sugg is None or len(curr_sugg) < len(min_sugg)):\\n min_sugg = curr_sugg\\n min_sugg_cell = (i, j)\\n \\n if min_sugg_cell is None:\\n return True\\n \\n for o in min_sugg:\\n board[min_sugg_cell[0]][min_sugg_cell[1]] = str(o)\\n if self.solveSudoku(board):\\n return True\\n board[min_sugg_cell[0]][min_sugg_cell[1]] = '.'\\n\\n \\n \",\n \"runtime\": \"124\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n \\n rows=9\\n cols=9\\n\\n rowset=defaultdict(set)\\n colset=defaultdict(set)\\n boxset=defaultdict(set)\\n\\n for i in range(rows):\\n\\n for j in range(cols):\\n \\n if board[i][j].isdigit():\\n rowset[i].add(board[i][j])\\n colset[j].add(board[i][j])\\n boxset[(i//3,j//3)].add(board[i][j])\\n \\n print(rowset)\\n print(colset)\\n print(boxset)\\n def backtrack(i,j):\\n\\n if i==9:\\n return True\\n \\n if j==9:\\n return backtrack(i+1,0)\\n \\n if board[i][j].isdigit():\\n return backtrack(i,j+1)\\n \\n for num in range(1,10):\\n num=str(num)\\n if num not in colset[j] and num not in rowset[i] and num not in boxset[(i//3,j//3)]:\\n rowset[i].add(num)\\n colset[j].add(num)\\n boxset[(i//3,j//3)].add(num)\\n board[i][j]=num\\n if backtrack(i,j+1):\\n return True\\n board[i][j]=\\\".\\\"\\n rowset[i].remove(num)\\n colset[j].remove(num)\\n boxset[(i//3,j//3)].remove(num)\\n return False\\n \\n backtrack(0,0)\",\n \"runtime\": \"124\"\n },\n {\n \"code\": \"import copy\\nfrom typing import List\\n\\n\\nclass Solution:\\n def __init__(self):\\n self.posibilities = [[set() for _ in range(9)] for _ in range(9)]\\n \\n def initPosibilities(self, board: List[List[str]]) -> None:\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n for value in range(1,10):\\n self.posibilities[i][j].add(str(value))\\n else:\\n self.posibilities[i][j].add(board[i][j])\\n board[i][j] = \\\".\\\"\\n\\n def removeValueFromCell(self,board,row:int,col:int,value:str)->None:\\n try:\\n self.posibilities[row][col].remove(value)\\n except KeyError as e:\\n return\\n\\n def setCell(self,board,row:int,col:int,value:str)->None:\\n board[row][col] = value\\n #on row\\n for j in range(9):\\n if(j==col):\\n continue\\n self.removeValueFromCell(board,row,j,value) \\n #on col\\n for i in range(9):\\n if(i==row):\\n continue\\n self.removeValueFromCell(board,i,col,value)\\n #on square\\n for i in range(3):\\n for j in range(3):\\n if row-row%3+i==row and col-col%3+j==col:\\n continue\\n self.removeValueFromCell(board,row-row%3+i,col-col%3+j,value)\\n\\n def fillByEliminating(self,board):\\n changeMade = True\\n while changeMade:\\n changeMade = False\\n for i in range(9):\\n for j in range(9):\\n if(board[i][j] == \\\".\\\" and len(self.posibilities[i][j]) == 1):\\n changeMade = True\\n self.setCell(board,i,j,next(iter(self.posibilities[i][j]))) \\n\\n def isValid(self)->bool:\\n for i in range(9):\\n for j in range(9):\\n if self.posibilities[i][j] == 0:\\n return False\\n return True\\n \\n def nextEmptySpace(self,board,row:int,col:int)->tuple[int,int]:\\n while board[row][col] != \\\".\\\":\\n col += 1\\n if col>8:\\n col=0\\n row+=1\\n if row == 9:\\n return (-1,-1)\\n return (row,col)\\n\\n def backtrackTheMdf(self,board: List[List[str]],row:int,col:int)->bool:\\n #all empty cells were filled\\n if row == -1:\\n return True\\n #trying the possible values\\n oldPossibilities = copy.deepcopy(self.posibilities)\\n oldBoard = copy.deepcopy(board)\\n for value in oldPossibilities[row][col]:\\n #filling the new guess\\n self.setCell(board,row,col,value)\\n self.fillByEliminating(board)\\n nextRow,nextCol = self.nextEmptySpace(board,row,col)\\n #restoring the sudoku in case of bad guess\\n if (self.isValid() and self.backtrackTheMdf(board,nextRow,nextCol)):\\n return True\\n else:\\n board = copy.deepcopy(oldBoard)\\n self.posibilities = copy.deepcopy(oldPossibilities)\\n \\n return False \\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n self.initPosibilities(board)\\n self.fillByEliminating(board)\\n nextRow,nextCol = self.nextEmptySpace(board,0,0)\\n self.backtrackTheMdf(board,nextRow,nextCol)\\n for i in range(9):\\n for j in range(9):\\n board[i][j] = str(next(iter(self.posibilities[i][j]))) \",\n \"runtime\": \"129\"\n },\n {\n \"code\": \"class Solution:\\n # The time complexity can be improved by using more space (dict and set) to save non-empty cells and their values.\\n def solveSudoku(self, board):\\n \\\"\\\"\\\"\\n :type board: List[List[str]]\\n :rtype: void Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n def could_place(d, row, col):\\n \\\"\\\"\\\"\\n Check if one could place a number `d` in (row, col) cell\\n \\\"\\\"\\\"\\n return not (\\n d in rows[row]\\n or d in columns[col]\\n or d in boxes[box_index(row, col)]\\n )\\n\\n def place_number(d, row, col):\\n \\\"\\\"\\\"\\n Place a number `d` in (row, col) cell\\n \\\"\\\"\\\"\\n rows[row][d] += 1\\n columns[col][d] += 1\\n boxes[box_index(row, col)][d] += 1\\n board[row][col] = str(d)\\n\\n def remove_number(d, row, col):\\n \\\"\\\"\\\"\\n Remove a number that didn't lead to a solution\\n \\\"\\\"\\\"\\n rows[row][d] -= 1\\n columns[col][d] -= 1\\n boxes[box_index(row, col)][d] -= 1\\n if rows[row][d] == 0:\\n del rows[row][d]\\n if columns[col][d] == 0:\\n del columns[col][d]\\n if boxes[box_index(row, col)][d] == 0:\\n del boxes[box_index(row, col)][d]\\n board[row][col] = \\\".\\\"\\n\\n def place_next_numbers(row, col):\\n \\\"\\\"\\\"\\n Call backtrack function in recursion to continue to place numbers\\n till the moment we have a solution (reached the bottom right)\\n \\\"\\\"\\\"\\n if col == N - 1 and row == N - 1:\\n sudoku_solved[0] = True\\n else: # place number row by row\\n if col == N - 1:\\n backtrack(row + 1, 0)\\n else:\\n backtrack(row, col + 1)\\n\\n def backtrack(row=0, col=0):\\n \\\"\\\"\\\"\\n Backtracking\\n \\\"\\\"\\\"\\n if board[row][col] == \\\".\\\":\\n for d in range(1, 10):\\n if could_place(d, row, col):\\n place_number(d, row, col)\\n place_next_numbers(row, col)\\n if sudoku_solved[0]:\\n return\\n remove_number(d, row, col)\\n else:\\n place_next_numbers(row, col)\\n\\n\\n n = 3\\n N = n * n\\n box_index = lambda row, col: (row // n) * n + col // n\\n\\n rows = [defaultdict(int) for _ in range(N)]\\n columns = [defaultdict(int) for _ in range(N)]\\n boxes = [defaultdict(int) for _ in range(N)]\\n for i in range(N):\\n for j in range(N):\\n if board[i][j] != \\\".\\\":\\n d = int(board[i][j])\\n place_number(d, i, j)\\n\\n sudoku_solved = [False]\\n backtrack()\",\n \"runtime\": \"129\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def could_place(d, row, col):\\n return not (d in rows[row] or d in cols[col] or d in boxes[box_id(row, col)])\\n def place_number(d, row, col):\\n rows[row][d] += 1\\n cols[col][d] += 1\\n boxes[box_id(row, col)][d] += 1\\n board[row][col] = str(d)\\n def remove_number(d, row, col):\\n del rows[row][d]\\n del cols[col][d]\\n del boxes[box_id(row, col)][d]\\n board[row][col] = '.'\\n def place_next(row, col):\\n if row == N - 1 and col == N - 1:\\n nonlocal solved\\n solved = True\\n else:\\n if col == N - 1:\\n backtrack(row + 1, 0)\\n else:\\n backtrack(row, col + 1)\\n def backtrack(row, col):\\n if board[row][col] == '.':\\n for d in range(1, 10):\\n if could_place(d, row, col):\\n place_number(d, row, col)\\n place_next(row, col)\\n if not solved:\\n remove_number(d, row, col)\\n else:\\n place_next(row, col)\\n N = 9\\n rows = [defaultdict(int) for i in range(N)]\\n cols = [defaultdict(int) for i in range(N)]\\n boxes = [defaultdict(int) for i in range(N)]\\n box_id = lambda row, col: (row // 3) * 3 + col // 3\\n for row in range(N):\\n for col in range(N):\\n if board[row][col] != '.':\\n d = int(board[row][col])\\n place_number(d, row, col)\\n solved = False\\n backtrack(0, 0)\",\n \"runtime\": \"135\"\n },\n {\n \"code\": \"class N:\\n def __init__(s):\\n s.L = s.R = s.U = s.D = s.C = s\\n \\ndef S(g):\\n N9, N81 = 9, 81\\n H = N()\\n C = [N() for _ in range(324)]\\n for i in range(324):\\n H.L.R = C[i]\\n C[i].R = H\\n C[i].L = H.L\\n H.L = C[i]\\n C[i].U = C[i].D = C[i]\\n C[i].C = C[i]\\n def ci(r, c, n):\\n return [r * 9 + c, 81 + r * 9 + n, 162 + c * 9 + n, 243 + ((r // 3) * 3 + (c // 3)) * 9 + n]\\n for r in range(9):\\n for c in range(9):\\n n = g[r][c]\\n if n:\\n n -= 1\\n cols = ci(r, c, n)\\n R = []\\n for col in cols:\\n node = N()\\n node.C = C[col]\\n node.U = C[col].U\\n node.D = C[col]\\n C[col].U.D = node\\n C[col].U = node\\n node.N = (r, c, n)\\n R.append(node)\\n for i in range(4):\\n R[i].R = R[(i + 1) % 4]\\n R[i].L = R[(i - 1) % 4]\\n else:\\n for n in range(9):\\n cols = ci(r, c, n)\\n R = []\\n for col in cols:\\n node = N()\\n node.C = C[col]\\n node.U = C[col].U\\n node.D = C[col]\\n C[col].U.D = node\\n C[col].U = node\\n node.N = (r, c, n)\\n R.append(node)\\n for i in range(4):\\n R[i].R = R[(i + 1) % 4]\\n R[i].L = R[(i - 1) % 4]\\n R = []\\n def Cc(c):\\n c.R.L = c.L\\n c.L.R = c.R\\n for i in I(c.D, lambda x: x != c, lambda x: x.D):\\n for j in I(i.R, lambda x: x != i, lambda x: x.R):\\n j.D.U = j.U\\n j.U.D = j.D\\n def Uc(c):\\n for i in I(c.U, lambda x: x != c, lambda x: x.U):\\n for j in I(i.L, lambda x: x != i, lambda x: x.L):\\n j.D.U = j\\n j.U.D = j\\n c.R.L = c\\n c.L.R = c\\n def I(s, c, m):\\n x = s\\n while c(x):\\n yield x\\n x = m(x)\\n def Sx(k):\\n if H.R == H:\\n return True\\n c = min(I(H.R, lambda x: x != H, lambda x: x.R), key=lambda c: sum(1 for _ in I(c.D, lambda x: x != c, lambda x: x.D)))\\n Cc(c)\\n for r in I(c.D, lambda x: x != c, lambda x: x.D):\\n R.append(r)\\n for j in I(r.R, lambda x: x != r, lambda x: x.R):\\n Cc(j.C)\\n if Sx(k + 1):\\n return True\\n for j in I(r.L, lambda x: x != r, lambda x: x.L):\\n Uc(j.C)\\n R.pop()\\n Uc(c)\\n return False\\n Sx(0)\\n for n in R:\\n r, c, v = n.N\\n g[r][c] = v + 1\\n return g\\n \\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n p = []\\n for row in board:\\n new_row = []\\n for char in row:\\n if char == \\\".\\\":\\n new_row.append(0)\\n else:\\n new_row.append(int(char))\\n p.append(new_row)\\n \\n s = S(p)\\n for ri, row in enumerate(s):\\n for ci, val in enumerate(row):\\n board[ri][ci] = str(val)\\n \\n\",\n \"runtime\": \"135\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def get_matrix_number(row, col):\\n return 3 * (row // 3) + (col // 3)\\n\\n def can_place(row, col, num):\\n return (num, row) not in rows_used and (num, col) not in cols_used and (num, get_matrix_number(row, col)) not in matrices_used\\n\\n def backtrack(row, col):\\n if row == ROWS - 1 and col == COLS:\\n return True\\n\\n if col == COLS:\\n row += 1\\n col = 0\\n\\n if board[row][col] != \\\".\\\":\\n return backtrack(row, col + 1)\\n\\n for i in range(1, 10):\\n num = str(i)\\n if can_place(row, col, num):\\n board[row][col] = num\\n rows_used.add((num, row))\\n cols_used.add((num, col))\\n matrices_used.add((num, get_matrix_number(row, col)))\\n\\n if backtrack(row, col + 1):\\n return True\\n\\n board[row][col] = \\\".\\\"\\n rows_used.remove((num, row))\\n cols_used.remove((num, col))\\n matrices_used.remove((num, get_matrix_number(row, col)))\\n\\n return False\\n\\n\\n # Sets of tuples, (number, row/col/matrix number)\\n ROWS = len(board)\\n COLS = len(board[0])\\n rows_used = set()\\n cols_used = set()\\n matrices_used = set()\\n\\n for row in range(ROWS):\\n for col in range(COLS):\\n num = board[row][col]\\n if num != \\\".\\\":\\n rows_used.add((num, row))\\n cols_used.add((num, col))\\n matrices_used.add((num, get_matrix_number(row, col)))\\n\\n backtrack(0, 0)\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n count = defaultdict(set)\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] != '.':\\n count[(i, -1)].add(board[i][j])\\n count[(-1, j)].add(board[i][j])\\n count[i // 3 * 3 + j // 3].add(board[i][j])\\n\\n def backtrack(board, count, x):\\n i, j = x // 9, x % 9\\n if x >= 81:\\n return True\\n if board[i][j] == '.':\\n for k in set(str(m) for m in range(1, 10)) - count[(i, -1)] - count[(-1, j)] - count[i // 3 * 3 + j // 3]:\\n count[(i, -1)].add(k)\\n count[(-1, j)].add(k)\\n count[i // 3 * 3 + j // 3].add(k)\\n board[i][j] = k\\n if backtrack(board, count, x + 1):\\n return True\\n board[i][j] = '.'\\n count[(i, -1)].remove(k)\\n count[(-1, j)].remove(k)\\n count[i // 3 * 3 + j // 3].remove(k)\\n else:\\n return backtrack(board, count, x + 1)\\n\\n backtrack(board, count, 0)\\n\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n rowSets = collections.defaultdict(set)\\n colSets = collections.defaultdict(set)\\n boxSets = collections.defaultdict(set)\\n\\n def populateSets():\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] != \\\".\\\":\\n rowSets[r].add(board[r][c])\\n colSets[c].add(board[r][c])\\n boxSets[(r // 3, c // 3)].add(board[r][c])\\n\\n # def findEmptySpace():\\n # for r in range(9):\\n # for c in range(9):\\n # if board[r][c] == \\\".\\\":\\n # return (r, c)\\n # return None\\n\\n def isValid(digit, r, c):\\n return (\\n digit not in rowSets[r] and\\n digit not in colSets[c] and\\n digit not in boxSets[(r // 3, c // 3)]\\n )\\n \\n def solve(r, c):\\n nonlocal solved\\n\\n if solved:\\n return\\n \\n if r == 9:\\n solved = True\\n return\\n\\n nextR, nextC = r + ((c + 1) // 9), (c + 1) % 9\\n\\n if board[r][c] != \\\".\\\":\\n solve(nextR, nextC)\\n else:\\n for digit in range(1, 10):\\n if isValid(str(digit), r, c):\\n\\n rowSets[r].add(str(digit))\\n colSets[c].add(str(digit))\\n boxSets[(r // 3, c // 3)].add(str(digit))\\n board[r][c] = str(digit)\\n solve(nextR, nextC)\\n\\n if not solved:\\n rowSets[r].remove(str(digit))\\n colSets[c].remove(str(digit))\\n boxSets[(r // 3, c // 3)].remove(str(digit))\\n board[r][c] = \\\".\\\"\\n \\n solved = False\\n populateSets()\\n solve(0, 0)\\n\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def find_existing_numbers(x, y):\\n seen_numbers = set()\\n\\n for i in range(9):\\n if board[i][y] != '.':\\n seen_numbers.add(board[i][y])\\n \\n for j in range(9):\\n if board[x][j] != '.':\\n seen_numbers.add(board[x][j])\\n \\n x = (x // 3) * 3\\n y = (y // 3) * 3\\n for i in range(0, 3):\\n for j in range(0, 3):\\n if board[x + i][y + j] != '.':\\n seen_numbers.add(board[x + i][y + j])\\n \\n return seen_numbers\\n\\n def find_candidates(x, y):\\n seen_numbers = find_existing_numbers(x, y)\\n \\n result = set()\\n for num in range(1,10):\\n if str(num) not in seen_numbers:\\n result.add(str(num))\\n \\n return result\\n \\n def is_valid(x, y, num):\\n seen_numbers = find_existing_numbers(x, y)\\n\\n return num not in seen_numbers\\n \\n def explore(x, y):\\n print(x, y, board[x][y])\\n # move on to next since the spot is already filled\\n if board[x][y] != '.':\\n if x == 8 and y == 8:\\n return True\\n \\n if y < 8:\\n return explore(x, y + 1)\\n else:\\n return explore(x + 1, 0)\\n\\n candidates = find_candidates(x, y)\\n\\n # spot is not filled but there are no possible candidates\\n if len(candidates) == 0:\\n return False\\n\\n # explore each candidate\\n for candidate in candidates:\\n \\n # set the current candidate\\n board[x][y] = candidate\\n\\n if x == 8 and y == 8:\\n return True\\n \\n if y < 8:\\n result = explore(x, y + 1)\\n\\n if result:\\n return True\\n else:\\n result = explore(x + 1, 0)\\n\\n if result:\\n return True\\n \\n board[x][y] = '.'\\n \\n return False\\n \\n explore(0, 0)\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\n rows=[set() for _ in range(9)]\\n cols=[set() for _ in range(9)]\\n boxs=[set() for _ in range(9)]\\n \\n for i in range(9):\\n for j in range(9):\\n if board[i][j]!=\\\".\\\":\\n num= board[i][j]\\n rows[i].add(num)\\n cols[j].add(num)\\n boxs[(i//3)*3+(j//3)].add(num)\\n\\n def backtrack():\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] ==\\\".\\\":\\n for num in \\\"123456789\\\":\\n box_num= (i//3)*3 + (j//3)\\n\\n if num not in rows[i] and num not in cols[j] and num not in boxs[box_num]:\\n board[i][j]= num\\n rows[i].add(num)\\n cols[j].add(num)\\n boxs[box_num].add(num)\\n\\n if backtrack():\\n return True\\n board[i][j]= \\\".\\\"\\n rows[i].remove(num)\\n cols[j].remove(num)\\n boxs[box_num].remove(num)\\n\\n return False\\n return True \\n \\n\\n backtrack()\\n\\n\\n \\n \",\n \"runtime\": \"151\"\n },\n {\n \"code\": \"class Solution:\\n # The time complexity can be improved by using more space (dict and set) to save non-empty cells and put into 3 separate dict for its row/col/cube-box.\\n def solveSudoku(self, board):\\n \\\"\\\"\\\"\\n :type board: List[List[str]]\\n :rtype: void Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n def could_place(d, row, col):\\n \\\"\\\"\\\"\\n Check if one could place a number `d` in (row, col) cell\\n \\\"\\\"\\\"\\n return not (\\n d in rows[row]\\n or d in columns[col]\\n or d in cubes[cube_index(row, col)]\\n )\\n\\n def place_number(d, row, col):\\n \\\"\\\"\\\"\\n Place a number `d` in (row, col) cell\\n \\\"\\\"\\\"\\n rows[row][d] += 1\\n columns[col][d] += 1\\n cubes[cube_index(row, col)][d] += 1\\n board[row][col] = str(d)\\n\\n def remove_number(d, row, col):\\n \\\"\\\"\\\"\\n Remove a number that didn't lead to a solution\\n \\\"\\\"\\\"\\n rows[row][d] -= 1\\n columns[col][d] -= 1\\n cubes[cube_index(row, col)][d] -= 1\\n if rows[row][d] == 0:\\n del rows[row][d]\\n if columns[col][d] == 0:\\n del columns[col][d]\\n if cubes[cube_index(row, col)][d] == 0:\\n del cubes[cube_index(row, col)][d]\\n board[row][col] = \\\".\\\"\\n\\n def place_next_numbers(row, col):\\n \\\"\\\"\\\"\\n Call backtrack function in recursion to continue to place numbers\\n till the moment we have a solution (reached the bottom right)\\n \\\"\\\"\\\"\\n if col == N - 1 and row == N - 1:\\n sudoku_solved[0] = True\\n else: # place number row by row\\n if col == N - 1:\\n backtrack(row + 1, 0)\\n else:\\n backtrack(row, col + 1)\\n\\n def backtrack(row=0, col=0):\\n \\\"\\\"\\\"\\n Backtracking\\n \\\"\\\"\\\"\\n if board[row][col] == \\\".\\\":\\n for d in range(1, 10):\\n if could_place(d, row, col):\\n place_number(d, row, col)\\n place_next_numbers(row, col)\\n if sudoku_solved[0]:\\n return\\n remove_number(d, row, col)\\n else:\\n place_next_numbers(row, col)\\n\\n\\n n = 3\\n N = n * n\\n cube_index = lambda row, col: (row // n) * n + col // n\\n\\n rows = [defaultdict(int) for _ in range(N)]\\n columns = [defaultdict(int) for _ in range(N)]\\n cubes = [defaultdict(int) for _ in range(N)]\\n for i in range(N):\\n for j in range(N):\\n if board[i][j] != \\\".\\\":\\n d = int(board[i][j])\\n place_number(d, i, j)\\n\\n sudoku_solved = [False]\\n backtrack()\",\n \"runtime\": \"151\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n BOARD_SIZE = 9\\n GRID_SIZE = 3\\n DIGITS = set([str(num) for num in range(1, BOARD_SIZE + 1)])\\n EMPTY_CELL = \\\".\\\"\\n \\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n \\n self.grids = defaultdict(list)\\n for row in range(self.BOARD_SIZE):\\n for col in range(self.BOARD_SIZE):\\n self.grids[self.get_grid_index(row, col)].append((row, col))\\n\\n self.backtrack(board)\\n \\n \\n def is_valid_state(self, board):\\n # check rows\\n for row in self.get_rows(board):\\n if set(row) != self.DIGITS:\\n return False\\n \\n # check columns\\n for column in self.get_columns(board):\\n if set(column) != self.DIGITS:\\n return False\\n \\n # check sub-boxes\\n for grid in self.get_grids(board):\\n if set(grid) != self.DIGITS:\\n return False\\n \\n return True\\n \\n def get_rows(self, board):\\n for row in board:\\n yield row\\n \\n def get_columns(self, board):\\n for col in range(self.BOARD_SIZE):\\n yield [ \\n board[row][col]\\n for row in range(self.BOARD_SIZE)\\n ]\\n \\n def get_grids(self, board):\\n for rows_and_cols in self.grids.values():\\n yield [\\n board[row][col] for (row, col) in rows_and_cols\\n ]\\n\\n def get_kth_row(self, board, k):\\n return board[k]\\n \\n def get_kth_col(self, board, k):\\n return [\\n board[row][k]\\n for row in range(self.BOARD_SIZE)\\n ]\\n \\n def get_grid_at(self, board, row, col):\\n rows_and_cols = self.grids[self.get_grid_index(row, col)]\\n return set([\\n board[row][col] for (row, col) in rows_and_cols\\n ])\\n \\n \\n def get_grid_index(self, row, col):\\n return row // self.GRID_SIZE * 3 + col // self.GRID_SIZE\\n \\n\\n def get_candidates(self, board, row, col):\\n used_digits = set()\\n # remove used digits used by the same row\\n used_digits.update(self.get_kth_row(board, row))\\n \\n # remove used digits from the same column\\n used_digits.update(self.get_kth_col(board, col))\\n \\n # remove used digits from the same 3x3 sub-box\\n used_digits.update(self.get_grid_at(board, row, col))\\n \\n used_digits.remove(self.EMPTY_CELL)\\n \\n return self.DIGITS - used_digits\\n \\n \\n def backtrack(self, board):\\n if self.is_valid_state(board):\\n return True\\n \\n # find the next empty spot and take a guess\\n for row in range(self.BOARD_SIZE):\\n for col in range(self.BOARD_SIZE):\\n if board[row][col] == self.EMPTY_CELL:\\n for candidate in self.get_candidates(board, row, col):\\n board[row][col] = candidate\\n is_solved = self.backtrack(board)\\n if is_solved:\\n return True\\n else:\\n board[row][col] = self.EMPTY_CELL\\n \\n return False\\n # no empty spot\\n return True\\n \",\n \"runtime\": \"162\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n if board[0][0] != \\\".\\\":\\n has_next = _find_next(board, 0, 0)\\n if has_next is not None:\\n row_idx, col_idx = has_next\\n else:\\n row_idx, col_idx = 0, 0\\n\\n _solve(board, row_idx=row_idx, col_idx=col_idx)\\n\\nref_set = set(\\\"123456789\\\")\\ndef _find_next(board, row_idx, col_idx):\\n row = board[row_idx]\\n for _col_idx in range(col_idx + 1, 9):\\n if row[_col_idx] == \\\".\\\":\\n return row_idx, _col_idx\\n for _row_idx in range(row_idx + 1, 9):\\n row = board[_row_idx]\\n for _col_idx in range(9):\\n if row[_col_idx] == \\\".\\\":\\n return _row_idx, _col_idx\\n return None\\n\\n\\ndef _solve(board, row_idx=0, col_idx=0):\\n # print(f\\\"Called, row = {row_idx}, col = {col_idx}\\\")\\n # if board[row_idx][col_idx] != \\\".\\\":\\n # has_next = _find_next(board, row_idx, col_idx)\\n # if has_next is None:\\n # return _check(board)\\n # row_idx, col_idx = has_next\\n # # print(f\\\"Updated, row = {row_idx}, col = {col_idx}\\\")\\n\\n choices = (\\n ref_set\\n - set(board[row_idx])\\n - {board[_row_idx][col_idx] for _row_idx in range(9)}\\n )\\n block_row_idx = row_idx // 3\\n block_col_idx = col_idx // 3\\n choices = choices - {\\n board[block_row_idx * 3 + _row_idx][block_col_idx * 3 + _col_idx]\\n for _row_idx in range(3)\\n for _col_idx in range(3)\\n }\\n if len(choices) == 0:\\n return False\\n\\n has_next = _find_next(board, row_idx, col_idx)\\n if has_next is None:\\n # for choice in choices:\\n if len(choices) == 1:\\n board[row_idx][col_idx] = choices.pop()\\n # if _check(board):\\n return True\\n return False\\n nex_row_idx, next_col_idx = has_next\\n for choice in choices:\\n board[row_idx][col_idx] = choice\\n if _solve(board, row_idx=nex_row_idx, col_idx=next_col_idx):\\n return True\\n board[row_idx][col_idx] = \\\".\\\"\\n return False \",\n \"runtime\": \"162\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def place_number(d, row, col):\\n rows[row][d] += 1\\n columns[col][d] += 1\\n boxes[box_index(row, col)][d] += 1\\n board[row][col] = str(d)\\n def could_place(d, row, col):\\n return not (d in rows[row] or d in columns[col] or d in boxes[box_index(row, col)])\\n def place_next_numbers(row, col):\\n if col == N - 1 and row == N - 1:\\n sudoku_solved[0] = True\\n else:\\n if col == N - 1:\\n backtrack(row + 1, 0)\\n else:\\n backtrack(row, col + 1)\\n def remove_number(d, row, col):\\n rows[row][d] -= 1\\n columns[col][d] -= 1\\n boxes[box_index(row, col)][d] -= 1\\n if rows[row][d] == 0:\\n del rows[row][d]\\n if columns[col][d] == 0:\\n del columns[col][d]\\n if boxes[box_index(row, col)][d] == 0:\\n del boxes[box_index(row, col)][d]\\n board[row][col] = \\\".\\\"\\n def backtrack(row=0, col=0):\\n if board[row][col] == \\\".\\\":\\n for d in range(1, 10):\\n if could_place(d, row, col):\\n place_number(d, row, col)\\n place_next_numbers(row, col)\\n if sudoku_solved[0]:\\n return\\n remove_number(d, row, col)\\n else:\\n place_next_numbers(row, col)\\n n = 3\\n N = n * n\\n box_index = lambda row, col: (row // n) * n + col // n\\n rows = [defaultdict(int) for _ in range(N)]\\n columns = [defaultdict(int) for _ in range(N)]\\n boxes = [defaultdict(int) for _ in range(N)]\\n for i in range(N):\\n for j in range(N):\\n if board[i][j] != \\\".\\\":\\n d = int(board[i][j])\\n place_number(d, i, j)\\n sudoku_solved = [False]\\n backtrack()\",\n \"runtime\": \"168\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Modify board in-place to solve the Sudoku puzzle.\\n \\\"\\\"\\\"\\n # Initialize sets to track numbers in rows, columns, and sub-boxes\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [set() for _ in range(9)]\\n \\n # Fill the sets with existing numbers from the board\\n for i in range(9):\\n for j in range(9):\\n num = board[i][j]\\n if num != '.':\\n box_index = (i // 3) * 3 + (j // 3)\\n rows[i].add(num)\\n cols[j].add(num)\\n boxes[box_index].add(num)\\n\\n def is_valid(num, row, col):\\n \\\"\\\"\\\"\\n Check if placing 'num' in board[row][col] is valid.\\n \\\"\\\"\\\"\\n box_index = (row // 3) * 3 + (col // 3)\\n if num in rows[row] or num in cols[col] or num in boxes[box_index]:\\n return False\\n return True\\n \\n def solve():\\n \\\"\\\"\\\"\\n Recursive backtracking function to solve the board.\\n \\\"\\\"\\\"\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n for num in '123456789':\\n if is_valid(num, i, j):\\n # Place the number and update the sets\\n board[i][j] = num\\n rows[i].add(num)\\n cols[j].add(num)\\n boxes[(i // 3) * 3 + (j // 3)].add(num)\\n \\n # Recur to solve the rest of the board\\n if solve():\\n return True\\n \\n # Undo the move (backtrack)\\n board[i][j] = '.'\\n rows[i].remove(num)\\n cols[j].remove(num)\\n boxes[(i // 3) * 3 + (j // 3)].remove(num)\\n return False\\n return True\\n \\n solve()\\n\",\n \"runtime\": \"168\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Modify board in-place to solve the Sudoku puzzle.\\n \\\"\\\"\\\"\\n # Initialize sets to track numbers in rows, columns, and sub-boxes\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [set() for _ in range(9)]\\n \\n # Fill the sets with existing numbers from the board\\n for i in range(9):\\n for j in range(9):\\n num = board[i][j]\\n if num != '.':\\n box_index = (i // 3) * 3 + (j // 3)\\n rows[i].add(num)\\n cols[j].add(num)\\n boxes[box_index].add(num)\\n\\n def is_valid(num, row, col):\\n \\\"\\\"\\\"\\n Check if placing 'num' in board[row][col] is valid.\\n \\\"\\\"\\\"\\n box_index = (row // 3) * 3 + (col // 3)\\n if num in rows[row] or num in cols[col] or num in boxes[box_index]:\\n return False\\n return True\\n \\n def solve():\\n \\\"\\\"\\\"\\n Recursive backtracking function to solve the board.\\n \\\"\\\"\\\"\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n for num in '123456789':\\n if is_valid(num, i, j):\\n # Place the number and update the sets\\n board[i][j] = num\\n rows[i].add(num)\\n cols[j].add(num)\\n boxes[(i // 3) * 3 + (j // 3)].add(num)\\n \\n # Recur to solve the rest of the board\\n if solve():\\n return True\\n \\n # Undo the move (backtrack)\\n board[i][j] = '.'\\n rows[i].remove(num)\\n cols[j].remove(num)\\n boxes[(i // 3) * 3 + (j // 3)].remove(num)\\n return False\\n return True\\n \\n solve()\\n\",\n \"runtime\": \"174\"\n },\n {\n \"code\": \"class Solution:\\n row_dict = {}\\n col_dict = {}\\n box_dict = {}\\n goal_set = set([1, 2, 3, 4, 5, 6, 7, 8, 9])\\n grid = []\\n \\n def fill_dict_with_null(self):\\n for i in range(9):\\n self.row_dict[i] = set()\\n self.col_dict[i] = set()\\n self.box_dict[i] = set()\\n\\n def fill_initial_values(self, board):\\n for i in range(len(board)):\\n for j in range(len(board[i])):\\n if(board[i][j] != \\\".\\\"):\\n self.row_dict[i].add(board[i][j])\\n if(board[j][i] != \\\".\\\"):\\n self.col_dict[i].add(board[j][i])\\n self.box_traversal(board)\\n\\n def box_traversal(self, board):\\n for i in range(3):\\n for j in range(3):\\n for x in range(3*i, 3*(i+1)):\\n for y in range(3*j, 3*(j+1)):\\n if(board[x][y] != 0):\\n self.box_dict[3*i +j].add(board[x][y])\\n\\n def get_box_num(self, x, y):\\n return (3*(x//3) + y//3)\\n\\n def get_next_empty_cell(self, board):\\n for i in range(9):\\n for j in range(9):\\n if(board[i][j] == 0):\\n return i,j\\n return -1, -1\\n\\n def check_if_num_can_fit_in_cell(self, num, row, col):\\n if num in self.row_dict[row]:\\n return False\\n elif num in self.col_dict[col]:\\n return False\\n elif num in self.box_dict[self.get_box_num(row, col)]:\\n return False\\n return True\\n \\n def assign_val_to_cell(self, val, row, col):\\n self.row_dict[row].add(val)\\n self.col_dict[col].add(val)\\n self.box_dict[self.get_box_num(row, col)].add(val)\\n\\n def remove_val_from_cell(self, val, row, col):\\n self.row_dict[row].remove(val)\\n self.col_dict[col].remove(val)\\n self.box_dict[self.get_box_num(row, col)].remove(val)\\n\\n def backtracker(self):\\n x, y = self.get_next_empty_cell(self.grid)\\n if(x == -1 and y == -1):\\n return True\\n for i in range(1,10):\\n if (self.check_if_num_can_fit_in_cell(i, x, y)):\\n self.assign_val_to_cell(i, x, y)\\n self.grid[x][y] = i\\n if(self.backtracker()):\\n return True\\n self.remove_val_from_cell(i, x, y)\\n self.grid[x][y] = 0\\n return False \\n\\n def convert_board_to_int(self, board):\\n self.grid = board\\n for row in range(len(self.grid)):\\n for col in range(len(self.grid[row])):\\n if self.grid[row][col] == '.':\\n self.grid[row][col] = '0'\\n self.grid[row][col] = int(self.grid[row][col])\\n\\n def format_output(self):\\n for row in range(len(self.grid)):\\n for col in range(len(self.grid[row])):\\n self.grid[row][col] = str(self.grid[row][col])\\n\\n def solveSudoku(self, board):\\n self.convert_board_to_int(board)\\n self.fill_dict_with_null()\\n self.fill_initial_values(self.grid)\\n\\n self.backtracker()\\n self.format_output()\\n board = self.grid\",\n \"runtime\": \"174\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def check(i,j,num):\\n if num in board[i]: \\n return False\\n for k in range(9):\\n if board[k][j] == num:\\n return False\\n for l in range(i//3 * 3, i//3*3 + 3):\\n for m in range(j//3 * 3, j//3*3 + 3):\\n if board[l][m] == num:\\n return False\\n return True\\n\\n def backtrack(i,j):\\n if j == 9:\\n i,j = i+1,0\\n if i == 9:\\n return True\\n if board[i][j] == '.':\\n for cur in range(1,10):\\n if check(i, j, str(cur)):\\n board[i][j] = str(cur)\\n if backtrack(i,j+1):\\n return True\\n board[i][j] = '.'\\n return False\\n else:\\n return backtrack(i, j+1)\\n backtrack(0,0)\\n\",\n \"runtime\": \"179\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board):\\n def find_candidates(board, r, c):\\n if board[r][c] != \\\".\\\":\\n return set()\\n candidates = set(\\\"123456789\\\")\\n # 检查行\\n for num in board[r]:\\n candidates.discard(num)\\n # 检查列\\n for i in range(9):\\n candidates.discard(board[i][c])\\n # 检查3x3子格\\n start_row, start_col = 3 * (r // 3), 3 * (c // 3)\\n for i in range(start_row, start_row + 3):\\n for j in range(start_col, start_col + 3):\\n candidates.discard(board[i][j])\\n return candidates\\n\\n def find_next_empty(board):\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\":\\n return r, c\\n return None # 棋盘已满\\n\\n def solve():\\n next_pos = find_next_empty(board)\\n if next_pos is None:\\n return True # 棋盘已填满，解完成\\n\\n r, c = next_pos\\n candidates = find_candidates(board, r, c)\\n for cand in candidates:\\n board[r][c] = cand\\n if solve():\\n return True # 递归成功，返回\\n board[r][c] = \\\".\\\" # 回溯：撤销选择\\n\\n return False # 触发回溯\\n\\n solve()\\n\",\n \"runtime\": \"179\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n n = len(board)\\n block_index_change = {0: [0, 1, 2], 1:[-1, 0, 1], 2:[-2, -1, 0]}\\n \\n def violate_numbers(row, col):\\n rows_digit = [x for x in board[row] if x.isdigit()]\\n cols_ditit = [x[col] for x in board if x[col].isdigit()]\\n \\n row_rank = row%3\\n col_rank = col%3\\n \\n cube_digit = []\\n rows_change = block_index_change[row_rank]\\n cols_change = block_index_change[col_rank]\\n for r in rows_change:\\n for c in cols_change:\\n if board[row+r][col+c].isdigit() and not (r==0 and c==0):\\n cube_digit.append(board[row+r][col+c])\\n cur_digit = set(cube_digit + cols_ditit + rows_digit)\\n \\n return cur_digit\\n \\n \\n empty_list = []\\n for i in range(n):\\n for j in range(n):\\n if board[i][j] == '.':\\n empty_list.append([i,j])\\n \\n def dfs(idx):\\n if idx == len(empty_list):\\n return True\\n \\n e = empty_list[idx]\\n\\n vn = violate_numbers(e[0], e[1])\\n valid_number = [x for x in range(1,10) if str(x) not in vn]\\n # print(valid_number)\\n for v in valid_number:\\n board[e[0]][e[1]] = str(v)\\n if dfs(idx+1):\\n return True\\n board[e[0]][e[1]] = '.'\\n \\n return False\\n \\n dfs(0)\\n\\n\\n \\n \\n \\n \\n\\n \\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"185\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n rowHash = {}\\n colHash = {}\\n groupHash = {}\\n cellGroupXref = {}\\n\\n group = 0\\n prevGroup = 0\\n for row in range(len(board)):\\n if row % 3 == 0:\\n prevGroup = group\\n else:\\n group = prevGroup\\n if row not in rowHash:\\n rowHash[row] = set()\\n for col in range(len(board[0])):\\n cellGroupXref[(row, col)] = group\\n if group not in groupHash:\\n groupHash[group] = set()\\n if col not in colHash:\\n colHash[col] = set()\\n if board[row][col] != \\\".\\\":\\n groupHash[group].add(board[row][col])\\n rowHash[row].add(board[row][col])\\n colHash[col].add(board[row][col])\\n if (col + 1) % 3 == 0:\\n group += 1\\n\\n def helperDfs():\\n for row in range(len(board)):\\n for col in range(len(board[0])):\\n if board[row][col] == \\\".\\\":\\n for cand in range (1, 10):\\n cand = str(cand)\\n if cand in rowHash[row] or cand in colHash[col] or cand in groupHash[cellGroupXref[(row, col)]]:\\n continue\\n board[row][col] = cand\\n rowHash[row].add(cand)\\n colHash[col].add(cand)\\n groupHash[cellGroupXref[(row, col)]].add(cand)\\n if helperDfs():\\n return True\\n board[row][col] = \\\".\\\"\\n rowHash[row].remove(cand)\\n colHash[col].remove(cand)\\n groupHash[cellGroupXref[(row, col)]].remove(cand)\\n return False\\n return True\\n\\n helperDfs()\\n \\n \\n\\n\",\n \"runtime\": \"185\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n squares_pos = [[[] for _ in range(3)] for _ in range(3)]\\n for row in range(9):\\n for col in range(9):\\n squares_pos[row // 3][col // 3].append((row, col))\\n\\n def is_valid(row, col, num):\\n for i in range(9):\\n if board[row][i] == num:\\n return False\\n if board[i][col] == num:\\n return False\\n for i, j in squares_pos[row // 3][col // 3]:\\n if board[i][j] == num:\\n return False\\n return True\\n \\n def dfs(row, col):\\n if row == 9:\\n return True\\n if col == 9:\\n return dfs(row+1, 0)\\n\\n if board[row][col] != '.':\\n return dfs(row, col+1)\\n \\n for num in range(1, 10):\\n if is_valid(row, col, str(num)):\\n board[row][col] = str(num)\\n if dfs(row, col+1):\\n return True\\n else:\\n board[row][col] = '.'\\n return False\\n \\n dfs(0, 0)\",\n \"runtime\": \"190\"\n },\n {\n \"code\": \"class Solution:\\n def solver(self, index, board, data):\\n if index >= len(board) * len(board[0]):\\n return True\\n \\n row = index // len(board[0])\\n col = index - row * len(board[0])\\n \\n if board[row][col] == \\\".\\\":\\n for digit in range(1, 10):\\n if (\\n f\\\"row_{row}_{digit}\\\" not in data and\\n f\\\"col_{col}_{digit}\\\" not in data and\\n f\\\"quad_{row // 3}_{col // 3}_{digit}\\\" not in data\\n ):\\n board[row][col] = str(digit)\\n data.add(f\\\"row_{row}_{digit}\\\")\\n data.add(f\\\"col_{col}_{digit}\\\")\\n data.add(f\\\"quad_{row // 3}_{col // 3}_{digit}\\\")\\n \\n res = self.solver(index + 1, board, data)\\n if res:\\n return True\\n \\n board[row][col] = \\\".\\\"\\n data.remove(f\\\"row_{row}_{digit}\\\")\\n data.remove(f\\\"col_{col}_{digit}\\\")\\n data.remove(f\\\"quad_{row // 3}_{col // 3}_{digit}\\\")\\n \\n return False\\n else:\\n return self.solver(index + 1, board, data)\\n \\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n The time complexity should be 9 ^ m (m represents the number of blanks to be filled in), since each blank can have 9 choices.\\n \\\"\\\"\\\"\\n data = set()\\n for i in range(len(board)):\\n for j in range(len(board[0])):\\n if board[i][j] != \\\".\\\":\\n data.add(f\\\"row_{i}_{board[i][j]}\\\")\\n data.add(f\\\"col_{j}_{board[i][j]}\\\")\\n data.add(f\\\"quad_{i // 3}_{j // 3}_{board[i][j]}\\\")\\n \\n self.solver(0, board, data)\",\n \"runtime\": \"190\"\n },\n {\n \"code\": \"class Solution:\\n def find_possible_digits(self, board, row, col):\\n possible_digits = {\\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\", \\\"5\\\", \\\"6\\\", \\\"7\\\", \\\"8\\\", \\\"9\\\"}\\n for i in range(9):\\n for j in range(9):\\n if i == row or j == col:\\n if board[i][j] != \\\".\\\":\\n possible_digits.discard(board[i][j])\\n area_row = int(row / 3) * 3\\n area_col = int(col / 3) * 3\\n for i in range(area_row, area_row + 3):\\n for j in range(area_col, area_col + 3):\\n if board[i][j] != \\\".\\\":\\n possible_digits.discard(board[i][j])\\n return possible_digits\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def rec(b):\\n row, col = -1, -1\\n for i in range(9):\\n break_flag = False\\n for j in range(9):\\n if b[i][j] == \\\".\\\":\\n row = i\\n col = j\\n break_flag = True\\n break\\n if break_flag:\\n break\\n\\n if row == -1:\\n return b\\n\\n digits = self.find_possible_digits(b, row, col)\\n\\n for digit in digits:\\n b[row][col] = digit\\n ret = rec(b)\\n if ret:\\n return b\\n b[row][col] = \\\".\\\"\\n return None\\n\\n rec(board)\\n\",\n \"runtime\": \"196\"\n },\n {\n \"code\": \"class Solution:\\n def canPlace(self, row, col, board, digit):\\n for idx in range(9):\\n if board[row][idx] == digit or board[idx][col] == digit:\\n return False\\n rstr = 3 * (row // 3)\\n cstr = 3 * (col // 3)\\n for r in range(rstr, rstr + 3):\\n for c in range(cstr, cstr + 3):\\n if board[r][c] == digit:\\n return False\\n return True\\n\\n def traverse(self, row, col, board):\\n if row == 9:\\n return True\\n if col == 9:\\n return self.traverse(row + 1, 0, board)\\n if board[row][col] != \\\".\\\":\\n return self.traverse(row, col + 1, board)\\n for digit in \\\"123456789\\\":\\n if self.canPlace(row, col, board, digit):\\n board[row][col] = digit\\n possible = self.traverse(row, col + 1, board)\\n if possible:\\n return True\\n board[row][col] = \\\".\\\"\\n return False\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.traverse(0, 0, board)\\n return board\\n \",\n \"runtime\": \"196\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n def isValid(i, j, num):\\n # check row, col\\n for x in range(9):\\n if self.board[i][x] == num or self.board[x][j] == num:\\n return False\\n # check sub-box\\n rstart, cstart = i//3*3, j//3*3\\n for x in range(rstart, rstart+3):\\n for y in range(cstart, cstart+3):\\n if x == i or y == j:\\n continue\\n if self.board[x][y] == num:\\n return False\\n return True\\n\\n def backtracking(i, j):\\n if i == 9:\\n return True\\n if j == 9:\\n return backtracking(i + 1, 0)\\n if self.board[i][j] != '.':\\n return backtracking(i, j + 1)\\n for n in \\\"123456789\\\":\\n if not isValid(i, j, n):\\n continue\\n self.board[i][j] = n\\n if backtracking(i, j + 1):\\n return True\\n self.board[i][j] = '.'\\n return False\\n\\n self.board = board\\n backtracking(0, 0)\\n return board\",\n \"runtime\": \"201\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n ROW_STATES = \\\"rowStates\\\"\\n COL_STATES = \\\"colStates\\\"\\n BOX_STATES = \\\"boxStates\\\"\\n\\n # Will contain state as set of values for each row, col, box\\n states = {ROW_STATES: {}, COL_STATES: {}, BOX_STATES: {}}\\n\\n for i in range(9):\\n states[ROW_STATES][i] = set()\\n states[COL_STATES][i] = set()\\n states[BOX_STATES][i] = set()\\n\\n def getBoxNumber(i: int, j: int) -> int:\\n \\\"\\\"\\\"\\n This function returns the box number for the given cell\\n \\\"\\\"\\\"\\n\\n return int(i / 3) * 3 + int(j / 3)\\n\\n # Iterate through the cells in the sudoku board and update states\\n for i in range(9):\\n for j in range(9):\\n\\n if board[i][j] != \\\".\\\":\\n\\n numStr = board[i][j]\\n # add to relevant board state\\n states[ROW_STATES][i].add(numStr)\\n states[COL_STATES][j].add(numStr)\\n\\n boxNum = getBoxNumber(i, j)\\n states[BOX_STATES][boxNum].add(numStr)\\n\\n # for box in states[BOX_STATES]:\\n # print(f\\\"Box {box} : {states[BOX_STATES][box]}\\\")\\n\\n def updateBoard(num_str: str, i: int, j: int):\\n\\n # update the board as well\\n board[i][j] = num_str\\n\\n states[ROW_STATES][i].add(num_str)\\n states[COL_STATES][j].add(num_str)\\n\\n boxNum = getBoxNumber(i, j)\\n states[BOX_STATES][boxNum].add(num_str)\\n\\n def resetBoard(num_str: str, i, j):\\n\\n # remove from board\\n board[i][j] = \\\".\\\"\\n\\n states[ROW_STATES][i].remove(num_str)\\n states[COL_STATES][j].remove(num_str)\\n\\n boxNum = getBoxNumber(i, j)\\n states[BOX_STATES][boxNum].remove(num_str)\\n\\n def findNextCell(i, j):\\n if i == 8 and j == 8:\\n solved[0] = True\\n return\\n\\n if j == 8:\\n fill(i + 1, 0)\\n else:\\n fill(i, j + 1)\\n\\n def canFillIn(numStr: str, i: int, j: int):\\n boxNum = getBoxNumber(i, j)\\n\\n return (\\n numStr not in states[ROW_STATES][i]\\n and numStr not in states[COL_STATES][j]\\n and numStr not in states[BOX_STATES][boxNum]\\n )\\n\\n def fill(i, j):\\n if board[i][j] != \\\".\\\":\\n findNextCell(i, j)\\n else:\\n for num in range(1, 10):\\n numStr = str(num)\\n if canFillIn(numStr, i, j):\\n updateBoard(numStr, i, j)\\n findNextCell(i, j)\\n if solved[0]:\\n return\\n resetBoard(numStr, i, j)\\n\\n solved = [False]\\n fill(0, 0)\\n\",\n \"runtime\": \"201\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isValid(board, row, col, num):\\n if num in board[row]:\\n return False\\n\\n for r in range(9):\\n if board[r][col] == num:\\n return False\\n\\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\\n for r in range(start_row, start_row + 3):\\n for c in range(start_col, start_col + 3):\\n if board[r][c] == num:\\n return False\\n return True\\n \\n\\n def backtrack(board):\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == '.':\\n for num in '123456789':\\n if isValid(board, r, c, num):\\n board[r][c] = num\\n if backtrack(board):\\n return True\\n board[r][c] = '.'\\n return False\\n return True \\n\\n backtrack(board)\\n return board\",\n \"runtime\": \"207\"\n },\n {\n \"code\": \"import copy\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n results = []\\n\\n traverse(board, 0, 0, results)\\n print(\\\"results\\\",results)\\n if len(results) > 0:\\n for row in range(len(board)):\\n for col in range(len(board[0])):\\n board[row][col] = results[0][row][col]\\n\\ndef traverse(board, row, col, results):\\n # print(\\\"row,col,board\\\",row,col,board)\\n if row > 8 :\\n if board[8][8] != '.':\\n print(\\\"board\\\", board)\\n newBoard = copy.deepcopy(board)\\n results.append(newBoard)\\n return\\n \\n nextRow = row\\n nextCol = col + 1\\n\\n if nextCol == 9:\\n nextRow += 1\\n nextCol = 0\\n # print(\\\"row, col\\\", row, col)\\n\\n if board[row][col] != '.': \\n traverse(board, nextRow, nextCol, results)\\n return\\n \\n units = findAvailableUnits(board, row, col)\\n # print(\\\"row, col, units\\\",row, col, units)\\n for unit in units:\\n board[row][col] = unit\\n traverse(board, nextRow, nextCol, results)\\n board[row][col] = '.'\\n\\ndef findAvailableUnits(board, row, col):\\n units = set(['1','2','3','4','5','6','7','8','9'])\\n for iterCol in range(len(board[0])):\\n if board[row][iterCol] != '.':\\n units.discard(board[row][iterCol])\\n\\n for iterRow in range(len(board)):\\n if board[iterRow][col] != '.':\\n units.discard(board[iterRow][col])\\n\\n squareInitRow = row // 3 * 3\\n squareInitCol= col // 3 * 3\\n\\n for i in range(3):\\n for j in range(3):\\n if board[squareInitRow + i][squareInitCol + j] != '.':\\n units.discard(board[squareInitRow + i][squareInitCol + j])\\n\\n return units\",\n \"runtime\": \"207\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n header_dict = dict()\\n h = ColumnNode()\\n size = len(board)\\n solution = []\\n\\n def rowRange(cIndex):\\n rows = [0] * size\\n res = int(cIndex / size ** 2)\\n if res == 0:\\n column = cIndex % size\\n row = int(cIndex / size)\\n for i in range(0, size):\\n rows[i] = row * size ** 2 + column * size + i\\n elif res == 1:\\n cIndex -= size ** 2\\n row = int(cIndex / size)\\n valueIndex = cIndex % size\\n for c in range(0, size):\\n rows[c] = row * size ** 2 + c * size + valueIndex\\n elif res == 2:\\n cIndex = cIndex - size ** 2 * 2\\n column = int(cIndex / size)\\n valueIndex = cIndex % size\\n for r in range(0, size):\\n rows[r] = r * size ** 2 + column * size + valueIndex\\n else:\\n cIndex = cIndex - size ** 2 * 3\\n valueIndex = cIndex % size\\n box = int(cIndex / size)\\n boxsize = int(size ** 0.5)\\n for r in range(int(box / boxsize) * boxsize, (int(box / boxsize) + 1) * boxsize):\\n for c in range(box % boxsize * boxsize, (box % boxsize + 1) * boxsize):\\n rows[(r - int(box / boxsize) * boxsize) * boxsize + (\\n c - box % boxsize * boxsize)] = r * size ** 2 + c * size + valueIndex\\n return rows\\n\\n def columnRange(rIndex):\\n columns = [0] * 4\\n row = int(rIndex / size ** 2)\\n column = int(rIndex % (size ** 2) / len(board))\\n valueIndex = int((rIndex % size ** 2) % len(board))\\n columns[0] = row * size + column\\n columns[1] = size ** 2 + row * size + valueIndex\\n columns[2] = size ** 2 * 2 + column * size + valueIndex\\n columns[3] = size ** 2 * 3 + (int(int(row / size ** 0.5) * size ** 0.5) + int(column / size ** 0.5)) * size + valueIndex\\n return columns\\n\\n def findMinColumn():\\n t = h.R\\n min = h\\n m = size + 1\\n while t != h:\\n if t.S == 0:\\n min = h\\n break\\n if t.S < m:\\n m = t.S\\n min = t\\n t = t.R\\n return min\\n\\n def findNode(c, rIndex, cIndex):\\n node = c.D\\n for i in range(0, size):\\n if (rowRange(cIndex)[i] == rIndex):\\n break\\n node = node.D\\n return node\\n\\n def cover(c):\\n c.removeH()\\n i = c.D\\n while i != c:\\n j = i.R\\n while j != i:\\n j.removeV()\\n j = j.R\\n i = i.D\\n\\n def uncover(c):\\n i = c.U\\n while i != c:\\n j = i.L\\n while j != i:\\n j.addV()\\n j = j.L\\n i = i.U\\n c.addH()\\n\\n def solving():\\n if h.R == h:\\n for i in solution:\\n while i.c.N >= size ** 2:\\n i = i.L\\n row = int(i.c.N / size)\\n column = i.c.N % size\\n valueIndex = i.R.c.N - size ** 2 - row * size\\n board[row][column] = str(valueIndex + 1)\\n return True\\n c = findMinColumn()\\n if c == h: return False\\n r = c.D\\n cover(c)\\n while r != c:\\n solution.append(r)\\n j = r.R\\n while j != r:\\n cover(j.c)\\n j = j.R\\n\\n if solving(): return True\\n solution.remove(r)\\n j = r.L\\n while j != r:\\n uncover(j.c)\\n j = j.L\\n r = r.D\\n uncover(c)\\n return False\\n\\n for i in range(0, len(board) ** 2 * 4):\\n c = ColumnNode(i)\\n header_dict[i] = c\\n for j in range(0, len(board)):\\n node = DancingNode(c)\\n c.linkDown(node)\\n if j == 0:\\n node.D = c\\n c.U = node\\n if i == 0:\\n h.linkRight(c)\\n else:\\n header_dict[i - 1].linkRight(c)\\n if i == len(board) ** 2 * 4 - 1:\\n c.R = h\\n h.L = c\\n\\n for i in range(0, size ** 2):\\n for j in range(0, size):\\n rIndex = rowRange(i)[j]\\n\\n r = findNode(header_dict.get(columnRange(rIndex)[0]), rIndex, columnRange(rIndex)[0])\\n for k in range(3, 0, -1):\\n c = findNode(header_dict.get(columnRange(rIndex)[k]), rIndex, columnRange(rIndex)[k])\\n r.linkRight(c)\\n if k == 3:\\n r.L = c\\n c.R = r\\n\\n for r in range(0, size):\\n for c in range(0, size):\\n if board[r][c] != \\\".\\\":\\n val = int(board[r][c])\\n val -= 1\\n rIndex = r * size ** 2 + c * size + val\\n for k in range(0, 4):\\n cover(header_dict[columnRange(rIndex)[k]])\\n\\n solving()\\n return board\\n\\nclass DancingNode:\\n def __init__(self, c=None):\\n self.U = self.D = self.L = self.R = self\\n self.c = c\\n\\n def linkRight(self, node):\\n node.L = self\\n node.R = self.R\\n self.R.L = node\\n self.R = node\\n\\n def linkDown(self, node):\\n node.U = self\\n self.D.U = node\\n node.D = self.D\\n self.D = node\\n self.c.S += 1\\n\\n def removeH(self):\\n self.L.R = self.R\\n self.R.L = self.L\\n\\n def removeV(self):\\n self.U.D = self.D\\n self.D.U = self.U\\n self.c.S -= 1\\n\\n def addH(self):\\n self.L.R = self\\n self.R.L = self\\n\\n def addV(self):\\n self.U.D = self\\n self.D.U = self\\n self.c.S += 1\\n\\n\\nclass ColumnNode(DancingNode):\\n def __init__(self, N=None):\\n super().__init__(self)\\n # size\\n self.S = 0\\n # name\\n self.N = N\\n\",\n \"runtime\": \"212\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # backtracking + pruning\\n\\n def possible_numbers(i,j,board):\\n possibles = set([str(x) for x in range(1, 10)])\\n \\n # rows\\n for x in board[i]:\\n if x in possibles:\\n possibles.remove(x)\\n \\n # cols\\n for row in board:\\n if row[j] in possibles:\\n possibles.remove(row[j])\\n \\n # 3x3 square\\n square_x = j//3\\n square_y = i//3\\n for y in range(square_x*3, square_x*3+3):\\n for x in range(square_y*3, square_y*3+3):\\n if board[x][y] in possibles:\\n possibles.remove(board[x][y])\\n \\n return list(possibles)\\n\\n empties = []\\n\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n empties.append((i,j))\\n \\n\\n res = []\\n # parameters: idx for empties, tuple of board\\n def backtrack(idx, t_board):\\n if idx == len(empties):\\n for i in range(9):\\n temp = []\\n for j in range(9):\\n temp.append(t_board[i][j])\\n res.append(temp)\\n return\\n \\n x, y = empties[idx][0], empties[idx][1]\\n possibles = possible_numbers(x, y, t_board)\\n \\n if len(possibles) == 0:\\n return\\n \\n for num in possibles:\\n t_board[x][y] = num\\n backtrack(idx+1, t_board)\\n t_board[x][y] = \\\".\\\"\\n \\n backtrack(0, board)\\n \\n for i in range(9):\\n for j in range(9):\\n board[i][j] = res[i][j]\\n \\n\\n\\n \\n \\n\\n \",\n \"runtime\": \"212\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n \\n # for each cell, find the row, col, and 3x3's occurences of 1-9\\n # find all possible cell vals\\n # continue from each\\n # \\n\\n def solve(i,j,num):\\n # need to check also for square\\n for k in range(9):\\n if board[i][k]==num or board[k][j]==num:\\n return False\\n rs = (i//3)*3\\n cs = (j//3)*3\\n for k in range(rs,rs+3):\\n for l in range(cs,cs+3):\\n if board[k][l]==num:\\n return False\\n return True\\n\\n def backtrack(i,j):\\n if i>8:\\n return True\\n if j>8:\\n return backtrack(i+1,0)\\n if board[i][j]==\\\".\\\":\\n for num in range(1,10):\\n if solve(i,j,str(num)):\\n board[i][j]=str(num)\\n if backtrack(i,j+1):\\n return True\\n board[i][j]=\\\".\\\"\\n return False\\n else:\\n return backtrack(i,j+1)\\n backtrack(0,0)\",\n \"runtime\": \"218\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isValid(r, c, k):\\n for i in range(9):\\n if board[i][c] == k or board[r][i] == k:\\n return False\\n startRow = r - r % 3\\n startCol = c - c % 3\\n for i in range(3):\\n for j in range(3):\\n if board[i + startRow][j + startCol] == k:\\n return False\\n return True \\n def backtrack(r, c):\\n if r == 9:\\n return True\\n if c == 9:\\n return backtrack(r + 1, 0)\\n if board[r][c] == '.':\\n for k in range(1, 10):\\n if isValid(r, c, str(k)):\\n board[r][c] = str(k)\\n if backtrack(r, c + 1):\\n return True\\n board[r][c] = '.'\\n return False\\n return backtrack(r, c + 1)\\n backtrack(0, 0)\",\n \"runtime\": \"218\"\n },\n {\n \"code\": \"def fixedlocation(sud) -> list:\\n fixed = []\\n for row in range(len(sud)):\\n for col in range(len(sud[row])):\\n if sud[row][col] != \\\".\\\":\\n fixed.append(str(row) + str(col))\\n return fixed\\n\\ndef transpose(sud) -> list:\\n transpose_sud = []\\n for row in range(len(sud)):\\n coln = []\\n for col in range(len(sud[row])):\\n coln.append(sud[col][row]) \\n transpose_sud.append(coln)\\n\\n return transpose_sud\\n\\ndef blockerize(sud) -> list:\\n blockerize_sud = []\\n for row in range(len(sud)):\\n block = []\\n for col in range(len(sud[row])):\\n block.append(sud[(row // 3)*3 + col // 3][col % 3 + (row % 3) * 3]) \\n blockerize_sud.append(block) \\n \\n return blockerize_sud\\n \\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n row, col = 0, 0\\n beginning_coor = \\\"99\\\"\\n fixed_sud = set(fixedlocation(board))\\n row_backtrack, col_backtrack = False, False\\n blockerize_sud = blockerize(board) \\n transpose_sud = transpose(board)\\n while -1 < row and row < 9:\\n if row_backtrack and col == -1:\\n col = 8\\n else:\\n col = 0\\n\\n while -1 < col and col < 9:\\n if (str(row) + str(col)) in fixed_sud:\\n if col_backtrack:\\n col -=1\\n if col < 0:\\n row_backtrack = True\\n continue\\n else:\\n col +=1\\n continue\\n sud_row = set(board[row])\\n sud_col = set(transpose_sud[col])\\n sud_block = set(blockerize_sud[(row // 3)*3 + col // 3])\\n union = sud_row | sud_col | sud_block\\n temp = board[row][col]\\n start = 0 if board[row][col] == '.' else board[row][col]\\n for i in range(int(start) + 1, 10):\\n if str(i) not in union:\\n if beginning_coor == \\\"99\\\":\\n beginning_coor = str(col) + str(row)\\n board[row][col] = str(i)\\n col_backtrack = False\\n row_backtrack = False\\n break\\n if board[row][col] == temp: #fail to find any number, start backtracking\\n if board[row][col] != \\\".\\\":\\n board[row][col] = \\\".\\\"\\n col_backtrack = True\\n\\n transpose_sud[col][row] = board[row][col]\\n blockerize_sud[(row // 3)*3 + col // 3][col % 3 + (row % 3) * 3] = board[row][col]\\n\\n if col_backtrack:\\n col -=1\\n if col < 0:\\n row_backtrack = True\\n else:\\n col +=1\\n \\n if row_backtrack:\\n row -=1\\n else:\\n row +=1\\n \",\n \"runtime\": \"224\"\n },\n {\n \"code\": \"class Solution:\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n def isSafe(row, col, num):\\n for i in range(9):\\n if board[row][i] == num:\\n return False\\n if board[i][col] == num:\\n return False\\n startRow = row - row % 3\\n startCol = col - col % 3\\n for i in range(3):\\n for j in range(3):\\n if board[i + startRow][j+startCol] == num:\\n return False\\n return True\\n \\n def validSol(row, col):\\n if row == 8 and col > 8:\\n return True\\n if col > 8:\\n row += 1\\n col = 0\\n \\n if board[row][col] != \\\".\\\":\\n return validSol(row, col+1)\\n \\n for i in range(1,10):\\n if isSafe(row, col, str(i)):\\n board[row][col] = str(i)\\n if validSol(row, col + 1):\\n return True\\n board[row][col] = \\\".\\\"\\n \\n return False\\n \\n validSol(0,0)\",\n \"runtime\": \"224\"\n },\n {\n \"code\": \"def fixedlocation(sud) -> list:\\n fixed = []\\n for row in range(len(sud)):\\n for col in range(len(sud[row])):\\n if sud[row][col] != \\\".\\\":\\n fixed.append(str(row) + str(col))\\n return fixed\\n\\ndef transpose(sud) -> list:\\n transpose_sud = []\\n for row in range(len(sud)):\\n coln = []\\n for col in range(len(sud[row])):\\n coln.append(sud[col][row]) \\n transpose_sud.append(coln)\\n\\n return transpose_sud\\n\\ndef blockerize(sud) -> list:\\n blockerize_sud = []\\n for row in range(len(sud)):\\n block = []\\n for col in range(len(sud[row])):\\n block.append(sud[(row // 3)*3 + col // 3][col % 3 + (row % 3) * 3]) \\n blockerize_sud.append(block) \\n \\n return blockerize_sud\\n \\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n row, col = 0, 0\\n beginning_coor = \\\"99\\\"\\n fixed_sud = set(fixedlocation(board))\\n row_backtrack, col_backtrack = False, False\\n blockerize_sud = blockerize(board) \\n transpose_sud = transpose(board)\\n while -1 < row and row < 9:\\n if row_backtrack and col == -1:\\n col = 8\\n else:\\n col = 0\\n\\n while -1 < col and col < 9:\\n if (str(row) + str(col)) in fixed_sud:\\n if col_backtrack:\\n col -=1\\n if col < 0:\\n row_backtrack = True\\n continue\\n else:\\n col +=1\\n continue\\n sud_row = set(board[row])\\n sud_col = set(transpose_sud[col])\\n sud_block = set(blockerize_sud[(row // 3)*3 + col // 3])\\n union = sud_row | sud_col | sud_block\\n temp = board[row][col]\\n start = 0 if board[row][col] == '.' else board[row][col]\\n for i in range(int(start) + 1, 10):\\n if str(i) not in union:\\n if beginning_coor == \\\"99\\\":\\n beginning_coor = str(col) + str(row)\\n board[row][col] = str(i)\\n col_backtrack = False\\n row_backtrack = False\\n break\\n if board[row][col] == temp: #fail to find any number, start backtracking\\n if board[row][col] != \\\".\\\":\\n board[row][col] = \\\".\\\"\\n col_backtrack = True\\n\\n transpose_sud[col][row] = board[row][col]\\n blockerize_sud[(row // 3)*3 + col // 3][col % 3 + (row % 3) * 3] = board[row][col]\\n\\n if col_backtrack:\\n col -=1\\n if col < 0:\\n row_backtrack = True\\n else:\\n col +=1\\n \\n if row_backtrack:\\n row -=1\\n else:\\n row +=1\\n \",\n \"runtime\": \"229\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n n = len(board)\\n rows = defaultdict(set)\\n cols = defaultdict(set)\\n squares = defaultdict(set)\\n\\n # add given numbers in original board\\n for i in range(n):\\n for j in range(n):\\n if board[i][j] != '.':\\n rows[i].add(board[i][j])\\n cols[j].add(board[i][j])\\n squares[(i//3,j//3)].add(board[i][j]) \\n \\n def valid():\\n return (\\n len(rows) == 9 and len(cols) == 9 and len(squares) == 9\\n and all([True if len(rows[r]) == 9 else False for r in rows])\\n and all([True if len(cols[c]) == 9 else False for c in cols])\\n and all([True if len(squares[s]) == 9 else False for s in squares])\\n )\\n\\n def solve(board, row, col):\\n if valid():\\n return True\\n\\n for i in range(n):\\n for j in range(n):\\n if board[i][j] == '.':\\n for k in range(1, 10):\\n k = str(k)\\n if k not in rows[i] and k not in cols[j] and k not in squares[(i//3,j//3)]:\\n # change\\n rows[i].add(k)\\n cols[j].add(k)\\n squares[(i//3,j//3)].add(k)\\n board[i][j] = str(k)\\n\\n # recurse\\n if solve(board, i, j):\\n return True\\n\\n # backtrack\\n board[i][j] = '.'\\n rows[i].remove(k)\\n cols[j].remove(k)\\n squares[(i//3,j//3)].remove(k)\\n\\n # no k exists that solves the board based on previous k's chosen\\n return False\\n\\n return False\\n\\n solve(board, 0, 0)\",\n \"runtime\": \"229\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n emptySpots = []\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == \\\".\\\":\\n emptySpots.append([row, col])\\n\\n def canInsert(row: int, col: int, num: str):\\n # check 3 things to make sure it's ok to add current num\\n # the row\\n for _col in range(9):\\n if board[row][_col] == num:\\n return False\\n\\n # the column\\n for _row in range(9):\\n if board[_row][col] == num:\\n return False\\n\\n # the 3 * 3 sub board\\n subBoardStartRow = (row // 3) * 3\\n subBoardStartCol = (col // 3) * 3\\n\\n for _row in range(subBoardStartRow, subBoardStartRow + 3):\\n for _col in range(subBoardStartCol, subBoardStartCol + 3):\\n if board[_row][_col] == num:\\n return False\\n\\n return True\\n\\n def solve(currIdx: int = 0) -> None:\\n # all empty spots are filled with a valid number\\n if currIdx == len(emptySpots):\\n return True\\n\\n row, col = emptySpots[currIdx]\\n for candidateNum in range(1, 10):\\n if canInsert(row, col, str(candidateNum)):\\n board[row][col] = str(candidateNum)\\n\\n # try current number\\n if solve(currIdx + 1):\\n return True\\n\\n # revert change and try out another number\\n board[row][col] = \\\".\\\"\\n\\n return False\\n\\n solve()\\n\",\n \"runtime\": \"235\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n n = 9\\n def solve(board):\\n for i in range(n):\\n for j in range(n):\\n if board[i][j]==\\\".\\\":\\n pos = set(map(str,range(1,10)))\\n for k in range(n):\\n if board[i][k].isdigit():\\n pos.discard(board[i][k])\\n if board[k][j].isdigit():\\n pos.discard(board[k][j])\\n for p,q in filter(\\n lambda x:3*(i//3)+j//3==3*(x[0]//3)+x[1]//3,\\n ((x,y) for x in range(9) for y in range(9))):\\n if board[p][q].isdigit():\\n pos.discard(board[p][q])\\n if not pos: return False\\n for k in pos:\\n board[i][j] = k\\n if solve(board):\\n return True\\n else:\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n solve(board)\\n \\n \",\n \"runtime\": \"235\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n ROWS, COLS = len(board), len(board[0])\\n\\n def find_empty():\\n for r in range(ROWS):\\n for c in range(COLS):\\n if board[r][c] == '.':\\n return (r, c)\\n \\n return None\\n\\n\\n colset, rowset, gridset = collections.defaultdict(set), collections.defaultdict(set), collections.defaultdict(set)\\n\\n def is_valid(r, c, val):\\n # val = board[r][c]\\n\\n if val in colset[c] or val in rowset[r] or val in gridset[(r // 3, c // 3)]:\\n return False\\n print('colset', colset[c], 'rowset', rowset[r], 'gridset', gridset[(r // 3, c // 3)])\\n return True\\n \\n def add_cell(r, c):\\n val = board[r][c]\\n\\n colset[c].add(val)\\n rowset[r].add(val)\\n gridset[(r // 3, c // 3)].add(val)\\n \\n def remove_cell(r, c):\\n val = board[r][c]\\n\\n colset[c].remove(val)\\n rowset[r].remove(val)\\n gridset[(r // 3, c // 3)].remove(val)\\n\\n\\n def solve(r, c):\\n if r == 9:\\n return True\\n if c == 9:\\n return solve(r + 1, 0)\\n \\n if board[r][c] == '.':\\n for i in range(1, 10):\\n if is_valid(r, c, str(i)):\\n board[r][c] = str(i)\\n\\n add_cell(r, c)\\n\\n if solve(r, c + 1):\\n return True\\n\\n remove_cell(r, c) \\n board[r][c] = '.'\\n\\n return False\\n \\n return solve(r, c + 1)\\n\\n # prepopulate sets\\n for r in range(ROWS):\\n for c in range(COLS):\\n if board[r][c] != '.':\\n add_cell(r, c)\\n\\n solve(0, 0)\",\n \"runtime\": \"240\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n arr = []\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n arr.append([i,j])\\n \\n def safe(i,j,num):\\n for x in range(9):\\n if board[i][x] == num:\\n return False\\n for y in range(9):\\n if board[y][j] == num:\\n return False\\n for x in range(3):\\n for y in range(3):\\n r = 3*(i//3) + x\\n c = 3*(j//3) + y\\n if board[r][c] == num:\\n return False\\n return True\\n\\n def solve(index):\\n if index == len(arr):\\n return True\\n row, col = arr[index]\\n for num in '123456789':\\n if safe(row, col, num):\\n board[row][col] = num\\n if solve(index+1):\\n return True\\n board[row][col] = '.'\\n return False\\n solve(0)\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"240\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def find_existing_numbers(x, y):\\n seen_numbers = set()\\n\\n for i in range(9):\\n if board[i][y] != '.':\\n seen_numbers.add(board[i][y])\\n \\n for j in range(9):\\n if board[x][j] != '.':\\n seen_numbers.add(board[x][j])\\n \\n x = (x // 3) * 3\\n y = (y // 3) * 3\\n for i in range(0, 3):\\n for j in range(0, 3):\\n if board[x + i][y + j] != '.':\\n seen_numbers.add(board[x + i][y + j])\\n \\n return seen_numbers\\n\\n def find_candidates(x, y):\\n seen_numbers = find_existing_numbers(x, y)\\n \\n result = set()\\n for num in range(1,10):\\n if str(num) not in seen_numbers:\\n result.add(str(num))\\n \\n return result\\n \\n def is_valid(x, y, num):\\n seen_numbers = find_existing_numbers(x, y)\\n\\n return num not in seen_numbers\\n \\n def explore(x, y):\\n print(x, y, board[x][y])\\n # move on to next since the spot is already filled\\n if board[x][y] != '.':\\n if x == 8 and y == 8:\\n return True\\n \\n if y < 8:\\n return explore(x, y + 1)\\n else:\\n return explore(x + 1, 0)\\n\\n candidates = find_candidates(x, y)\\n\\n # spot is not filled but there are no possible candidates\\n if len(candidates) == 0:\\n return False\\n\\n # explore each candidate\\n for candidate in candidates:\\n \\n # set the current candidate\\n board[x][y] = candidate\\n\\n if x == 8 and y == 8:\\n return True\\n \\n if y < 8:\\n result = explore(x, y + 1)\\n\\n if result:\\n return True\\n else:\\n result = explore(x + 1, 0)\\n\\n if result:\\n return True\\n \\n board[x][y] = '.'\\n \\n return False\\n \\n explore(0, 0)\",\n \"runtime\": \"246\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: list[list[str]]) -> None:\\n def isValid(row: int, col: int, c: str) -> bool:\\n for i in range(9):\\n if (board[i][col] == c or\\n board[row][i] == c or\\n board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c):\\n return False\\n return True\\n\\n def solve(s: int) -> bool:\\n if s == 81:\\n return True\\n\\n i = s // 9\\n j = s % 9\\n\\n if board[i][j] != '.':\\n return solve(s + 1)\\n\\n for c in string.digits[1:]:\\n if isValid(i, j, c):\\n board[i][j] = c\\n if solve(s + 1):\\n return True\\n board[i][j] = '.'\\n\\n return False\\n\\n solve(0)\",\n \"runtime\": \"246\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def square(a,b):\\n squares = [{(x+i,y+j) for i in range(-1,2) for j in range(-1,2)} for (x,y) in [(1,1),(1,4),(1,7),(4,1),(4,4),(4,7),(7,1),(7,4),(7,7)]] \\n for s in squares:\\n if (a,b) in s:\\n return s\\n def valid_numbers(x,y):\\n return {'1','2','3','4','5','6','7','8','9'} - (set(board[x]) | set(board[i][y] for i in range(9)) | set(board[i][j] for (i,j) in square(x,y)))\\n def solve(p):\\n for s in range(p,81):\\n i,j = s//9,s%9\\n if board[i][j] == \\\".\\\":\\n possibilities = valid_numbers(i,j)\\n if not possibilities:\\n return False\\n for n in possibilities:\\n board[i][j] = str(n)\\n if solve(s+1):\\n return True\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n solve(0)\\n\",\n \"runtime\": \"251\"\n },\n {\n \"code\": \"# 注意：python 代码由 chatGPT\\\\U0001f916 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。\\n# 本代码已经通过力扣的测试用例，应该可直接成功提交。\\n\\nclass Solution:\\n def solveSudoku(self, board):\\n self.backtrack(board, 0, 0)\\n\\n def backtrack(self, board, i, j):\\n m, n = 9, 9\\n if j == n:\\n # 穷举到最后一列的话就换到下一行重新开始。\\n return self.backtrack(board, i + 1, 0)\\n if i == m:\\n # 找到一个可行解，触发 base case\\n return True\\n\\n if board[i][j] != '.':\\n # 如果有预设数字，不用我们穷举\\n return self.backtrack(board, i, j + 1)\\n\\n for ch in '123456789': # Corrected range for '1' to '9'\\n # 如果遇到不合法的数字，就跳过\\n if not self.isValid(board, i, j, ch):\\n continue\\n\\n board[i][j] = ch\\n # 如果找到一个可行解，立即结束\\n if self.backtrack(board, i, j + 1):\\n return True\\n board[i][j] = '.'\\n\\n # 穷举完 1~9，依然没有找到可行解，此路不通\\n return False\\n\\n # 判断 board[i][j] 是否可以填入 n\\n def isValid(self, board, r, c, n):\\n for i in range(9):\\n # 判断行是否存在重复\\n if board[r][i] == n:\\n return False\\n # 判断列是否存在重复\\n if board[i][c] == n:\\n return False\\n # 判断 3 x 3 方框是否存在重复\\n if board[(r // 3) * 3 + i // 3][(c // 3) * 3 + i % 3] == n:\\n return False\\n return True\\n# 详细解析参见：\\n# https://labuladong.online/algo/practice-in-action/sudoku/\\n\",\n \"runtime\": \"251\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: list[list[str]]) -> None:\\n def isValid(row: int, col: int, c: str) -> bool:\\n for i in range(9):\\n if (board[i][col] == c or\\n board[row][i] == c or\\n board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c):\\n return False\\n return True\\n\\n def solve(s: int) -> bool:\\n if s == 81:\\n return True\\n\\n i = s // 9\\n j = s % 9\\n\\n if board[i][j] != '.':\\n return solve(s + 1)\\n\\n for c in string.digits[1:]:\\n if isValid(i, j, c):\\n board[i][j] = c\\n if solve(s + 1):\\n return True\\n board[i][j] = '.'\\n\\n return False\\n\\n solve(0)\",\n \"runtime\": \"257\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def is_valid(board, row, col, num):\\n \\\"\\\"\\\"\\n Check if it's valid to place `num` at board[row][col].\\n \\\"\\\"\\\"\\n # Check the row\\n for c in range(9):\\n if board[row][c] == num:\\n return False\\n \\n # Check the column\\n for r in range(9):\\n if board[r][col] == num:\\n return False\\n \\n # Check the 3x3 sub-box\\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\\n for r in range(start_row, start_row + 3):\\n for c in range(start_col, start_col + 3):\\n if board[r][c] == num:\\n return False\\n \\n return True\\n \\n def solve(board):\\n \\\"\\\"\\\"\\n Use backtracking to solve the Sudoku board.\\n \\\"\\\"\\\"\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == '.':\\n for num in '123456789':\\n if is_valid(board, row, col, num):\\n board[row][col] = num\\n if solve(board):\\n return True\\n board[row][col] = '.' # Undo the move\\n return False # Trigger backtracking\\n return True\\n \\n solve(board)\",\n \"runtime\": \"257\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: list[list[str]]) -> None:\\n def isValid(row: int, col: int, c: str) -> bool:\\n for i in range(9):\\n if (board[i][col] == c or\\n board[row][i] == c or\\n board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c):\\n return False\\n return True\\n\\n def solve(s: int) -> bool:\\n if s == 81:\\n return True\\n\\n i = s // 9\\n j = s % 9\\n\\n if board[i][j] != '.':\\n return solve(s + 1)\\n\\n for c in string.digits[1:]:\\n if isValid(i, j, c):\\n board[i][j] = c\\n if solve(s + 1):\\n return True\\n board[i][j] = '.'\\n\\n return False\\n\\n solve(0)\",\n \"runtime\": \"262\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: list[list[str]]) -> None:\\n def isValid(row: int, col: int, c: str) -> bool:\\n for i in range(9):\\n if (board[i][col] == c or\\n board[row][i] == c or\\n board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c):\\n return False\\n return True\\n\\n def solve(s: int) -> bool:\\n if s == 81:\\n return True\\n\\n i = s // 9\\n j = s % 9\\n\\n if board[i][j] != '.':\\n return solve(s + 1)\\n\\n for c in string.digits[1:]:\\n if isValid(i, j, c):\\n board[i][j] = c\\n if solve(s + 1):\\n return True\\n board[i][j] = '.'\\n\\n return False\\n\\n solve(0)\\n \",\n \"runtime\": \"262\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board):\\n def is_valid(num, row, col):\\n for i in range(9):\\n if board[row][i] == num or board[i][col] == num:\\n return False\\n box_row, box_col = 3 * (row // 3), 3 * (col // 3)\\n for i in range(box_row, box_row + 3):\\n for j in range(box_col, box_col + 3):\\n if board[i][j] == num:\\n return False\\n return True\\n\\n def backtrack():\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n for num in '123456789':\\n if is_valid(num, i, j):\\n board[i][j] = num\\n if backtrack():\\n return True\\n board[i][j] = '.' # Reset on backtrack\\n return False # Trigger backtrack if no number is valid\\n return True # Solved\\n\\n backtrack()\",\n \"runtime\": \"268\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: list[list[str]]) -> None:\\n def isValid(row: int, col: int, c: str) -> bool:\\n for i in range(9):\\n if (board[i][col] == c or\\n board[row][i] == c or\\n board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c):\\n return False\\n return True\\n\\n def solve(s: int) -> bool:\\n if s == 81:\\n return True\\n\\n i = s // 9\\n j = s % 9\\n\\n if board[i][j] != '.':\\n return solve(s + 1)\\n\\n for c in string.digits[1:]:\\n if isValid(i, j, c):\\n board[i][j] = c\\n if solve(s + 1):\\n return True\\n board[i][j] = '.'\\n\\n return False\\n\\n solve(0)\",\n \"runtime\": \"268\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n curr_pos = (0,0)\\n from itertools import product, islice\\n to_next = {x:y for x,y in zip(product(range(9),range(9)), islice(product(range(9),range(9)), 1, None))}\\n to_next[(8,8)] = None\\n def pos_to_row(pos):\\n return pos[0]\\n def pos_to_col(pos):\\n return pos[1]\\n def pos_to_block(pos):\\n return (pos[0]//3) + 3 * (pos[1]//3)\\n \\n set_row = [ set() for _ in range(9)]\\n set_col = [ set() for _ in range(9)]\\n set_block = [ set() for _ in range(9)]\\n f_and_s = ((pos_to_row, set_row), (pos_to_col, set_col), (pos_to_block, set_block))\\n for pos in product(range(9), repeat = 2):\\n if board[pos[0]][pos[1]] == '.':\\n continue\\n else:\\n filling = int(board[pos[0]][pos[1]])\\n for fun_, set_ in f_and_s:\\n set_[fun_(pos)].add(filling)\\n\\n\\n def search(pos):\\n if pos is None:\\n return True\\n u, v = pos\\n if board[u][v] != '.':\\n if search(to_next[pos]):\\n return True\\n return False\\n else:\\n for i in range(1, 10):\\n if any([i in set_[fun_(pos)] for fun_, set_ in f_and_s]):\\n continue\\n for fun_, set_ in f_and_s:\\n set_[fun_(pos)].add(i)\\n board[u][v] = str(i)\\n if search(to_next[pos]):\\n return True\\n for fun_, set_ in f_and_s:\\n set_[fun_(pos)].remove(i)\\n board[u][v] = '.'\\n search((0,0))\\n \\n \",\n \"runtime\": \"273\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n # Backtracking problem: simple in concept, but difficult in execution\\n # Setup a method to check if value we want to add is valid or not\\n # Use recursion to do the backtracking\\n # Need to setup the end case for returning\\n\\n def isBoardValid():\\n for i in range(len(board)):\\n row = board[i]\\n if len(set(row)) != 9:\\n return False\\n for j in range(len(board[0])):\\n col = [i[j] for i in board]\\n if len(set(col)) != 9:\\n return False\\n for box_row in range(3):\\n for box_col in range(3):\\n box_vals = []\\n for i in range(box_row*3, (box_row+1)*3):\\n for j in range(box_col*3, (box_col+1)*3):\\n box_vals.append(board[i][j])\\n if len(set(box_vals)) != 9:\\n return False\\n return True\\n \\n\\n def isValid(row, col, val):\\n # Check row\\n # if val in board[row]:\\n # return False\\n # # Check col\\n # col_vals = [i[col] for i in board]\\n # if val in col_vals:\\n # return False\\n # # Check 3x3 box\\n # box_vals = []\\n # for i in range(row//3*3, (row//3+1)*3):\\n # for j in range(col//3*3, (col//3+1)*3):\\n # box_vals.append(board[i][j])\\n # if val in box_vals:\\n # return False\\n # return True\\n \\n region_row = (row//3)*3\\n region_col = (col//3)*3\\n\\n for col_check in range(9):\\n if val in board[row][col_check]:\\n return False\\n for row_check in range(9):\\n if val in board[row_check][col]:\\n return False\\n for row_check in range(region_row,region_row+3):\\n for col_check in range(region_col,region_col+3):\\n # print(row_check,col_check)\\n if val in board[row_check][col_check]:\\n return False\\n return True\\n \\n \\n soln_found = False\\n def backtrack(start_row, start_col):\\n nonlocal soln_found\\n # if row == 1 and start_col == 1:\\n # print(board)\\n # return\\n if start_col >= 9:\\n start_row += 1\\n start_col = 0\\n if start_row >= 9:\\n soln_found = True\\n return\\n if soln_found:\\n return\\n for i in range(start_row, 9):\\n # start = start_col if i == row else 0\\n if i != start_row:\\n start_col = 0\\n for j in range(start_col, 9):\\n if board[i][j] == '.':\\n for num in range(9):\\n val = str(num+1)\\n if isValid(i, j, val):\\n board[i][j] = val\\n backtrack(i,j+1)\\n if not soln_found:\\n board[i][j] = '.'\\n else:\\n return\\n return\\n soln_found = True\\n # if isBoardValid():\\n # soln_found = True\\n \\n # print(isValid(0,2,\\\"3\\\"))\\n # print(isValid(0,2,\\\"1\\\"))\\n # print(isValid(0,2,\\\"9\\\"))\\n # print(isBoardValid())\\n backtrack(0,0)\\n print(soln_found)\\n\\n \",\n \"runtime\": \"273\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Solves the Sudoku puzzle in-place.\\n \\\"\\\"\\\"\\n # Helper function to check if placing num at board[row][col] is valid\\n def is_valid(board, row, col, num):\\n # Check row\\n for i in range(9):\\n if board[row][i] == num:\\n return False\\n \\n # Check column\\n for i in range(9):\\n if board[i][col] == num:\\n return False\\n \\n # Check 3x3 sub-grid\\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\\n for i in range(3):\\n for j in range(3):\\n if board[start_row + i][start_col + j] == num:\\n return False\\n \\n return True\\n \\n # Helper function to solve the board using backtracking\\n def backtrack(board):\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == '.': # Found an empty space\\n for num in '123456789': # Try placing numbers 1-9\\n if is_valid(board, row, col, num):\\n board[row][col] = num # Place the number\\n \\n if backtrack(board): # Recursively solve the next cell\\n return True\\n \\n board[row][col] = '.' # Undo the move (backtrack)\\n return False # No valid number was found for this cell\\n return True # Solved the board\\n \\n # Call the backtracking function to solve the board\\n backtrack(board)\\n\\n\\n\\n\\n\",\n \"runtime\": \"279\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n #这题类似N皇后 用dfs去生成每一行 在行里每个坐标填数字 \\n #还需要一个check每行 每列 每3X3格子有效性的function 每3X3格子需要背 比任何东西都不直观\\n self.fill(0, 0, board) #row, col, board\\n \\n def fill(self, row, col, board):\\n #这里边fill的逻辑要非常清楚\\n if row == 9: return True #填满所有行 就T\\n if col == 9: return self.fill(row+1, 0, board) #填满当前行所有格子 就去下一行继续填 col初始化为0 从头开始走\\n \\n if board[row][col] == '.': #当前格子能填数字\\n for i in range(1, 10):\\n if self.isvalid(row, col, board, str(i)): #如果数字在当前格子valid\\n board[row][col] = str(i)\\n if self.fill(row, col+1, board): #就去同行下一个格子填\\n return True #?T去哪里\\n else:\\n board[row][col] = '.' #如果下一个格子不行 就把这个当前格子改回‘.’ 回到for循环选一个新数字来填\\n else:\\n return self.fill(row, col+1, board) #如果当前格子不能填数字 就去下一个格子填\\n\\n def isvalid(self, row, col, board, letter):\\n for i in range(9): #这里不能是(1,10) 因为i是0-index坐标\\n if letter == board[i][col] or letter == board[row][i]:\\n return False\\n if letter == board[3*(row//3)+i//3][3*(col//3)+i%3]:\\n return False\\n return True\",\n \"runtime\": \"279\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\n def is_valid(r,c,n):\\n for i in range(9):\\n if board[r][i]==n:\\n return False\\n for i in range(9):\\n if board[i][c] == n:\\n return False\\n\\n rs = (r//3)*3\\n cs = (c//3)*3\\n\\n for i in range(rs,rs+3):\\n for j in range(cs,cs+3):\\n if board[i][j]==n:\\n return False\\n return True\\n\\n def solve():\\n for r in range(0,9):\\n for c in range(0,9):\\n if board[r][c]=='.':\\n for n in '123456789':\\n if is_valid(r,c,n):\\n board[r][c] = n\\n if solve():\\n return True\\n else:\\n board[r][c] = '.'\\n return False\\n return True\\n solve() \\n\\n \\n\",\n \"runtime\": \"285\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isValid(r,c,k):\\n for i in range(9):\\n if board[i][c]==k or board[r][i]==k:\\n return False\\n subgrid_row = 3 * (r//3) + i//3\\n subgrid_col = 3 * (c//3) + i%3\\n if board[subgrid_row][subgrid_col]==k:\\n return False\\n return True\\n\\n def fill(r,c):\\n if r==9:\\n return True\\n if c==9:\\n return fill(r + 1, 0)\\n if board[r][c]=='.':\\n for k in range(1,10):\\n if isValid(r,c,str(k)):\\n board[r][c] = str(k)\\n if fill(r,c+1):\\n return True\\n board[r][c] = '.'\\n return False\\n return fill(r,c+1)\\n fill(0,0)\",\n \"runtime\": \"285\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n # Check if placing 'k' at position (r, c) is valid\\n def isValid(r, c, k):\\n for i in range(9):\\n # Check row and column\\n if board[i][c] == k or board[r][i] == k:\\n return False\\n \\n # Check the 3x3 subgrid\\n subgrid_row = 3 * (r // 3) + i // 3\\n subgrid_col = 3 * (c // 3) + i % 3\\n if board[subgrid_row][subgrid_col] == k:\\n return False\\n return True \\n\\n # Recursively fill the board\\n def fill(r, c):\\n # If we reach the end of the board, the solution is found\\n if r == 9:\\n return True\\n \\n # Move to the next row if we reach the end of the current row\\n if c == 9:\\n return fill(r + 1, 0)\\n \\n # If the current cell is empty, try filling it\\n if board[r][c] == '.':\\n for k in range(1, 10):\\n if isValid(r, c, str(k)):\\n board[r][c] = str(k)\\n \\n # Recur for the next cell\\n if fill(r, c + 1):\\n return True\\n \\n # Backtrack if placing 'k' doesn't lead to a solution\\n board[r][c] = '.'\\n \\n # Return False if no valid number can be placed\\n return False\\n \\n # Move to the next cell if the current one is already filled\\n return fill(r, c + 1)\\n\\n # Start solving from the top-left corner\\n fill(0, 0)\",\n \"runtime\": \"290\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Solves the Sudoku puzzle in-place.\\n \\\"\\\"\\\"\\n def is_safe(board, row, col, num) -> bool:\\n # Check if 'num' is in the current row\\n if num in board[row]:\\n return False\\n \\n # Check if 'num' is in the current column\\n if num in [board[i][col] for i in range(9)]:\\n return False\\n \\n # Check the 3x3 sub-grid\\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\\n for i in range(start_row, start_row + 3):\\n for j in range(start_col, start_col + 3):\\n if board[i][j] == num:\\n return False\\n \\n return True\\n \\n def solve(board):\\n # Try to find an empty cell\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == '.':\\n # Try placing digits 1 to 9\\n for num in map(str, range(1, 10)):\\n if is_safe(board, row, col, num):\\n board[row][col] = num # Place the number\\n \\n # Recursively try to solve the rest of the board\\n if solve(board):\\n return True\\n \\n # Backtrack if it didn't lead to a solution\\n board[row][col] = '.' # Reset the cell\\n return False\\n return True\\n \\n # Start solving the board\\n solve(board)\\n\",\n \"runtime\": \"290\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n def is_valid(num, row, col):\\n # Check if 'num' is not in the current row\\n for i in range(9):\\n if board[row][i] == num:\\n return False\\n \\n # Check if 'num' is not in the current column\\n for i in range(9):\\n if board[i][col] == num:\\n return False\\n \\n # Check if 'num' is not in the current 3x3 grid\\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\\n for i in range(3):\\n for j in range(3):\\n if board[start_row + i][start_col + j] == num:\\n return False\\n \\n return True\\n \\n def solve():\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == '.':\\n for num in '123456789':\\n if is_valid(num, row, col):\\n board[row][col] = num # Place the number\\n if solve(): # Recursively call solve\\n return True\\n board[row][col] = '.' # Backtrack\\n return False # If no number is valid, return False\\n return True # All cells filled successfully\\n \\n solve()\",\n \"runtime\": \"296\"\n },\n {\n \"code\": \"class Solution:\\n def is_valid(self, val, row, col, board):\\n if val in board[row]:\\n return False\\n\\n if val in [board[j][col] for j in range(len(board))]:\\n return False\\n\\n ri, ci = (row // 3)*3, (col//3) * 3\\n if val in [board[i][j] for i in range(ri, ri+3) for j in range(ci, ci+3)]:\\n return False\\n\\n return True\\n \\n def solve(self, board):\\n n = len(board)\\n for i in range(n):\\n for j in range(n):\\n if board[i][j] != \\\".\\\":\\n continue\\n for val in range(1,10):\\n if self.is_valid(str(val), i, j, board):\\n board[i][j] = str(val)\\n status = self.solve(board)\\n if status:\\n return True\\n else:\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.solve(board)\\n \",\n \"runtime\": \"296\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def solve(row, col):\\n if row == 9 :\\n return True\\n if col == 9:\\n return solve(row+1, 0)\\n if board[row][col] == '.':\\n for k in range(1,10):\\n if isValid(row, col, str(k)):\\n board[row][col] = str(k)\\n res = solve(row, col+1)\\n if res == True:\\n return True\\n board[row][col] = '.'\\n return False\\n return solve(row, col+1)\\n \\n def isValid(r, c, k):\\n for i in range(9):\\n # Check row and column\\n if board[i][c] == k or board[r][i] == k:\\n return False\\n \\n # Check the 3x3 subgrid\\n subgrid_row = 3 * (r // 3) + i // 3\\n subgrid_col = 3 * (c // 3) + i % 3\\n if board[subgrid_row][subgrid_col] == k:\\n return False\\n return True \\n \\n solve(0,0)\\n \\n\\n\\n \",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.solve(board)\\n \\n def solve(self, board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n for num in '123456789':\\n if self.is_valid(board, i, j, num):\\n board[i][j] = num\\n if self.solve(board):\\n return True\\n board[i][j] = '.'\\n return False\\n return True\\n \\n def is_valid(self, board, i, j, num):\\n box_base_row = (i // 3) * 3\\n box_base_col = (j // 3) * 3\\n for k in range(9):\\n if board[i][k] == num:\\n return False\\n if board[k][j] == num:\\n return False\\n if board[box_base_row + k // 3][box_base_col + k % 3] == num:\\n return False\\n return True \",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.backtracking(board)\\n \\n def backtracking(self, board: List[List[str]]) -> bool:\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == \\\".\\\":\\n for num in range(1, 10):\\n if self.isValid(board, r, c, str(num)):\\n board[r][c] = str(num)\\n res = self.backtracking(board) # 接住从下面返回上来的bool值\\n if res: # 只要找到一个valid的叶子结点，就返回\\n return True\\n board[r][c] = \\\".\\\"\\n return False # 如果1-9所有的数都尝试之后的棋盘也没填好，那就无解\\n return True\\n \\n\\n def isValid(self, board: List[List[str]], row: int, col: int, num: str):\\n for c in range(9):\\n if board[row][c] == num:\\n return False\\n for r in range(9):\\n if board[r][col] == num:\\n return False\\n start_r, start_c = row // 3 * 3, col // 3 * 3\\n for r in range(start_r, start_r + 3):\\n for c in range(start_c, start_c + 3):\\n if board[r][c] == num:\\n return False\\n return True\\n\\n \",\n \"runtime\": \"307\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board):\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def is_valid(board, row, col, num):\\n # Check if the number is not in the current row\\n for x in range(9):\\n if board[row][x] == num:\\n return False\\n\\n # Check if the number is not in the current column\\n for x in range(9):\\n if board[x][col] == num:\\n return False\\n\\n # Check if the number is not in the current 3x3 sub-box\\n startRow = row - row % 3\\n startCol = col - col % 3\\n for i in range(3):\\n for j in range(3):\\n if board[i + startRow][j + startCol] == num:\\n return False\\n\\n return True\\n\\n def solve(board):\\n empty = find_empty_location(board)\\n if not empty:\\n return True # Puzzle solved\\n\\n row, col = empty\\n\\n for num in \\\"123456789\\\":\\n if is_valid(board, row, col, num):\\n board[row][col] = num\\n\\n if solve(board):\\n return True\\n\\n board[row][col] = '.'\\n\\n return False\\n\\n def find_empty_location(board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n return i, j\\n return None\\n\\n solve(board)\\n\\n# Example usage:\\nsolution = Solution()\\nboard = [[\\\"5\\\",\\\"3\\\",\\\".\\\",\\\".\\\",\\\"7\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\"],\\n [\\\"6\\\",\\\".\\\",\\\".\\\",\\\"1\\\",\\\"9\\\",\\\"5\\\",\\\".\\\",\\\".\\\",\\\".\\\"],\\n [\\\".\\\",\\\"9\\\",\\\"8\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"6\\\",\\\".\\\"],\\n [\\\"8\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"6\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"3\\\"],\\n [\\\"4\\\",\\\".\\\",\\\".\\\",\\\"8\\\",\\\".\\\",\\\"3\\\",\\\".\\\",\\\".\\\",\\\"1\\\"],\\n [\\\"7\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"2\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"6\\\"],\\n [\\\".\\\",\\\"6\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"2\\\",\\\"8\\\",\\\".\\\"],\\n [\\\".\\\",\\\".\\\",\\\".\\\",\\\"4\\\",\\\"1\\\",\\\"9\\\",\\\".\\\",\\\".\\\",\\\"5\\\"],\\n [\\\".\\\",\\\".\\\",\\\".\\\",\\\".\\\",\\\"8\\\",\\\".\\\",\\\".\\\",\\\"7\\\",\\\"9\\\"]]\\n\\nsolution.solveSudoku(board)\\n\\n# Print the solved board\\nfor row in board:\\n print(' '.join(row))\",\n \"runtime\": \"307\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n from typing import List\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # Function to check if placing num at board[row][col] is valid\\n def is_valid(board, row, col, num):\\n # Check row\\n for i in range(9):\\n if board[row][i] == num:\\n return False\\n # Check column\\n for i in range(9):\\n if board[i][col] == num:\\n return False\\n # Check 3x3 sub-box\\n start_row, start_col = 3 * (row // 3), 3 * (col // 3)\\n for i in range(3):\\n for j in range(3):\\n if board[start_row + i][start_col + j] == num:\\n return False\\n return True\\n\\n # Recursive backtracking function to solve the board\\n def solve():\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == '.':\\n # Try placing digits 1 to 9\\n for num in '123456789':\\n if is_valid(board, row, col, num):\\n board[row][col] = num # Place the digit\\n if solve(): # Recursively solve the next cell\\n return True\\n board[row][col] = '.' # Backtrack if not solvable\\n return False # No valid number was found, return False\\n return True # All cells are filled correctly\\n\\n solve()\\n\",\n \"runtime\": \"312\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isvalid(board,row,col,num):\\n for i in range(9):\\n if board[i][col]==num:\\n return False\\n for i in range(9):\\n if board[row][i]==num:\\n return False\\n start_row=3*(row//3)\\n start_col=3*(col//3)\\n for i in range(start_row,start_row+3):\\n for j in range(start_col,start_col+3):\\n if board[i][j]==num:\\n return False\\n return True\\n def solve(board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j]=='.':\\n for num in map(str,range(1,10)):\\n if isvalid(board,i,j,num):\\n board[i][j]=num\\n if solve(board):\\n return True\\n board[i][j]='.'\\n return False\\n return True\\n solve(board)\\n return board\\n \\n\\n \",\n \"runtime\": \"312\"\n },\n {\n \"code\": \"from functools import cmp_to_key\\n\\nclass Solution:\\n def isValid(self, board: List[List[str]], x:int, y:int, val: int) -> None:\\n for j, cell in enumerate(board[x]):\\n if j!=y and cell == val:\\n return False\\n for i, row in enumerate(board):\\n if i!=x and row[y] == val:\\n return False\\n x_range = list(range((x // 3) * 3, (x // 3 + 1) * 3))\\n y_range = list(range((y // 3) * 3, (y // 3 + 1) * 3))\\n for i in x_range:\\n for j in y_range:\\n if board[i][j] == val and not (i == x and j == y):\\n return False\\n return True\\n \\n def helper(self, board: List[List[str]]) -> bool:\\n for x in range(9):\\n for y in range(9):\\n if board[x][y] == '.':\\n for val in range(1, 10):\\n if self.isValid(board, x, y, str(val)):\\n board[x][y] = str(val)\\n retval = self.helper(board)\\n if retval: return retval\\n else: board[x][y] = '.'\\n if board[x][y] == '.':\\n return False\\n return True\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.helper(board)\\n\\n \",\n \"runtime\": \"318\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n def isgood(board,row,col,i):\\n for j in board[row]:\\n if j == str(i):\\n return False\\n \\n for j in range(9):\\n if board[j][col] == str(i):\\n return False\\n \\n temprow = (row//3)*3\\n tempcol = (col//3)*3\\n\\n for a in range(temprow , temprow+3):\\n for b in range(tempcol , tempcol+3):\\n if board[a][b] == str(i):\\n return False\\n \\n return True\\n \\n def help(board,row,col):\\n if row == 9:\\n return True\\n if col == 9:\\n return help(board,row+1,0)\\n \\n if board[row][col] != \\\".\\\" :\\n return help(board,row,col+1)\\n \\n for i in range(1,10):\\n if isgood(board,row,col,i):\\n board[row][col] = str(i)\\n if(help(board,row,col)):\\n return True\\n else:\\n board[row][col] = \\\".\\\"\\n \\n help(board,0,0)\\n\\n \",\n \"runtime\": \"318\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Solves the Sudoku puzzle in-place.\\n \\\"\\\"\\\"\\n self.solve(board)\\n\\n def solve(self, board) -> bool:\\n # Try to find an empty cell\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == '.':\\n # Try placing digits 1-9\\n for num in '123456789':\\n if self.isValid(board, row, col, num):\\n board[row][col] = num\\n \\n # Recursively try to solve the board\\n if self.solve(board):\\n return True\\n \\n # If it doesn't lead to a solution, backtrack\\n board[row][col] = '.'\\n return False # If no number fits, backtrack\\n return True # Puzzle is solved when no empty cell is left\\n\\n def isValid(self, board, row, col, num) -> bool:\\n # Check if 'num' is not present in the current row, column, and 3x3 sub-grid\\n for i in range(9):\\n # Check row and column\\n if board[row][i] == num or board[i][col] == num:\\n return False\\n \\n # Check the 3x3 sub-box\\n boxRow = 3 * (row // 3) + i // 3\\n boxCol = 3 * (col // 3) + i % 3\\n if board[boxRow][boxCol] == num:\\n return False\\n\\n return True\",\n \"runtime\": \"323\"\n },\n {\n \"code\": \"class Solution:\\n def findUnassigned(self):\\n\\n for row in range(9):\\n for col in range(9):\\n if self.board[row][col] == '.':\\n return row, col\\n return -1, -1\\n\\n def solve(self):\\n row, col = self.findUnassigned()\\n if row == -1 and col == -1:\\n return True\\n \\n for num in [\\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\", \\\"5\\\", \\\"6\\\", \\\"7\\\", \\\"8\\\", \\\"9\\\"]:\\n if self.isValid(row, col, num):\\n self.board[row][col] = num\\n if self.solve():\\n return True\\n self.board[row][col] = '.'\\n return False\\n \\n def isValid(self, row, col, num):\\n boxRow = row - row % 3\\n boxCol = col - col % 3\\n\\n if self.isRowValid(row, num) and self.isColValid(col, num) and self.isSquareValid(boxRow, boxCol, num):\\n return True\\n return False\\n\\n def isRowValid(self, row, num):\\n for col in range(9):\\n if self.board[row][col] == num:\\n return False\\n return True\\n \\n def isColValid(self, col, num):\\n for row in range(9):\\n if self.board[row][col] == num:\\n return False\\n return True\\n \\n def isSquareValid(self, row, col, num):\\n for r in range(row, row + 3):\\n for c in range(col, col + 3):\\n if self.board[r][c] == num:\\n return False\\n return True\\n \\n\\n \\n\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.board = board\\n self.solve()\\n \\n \",\n \"runtime\": \"323\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def check_number(x,y, cur_nb):\\n # check row and column\\n # for i in range (9):\\n # if y == i or x == i:\\n # continue\\n # if board[x][i] == cur_nb or board[i][y] == cur_nb:\\n # return False\\n \\n for i in range(9):\\n if y != i and board[x][i] == cur_nb:\\n return False\\n if x != i and board[i][y] == cur_nb:\\n return False\\n \\n # check small square\\n index_x = x // 3 * 3\\n index_y = y // 3 * 3\\n \\n \\n for i in range(0, 3):\\n for j in range(0, 3):\\n if index_x + i == x and index_y + j == y:\\n continue\\n if(board[index_x + i][index_y + j] == cur_nb):\\n return False\\n return True\\n \\n \\n \\n def is_solved():\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n return False, (i, j)\\n return True, (0,0)\\n \\n \\n def backtrack():\\n solved, coord = is_solved()\\n x, y = coord\\n if solved:\\n return True\\n \\n for i in range(1, 10):\\n if check_number(x, y, str(i)):\\n board[x][y] = str(i)\\n if(backtrack()):\\n return True\\n board[x][y] = '.'\\n \\n backtrack()\\n \",\n \"runtime\": \"335\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isValidPlacement(board: List[List[str]], row: int, col: int, num: str) -> bool:\\n\\n for i in range(9):\\n if board[row][i] == num: \\n return False\\n if board[i][col] == num: \\n return False\\n if board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == num:\\n return False\\n return True\\n \\n def solve() -> bool:\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n for num in \\\"123456789\\\":\\n if isValidPlacement(board, i, j, num):\\n board[i][j] = num\\n if solve():\\n return True\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n \\n solve()\\n\",\n \"runtime\": \"335\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead. \\\"\\\"\\\"\\n \\n def check (board, row, col, val):\\n for i in range(0, 9):\\n if board[i][col] == val :\\n return False\\n if board[row][i] == val : \\n return False \\n if board[3*(row//3)+(i//3)][3*(col//3)+i%3]== val: \\n return False\\n return True \\n def solve(board): \\n for a in range(9):\\n for b in range(9):\\n if board[a][b]=='.' : \\n for z in range(1, 10):\\n z=str(z)\\n if check(board, a, b, z) :\\n board[a][b]=z\\n if solve(board):\\n return True\\n else:\\n board[a][b]='.'\\n \\n return False\\n return True \\n \\n\\n solve(board)\\n return board\\n\",\n \"runtime\": \"340\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n def f(board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j]=='.':\\n for c in range(1,10):\\n if isvalid(i,j,str(c)):\\n board[i][j]=str(c)\\n if f(board):\\n return True\\n board[i][j]='.'\\n return False\\n return True\\n def isvalid(row,col,k):\\n for i in range(9):\\n if board[i][col]==k:\\n return False\\n if board[row][i]==k:\\n return False\\n if board[3*(row//3)+i//3][3*(col//3)+i%3]==k:\\n return False\\n return True\\n f(board)\\n\",\n \"runtime\": \"340\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isvalid(num,row,col):\\n for i in range(9):\\n if board[i][col] == num:\\n return False\\n if board[row][i] == num:\\n return False\\n r = 3*(row//3) + i//3\\n c = 3*(col//3) + i%3\\n if board[r][c]==num:\\n return False\\n return True\\n def fillboard():\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == '.':\\n for num in \\\"123456789\\\":\\n if isvalid(num,row,col):\\n board[row][col] = num\\n if fillboard() : return True\\n board[row][col] = \\\".\\\"\\n return False\\n return True\\n fillboard()\",\n \"runtime\": \"346\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isPossible(board, row, col, value):\\n for i in range(9):\\n if board[i][col] == value:\\n return False\\n\\n if board[row][i] == value:\\n return False\\n\\n if board[3*(row//3) + i//3][3*(col//3) + i%3] == value:\\n return False\\n return True\\n\\n\\n def solve(board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n for val in range(1, 10):\\n if isPossible(board, i, j, str(val)):\\n board[i][j] = str(val)\\n if solve(board):\\n return True\\n else:\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n \\n \\n solve(board)\",\n \"runtime\": \"346\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def is_valid(row, col, num):\\n for i in range(9):\\n # Check row and column\\n if board[row][i] == num or board[i][col] == num:\\n return False\\n # Check 3x3 subgrid\\n subgrid_row = 3 * (row // 3) + i // 3\\n subgrid_col = 3 * (col // 3) + i % 3\\n if board[subgrid_row][subgrid_col] == num:\\n return False\\n return True\\n\\n def solve():\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == '.':\\n for num in '123456789':\\n if is_valid(row, col, num):\\n board[row][col] = num\\n if solve():\\n return True\\n board[row][col] = '.' # Backtrack\\n return False # Trigger backtracking\\n return True # Puzzle solved\\n\\n solve()\\n\",\n \"runtime\": \"351\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isValid(board,i, j, k):\\n for row in range(len(board)):\\n if board[row][j] == k:\\n return False\\n\\n if board[i][row] == k:\\n return False\\n\\n if board[3*(i//3) + row//3][3*(j//3) + row%3] == k:\\n return False\\n\\n return True\\n\\n\\n def solve(board):\\n for i in range(len(board)):\\n for j in range(len(board)):\\n if board[i][j] == \\\".\\\":\\n for k in range(1, 10):\\n if isValid(board, i, j, str(k)):\\n board[i][j] = str(k)\\n if solve(board) == True:\\n return True\\n board[i][j] = \\\".\\\"\\n\\n return False\\n \\n \\n return True\\n\\n solve(board)\\n \\n\\n\\n \\n\\n\\n \",\n \"runtime\": \"351\"\n },\n {\n \"code\": \"class Solution:\\n def isPossible(self, board, x, y, value):\\n # Same row checking \\n for col in range(9):\\n if board[x][col] == str(value):\\n return False\\n \\n # Same col checking\\n for row in range(9):\\n if board[row][y] == str(value):\\n return False\\n \\n # Same 3 * 3 matrix checking \\n topRow = (x // 3) * 3 \\n topCol = (y // 3) * 3 \\n \\n for i in range(3):\\n for j in range(3):\\n if board[topRow + i][topCol + j] == str(value):\\n return False\\n return True\\n\\n def solveThis(self, x, y, board):\\n #print(x, y, board)\\n if x == 9:\\n return True\\n \\n nextX, nextY = -1, -1 \\n \\n if y == 8:\\n nextX = x + 1 \\n nextY = 0 \\n else:\\n nextX = x \\n nextY = y + 1\\n \\n if board[x][y] != \\\".\\\":\\n return self.solveThis(nextX, nextY, board)\\n \\n \\n for value in range(1, 10):\\n if self.isPossible(board, x, y, value) == True:\\n board[x][y] = str(value)\\n result = self.solveThis(nextX, nextY, board)\\n if result == True:\\n return True\\n board[x][y] = \\\".\\\"\\n \\n return False\\n\\n def solveSudoku(self, board):\\n self.solveThis(0, 0, board)\",\n \"runtime\": \"357\"\n },\n {\n \"code\": \"def ac3(board:List[List[str]],domain:List[List[List[int]]],rowStart:int,rowEnd:int,colStart:int,colEnd:int)->None:\\n ##Row Constraints;\\n for i in range(rowStart,rowEnd):\\n for j in range(9):\\n if board[i][j] != '.':\\n domain[i][j]=['-1']\\n continue\\n revised=reviseRow(board,domain,i,j)\\n if revised:\\n ac3(board,domain,i,i+1,j,j+1)\\n revised = False\\n for j in range(colStart,colEnd):\\n for i in range(9):\\n if board[i][j] !='.':\\n continue\\n revised = reviseCol(board,domain,i,j)\\n if revised:\\n ac3(board,domain,i,i+1,j,j+1)\\n revised = False\\n for i in range(rowStart,rowEnd):\\n for j in range(colStart,colEnd):\\n if board[i][j] != '.':\\n continue\\n revised = reviseSubGrid(board,domain,i,j)\\n if revised:\\n ac3(board,domain,i,i+1,j,j+1)\\n \\n\\ndef reviseRow(board,domain,i,j):\\n revised = False\\n for k in range(9):\\n if k == j:\\n continue\\n val = board[i][k]\\n \\n if val != '.':\\n if val in domain[i][j]:\\n if(len(domain[i][j])>1):\\n domain[i][j].remove(val)\\n else:\\n domain[i][j]=['-1']\\n revised = True\\n\\n return revised\\n\\ndef reviseCol(board,domain,i,j):\\n revised = False\\n for k in range(9):\\n if k==i:\\n continue\\n val = board[k][j]\\n if val !='.':\\n if val in domain[i][j]:\\n if(len(domain[i][j])>1):\\n domain[i][j].remove(val)\\n else:\\n domain[i][j]=['-1']\\n revised = True\\n return revised\\n\\ndef reviseSubGrid(board,domain,i,j):\\n revised = False\\n for k in range(int(i/3)*3,int((i+3)/3)*3):\\n for l in range(int(j/3)*3,int((j+3)/3)*3):\\n if i==k and j==l:\\n continue\\n val = board[k][l]\\n if val != '.':\\n if val in domain[i][j]:\\n if(len(domain[i][j])>1):\\n domain[i][j].remove(val)\\n else:\\n domain[i][j]=['-1']\\n revised = True\\n return revised\\n\\n \\n# Function to Find the entry in \\n# the Grid that is still not used\\n# Searches the grid to find an \\n# entry that is still unassigned. If\\n# found, the reference parameters \\n# row, col will be set the location\\n# that is unassigned, and true is \\n# returned. If no unassigned entries\\n# remains, false is returned.\\n# 'l' is a list variable that has \\n# been passed from the solve_sudoku function\\n# to keep track of incrementation \\n# of Rows and Columns\\ndef find_empty_location(board, l):\\n for row in range(9):\\n for col in range(9):\\n if(board[row][col]== '.'):\\n l[0]= row\\n l[1]= col\\n return True\\n return False\\n\\n# Returns a boolean which indicates \\n# whether any assigned entry\\n# in the specified row matches \\n# the given number.\\ndef used_in_row(board, row, num):\\n for i in range(9):\\n if(board[row][i] == num):\\n return True\\n return False\\n\\n# Returns a boolean which indicates \\n# whether any assigned entry\\n# in the specified column matches \\n# the given number.\\ndef used_in_col(board, col, num):\\n for i in range(9):\\n if(board[i][col] == num):\\n return True\\n return False\\n\\n# Returns a boolean which indicates \\n# whether any assigned entry\\n# within the specified 3x3 box \\n# matches the given number\\ndef used_in_box(board, row, col, num):\\n for i in range(3):\\n for j in range(3):\\n if(board[i + row][j + col] == num):\\n return True\\n return False\\n\\n# Checks whether it will be legal \\n# to assign num to the given row, col\\n# Returns a boolean which indicates \\n# whether it will be legal to assign\\n# num to the given row, col location.\\ndef check_location_is_safe(board, row, col, num):\\n \\n # Check if 'num' is not already \\n # placed in current row,\\n # current column and current 3x3 box\\n return (not used_in_row(board, row, num) and \\n (not used_in_col(board, col, num) and \\n (not used_in_box(board, row - row % 3,col - col % 3, num)))) \\n \\n\\ndef printSubgrid(board,i,j):\\n for k in range(int(i/3)*3,int((i+3)/3)*3):\\n for l in range(int(j/3)*3,int((j+3)/3)*3):\\n if i==k and j==l:\\n continue\\n print(board[k][l])\\n\\ndef solve_sudoku(board: List[List[str]],domain) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # 'l' is a list variable that keeps the \\n # record of row and col in \\n # find_empty_location Function \\n l = [0, 0]\\n \\n # If there is no unassigned \\n # location, we are done \\n if(not find_empty_location(board, l)):\\n return True\\n \\n # Assigning list values to row and col \\n # that we got from the above Function \\n row = l[0]\\n col = l[1]\\n \\n # consider digits 1 to 9\\n for num in range(1,10):\\n num = str(num)\\n # if looks promising\\n if(check_location_is_safe(board, \\n row, col, num)):\\n print(\\\"IN !\\\")\\n # make tentative assignment\\n board[row][col]= num\\n\\n # return, if success, \\n # ya ! \\n if(solve_sudoku(board,domain)):\\n return True\\n\\n # failure, unmake & try again\\n board[row][col] = '.'\\n print(\\\"backtracked\\\")\\n \\n # this triggers backtracking \\n return False\\n \\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\n #printSubgrid(board,0,8)\\n domain = []\\n\\n for i in range(9):\\n a = []\\n for j in range(9):\\n a.append([])\\n for l in range(1,10):\\n a[j].append(str(l))\\n domain.append(a)\\n ac3(board,domain,0,9,0,9)\\n for i in range(9):\\n print(i)\\n print(domain[i])\\n print('-'*30)\\n \\n print(solve_sudoku(board,domain))\\n \",\n \"runtime\": \"357\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def validPlacement(i, j, val):\\n # returns true if placing val at i,j is valid\\n baseI, baseJ = 3 * (i // 3), 3 * (j // 3)\\n for m in range(baseI, baseI + 3):\\n for n in range(baseJ, baseJ + 3):\\n if board[m][n] == val:\\n return False\\n for k in range(9):\\n if board[i][k] == val or board[k][j] == val:\\n return False\\n return True\\n\\n nums = [str(i) for i in range(1, 10)]\\n def dfs():\\n for m in range(9):\\n for n in range(9):\\n if board[m][n] == '.': # only test if it's possible to fill this square\\n for test in nums:\\n if validPlacement(m, n, test):\\n board[m][n] = test\\n if dfs():\\n return True\\n board[m][n] = '.'\\n return False\\n return True # base case: only return True if no '.' characters were found this call, meaning the board is solved.\\n \\n dfs()\\n \\n\\n\\n \\n\\n \\n\",\n \"runtime\": \"362\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n def is_valid(num : int,pos: List[int])-> bool:\\n #row\\n for j in range(9):\\n if board[pos[0]][j] == num and pos[1] != j:\\n return False\\n #col \\n for i in range(9):\\n if board[i][pos[1]] == num and pos[0] != i:\\n return False\\n\\n box_x,box_y= (pos[1]//3),(pos[0]//3)\\n for i in range(box_y*3,(box_y*3)+3):\\n for j in range(box_x*3,(box_x*3)+3):\\n if board[i][j] == num and (i,j) != pos:\\n return False\\n\\n return True\\n\\n def solve():\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\": \\n for num in \\\"123456789\\\":\\n if is_valid(num,[i,j]):\\n board[i][j]= num\\n if solve():\\n return True\\n board[i][j]= \\\".\\\"\\n return False\\n return True \\n\\n solve() \\n\\n \\n\\n\\n \\n \",\n \"runtime\": \"362\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n nrows = len(board)\\n ncols = len(board[0])\\n\\n def isValid(row,col, num):\\n sbox_l_boundary = col//3\\n sbox_r_boundary = col//3+1\\n sbox_u_boundary = row//3\\n sbox_d_boundary = row//3+1\\n for x in range(sbox_u_boundary * 3, sbox_d_boundary * 3):\\n for y in range(sbox_l_boundary* 3, sbox_r_boundary*3):\\n if board[x][y] == num:\\n return False\\n if num in board[row]:\\n return False\\n if num in [board[_][col] for _ in range(nrows)]:\\n return False\\n return True\\n\\n\\n def backtracking(r_start, c_start) -> bool:\\n for row in range(r_start, 9): \\n c_s = 0\\n if row == r_start:\\n c_s = c_start\\n for col in range(c_s, 9): \\n if board[row][col] == '.':\\n for n in range(1,10):\\n num = str(n)\\n # check if we can place the number in the grid\\n if isValid(row, col, num):\\n board[row][col] = num\\n if backtracking(row,col+1):\\n return True\\n board[row][col] = '.'\\n return False\\n return True\\n \\n return backtracking(0,0)\\n\",\n \"runtime\": \"368\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n nrows = len(board)\\n ncols = len(board[0])\\n\\n def isValid(row,col, num):\\n sbox_l_boundary = col//3\\n sbox_r_boundary = col//3+1\\n sbox_u_boundary = row//3\\n sbox_d_boundary = row//3+1\\n for x in range(sbox_u_boundary * 3, sbox_d_boundary * 3):\\n for y in range(sbox_l_boundary* 3, sbox_r_boundary*3):\\n if board[x][y] == num:\\n return False\\n if num in board[row]:\\n return False\\n if num in [board[_][col] for _ in range(nrows)]:\\n return False\\n return True\\n\\n\\n def backtracking(rStart, cStart) -> bool:\\n for row in range(rStart, 9): \\n cS = 0\\n if row == rStart:\\n cS = cStart\\n for col in range(cS, 9): \\n if board[row][col] == '.':\\n for n in range(1,10):\\n num = str(n)\\n # check if we can place the number in the grid\\n if isValid(row, col, num):\\n board[row][col] = num\\n if backtracking(row,col+1):\\n return True\\n board[row][col] = '.'\\n return False\\n return True\\n \\n return backtracking(0,0)\\n\",\n \"runtime\": \"368\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n import collections\\n n, occupied, empties = 9, collections.defaultdict(set), []\\n for i in range(n):\\n for j in range(n):\\n if board[i][j] == '.': empties.append((i, j))\\n else:\\n v = board[i][j]\\n occupied[(i, -1)].add(v)\\n occupied[(-1, j)].add(v)\\n occupied[(i // 3, j // 3)].add(v)\\n\\n def dfs():\\n if not empties: return True\\n i, j = empties.pop()\\n for v in map(str, range(1, 10)):\\n keys = ((i, -1), (-1, j), (i // 3, j // 3))\\n if any(tuple(v in occupied[e] for e in keys)): continue\\n board[i][j] = v\\n for e in keys: occupied[e].add(v)\\n if dfs(): return True\\n for e in keys: occupied[e].remove(v)\\n empties.append((i, j))\\n return False\\n \\n dfs()\",\n \"runtime\": \"373\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n def is_valid(x, y, num):\\n for i in range(9):\\n if board[x][i] == str(num) or board[i][y] == str(num):\\n return False\\n x_start = (x // 3) * 3\\n y_start = (y // 3) * 3\\n for i in range(3):\\n for j in range(3):\\n if board[x_start + i][y_start + j] == str(num):\\n return False\\n return True\\n \\n def dfs(board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n for num in range(1, 10):\\n if is_valid(i, j, num):\\n board[i][j] = str(num)\\n if dfs(board):\\n return True\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n \\n dfs(board)\\n \",\n \"runtime\": \"373\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n result=[]\\n self.backtrack(0,board,result)\\n print(board)\\n\\n def backtrack(self,start,board,result):\\n if start==len(board)**2:\\n return True\\n row=start//len(board)\\n column=start%len(board)\\n if board[row][column]==\\\".\\\":\\n for num in range(1,10):\\n if self.checker(start,num,board):\\n board[row][column]=str(num)\\n if self.backtrack(start+1,board,result) : return True\\n board[row][column]=\\\".\\\"\\n return False\\n else:\\n return self.backtrack(start+1,board,result)\\n def checker(self,start,num,board):\\n\\n #row\\n row=start//len(board)\\n for i in range(len(board)):\\n if board[row][i]==str(num):\\n return False\\n #column\\n column=start%len(board)\\n for i in range(len(board)):\\n if board[i][column]==str(num):\\n return False\\n \\n\\n #boxa\\n start_row=0\\n end_row=0\\n start_col=0\\n end_col=0\\n if row>=0 and row<=2:\\n start_row=0\\n end_row=2\\n elif row>=3 and row<=5:\\n start_row=3\\n end_row=5\\n elif row>=6 and row<=8:\\n start_row=6\\n end_row=8\\n\\n if column>=0 and column<=2:\\n start_col=0\\n end_col=2\\n\\n elif column>=3 and column<=5:\\n start_col=3\\n end_col=5\\n elif column>=6 and column<=8:\\n start_col=6\\n end_col=8\\n\\n \\n for i in range(start_row,end_row+1):\\n for j in range(start_col,end_col+1):\\n if board[i][j]==str(num):\\n return False\\n\\n return True\\n\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"379\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isValid(row: int, col: int, num: str) -> bool:\\n for i in range(9):\\n # Check in row\\n if board[row][i] == num: return False\\n\\n # Check in col\\n if board[i][col] == num: return False\\n\\n # Check in sub-square\\n subRow = 3 * (row // 3) + (i // 3)\\n subCol = 3 * (col // 3) + (i % 3)\\n if board[subRow][subCol] == num: return False\\n return True\\n\\n def solve() -> bool:\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n for num in \\\"123456789\\\":\\n if isValid(i, j, num):\\n board[i][j] = num\\n if solve() == True: return True\\n else:\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n\\n solve()\\n \",\n \"runtime\": \"379\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def square(a,b):\\n squares = [{(x+i,y+j) for i in range(-1,2) for j in range(-1,2)} for (x,y) in [(1,1),(1,4),(1,7),(4,1),(4,4),(4,7),(7,1),(7,4),(7,7)]] \\n for s in squares:\\n if (a,b) in s:\\n return s\\n def valid_numbers(x,y):\\n return {'1','2','3','4','5','6','7','8','9'} - (set(board[x]) | set(board[i][y] for i in range(9)) | set(board[i][j] for (i,j) in square(x,y)))\\n def solve(p):\\n for s in range(p,81):\\n i,j = s//9,s%9\\n if board[i][j] == \\\".\\\":\\n possibilities = valid_numbers(i,j)\\n if not possibilities:\\n return False\\n for n in possibilities:\\n board[i][j] = str(n)\\n if solve(s+1):\\n return True\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n solve(0)\\n\",\n \"runtime\": \"384\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Solution from:\\n https://leetcode.com/problems/sudoku-solver/solutions/1947604/python-easiest-recursive-solution/\\n \\\"\\\"\\\"\\n\\n def isValid(row, col, ch):\\n for i in range(9):\\n if board[i][col] == str(ch):\\n return False\\n if board[row][i] == str(ch):\\n return False\\n if board[3*(row//3) + i//3][3*(col//3) + i%3] == str(ch):\\n return False\\n return True\\n \\n def solve(row, col):\\n if row == 9:\\n return True\\n if col == 9:\\n return solve(row+1, 0)\\n if board[row][col] == \\\".\\\":\\n for i in range(1, 10):\\n if isValid(row, col, i):\\n board[row][col] = str(i)\\n if solve(row, col + 1):\\n return True\\n else:\\n board[row][col] = \\\".\\\"\\n return False\\n else:\\n return solve(row, col + 1)\\n solve(0, 0)\",\n \"runtime\": \"384\"\n },\n {\n \"code\": \"class Solution:\\n def is_valid(self, board, i, j, number):\\n\\n cubeX, cubeY = j // 3, i // 3\\n\\n # First we check if the number is in the same cube\\n\\n for row in range(3):\\n\\n for col in range(3):\\n\\n if board[cubeY * 3 + row][cubeX * 3 + col] == number:\\n return False\\n\\n # Secondly we will check if the number is in the same line - horitzontal and diognal\\n\\n for line in range(9):\\n \\n if (line != j and board[i][line] == number) or (line != i and board[line][j] == number):\\n return False\\n \\n # Passed all checks then it is true\\n\\n return True\\n \\n def solve(self, board, row, col):\\n for i in range(row, 9):\\n\\n for j in range(col, 9):\\n\\n if board[i][j] == \\\".\\\":\\n\\n for chance in range(1,10):\\n chance = str(chance)\\n if self.is_valid(board, i, j, chance):\\n board[i][j] = chance\\n if not self.solve(board, i, j):\\n board[i][j] = \\\".\\\"\\n \\n else:\\n return True\\n \\n return False\\n \\n col = 0\\n\\n return True\\n\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n self.solve(board, 0, 0)\",\n \"runtime\": \"390\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n if not board: return\\n self.sudoku(board)\\n\\n def sudoku(self, board: List[List[str]]) -> bool:\\n if not board: return True\\n\\n m = len(board)\\n n = len(board[0])\\n\\n for i in range(m):\\n for j in range(n):\\n if board[i][j] == '.': # empty spot to fill\\n for k in range(1, 10):\\n if self.isValidToPutNum(board, k, i, j):\\n board[i][j] = str(k)\\n if self.sudoku(board):\\n return True # trim 1: don't need to try other numbers\\n board[i][j] = '.'\\n return False # trim2: tried all numbers, none works\\n return True\\n\\n def isValidToPutNum(self, board: List[List[int]], num: int, i: int, j:int) -> bool:\\n for n in range(0, 9):\\n if board[i][n] == str(num):\\n return False\\n \\n for n in range(0, 9):\\n if board[n][j] == str(num):\\n return False\\n\\n cuberow = 3 * (i // 3)\\n cubecol = 3 * (j // 3)\\n\\n for a in range(cuberow, cuberow + 3):\\n for b in range(cubecol, cubecol + 3):\\n if board[a][b] == str(num):\\n return False\\n \\n return True\\n\",\n \"runtime\": \"390\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def is_valid(row, col, num):\\n for i in range(0, 9):\\n if board[row][i] == str(num):\\n return False\\n if board[i][col] == str(num):\\n return False\\n \\n start_row = 3 * (row // 3)\\n start_col = 3 * (col // 3)\\n for i in range(3):\\n for j in range(3):\\n if board[start_row + i][start_col + j] == str(num):\\n return False\\n \\n return True\\n\\n def backtrack(board):\\n for row in range(len(board)):\\n for col in range(len(board)):\\n if board[row][col] == '.':\\n for i in range(1, 10):\\n if is_valid(row, col, i):\\n board[row][col] = str(i)\\n if backtrack(board):\\n return True\\n board[row][col] = '.'\\n return False\\n return True\\n \\n if backtrack(board):\\n return board\",\n \"runtime\": \"396\"\n },\n {\n \"code\": \"class Solution:\\n def isValid(self, board,row,col,num):\\n for i in range(9):\\n if board[row][i] == str(num):\\n return False\\n for j in range(9):\\n if board[j][col] == str(num):\\n return False\\n start_row = (row // 3) * 3\\n start_col = (col // 3) * 3\\n for i in range(start_row, start_row+3):\\n for j in range(start_col,start_col+3):\\n if board[i][j] == str(num):\\n return False\\n return True\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n length = len(board)\\n def backtracking(board)->bool:\\n for i in range(length):\\n for j in range(length):\\n if board[i][j] != \\\".\\\":\\n continue\\n else :\\n for num in range(1,10):\\n if self.isValid(board,i,j,num) :\\n board[i][j] = str(num)\\n if backtracking(board):\\n return True\\n board[i][j] = '.'\\n return False\\n return True\\n backtracking(board) \\n\",\n \"runtime\": \"396\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n if board is None or len(board) == 0: return\\n self.helper(board)\\n\\n def helper(self, board):\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == '.':\\n for i in range(1, 10):\\n char = str(i)\\n if self.valid(board, row, col, char):\\n board[row][col] = char\\n if self.helper(board): return True\\n board[row][col] = '.'\\n return False\\n return True\\n\\n def valid(self, board, row, col, char):\\n for i in range(9):\\n if board[i][col] != '.' and board[i][col] == char: return False\\n if board[row][i] != '.' and board[row][i] == char: return False\\n r = 3 * (row // 3) + i // 3\\n c = 3 * (col // 3) + i % 3\\n if board[r][c] != '.' and board[r][c] == char: return False\\n return True\\n\\n \",\n \"runtime\": \"401\"\n },\n {\n \"code\": \"class Solution:\\n def isValid(self,board: List[List[str]], row: int, col: int, c: str) -> bool:\\n for i in range(9):\\n if board[i][col] == c:\\n return False\\n if board[row][i] == c:\\n return False\\n if board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == c:\\n return False\\n return True\\n def solveSudoku(self,board: List[List[str]]) -> bool:\\n for i in range(len(board)):\\n for j in range(len(board[0])):\\n if board[i][j] == \\\".\\\":\\n for c in \\\"123456789\\\":\\n if self.isValid(board, i, j, c):\\n board[i][j] = c\\n if self.solveSudoku(board):\\n return True\\n else:\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n \",\n \"runtime\": \"401\"\n },\n {\n \"code\": \"class Solution:\\n def isValid(self, board, row, col, num):\\n # check if the number is already in the row or column\\n for i in range(9):\\n if board[i][col] == str(num):\\n return False\\n if board[row][i] == str(num):\\n return False\\n # check if the number is in the 3x3 box\\n box_row_start = (row//3)*3\\n box_row_end = box_row_start + 3\\n box_col_start = (col//3)*3\\n box_col_end = box_col_start + 3\\n for i in range(box_row_start, box_row_end):\\n for j in range(box_col_start, box_col_end):\\n if board[i][j] == str(num):\\n return False\\n return True\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n def solve_backtrack(board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n for num in range(1, 10):\\n if self.isValid(board, i, j, num):\\n board[i][j] = str(num)\\n if solve_backtrack(board):\\n return True\\n else:\\n board[i][j] = \\\".\\\"\\n return False \\n return True \\n\\n solve_backtrack(board)\",\n \"runtime\": \"407\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.backtracking(board)\\n\\n def backtracking(self, board: List[List[str]]) -> bool:\\n # 若有解，返回True；若无解，返回False\\n for i in range(len(board)): # 遍历行\\n for j in range(len(board[0])): # 遍历列\\n # 若空格内已有数字，跳过\\n if board[i][j] != '.': continue\\n for k in range(1, 10):\\n if self.is_valid(i, j, k, board):\\n board[i][j] = str(k)\\n if self.backtracking(board): return True\\n board[i][j] = '.'\\n # 若数字1-9都不能成功填入空格，返回False无解\\n return False\\n return True # 有解\\n\\n def is_valid(self, row: int, col: int, val: int, board: List[List[str]]) -> bool:\\n # 判断同一行是否冲突\\n for i in range(9):\\n if board[row][i] == str(val):\\n return False\\n # 判断同一列是否冲突\\n for j in range(9):\\n if board[j][col] == str(val):\\n return False\\n # 判断同一九宫格是否有冲突\\n start_row = (row // 3) * 3\\n start_col = (col // 3) * 3\\n for i in range(start_row, start_row + 3):\\n for j in range(start_col, start_col + 3):\\n if board[i][j] == str(val):\\n return False\\n return True\\n \",\n \"runtime\": \"407\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def backtracking(board):\\n for i in range(len(board)):\\n for j in range(len(board[0])):\\n if board[i][j] == '.':\\n for k in range(1, 10):\\n if isValid(i, j, k, board):\\n board[i][j] = str(k)\\n if backtracking(board):\\n return True\\n board[i][j] = '.'\\n return False\\n return True\\n\\n def isValid(row, col, k, board):\\n for i in range(9):\\n if board[i][col] == str(k):\\n return False\\n for j in range(9):\\n if board[row][j] == str(k):\\n return False \\n startRowIdx, startColIdx = (row//3) *3, (col//3)*3\\n for i in range(startRowIdx, startRowIdx+3):\\n for j in range(startColIdx, startColIdx+3):\\n if board[i][j] == str(k):\\n return False\\n return True\\n\\n\\n \\n backtracking(board)\",\n \"runtime\": \"412\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n def checkValid(row,col,board,k):\\n for i in range(0,9):\\n if board[i][col] == str(k):\\n if i==row:\\n continue\\n #print(\\\"Returning false \\\",board[i], k)\\n return False\\n if board[row][i]== str(k):\\n if i==col:\\n continue\\n return False\\n start_row = row//3\\n start_col = col//3\\n for i in range(start_row*3,start_row*3+3):\\n for j in range(start_col*3, start_col*3 + 3):\\n if i==row and j==col:\\n continue\\n if board[i][j] == str(k):\\n return False\\n #print(\\\"returning true\\\")\\n return True\\n\\n def dfs(board):\\n filled = 0\\n for i in range(0,9):\\n for j in range(0,9):\\n if board[i][j] == '.':\\n for k in range(1,10):\\n if(checkValid(i,j,board,k)):\\n \\n board[i][j] = str(k)\\n if(dfs(board)):\\n return True\\n else:\\n board[i][j]= '.'\\n return False\\n else:\\n filled += 1\\n if filled == 81:\\n #print(filled) \\n return True\\n return False\\n dfs(board)\\n\",\n \"runtime\": \"412\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n ## Initialize board with nums that cannot be backtracked on\\n row_set = set()\\n col_set = set()\\n square_set = set()\\n\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] != \\\".\\\":\\n num = board[r][c]\\n row_set.add((r,num))\\n col_set.add((c,num))\\n square_set.add((r//3,c//3,num))\\n \\n def is_valid(r,c,num):\\n if (r,num) in row_set or (c,num) in col_set or (r//3, c//3, num) in square_set:\\n return False\\n else:\\n row_set.add((r,num))\\n col_set.add((c,num))\\n square_set.add((r//3,c//3,num))\\n return True\\n \\n def remove(r,c,num):\\n row_set.remove((r,num))\\n col_set.remove((c,num))\\n square_set.remove((r//3,c//3,num))\\n\\n def solve(r,c):\\n if r == 9:\\n return True\\n if c == 9:\\n return solve(r+1, 0)\\n \\n if board[r][c] != \\\".\\\":\\n return solve(r, c+1)\\n \\n for num in range(1,10):\\n print(board[0])\\n num = str(num)\\n if is_valid(r,c,num):\\n board[r][c] = num\\n if solve(r, c+1):\\n return True\\n board[r][c] = \\\".\\\"\\n remove(r,c,num)\\n\\n\\n return solve(0,0)\",\n \"runtime\": \"418\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n def is_valid(row: int, col: int, val: int, board: List[List[str]]) -> bool:\\n # 判断同一行是否冲突\\n for i in range(9):\\n if board[row][i] == str(val):\\n return False\\n # 判断同一列是否冲突\\n for j in range(9):\\n if board[j][col] == str(val):\\n return False\\n # 判断同一九宫格是否有冲突\\n start_row = (row // 3) * 3\\n start_col = (col // 3) * 3\\n for i in range(start_row, start_row + 3):\\n for j in range(start_col, start_col + 3):\\n if board[i][j] == str(val):\\n return False\\n return True\\n \\n def backtracking(board):\\n for i in range(9):\\n for j in range(9):\\n cur_num = board[i][j]\\n if cur_num != \\\".\\\":\\n continue\\n for k in range(1, 10):\\n if is_valid(i,j,k, board):\\n board[i][j] = str(k)\\n if backtracking(board): return True\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n\\n backtracking(board)\\n\\n \\n\\n\\n \",\n \"runtime\": \"418\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n n = len(board)\\n \\n def backtracking(board):\\n for i in range(n):\\n for j in range(n):\\n if board[i][j] != '.': continue\\n for v in range(1, 10):\\n if isValid(i, j, v, board):\\n board[i][j] = str(v)\\n if backtracking(board): return True\\n board[i][j] = '.'\\n return False\\n return True\\n \\n def isValid(x, y, v, board):\\n for i in range(n):\\n if board[x][i] == str(v): return False\\n for i in range(n):\\n if board[i][y] == str(v): return False\\n r = (x // 3) * 3\\n c = (y // 3) * 3\\n for i in range(r, r + 3):\\n for j in range(c, c + 3):\\n if board[i][j] == str(v): return False\\n return True\\n \\n backtracking(board)\",\n \"runtime\": \"423\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def backtracking(board):\\n for i in range(len(board)):\\n for j in range(len(board[0])):\\n if board[i][j] == '.':\\n for k in range(1, 10):\\n if isValid(i, j, k, board):\\n board[i][j] = str(k)\\n if backtracking(board):\\n return True\\n board[i][j] = '.'\\n return False\\n return True\\n\\n def isValid(row, col, k, board):\\n for i in range(9):\\n if board[i][col] == str(k):\\n return False\\n for j in range(9):\\n if board[row][j] == str(k):\\n return False \\n startRowIdx, startColIdx = (row//3) *3, (col//3)*3\\n for i in range(startRowIdx, startRowIdx+3):\\n for j in range(startColIdx, startColIdx+3):\\n if board[i][j] == str(k):\\n return False\\n return True\\n\\n\\n \\n backtracking(board)\",\n \"runtime\": \"423\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n rows,cols=len(board),len(board[0])\\n self.result=[]\\n self.board=board\\n self.backtracking(rows)\\n # return self.result[0]\\n \\n def backtracking(self,n):\\n for i in range(n): #rows\\n for j in range(n): #cols\\n if self.board[i][j]=='.' :\\n for num in range(1,10):\\n if self.isValid(j,i,n,num):\\n self.board[i][j]=str(num)\\n if self.backtracking(n): return True\\n self.board[i][j]='.'\\n return False\\n return True\\n \\n def isValid(self,currentcol,currentrow,n,num):\\n for i in range(9):\\n if str(num)==self.board[i][currentcol]:\\n return False\\n for i in range(9):\\n if str(num)==self.board[currentrow][i]:\\n return False\\n \\n startrow=(currentrow//3)*3\\n startcol=(currentcol//3)*3\\n\\n for i in range(startrow,startrow+3):\\n for j in range(startcol,startcol+3):\\n if str(num)==self.board[i][j]:\\n return False\\n \\n return True\\n\\n\\n\\n\",\n \"runtime\": \"429\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def valid(row, col, num):\\n for i in range(9):\\n if board[i][col] == str(num):\\n return False\\n for i in range(9):\\n if board[row][i] == str(num):\\n return False\\n sr, sc = row // 3 * 3, col // 3 * 3\\n for i in range(sr, sr+3):\\n for j in range(sc, sc+3):\\n if board[i][j] == str(num):\\n return False\\n return True\\n \\n def backtrack(board):\\n for i in range(len(board)):\\n for j in range(len(board[0])):\\n if board[i][j] != '.': \\n continue\\n for k in range(1, 10):\\n if valid(i, j, k):\\n board[i][j] = str(k)\\n if backtrack(board):\\n return True\\n board[i][j] = '.'\\n return False\\n return True\\n\\n backtrack(board)\",\n \"runtime\": \"429\"\n },\n {\n \"code\": \"from random import choice, random\\n\\nimport numpy as np\\n\\n\\n# Setup masks for each tile\\ntarget_set = set([str(s) for s in range(1, 10)])\\n\\nmasks = np.zeros((9, 9, 9, 9), dtype=bool)\\nfor i in range(9):\\n for j in range(9):\\n masks[i, j, i, :] = True\\n masks[i, j, :, j] = True\\n\\n # All members in same box\\n iboxx = 3 * (i // 3)\\n iboxy = 3 * (j // 3)\\n masks[i, j, iboxx:iboxx + 3,iboxy:iboxy + 3] = True\\n\\n masks[i, j, i, j] = False\\n\\n\\ndef do_exclusion(board_np: np.array):\\n '''\\n Try to solve sudoku board by exclusion:\\n Check if any of the squares has to be a specific digit.\\n '''\\n for i in range(16):\\n if not np.isin(\\\".\\\", board_np):\\n print(\\\"Finished board!\\\")\\n return True\\n\\n found_exclusion = False\\n\\n for irow in range(9):\\n for icol in range(9):\\n if board_np[irow, icol] != \\\".\\\":\\n continue\\n\\n digits = np.unique(board_np[masks[irow, icol]])\\n remaining = target_set.difference(set(digits))\\n\\n num_remaining = len(remaining)\\n if num_remaining == 0:\\n return False # Due to heuristics we could encounter invalid --> End immediately\\n \\n elif len(remaining) == 1:\\n found_exclusion = True\\n board_np[irow, icol] = list(remaining)[0]\\n\\n if not found_exclusion:\\n return False\\n \\n raise Exception(\\\"INCREASE DEPTH\\\")\\n return False\\n\\n\\ndef get_heuristic_candidates(board_np: np.array):\\n '''\\n Produce a list of candidates for heuristics to check.\\n Sorted by their probability.\\n '''\\n\\n candidates = []\\n\\n for irow in range(9):\\n for icol in range(9):\\n if board_np[irow, icol] != \\\".\\\":\\n continue\\n mask = masks[irow, icol]\\n\\n digits = np.unique(board_np[mask])\\n possible = target_set.difference(set(digits))\\n\\n candidates.append((list(possible), (irow, icol)))\\n\\n candidates.sort(key=lambda x: len(x[0]))\\n\\n return candidates\\n\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n board_np = np.array(board)\\n\\n success = do_exclusion(board_np)\\n\\n if success:\\n print(\\\"Found using initial exclusion!\\\")\\n for x in range(9):\\n board[x] = board_np[x].tolist()\\n return\\n\\n # Now we start brute-force heuristics\\n candidates = get_heuristic_candidates(board_np)\\n\\n count = 0\\n\\n for digits, (x, y) in candidates:\\n for digit in digits:\\n count += 1\\n board_copy = board_np.copy()\\n board_copy[x, y] = digit\\n\\n success = do_exclusion(board_copy)\\n\\n if success:\\n print(f\\\"Found using brute-force in {count} tries!\\\")\\n for x in range(9):\\n board[x] = board_copy[x].tolist()\\n return\\n\\n\\n \",\n \"runtime\": \"434\"\n },\n {\n \"code\": \"class Solution(object):\\n def solveSudoku(self, board):\\n \\n \\\"\\\"\\\"\\n Solves the Sudoku puzzle by modifying the board in-place.\\n :type board: List[List[str]]\\n :rtype: None\\n \\\"\\\"\\\"\\n def isvalid(row, col, k):\\n k = str(k)\\n for i in range(9):\\n if board[row][i] == k:\\n return False\\n for i in range(9):\\n if board[i][col] == k:\\n return False\\n curRow = row//3\\n curCol = col//3\\n\\n for i in range(9):\\n for j in range(9):\\n if i //3 == curRow and j //3 == curCol and board[i][j] == k:\\n return False\\n return True\\n \\n def backtrack():\\n\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n for k in range(1, 10):\\n if isvalid(i, j, k):\\n board[i][j] = str(k)\\n\\n if backtrack():\\n return True\\n \\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n \\n backtrack()\\n\",\n \"runtime\": \"434\"\n },\n {\n \"code\": \"import threading\\nfrom concurrent.futures import ThreadPoolExecutor, as_completed\\nfrom typing import List\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def solve(local_board: List[List[str]]) -> List[List[str]]:\\n for i in range(len(local_board)):\\n for j in range(len(local_board[0])):\\n if local_board[i][j] == '.':\\n for num in range(1, 10):\\n c = str(num)\\n if isValid(local_board, i, j, c):\\n local_board[i][j] = c\\n if solve(local_board):\\n return local_board\\n local_board[i][j] = '.'\\n return None\\n return local_board\\n\\n def isValid(board, row, col, c):\\n for i in range(9):\\n if board[row][i] == c:\\n return False \\n if board[i][col] == c:\\n return False\\n if board[3*(row//3) + i//3][3*(col//3)+i%3] == c:\\n return False\\n return True\\n\\n def solve_with_starting_point(start_row, start_col, num):\\n local_board = [row[:] for row in board]\\n if isValid(local_board, start_row, start_col, str(num)):\\n local_board[start_row][start_col] = str(num)\\n result = solve(local_board)\\n if result:\\n return result\\n return None\\n\\n # Find the first empty cell\\n start_row, start_col = next((i, j) for i in range(9) for j in range(9) if board[i][j] == '.')\\n\\n # Create a thread pool\\n with ThreadPoolExecutor(max_workers=9) as executor:\\n # Submit tasks for each possible starting number\\n futures = [executor.submit(solve_with_starting_point, start_row, start_col, num) for num in range(1, 10)]\\n\\n # Wait for the first successful result\\n for future in as_completed(futures):\\n result = future.result()\\n if result:\\n # Copy the solution back to the original board\\n for i in range(9):\\n for j in range(9):\\n board[i][j] = result[i][j]\\n return\\n\\n # If no solution found\\n raise ValueError(\\\"No solution exists\\\")\",\n \"runtime\": \"440\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def find_empty_location():\\n for i in range(9):\\n for j in range(9):\\n if(board[i][j] == '.'):\\n return [i, j]\\n return [-1, -1]\\n def is_valid(row, col, num):\\n # check direct duplicates\\n for i in range(9):\\n if(board[i][col] == str(num)):\\n return False\\n for j in range(9):\\n if(board[row][j] == str(num)):\\n return False\\n x, y = int(row / 3), int(col / 3)\\n for i in range(3 * x, 3 * x + 3):\\n for j in range(3 * y, 3 * y + 3):\\n if(board[i][j] == str(num)):\\n return False\\n return True\\n \\n row, col = find_empty_location()\\n if(row == -1 and col == -1):\\n return True\\n\\n for num in range(1, 10):\\n if(is_valid(row, col, num)):\\n board[row][col] = str(num)\\n if(Solution.solveSudoku(self, board)):\\n return True\\n board[row][col] = '.'\\n \\n return False\\n \\n\\n \",\n \"runtime\": \"440\"\n },\n {\n \"code\": \"class Solution:\\n def solve(self,board):\\n for i in range(len(board)):\\n for j in range(len(board[0])):\\n if(board[i][j]=='.'):\\n for c in range(1,10):\\n if(self.valid(board,i,j,c)):\\n board[i][j]=str(c)\\n if(self.solve(board)==True):\\n return True\\n else:\\n board[i][j]='.'\\n return False\\n\\n return True\\n def valid(self,board,row,col,c):\\n for i in range(9):\\n if(board[row][i]==str(c)):\\n return False\\n if(board[i][col]==str(c)):\\n return False\\n if(board[3*(row//3)+(i//3)][3*(col//3)+(i%3)]==str(c)):\\n return False\\n return True\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.solve(board)\",\n \"runtime\": \"446\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def validPlacement(i, j, val):\\n # returns true if placing val at i,j is valid\\n baseI, baseJ = 3 * (i // 3), 3 * (j // 3)\\n square = []\\n for m in range(baseI, baseI + 3):\\n for n in range(baseJ, baseJ + 3):\\n if board[m][n] == val:\\n return False\\n valInRow = val in board[i]\\n valInCol = val in [board[x][j] for x in range(len(board))]\\n return not valInRow and not valInCol\\n\\n nums = [str(i) for i in range(1, 10)]\\n def dfs():\\n for m in range(9):\\n for n in range(9):\\n if board[m][n] == '.': # only test if it's possible to fill this square\\n for test in nums:\\n if validPlacement(m, n, test):\\n board[m][n] = test\\n if dfs():\\n return True\\n board[m][n] = '.'\\n return False\\n return True # base case: only return True if no '.' characters were found this call, meaning the board is solved.\\n \\n for i in range(9):\\n for j in range(9):\\n if dfs():\\n return\\n print('oops')\\n \\n\\n\\n \\n\\n \\n\",\n \"runtime\": \"446\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n def isValid(board, row, col, num):\\n for i in range(9):\\n if board[row][i] == str(num):\\n return False\\n if board[i][col] == str(num):\\n return False\\n if board[3 * (row//3) +i//3][3 * (col//3) + i%3] == str(num):\\n return False\\n return True\\n\\n def tryAndPlace(board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n for num in range(1,10):\\n if isValid(board, i, j, num):\\n board[i][j] = str(num)\\n if tryAndPlace(board):\\n return True\\n\\n board[i][j] = \\\".\\\"\\n\\n return False\\n\\n return True\\n\\n tryAndPlace(board)\\n \\n\\n \\n\\n \\n \",\n \"runtime\": \"451\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n N = len(board)\\n UNIT = N // 3\\n\\n\\n def validate(r: int, c: int, target: str) -> bool:\\n if any(board[r][j] == target for j in range(9)):\\n return False\\n if any(board[i][c] == target for i in range(9)):\\n return False\\n \\n x, y = (r // 3) * 3, (c // 3) * 3\\n if any(board[i][j] == target \\n for i in range(x, x + 3) \\n for j in range(y, y + 3)):\\n return False\\n return True\\n \\n\\n\\n\\n def backtrace(r: int, c: int) -> bool:\\n if r >= 9:\\n return True\\n if c >= 9:\\n return backtrace(r + 1, 0)\\n if board[r][c] != '.':\\n return backtrace(r, c + 1)\\n\\n for char in '123456789':\\n if not validate(r, c, char):\\n continue\\n \\n board[r][c] = char\\n if backtrace(r, c + 1):\\n return True\\n board[r][c] = '.'\\n return False\\n\\n backtrace(0, 0)\\n\\n\",\n \"runtime\": \"451\"\n },\n {\n \"code\": \"class Solution:\\n\\n def isValid(self, i, j, n, board):\\n for k in range(9):\\n if board[i][k] == str(n):\\n return False\\n if board[k][j] == str(n):\\n return False\\n if board[3 * (i//3) + k//3][3 * (j//3) + k % 3] == str(n):\\n return False\\n return True\\n\\n def solve(self, board):\\n for i in range(len(board)):\\n for j in range(len(board)):\\n if board[i][j] == \\\".\\\":\\n for n in range(1, 10):\\n if self.isValid(i, j, n, board):\\n board[i][j] = str(n)\\n if self.solve(board):\\n return True\\n board[i][j] = \\\".\\\"\\n\\n return False\\n return True\\n\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.solve(board)\",\n \"runtime\": \"457\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # Backtracking\\n # Try 1 through 9 for each cell. The time complexity should be 9 ^ m \\n # (m represents the number of blanks to be filled in), since each blank can have 9 choices.\\n\\n if len(board) == 0: return\\n self.solve(board)\\n\\n def solve(self, board):\\n for i in range(len(board)):\\n for j in range(len(board[0])):\\n if board[i][j] == '.':\\n for c in range(1, 10):\\n ch = str(c)\\n if self.is_valid(board, i, j, ch):\\n board[i][j] = ch\\n if self.solve(board):\\n return True\\n else:\\n board[i][j] = '.'\\n return False\\n return True\\n \\n def is_valid(self, board, row, col, c):\\n for i in range(9):\\n if board[i][col] != '.' and board[i][col] == c: return False\\n if board[row][i] != '.' and board[row][i] == c: return False\\n if board[3*(row//3)+i//3][3*(col//3)+i%3] != '.' and board[3*(row//3)+i//3][3*(col//3)+i%3] == c: return False\\n \\n return True\\n\",\n \"runtime\": \"457\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n \\n\\n def isValidBoard(board,row,col,val):\\n\\n for i in range(9):\\n\\n if board[row][i] == str(val):\\n return False\\n \\n if board[i][col] == str(val):\\n return False\\n \\n if board[3*(row//3)+i//3][3*(col//3)+i%3] == str(val):\\n return False\\n return True\\n\\n def solve(board):\\n\\n for i in range(9):\\n for j in range(9):\\n\\n if board[i][j]=='.':\\n\\n for c in range(1,10):\\n\\n if isValidBoard(board,i,j,c):\\n board[i][j] = str(c)\\n if solve(board):\\n return True\\n else:\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n solve(board)\\n \",\n \"runtime\": \"462\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def solve(board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n for c in range(1, 10):\\n if isValid(i, j, c):\\n board[i][j] = str(c)\\n if solve(board):\\n return True\\n board[i][j] = \\\".\\\"\\n return False\\n return True\\n\\n def isValid(row, col, c):\\n for i in range(9):\\n if board[i][col] == str(c):\\n return False\\n if board[row][i] == str(c):\\n return False\\n if board[3 * (row // 3) + i // 3][3 * (col // 3) + i % 3] == str(c):\\n return False\\n return True\\n\\n solve(board)\\n \",\n \"runtime\": \"462\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isValid(board,r,c,l):\\n for i in range(9):\\n if board[i][c]==str(l):\\n return False\\n elif board[r][i]==str(l):\\n return False\\n elif board[(3*(r//3))+i//3][(3*(c//3))+i%3]==str(l):\\n return False\\n return True\\n def solve(board):\\n for r in range(9):\\n for c in range(9):\\n if board[r][c]=='.':\\n for l in range(1,10):\\n if isValid(board,r,c,l):\\n board[r][c]=str(l)\\n if solve(board):\\n return True\\n else:\\n board[r][c]='.'\\n return False\\n return True\\n solve(board)\\n return board\\n\",\n \"runtime\": \"468\"\n },\n {\n \"code\": \"class Solution:\\n def is_valid(self, board, row, col, digit):\\n for i in range(9):\\n if board[row][i] == str(digit): return False\\n\\n if board[i][col] == str(digit): return False\\n\\n if board[3*(row//3)+(i//3)][3*(col//3)+(i%3)] == str(digit): return False\\n return True\\n\\n def solve(self, board):\\n for row in range(len(board)):\\n for col in range(len(board[0])):\\n if board[row][col] == '.':\\n for digit in range(1, 10):\\n if self.is_valid(board, row, col, digit):\\n board[row][col] = str(digit)\\n if self.solve(board): return True\\n else:\\n board[row][col] = '.'\\n return False\\n return True\\n\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.solve(board)\\n \",\n \"runtime\": \"468\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":156,"string":"156"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n\n # Ideas...\n\n # 3 lists of sets, representing 3x3, row, col\n\n # first pass to populate board\n\n # note that boxes is \n\n\n\n\n rows = [set() for _ in range(9)]\n cols = [set() for _ in range(9)]\n boxes = [set() for _ in range(9)]\n\n for i in range(9):\n for j in range(9):\n if board[i][j] != \".\":\n num = int(board[i][j])\n rows[i].add(num)\n cols[j].add(num)\n\n box_id = i // 3 * 3 + j // 3\n boxes[box_id].add(num)\n \n def backTrack(i, j):\n nonlocal solved\n if i == 9:\n solved = True\n return\n \n new_i = i + (j+1) // 9\n new_j = (j+1) % 9\n\n if board[i][j] != \".\":\n backTrack(new_i, new_j)\n else:\n for num in range(1,10):\n box_id = i // 3 * 3 + j // 3\n if num not in rows[i] and num not in cols[j] and num not in boxes[box_id]:\n rows[i].add(num)\n cols[j].add(num)\n boxes[box_id].add(num)\n board[i][j] = str(num)\n\n backTrack(new_i, new_j)\n\n if solved:\n return\n\n if not solved:\n rows[i].remove(num)\n cols[j].remove(num)\n boxes[box_id].remove(num)\n board[i][j] = \".\"\n\n\n solved = False\n\n backTrack(0, 0)\n ","memory":"16000"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # placing i in pos board[r][c]\n def isValid(r,c,k):\n for i in range(9):\n if board[i][c] == k or board[r][i] == k:\n return False\n \n gridRow = 3*(r//3) + i // 3\n gridCol = 3*(c//3) + i % 3\n if board[gridRow][gridCol] == k:\n return False\n return True\n \n def solve(r, c):\n if r==9:\n return True\n \n if c==9:\n return solve(r+1,0)\n \n if board[r][c] == '.':\n for k in range(1, 10):\n if isValid(r,c,str(k)):\n board[r][c] = str(k)\n if solve(r,c+1):\n return True\n board[r][c] = '.'\n return False\n return solve(r,c+1)\n solve(0,0)","memory":"16100"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # backtracking + pruning\n\n def possible_numbers(i,j,board):\n possibles = set([str(x) for x in range(1, 10)])\n \n # rows\n for x in board[i]:\n if x in possibles:\n possibles.remove(x)\n \n # cols\n for row in board:\n if row[j] in possibles:\n possibles.remove(row[j])\n \n # 3x3 square\n square_x = j//3\n square_y = i//3\n # print(\":::\", square_x, square_y)\n for y in range(square_x*3, square_x*3+3):\n for x in range(square_y*3, square_y*3+3):\n # print(x,y)\n if board[x][y] in possibles:\n possibles.remove(board[x][y])\n \n return list(possibles)\n \n # print(possible_numbers(0,2,board))\n # print(possible_numbers(0,5,board))\n\n\n\n # get every empty cell and add to list\n # problem: how will i save the state?\n # idea 1: tuple entire grid (memory inefficient, but will probably work)\n # tuple conversion is O(n), not O(1)\n # lets try\n # if not work, then try saving just the modified vals and add the functionality \n # to the check func\n\n empties = []\n\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n empties.append((i,j))\n \n\n t = 0\n res = []\n # parameters: idx for empties, tuple of board\n def backtrack(idx, t_board):\n # t = max(t, idx)\n # print(t, len(empties))\n if idx == len(empties):\n # print(t_board)\n # print(\"HIT\")\n for i in range(9):\n temp = []\n for j in range(9):\n temp.append(t_board[i][j])\n res.append(temp)\n return\n \n x, y = empties[idx][0], empties[idx][1]\n possibles = possible_numbers(x, y, t_board)\n \n if len(possibles) == 0:\n return\n \n # print()\n # if t_board[0][5] == '8':\n # print(t_board)\n \n for num in possibles:\n t_board[x][y] = num\n backtrack(idx+1, t_board)\n t_board[x][y] = \".\"\n \n backtrack(0, board)\n \n for i in range(9):\n for j in range(9):\n board[i][j] = res[i][j]\n pass\n \n\n\n \n \n\n ","memory":"16200"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \n def is_valid(x, y, val):\n for i in range(9):\n if board[x][i] == val or board[i][y] == val:\n return False\n \n start_x, start_y = 3 * (x // 3), 3 * (y // 3)\n for i in range(3):\n for j in range(3):\n if board[start_x + i][start_y + j] == val:\n return False\n \n return True\n\n def backtrack():\n for i in range(9):\n for j in range(9):\n if board[i][j] == \".\":\n for num in \"123456789\":\n if is_valid(i, j, num):\n board[i][j] = num\n if backtrack():\n return True\n board[i][j] = \".\"\n return False\n \n return True\n \n backtrack()\n\n\n\n ","memory":"16300"},{"code":"class Solution:\n def solveSudoku(self, board):\n def is_valid(num, row, col):\n for i in range(9):\n if board[row][i] == num or board[i][col] == num:\n return False\n box_row, box_col = 3 * (row // 3), 3 * (col // 3)\n for i in range(box_row, box_row + 3):\n for j in range(box_col, box_col + 3):\n if board[i][j] == num:\n return False\n return True\n\n def backtrack():\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n for num in '123456789':\n if is_valid(num, i, j):\n board[i][j] = num\n if backtrack():\n return True\n board[i][j] = '.' # Reset on backtrack\n return False # Trigger backtrack if no number is valid\n return True # Solved\n\n backtrack()","memory":"16400"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n # 判断是否可以在 board[row][col] 位置放置数字 num\n def isValid(board, row, col, num):\n # 检查行是否有重复数字\n for i in range(9):\n if board[row][i] == num:\n return False\n # 检查列是否有重复数字\n for i in range(9):\n if board[i][col] == num:\n return False\n # 检查3x3子方块是否有重复数字\n startRow, startCol = 3 * (row // 3), 3 * (col // 3)\n for i in range(3):\n for j in range(3):\n if board[startRow + i][startCol + j] == num:\n return False\n return True\n\n # 回溯算法解决数独\n def solve(board):\n # 遍历整个数独棋盘\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n # 尝试放入1到9的数字\n for num in '123456789':\n if isValid(board, i, j, num):\n board[i][j] = num # 填入数字\n if solve(board): # 递归解决下一个空格\n return True\n board[i][j] = '.' # 回溯，撤销数字\n return False # 没有合适的数字可填，返回False\n return True # 全部格子都填满，返回True\n \n solve(board) # 调用solve函数解决数独","memory":"16400"},{"code":"class Solution:\n def findEmpty(self,board):\n for i in range(9):\n for j in range(9):\n if board[i][j] == '.':\n return (i,j)\n return None\n\n def isValid(self,board, pos):\n # col\n for i in range(9):\n if i != pos[1] and board[pos[0]][i] == board[pos[0]][pos[1]]:\n return False\n # row\n for j in range(9):\n if j != pos[0] and board[j][pos[1]] == board[pos[0]][pos[1]]:\n return False\n \n # boxtobox midfielder\n x = pos[1] // 3\n y = pos[0] // 3\n\n for i in range(y * 3, y * 3 + 3):\n for j in range(x * 3, x * 3 + 3):\n if board[i][j] == board[pos[0]][pos[1]] and (i, j) != pos:\n return False\n return True\n \n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def solve():\n if not (pos := self.findEmpty(board)):\n return True\n for num in range(1,10):\n board[pos[0]][pos[1]] = str(num)\n if self.isValid(board,pos):\n if solve():\n return True\n board[pos[0]][pos[1]] = '.'\n return False\n \n solve()\n \n ","memory":"16500"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n self.backtracking(board)\n\n def backtracking(self, board: List[List[str]]) -> bool:\n # 若有解，返回True；若无解，返回False\n for i in range(len(board)): # 遍历行\n for j in range(len(board[0])): # 遍历列\n # 若空格内已有数字，跳过\n if board[i][j] != '.': continue\n for k in range(1, 10):\n if self.is_valid(i, j, k, board):\n board[i][j] = str(k)\n if self.backtracking(board): return True\n board[i][j] = '.'\n # 若数字1-9都不能成功填入空格，返回False无解\n return False\n return True # 有解\n\n def is_valid(self, row: int, col: int, val: int, board: List[List[str]]) -> bool:\n # 判断同一行是否冲突\n for i in range(9):\n if board[row][i] == str(val):\n return False\n # 判断同一列是否冲突\n for j in range(9):\n if board[j][col] == str(val):\n return False\n # 判断同一九宫格是否有冲突\n start_row = (row // 3) * 3\n start_col = (col // 3) * 3\n for i in range(start_row, start_row + 3):\n for j in range(start_col, start_col + 3):\n if board[i][j] == str(val):\n return False\n return True","memory":"16500"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n def isvalid(board,row,col,num):\n for i in range(9):\n if board[i][col]==num:\n return False\n for i in range(9):\n if board[row][i]==num:\n return False\n start_row=3*(row//3)\n start_col=3*(col//3)\n for i in range(start_row,start_row+3):\n for j in range(start_col,start_col+3):\n if board[i][j]==num:\n return False\n return True\n def solve(board):\n for i in range(9):\n for j in range(9):\n if board[i][j]=='.':\n for num in map(str,range(1,10)):\n if isvalid(board,i,j,num):\n board[i][j]=num\n if solve(board):\n return True\n board[i][j]='.'\n return False\n return True\n solve(board)\n return board\n \n\n ","memory":"16600"},{"code":"from typing import List\n\nclass Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n def is_valid(board: List[List[str]], row: int, col: int, num: str) -> bool:\n # Check if 'num' is not in the current row, column and 3x3 sub-box\n for i in range(9):\n if board[row][i] == num or board[i][col] == num:\n return False\n if board[(row // 3) * 3 + i // 3][(col // 3) * 3 + i % 3] == num:\n return False\n return True\n \n def solve(board: List[List[str]]) -> bool:\n for row in range(9):\n for col in range(9):\n if board[row][col] == '.':\n for num in '123456789':\n if is_valid(board, row, col, num):\n board[row][col] = num\n if solve(board):\n return True\n board[row][col] = '.' # Backtrack\n return False # No valid number found, trigger backtracking\n return True # All cells filled correctly\n \n solve(board)\n","memory":"16600"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n \"\"\"\n Do not return anything, modify board in-place instead.\n \"\"\"\n \n def couldPlace(d, row, col):\n\n return not (\n d in rows[row] \n or d in columns[col] \n or d in boxes[box_index(row, col)]\n )\n\n def placeNumber(d, row, col):\n\n rows[row][d] += 1\n columns[col][d] += 1\n boxes[box_index(row, col)][d] += 1\n board[row][col] = str(d)\n \n def removeNumber(d, row, col):\n\n rows[row][d] -= 1\n columns[col][d] -= 1\n boxes[box_index(row, col)][d] -= 1 \n if rows[row][d] == 0:\n del rows[row][d]\n if columns[col][d] == 0:\n del columns[col][d]\n if boxes[box_index(row,col)][d] == 0:\n del boxes[box_index(row, col)][d]\n board[row][col] = '.'\n\n def placeNext(row, col):\n\n if col == N - 1 and row == N - 1:\n sudokuSolved[0] = True\n else:\n if col == N - 1:\n backtrack(row + 1, 0)\n else:\n backtrack(row, col + 1)\n \n def backtrack(row = 0, col = 0):\n\n if board[row][col] == '.':\n for d in range(1, 10):\n if couldPlace(d, row, col):\n placeNumber(d, row, col)\n placeNext(row, col)\n if sudokuSolved[0]:\n return\n removeNumber(d, row, col)\n else:\n placeNext(row, col)\n\n n = 3\n N = n * n\n box_index = lambda row, col: (row // n) * n + col // n\n\n rows = [defaultdict(int) for _ in range(N)]\n columns = [defaultdict(int) for _ in range(N)]\n boxes = [defaultdict(int) for _ in range(N)]\n\n for r in range(N):\n for c in range(N):\n if board[r][c] != '.':\n d = int(board[r][c])\n placeNumber(d, r, c)\n \n sudokuSolved = [False]\n backtrack()\n","memory":"16900"},{"code":"class Solution:\n def solveSudoku(self, board: List[List[str]]) -> None:\n rows = [set() for _ in range(9)]\n columns = [set() for _ in range(9)]\n buckets = [set() for _ in range(9)]\n empty_cells = []\n\n # Initialize rows, columns, and buckets with the board's current numbers\n for r in range(9):\n for c in range(9):\n if board[r][c] == '.':\n empty_cells.append((r, c))\n else:\n columns[c].add(board[r][c])\n rows[r].add(board[r][c])\n bucket_index = (r // 3) * 3 + c // 3\n buckets[bucket_index].add(board[r][c])\n\n # Check if placing number n at (r, c) is valid\n def is_valid(r, c, n):\n bucket_index = (r // 3) * 3 + c // 3\n if n in rows[r] or n in columns[c] or n in buckets[bucket_index]:\n return False\n return True\n\n # Recursive backtracking function to solve the Sudoku\n def solve(index=0):\n if index == len(empty_cells):\n return True # Solved!\n\n r, c = empty_cells[index]\n for n in '123456789':\n if is_valid(r, c, n):\n bucket_index = (r // 3) * 3 + c // 3\n\n # First, update the sets\n rows[r].add(n)\n columns[c].add(n)\n buckets[bucket_index].add(n)\n \n # Then update the board\n board[r][c] = n\n\n # Proceed with the recursive call\n if solve(index + 1):\n return True\n\n # Backtrack if the recursive call fails\n rows[r].discard(n)\n columns[c].discard(n)\n buckets[bucket_index].discard(n)\n board[r][c] = '.'\n\n return False\n\n solve()","memory":"16900"}],"string":"[\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n\\n # Ideas...\\n\\n # 3 lists of sets, representing 3x3, row, col\\n\\n # first pass to populate board\\n\\n # note that boxes is \\n\\n\\n\\n\\n rows = [set() for _ in range(9)]\\n cols = [set() for _ in range(9)]\\n boxes = [set() for _ in range(9)]\\n\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] != \\\".\\\":\\n num = int(board[i][j])\\n rows[i].add(num)\\n cols[j].add(num)\\n\\n box_id = i // 3 * 3 + j // 3\\n boxes[box_id].add(num)\\n \\n def backTrack(i, j):\\n nonlocal solved\\n if i == 9:\\n solved = True\\n return\\n \\n new_i = i + (j+1) // 9\\n new_j = (j+1) % 9\\n\\n if board[i][j] != \\\".\\\":\\n backTrack(new_i, new_j)\\n else:\\n for num in range(1,10):\\n box_id = i // 3 * 3 + j // 3\\n if num not in rows[i] and num not in cols[j] and num not in boxes[box_id]:\\n rows[i].add(num)\\n cols[j].add(num)\\n boxes[box_id].add(num)\\n board[i][j] = str(num)\\n\\n backTrack(new_i, new_j)\\n\\n if solved:\\n return\\n\\n if not solved:\\n rows[i].remove(num)\\n cols[j].remove(num)\\n boxes[box_id].remove(num)\\n board[i][j] = \\\".\\\"\\n\\n\\n solved = False\\n\\n backTrack(0, 0)\\n \",\n \"memory\": \"16000\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # placing i in pos board[r][c]\\n def isValid(r,c,k):\\n for i in range(9):\\n if board[i][c] == k or board[r][i] == k:\\n return False\\n \\n gridRow = 3*(r//3) + i // 3\\n gridCol = 3*(c//3) + i % 3\\n if board[gridRow][gridCol] == k:\\n return False\\n return True\\n \\n def solve(r, c):\\n if r==9:\\n return True\\n \\n if c==9:\\n return solve(r+1,0)\\n \\n if board[r][c] == '.':\\n for k in range(1, 10):\\n if isValid(r,c,str(k)):\\n board[r][c] = str(k)\\n if solve(r,c+1):\\n return True\\n board[r][c] = '.'\\n return False\\n return solve(r,c+1)\\n solve(0,0)\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # backtracking + pruning\\n\\n def possible_numbers(i,j,board):\\n possibles = set([str(x) for x in range(1, 10)])\\n \\n # rows\\n for x in board[i]:\\n if x in possibles:\\n possibles.remove(x)\\n \\n # cols\\n for row in board:\\n if row[j] in possibles:\\n possibles.remove(row[j])\\n \\n # 3x3 square\\n square_x = j//3\\n square_y = i//3\\n # print(\\\":::\\\", square_x, square_y)\\n for y in range(square_x*3, square_x*3+3):\\n for x in range(square_y*3, square_y*3+3):\\n # print(x,y)\\n if board[x][y] in possibles:\\n possibles.remove(board[x][y])\\n \\n return list(possibles)\\n \\n # print(possible_numbers(0,2,board))\\n # print(possible_numbers(0,5,board))\\n\\n\\n\\n # get every empty cell and add to list\\n # problem: how will i save the state?\\n # idea 1: tuple entire grid (memory inefficient, but will probably work)\\n # tuple conversion is O(n), not O(1)\\n # lets try\\n # if not work, then try saving just the modified vals and add the functionality \\n # to the check func\\n\\n empties = []\\n\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n empties.append((i,j))\\n \\n\\n t = 0\\n res = []\\n # parameters: idx for empties, tuple of board\\n def backtrack(idx, t_board):\\n # t = max(t, idx)\\n # print(t, len(empties))\\n if idx == len(empties):\\n # print(t_board)\\n # print(\\\"HIT\\\")\\n for i in range(9):\\n temp = []\\n for j in range(9):\\n temp.append(t_board[i][j])\\n res.append(temp)\\n return\\n \\n x, y = empties[idx][0], empties[idx][1]\\n possibles = possible_numbers(x, y, t_board)\\n \\n if len(possibles) == 0:\\n return\\n \\n # print()\\n # if t_board[0][5] == '8':\\n # print(t_board)\\n \\n for num in possibles:\\n t_board[x][y] = num\\n backtrack(idx+1, t_board)\\n t_board[x][y] = \\\".\\\"\\n \\n backtrack(0, board)\\n \\n for i in range(9):\\n for j in range(9):\\n board[i][j] = res[i][j]\\n pass\\n \\n\\n\\n \\n \\n\\n \",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\n def is_valid(x, y, val):\\n for i in range(9):\\n if board[x][i] == val or board[i][y] == val:\\n return False\\n \\n start_x, start_y = 3 * (x // 3), 3 * (y // 3)\\n for i in range(3):\\n for j in range(3):\\n if board[start_x + i][start_y + j] == val:\\n return False\\n \\n return True\\n\\n def backtrack():\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == \\\".\\\":\\n for num in \\\"123456789\\\":\\n if is_valid(i, j, num):\\n board[i][j] = num\\n if backtrack():\\n return True\\n board[i][j] = \\\".\\\"\\n return False\\n \\n return True\\n \\n backtrack()\\n\\n\\n\\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board):\\n def is_valid(num, row, col):\\n for i in range(9):\\n if board[row][i] == num or board[i][col] == num:\\n return False\\n box_row, box_col = 3 * (row // 3), 3 * (col // 3)\\n for i in range(box_row, box_row + 3):\\n for j in range(box_col, box_col + 3):\\n if board[i][j] == num:\\n return False\\n return True\\n\\n def backtrack():\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n for num in '123456789':\\n if is_valid(num, i, j):\\n board[i][j] = num\\n if backtrack():\\n return True\\n board[i][j] = '.' # Reset on backtrack\\n return False # Trigger backtrack if no number is valid\\n return True # Solved\\n\\n backtrack()\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n # 判断是否可以在 board[row][col] 位置放置数字 num\\n def isValid(board, row, col, num):\\n # 检查行是否有重复数字\\n for i in range(9):\\n if board[row][i] == num:\\n return False\\n # 检查列是否有重复数字\\n for i in range(9):\\n if board[i][col] == num:\\n return False\\n # 检查3x3子方块是否有重复数字\\n startRow, startCol = 3 * (row // 3), 3 * (col // 3)\\n for i in range(3):\\n for j in range(3):\\n if board[startRow + i][startCol + j] == num:\\n return False\\n return True\\n\\n # 回溯算法解决数独\\n def solve(board):\\n # 遍历整个数独棋盘\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n # 尝试放入1到9的数字\\n for num in '123456789':\\n if isValid(board, i, j, num):\\n board[i][j] = num # 填入数字\\n if solve(board): # 递归解决下一个空格\\n return True\\n board[i][j] = '.' # 回溯，撤销数字\\n return False # 没有合适的数字可填，返回False\\n return True # 全部格子都填满，返回True\\n \\n solve(board) # 调用solve函数解决数独\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def findEmpty(self,board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j] == '.':\\n return (i,j)\\n return None\\n\\n def isValid(self,board, pos):\\n # col\\n for i in range(9):\\n if i != pos[1] and board[pos[0]][i] == board[pos[0]][pos[1]]:\\n return False\\n # row\\n for j in range(9):\\n if j != pos[0] and board[j][pos[1]] == board[pos[0]][pos[1]]:\\n return False\\n \\n # boxtobox midfielder\\n x = pos[1] // 3\\n y = pos[0] // 3\\n\\n for i in range(y * 3, y * 3 + 3):\\n for j in range(x * 3, x * 3 + 3):\\n if board[i][j] == board[pos[0]][pos[1]] and (i, j) != pos:\\n return False\\n return True\\n \\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def solve():\\n if not (pos := self.findEmpty(board)):\\n return True\\n for num in range(1,10):\\n board[pos[0]][pos[1]] = str(num)\\n if self.isValid(board,pos):\\n if solve():\\n return True\\n board[pos[0]][pos[1]] = '.'\\n return False\\n \\n solve()\\n \\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n self.backtracking(board)\\n\\n def backtracking(self, board: List[List[str]]) -> bool:\\n # 若有解，返回True；若无解，返回False\\n for i in range(len(board)): # 遍历行\\n for j in range(len(board[0])): # 遍历列\\n # 若空格内已有数字，跳过\\n if board[i][j] != '.': continue\\n for k in range(1, 10):\\n if self.is_valid(i, j, k, board):\\n board[i][j] = str(k)\\n if self.backtracking(board): return True\\n board[i][j] = '.'\\n # 若数字1-9都不能成功填入空格，返回False无解\\n return False\\n return True # 有解\\n\\n def is_valid(self, row: int, col: int, val: int, board: List[List[str]]) -> bool:\\n # 判断同一行是否冲突\\n for i in range(9):\\n if board[row][i] == str(val):\\n return False\\n # 判断同一列是否冲突\\n for j in range(9):\\n if board[j][col] == str(val):\\n return False\\n # 判断同一九宫格是否有冲突\\n start_row = (row // 3) * 3\\n start_col = (col // 3) * 3\\n for i in range(start_row, start_row + 3):\\n for j in range(start_col, start_col + 3):\\n if board[i][j] == str(val):\\n return False\\n return True\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n def isvalid(board,row,col,num):\\n for i in range(9):\\n if board[i][col]==num:\\n return False\\n for i in range(9):\\n if board[row][i]==num:\\n return False\\n start_row=3*(row//3)\\n start_col=3*(col//3)\\n for i in range(start_row,start_row+3):\\n for j in range(start_col,start_col+3):\\n if board[i][j]==num:\\n return False\\n return True\\n def solve(board):\\n for i in range(9):\\n for j in range(9):\\n if board[i][j]=='.':\\n for num in map(str,range(1,10)):\\n if isvalid(board,i,j,num):\\n board[i][j]=num\\n if solve(board):\\n return True\\n board[i][j]='.'\\n return False\\n return True\\n solve(board)\\n return board\\n \\n\\n \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n def is_valid(board: List[List[str]], row: int, col: int, num: str) -> bool:\\n # Check if 'num' is not in the current row, column and 3x3 sub-box\\n for i in range(9):\\n if board[row][i] == num or board[i][col] == num:\\n return False\\n if board[(row // 3) * 3 + i // 3][(col // 3) * 3 + i % 3] == num:\\n return False\\n return True\\n \\n def solve(board: List[List[str]]) -> bool:\\n for row in range(9):\\n for col in range(9):\\n if board[row][col] == '.':\\n for num in '123456789':\\n if is_valid(board, row, col, num):\\n board[row][col] = num\\n if solve(board):\\n return True\\n board[row][col] = '.' # Backtrack\\n return False # No valid number found, trigger backtracking\\n return True # All cells filled correctly\\n \\n solve(board)\\n\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n \\\"\\\"\\\"\\n Do not return anything, modify board in-place instead.\\n \\\"\\\"\\\"\\n \\n def couldPlace(d, row, col):\\n\\n return not (\\n d in rows[row] \\n or d in columns[col] \\n or d in boxes[box_index(row, col)]\\n )\\n\\n def placeNumber(d, row, col):\\n\\n rows[row][d] += 1\\n columns[col][d] += 1\\n boxes[box_index(row, col)][d] += 1\\n board[row][col] = str(d)\\n \\n def removeNumber(d, row, col):\\n\\n rows[row][d] -= 1\\n columns[col][d] -= 1\\n boxes[box_index(row, col)][d] -= 1 \\n if rows[row][d] == 0:\\n del rows[row][d]\\n if columns[col][d] == 0:\\n del columns[col][d]\\n if boxes[box_index(row,col)][d] == 0:\\n del boxes[box_index(row, col)][d]\\n board[row][col] = '.'\\n\\n def placeNext(row, col):\\n\\n if col == N - 1 and row == N - 1:\\n sudokuSolved[0] = True\\n else:\\n if col == N - 1:\\n backtrack(row + 1, 0)\\n else:\\n backtrack(row, col + 1)\\n \\n def backtrack(row = 0, col = 0):\\n\\n if board[row][col] == '.':\\n for d in range(1, 10):\\n if couldPlace(d, row, col):\\n placeNumber(d, row, col)\\n placeNext(row, col)\\n if sudokuSolved[0]:\\n return\\n removeNumber(d, row, col)\\n else:\\n placeNext(row, col)\\n\\n n = 3\\n N = n * n\\n box_index = lambda row, col: (row // n) * n + col // n\\n\\n rows = [defaultdict(int) for _ in range(N)]\\n columns = [defaultdict(int) for _ in range(N)]\\n boxes = [defaultdict(int) for _ in range(N)]\\n\\n for r in range(N):\\n for c in range(N):\\n if board[r][c] != '.':\\n d = int(board[r][c])\\n placeNumber(d, r, c)\\n \\n sudokuSolved = [False]\\n backtrack()\\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def solveSudoku(self, board: List[List[str]]) -> None:\\n rows = [set() for _ in range(9)]\\n columns = [set() for _ in range(9)]\\n buckets = [set() for _ in range(9)]\\n empty_cells = []\\n\\n # Initialize rows, columns, and buckets with the board's current numbers\\n for r in range(9):\\n for c in range(9):\\n if board[r][c] == '.':\\n empty_cells.append((r, c))\\n else:\\n columns[c].add(board[r][c])\\n rows[r].add(board[r][c])\\n bucket_index = (r // 3) * 3 + c // 3\\n buckets[bucket_index].add(board[r][c])\\n\\n # Check if placing number n at (r, c) is valid\\n def is_valid(r, c, n):\\n bucket_index = (r // 3) * 3 + c // 3\\n if n in rows[r] or n in columns[c] or n in buckets[bucket_index]:\\n return False\\n return True\\n\\n # Recursive backtracking function to solve the Sudoku\\n def solve(index=0):\\n if index == len(empty_cells):\\n return True # Solved!\\n\\n r, c = empty_cells[index]\\n for n in '123456789':\\n if is_valid(r, c, n):\\n bucket_index = (r // 3) * 3 + c // 3\\n\\n # First, update the sets\\n rows[r].add(n)\\n columns[c].add(n)\\n buckets[bucket_index].add(n)\\n \\n # Then update the board\\n board[r][c] = n\\n\\n # Proceed with the recursive call\\n if solve(index + 1):\\n return True\\n\\n # Backtrack if the recursive call fails\\n rows[r].discard(n)\\n columns[c].discard(n)\\n buckets[bucket_index].discard(n)\\n board[r][c] = '.'\\n\\n return False\\n\\n solve()\",\n \"memory\": \"16900\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":12,"string":"12"}}},{"rowIdx":74,"cells":{"question_id":{"kind":"number","value":38,"string":"38"},"name":{"kind":"string","value":"count-and-say"},"content":{"kind":"string","value":"<p>The <strong>count-and-say</strong> sequence is a sequence of digit strings defined by the recursive formula:</p>\n\n<ul>\n\t<li><code>countAndSay(1) = "1"</code></li>\n\t<li><code>countAndSay(n)</code> is the run-length encoding of <code>countAndSay(n - 1)</code>.</li>\n</ul>\n\n<p><a href=\"http://en.wikipedia.org/wiki/Run-length_encoding\" target=\"_blank\">Run-length encoding</a> (RLE) is a string compression method that works by replacing consecutive identical characters (repeated 2 or more times) with the concatenation of the character and the number marking the count of the characters (length of the run). For example, to compress the string <code>"3322251"</code> we replace <code>"33"</code> with <code>"23"</code>, replace <code>"222"</code> with <code>"32"</code>, replace <code>"5"</code> with <code>"15"</code> and replace <code>"1"</code> with <code>"11"</code>. Thus the compressed string becomes <code>"23321511"</code>.</p>\n\n<p>Given a positive integer <code>n</code>, return <em>the </em><code>n<sup>th</sup></code><em> element of the <strong>count-and-say</strong> sequence</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">n = 4</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">"1211"</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<pre>\ncountAndSay(1) = "1"\ncountAndSay(2) = RLE of "1" = "11"\ncountAndSay(3) = RLE of "11" = "21"\ncountAndSay(4) = RLE of "21" = "1211"\n</pre>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">n = 1</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">"1"</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>This is the base case.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n <= 30</code></li>\n</ul>\n\n<p> </p>\n<strong>Follow up:</strong> Could you solve it iteratively?"},"acRate":{"kind":"number","value":56.405607502156116,"string":"56.405608"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["string"],"string":"[\n \"string\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"18\", 0.0124], [\"22\", 0.0372], [\"23\", 0.0868], [\"24\", 0.0372], [\"25\", 0.0868], [\"26\", 0.2108], [\"27\", 0.2604], [\"28\", 0.3349], [\"29\", 0.3225], [\"30\", 0.7441], [\"31\", 1.017], [\"32\", 1.017], [\"33\", 1.141], [\"34\", 2.0216], [\"35\", 2.9145], [\"36\", 2.8277], [\"37\", 3.1874], [\"38\", 4.316], [\"39\", 5.6803], [\"40\", 4.7749], [\"41\", 5.1594], [\"42\", 7.1313], [\"43\", 7.4042], [\"44\", 6.5732], [\"45\", 6.288], [\"46\", 5.9655], [\"47\", 5.9655], [\"48\", 4.9113], [\"49\", 4.1052], [\"50\", 3.8819], [\"51\", 2.7905], [\"52\", 2.1828], [\"53\", 1.5503]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16200\", 0.0124], [\"16300\", 0.3969], [\"16400\", 7.6274], [\"16500\", 21.1832], [\"16600\", 38.3728], [\"16700\", 15.9618], [\"16800\", 7.9871], [\"16900\", 3.0386]]}"},"rt_list":{"kind":"list like","value":[{"code":"import gc\ngc.disable()\n\nfrom os import _exit\nfrom sys import stdin \nimport pickle, base64, zlib\n\nd = pickle.loads(zlib.decompress(base64.a85decode( b'GQI294c^j[&`\\'!>(3BTa0X.cN(g(I`k<;$cA)^nc,;=,Q6c)7Tbeh35`9%;5nO%OC&Xeb]=k2?7Z_uijBX^&R1ZHB#0-Y1TDoH(tp\\\\-oNk*>r?kN/%;^HO5F+5NRWQ`jbgQ`#o5:Kfr$H.MQ8jlt%gl0SApQDYfIjE1+KkBq[8P=!#dSj\\'\\\\L4n.+e?S5,=AGF\\'1^D-:io(6Ff+:9(c<92m\"mIKm*jC/dXVm@Q[q!J9J58TEi*a$:akH&fM!rZIC=aOdj[2Q1a,jnFSpGT#hLj6dSQ\\'7\\'=P9nHJFlAJXiZmSbhRPf=$#I#m+?[O*]+]SiD;eYU8%*Z(S++9DX5G=Hdj!`e&($Eq(L=28Hl>Xfg1u?YYC\"QrliD_o5?.+h^SM#Qs6IZ8ZU5\">jf3Yn_XsLme4SF2X3f]!%\\'>cKnDL:1P8cD[6[US,s.9(U3YX75S4[YTP:2+;n\\\\V]<fPhY%[9brGHu%9b1Ejsh!r(]h4.R>?Vgm[S\\\\bhO;i<OMQs57.0XZ+-K\\\\!jj\\'%q`QK?48ujFf_JoqFX_<W(28.cYo/j\\\\$\\'/P\\\\i;Yrk>+>^Mi+aYXrAaVfOF@oU:.;Lg#a3W%taCNA@/Fo\"%!l^N!#PcJ8C<)_<Gq:6]\\'e\\'7WIM+.NT@?jWb$.Hs.Tk60h3\"!^\\\\l!p1+<f1bB%G3m,OTO8s7V#uMRX7u\\\\%:9F\"&09tP$8-F51iRB(pI2J]O\"g.66\"\\'?\"\\'/(_!NjK^Kd\".B4D\\\\Q,oIrA:E\\'I\"ir#\\\\75.PC\\'6!%cF?V@=5J?*)93r;\\\\(;9=`K\\\\S7r<CL/.41bO!Mo\\'A:G[;\\\\TiLpZ(C0I$[f66udZPc7X67=&4E+8AU+4?8.XW;-ZX8+()Gj8XG`(LZ(%0I^u_ee:WU]P8e\\\\WVs-SmOV\\\\,gVF%C5QIt<725)=<@L=iKt=^L4on)+]4+Y2HZ[gYA.rKb=Qc*<CX6O:ei`2Y\"Rnb7NJQ>:9?h]Hp2:ZNl%k(eI-DpJN4QZjQ9T2<Y!^ugmCR:p;i#%K;PA1=g$i:73qB9!ihZ\"7A2\"`Co6K$V7\\\\_k<\\'i@C@eMqpIu_j*g8g&Z@n*psL8gf(=`/?/ZD`e=16\"S5)f[a@T.Z1Sqrk`md$_;$`fM`W&F$PS\"dEGTk/=K*1Q7h^cRa3lD(,,5N;ia;P0t1@2JLohF+aQRWY$/NN42Gp*oe,Nh8sJ_$pA2@,h6;6p*urjMW(+dP@2CCmBS4.4^pREN3%>gh6off`mZpaPh<+Z&P%i10W@\"&,</hmQ[p0M+qRoQ=qtR9h%M_f=.YO`YBDU)A:673hsa1]`oC3$f.qf8I\\'u0:oAace%iP6hPjS)(UEqo)Bb/lq&t^2(-cjk&4t+mCl_%<HE9sGLG%k!sFX(W\"$eO8)*JZ`/-VIH8(K.=4Bhsu;?Z,Bkl9%tF8AN$)\\\\``HIVldt3+u6\\'$mA8NgN^\\\\TEpr:ocmuH$GK4+)opEdqAD\\'pJZ&TSg[HBEHQCYp/3XrH%-R+3%qIEkO[->.280&r@<,\\\\A(d@Z-\"D\\'e4V*(_1tbc[357\\'/6tl<(CAsQi4jDf?2@o$)04dcYl5aM_\"32$mRP8S#WDO5CC1-^3RUteNecOms9CQ_PC0%5_=eYi,^Q&g!8p:Jf)gK@VOFRgp./CJQ4RIBOiknAMU`^h5bE`V`0JJpuHAdD05#*E6MKc-#JckU/4r`&Y?V?i7IX%p1k(2>0,^Vo3Gg.OQ\\\\gLjn+[*R\\\\.rY?q$E2Du3q\\\\[3)llA5GeHd);#=\"BFp^>^42F#Wp7DhI_cl[EFh%r67f)gnn\\'`c.Aml/q.EN8Lh.b<1^gE*VfCFYMF*`cUtga[2rp^G#2u*J>?Za@QKqVA*/HBVW:T(@[X7!i8<4E.=HDOo+$GPB&%LV&P1@r,*?2&HUb)>0fCN&W-ZaKk*4FO\"\"T//]DRa8A\"bV!MoGg/Gc$@W<tn7^=?dA2=<@M6rU8ZO-tu4.dtXei2W$*l3?1s^CCHIsLQlYn3mo9SKaRNsF96ZaM7$VL1s*C>obL%ZlP1q_W$[6I,,B,+7<?<\\\\BanquQE\"!O(npSTHcUVBW\\\\hBH,Q.+1kUKDX`ZJs_(DK`2A,:nr(/IEVql`fW,PZ]_mKk\\\\m_ALJ5\\'D6Rq-@OV:IEp\\'j?(\"Z-<7K&9VPX%+rbug5DtY.<q@06)dANda625JcTmG-7@ZA<3C5tmuTpJl>=(]B`-1&%0l5A0+ibY\\\\DJhT6T=6(q7Vp(X[)p\\\\nE1:R-$hOD2hSB=*i.PIl:Pe=A\\\\BBZfch]$=T?:<$W2\"+quI?E^`f,EG@pn7m<UO!IXXe$1i1Pf1oF@8W1\\\\.oU6\\'+jH\\'T8lusYTsEi::+lNG6gS^(=b?bYaKr[04Sn3]B]d4T?38#_\"Q#\\\\bu!5!FWN+?9ZU*rkeG\\'NoR?Ai5>nK&6Y!]q)?UmACF8a47/7aPruA#s<L(hGr`(TO!YEnXS=KbPF]tgX`O2k\\\\.eaTO7\\\\Y,MHE8!YbbQ$KX;-Ya+muq*)(K@%QpH7]i-G\\'m`<7uh1nISi)0.F*!G0\"&;J4G>SR.C@h$I_Kfgt3T+\\'Q<i^lHiFFp(Vu=)HrKVt7GaLs0C!AnOP-#.N-`>RCGYUl,7/)@KWWZK$+[N3#JWP?l\\'34Ue$9^%9&J3\\\\7-*4QM8bi\\'r.[O:0A(9gSjR<n2t?WW?FIk@lKn86t,4PP]l#lphakr1tA\\\\\\\\UO4/l@Na>:aGVkY,..tXK1TA>7=6RL`tm*2TL]n:@P_mOYlCi\\':[eEeJQDco\\'m\\'1),J_?1hbY7MHW/dbnlC8)-.L2Sor^J[nRc>TDI?IW6!\\'3oIN7i&H/qBTIl+83,464m<g+@e[tX$*WBWrNC0hZ%QF2EmhB[NYj?&s69]-c?\"Z^Z6tl4nFWf>Tm$&Q1*Y^06(GdF%[ENs_CHpC!ac9ALp/MbR,\\'5D]i7fk>@GQ>9pUtZDb/[Z>;eA83=`SDNF2$e&Q1[YfYEm5drTM-`)FQs^7DE#Y55[##pj0e-%(WS!o`IsEDu4&@?6A/AY//DM_pL@7b6/VJQU\\'.r$E/UTH\"3[B&\\\\>V;O/F&fG=u8f;1H9nCJUn!\\\\bO,_R.\\\\TDQnH,d`U@$rq-#GD.9+U7=\\\\!S!Gij:aXmM!igs8CD@V!767mA_UHTRh2XQ^i0*/*A,3>d+a86/]fY$flA;1Vm$j0`t2/9rLI@CP?.]tf\\'$\\\\Kj\\\\U%1d@:,&d)cI6(oA^qoDEQgUd_=/a:@-J+c@oU=)d>60VV/]6aoIRFujoYOPS($)11FF*r)atBoJAEe\"f-W>Kg:8l(_,\\'IXsX;8WncNcJ<(p8S2g,p7Rm(Y7q=##>k:]__h\")>\"dVCX8WUs-IcO8\\\\F3>Uk%7>&+E.8Aj.1]5rfh/Rn,.@<TdFWik9pd4@tc[hJSq5,]fT_UE&\\\\IVijTc[ES1R9m\\';9-*85U=6I-k@`0g]Z)VXC`+L1\\\\o^AXe21Bm:RBVHVVibHZT#FA(%!_9;\\'eDJs6-#aE@4Km\\'[4*he>,mikBJ&N0t91,>%3cRqnBA)ONBq)M2r*IO5(Z\"R#J3g1FN!\\\\%+a2<l0-BV$\\\\D1a^[tjC#,g#pF$;D5eP*]`,\\\\+0hWd-Mu1+\\\\q[F=Z.GI#D%q0p7bY<d9cPXH=kt4lPO?CF;WtV#$rOPa4qs0d`pC$-a7cHM)gg&(VhOo&65!@t7sOg31gg7,W19,3N[!3>=g--`6]Q=>Y\\'@+DQpc%cM[\"nd=Ji@Ku^d@e`])3=#Zq*fA<*0R+GbC(9?pmh*-c83TFI^a1MtpaUB/WZ6ZCGVXuX3KRKE$?j+,J3W1T5P>.E335Cd\\\\,\"2AQ?1Tap9b)$RMl%Z+#]\"SeYTDm18eCA7Tb:7MA;*PhX`d.q@biAAJHoK:A0.kNL1eU8eLY;6YqF\\\\7S61nlR:eo=$X)f7.]l7K#2:bWTM5(1B)083M#fDaaMEt[)7LD#s\"Ie4L]D(B[X#%ca/j90(`qp9]$4AQL7>;DJ!B?=fJ1PONi07H`:Gu*1(fU9dXA[aZDkSHo=&KrEnA,ZJOFACFT5s=\"_(DjC`)Q<F0![E_Ua.4.bq$U,X\\\\kXQP7Bfs2;C5P.%pG<)FMS\\\\Le$]ffZ>Cn03@B$9,\\\\<-!#X2ri>EIXa=rX\\\\u1>*rYM(4>77sZ,G@b&X]W;2W!0Ni6H(Zf_@f#oiHQ-A6#]njH>Akn\\\\oY@GfBn1]+rGUl6C4FD`h[?@\\'HV&a-%$[o=6q\"-g&it=-GuS.I\\'n>,;18tWXCtj0nd2Wl\\\\0bWH/,G>2`94d\\\\2/srpI-.EheU`jY>gbcZ#Si4T5);`F\\'QW.+eEZuZb8Q@*$b5i-9?ENLON1;2a/rI%47Z`]#SG=nP!EF,;_80Ic<\\\\)>EDZ^G6V0Cn@&-(NG#T_<U9Uu4E2M$C-qXPKUmFWkoi[Wb<_n@Vn\"Tq\\\\@\\\\X+OQGCW&W!s9kUILj<gg0:;V2tGZ27#aFC[865Zp9,c\\'\\'C\\\\Kd]7i:X@*:HB$VB+,,;=.`u\\\\\\\\9>0_@=7fHK`>O<m6DT457JsP,-Rd_geH,5[B8Ed_nasc0em1>9>U7HI<mCuR.kBpc\"YpN^W<$\"L1idRh)Ii`Gi`0Lp!Jtp)ZZ,#&MYM:K-17*arp\"tm9u$u' )))\n\nwith open('user.out', 'wb') as f:\n for i in sys.stdin:\n if i[-1] == '\\n':\n f.write(d[i[:-1]])\n else:\n f.write(d[i])\n f.write(b\"\\n\")\n_exit(0)","runtime":"18"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n x = self.countAndSay(n - 1)\n result = \"\"\n character = x[0]\n count = 1\n for i in range(1, len(x)):\n if x[i] == character:\n count = count + 1\n else:\n result = result + str(count)\n result = result + str(character)\n character = x[i]\n count = 1\n result = result + str(count)\n result = result + str(character)\n\n return result","runtime":"22"},{"code":"class Solution:\n def process_str(self, s):\n r = ''\n prev = s[0]\n c = 1\n for el in s[1:]:\n if el == prev:\n c+=1\n else:\n r+=f'{c}{prev}'\n prev = el\n c=1\n else:\n r+=f'{c}{prev}'\n return r\n\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return '1'\n return self.process_str(self.countAndSay(n-1))","runtime":"23"},{"code":"import gc\ngc.disable()\n\nfrom os import _exit\nfrom sys import stdin \nimport pickle, base64, zlib\n\nd = pickle.loads(zlib.decompress(base64.a85decode( b'GQI294c^j[&`\\'!>(3BTa0X.cN(g(I`k<;$cA)^nc,;=,Q6c)7Tbeh35`9%;5nO%OC&Xeb]=k2?7Z_uijBX^&R1ZHB#0-Y1TDoH(tp\\\\-oNk*>r?kN/%;^HO5F+5NRWQ`jbgQ`#o5:Kfr$H.MQ8jlt%gl0SApQDYfIjE1+KkBq[8P=!#dSj\\'\\\\L4n.+e?S5,=AGF\\'1^D-:io(6Ff+:9(c<92m\"mIKm*jC/dXVm@Q[q!J9J58TEi*a$:akH&fM!rZIC=aOdj[2Q1a,jnFSpGT#hLj6dSQ\\'7\\'=P9nHJFlAJXiZmSbhRPf=$#I#m+?[O*]+]SiD;eYU8%*Z(S++9DX5G=Hdj!`e&($Eq(L=28Hl>Xfg1u?YYC\"QrliD_o5?.+h^SM#Qs6IZ8ZU5\">jf3Yn_XsLme4SF2X3f]!%\\'>cKnDL:1P8cD[6[US,s.9(U3YX75S4[YTP:2+;n\\\\V]<fPhY%[9brGHu%9b1Ejsh!r(]h4.R>?Vgm[S\\\\bhO;i<OMQs57.0XZ+-K\\\\!jj\\'%q`QK?48ujFf_JoqFX_<W(28.cYo/j\\\\$\\'/P\\\\i;Yrk>+>^Mi+aYXrAaVfOF@oU:.;Lg#a3W%taCNA@/Fo\"%!l^N!#PcJ8C<)_<Gq:6]\\'e\\'7WIM+.NT@?jWb$.Hs.Tk60h3\"!^\\\\l!p1+<f1bB%G3m,OTO8s7V#uMRX7u\\\\%:9F\"&09tP$8-F51iRB(pI2J]O\"g.66\"\\'?\"\\'/(_!NjK^Kd\".B4D\\\\Q,oIrA:E\\'I\"ir#\\\\75.PC\\'6!%cF?V@=5J?*)93r;\\\\(;9=`K\\\\S7r<CL/.41bO!Mo\\'A:G[;\\\\TiLpZ(C0I$[f66udZPc7X67=&4E+8AU+4?8.XW;-ZX8+()Gj8XG`(LZ(%0I^u_ee:WU]P8e\\\\WVs-SmOV\\\\,gVF%C5QIt<725)=<@L=iKt=^L4on)+]4+Y2HZ[gYA.rKb=Qc*<CX6O:ei`2Y\"Rnb7NJQ>:9?h]Hp2:ZNl%k(eI-DpJN4QZjQ9T2<Y!^ugmCR:p;i#%K;PA1=g$i:73qB9!ihZ\"7A2\"`Co6K$V7\\\\_k<\\'i@C@eMqpIu_j*g8g&Z@n*psL8gf(=`/?/ZD`e=16\"S5)f[a@T.Z1Sqrk`md$_;$`fM`W&F$PS\"dEGTk/=K*1Q7h^cRa3lD(,,5N;ia;P0t1@2JLohF+aQRWY$/NN42Gp*oe,Nh8sJ_$pA2@,h6;6p*urjMW(+dP@2CCmBS4.4^pREN3%>gh6off`mZpaPh<+Z&P%i10W@\"&,</hmQ[p0M+qRoQ=qtR9h%M_f=.YO`YBDU)A:673hsa1]`oC3$f.qf8I\\'u0:oAace%iP6hPjS)(UEqo)Bb/lq&t^2(-cjk&4t+mCl_%<HE9sGLG%k!sFX(W\"$eO8)*JZ`/-VIH8(K.=4Bhsu;?Z,Bkl9%tF8AN$)\\\\``HIVldt3+u6\\'$mA8NgN^\\\\TEpr:ocmuH$GK4+)opEdqAD\\'pJZ&TSg[HBEHQCYp/3XrH%-R+3%qIEkO[->.280&r@<,\\\\A(d@Z-\"D\\'e4V*(_1tbc[357\\'/6tl<(CAsQi4jDf?2@o$)04dcYl5aM_\"32$mRP8S#WDO5CC1-^3RUteNecOms9CQ_PC0%5_=eYi,^Q&g!8p:Jf)gK@VOFRgp./CJQ4RIBOiknAMU`^h5bE`V`0JJpuHAdD05#*E6MKc-#JckU/4r`&Y?V?i7IX%p1k(2>0,^Vo3Gg.OQ\\\\gLjn+[*R\\\\.rY?q$E2Du3q\\\\[3)llA5GeHd);#=\"BFp^>^42F#Wp7DhI_cl[EFh%r67f)gnn\\'`c.Aml/q.EN8Lh.b<1^gE*VfCFYMF*`cUtga[2rp^G#2u*J>?Za@QKqVA*/HBVW:T(@[X7!i8<4E.=HDOo+$GPB&%LV&P1@r,*?2&HUb)>0fCN&W-ZaKk*4FO\"\"T//]DRa8A\"bV!MoGg/Gc$@W<tn7^=?dA2=<@M6rU8ZO-tu4.dtXei2W$*l3?1s^CCHIsLQlYn3mo9SKaRNsF96ZaM7$VL1s*C>obL%ZlP1q_W$[6I,,B,+7<?<\\\\BanquQE\"!O(npSTHcUVBW\\\\hBH,Q.+1kUKDX`ZJs_(DK`2A,:nr(/IEVql`fW,PZ]_mKk\\\\m_ALJ5\\'D6Rq-@OV:IEp\\'j?(\"Z-<7K&9VPX%+rbug5DtY.<q@06)dANda625JcTmG-7@ZA<3C5tmuTpJl>=(]B`-1&%0l5A0+ibY\\\\DJhT6T=6(q7Vp(X[)p\\\\nE1:R-$hOD2hSB=*i.PIl:Pe=A\\\\BBZfch]$=T?:<$W2\"+quI?E^`f,EG@pn7m<UO!IXXe$1i1Pf1oF@8W1\\\\.oU6\\'+jH\\'T8lusYTsEi::+lNG6gS^(=b?bYaKr[04Sn3]B]d4T?38#_\"Q#\\\\bu!5!FWN+?9ZU*rkeG\\'NoR?Ai5>nK&6Y!]q)?UmACF8a47/7aPruA#s<L(hGr`(TO!YEnXS=KbPF]tgX`O2k\\\\.eaTO7\\\\Y,MHE8!YbbQ$KX;-Ya+muq*)(K@%QpH7]i-G\\'m`<7uh1nISi)0.F*!G0\"&;J4G>SR.C@h$I_Kfgt3T+\\'Q<i^lHiFFp(Vu=)HrKVt7GaLs0C!AnOP-#.N-`>RCGYUl,7/)@KWWZK$+[N3#JWP?l\\'34Ue$9^%9&J3\\\\7-*4QM8bi\\'r.[O:0A(9gSjR<n2t?WW?FIk@lKn86t,4PP]l#lphakr1tA\\\\\\\\UO4/l@Na>:aGVkY,..tXK1TA>7=6RL`tm*2TL]n:@P_mOYlCi\\':[eEeJQDco\\'m\\'1),J_?1hbY7MHW/dbnlC8)-.L2Sor^J[nRc>TDI?IW6!\\'3oIN7i&H/qBTIl+83,464m<g+@e[tX$*WBWrNC0hZ%QF2EmhB[NYj?&s69]-c?\"Z^Z6tl4nFWf>Tm$&Q1*Y^06(GdF%[ENs_CHpC!ac9ALp/MbR,\\'5D]i7fk>@GQ>9pUtZDb/[Z>;eA83=`SDNF2$e&Q1[YfYEm5drTM-`)FQs^7DE#Y55[##pj0e-%(WS!o`IsEDu4&@?6A/AY//DM_pL@7b6/VJQU\\'.r$E/UTH\"3[B&\\\\>V;O/F&fG=u8f;1H9nCJUn!\\\\bO,_R.\\\\TDQnH,d`U@$rq-#GD.9+U7=\\\\!S!Gij:aXmM!igs8CD@V!767mA_UHTRh2XQ^i0*/*A,3>d+a86/]fY$flA;1Vm$j0`t2/9rLI@CP?.]tf\\'$\\\\Kj\\\\U%1d@:,&d)cI6(oA^qoDEQgUd_=/a:@-J+c@oU=)d>60VV/]6aoIRFujoYOPS($)11FF*r)atBoJAEe\"f-W>Kg:8l(_,\\'IXsX;8WncNcJ<(p8S2g,p7Rm(Y7q=##>k:]__h\")>\"dVCX8WUs-IcO8\\\\F3>Uk%7>&+E.8Aj.1]5rfh/Rn,.@<TdFWik9pd4@tc[hJSq5,]fT_UE&\\\\IVijTc[ES1R9m\\';9-*85U=6I-k@`0g]Z)VXC`+L1\\\\o^AXe21Bm:RBVHVVibHZT#FA(%!_9;\\'eDJs6-#aE@4Km\\'[4*he>,mikBJ&N0t91,>%3cRqnBA)ONBq)M2r*IO5(Z\"R#J3g1FN!\\\\%+a2<l0-BV$\\\\D1a^[tjC#,g#pF$;D5eP*]`,\\\\+0hWd-Mu1+\\\\q[F=Z.GI#D%q0p7bY<d9cPXH=kt4lPO?CF;WtV#$rOPa4qs0d`pC$-a7cHM)gg&(VhOo&65!@t7sOg31gg7,W19,3N[!3>=g--`6]Q=>Y\\'@+DQpc%cM[\"nd=Ji@Ku^d@e`])3=#Zq*fA<*0R+GbC(9?pmh*-c83TFI^a1MtpaUB/WZ6ZCGVXuX3KRKE$?j+,J3W1T5P>.E335Cd\\\\,\"2AQ?1Tap9b)$RMl%Z+#]\"SeYTDm18eCA7Tb:7MA;*PhX`d.q@biAAJHoK:A0.kNL1eU8eLY;6YqF\\\\7S61nlR:eo=$X)f7.]l7K#2:bWTM5(1B)083M#fDaaMEt[)7LD#s\"Ie4L]D(B[X#%ca/j90(`qp9]$4AQL7>;DJ!B?=fJ1PONi07H`:Gu*1(fU9dXA[aZDkSHo=&KrEnA,ZJOFACFT5s=\"_(DjC`)Q<F0![E_Ua.4.bq$U,X\\\\kXQP7Bfs2;C5P.%pG<)FMS\\\\Le$]ffZ>Cn03@B$9,\\\\<-!#X2ri>EIXa=rX\\\\u1>*rYM(4>77sZ,G@b&X]W;2W!0Ni6H(Zf_@f#oiHQ-A6#]njH>Akn\\\\oY@GfBn1]+rGUl6C4FD`h[?@\\'HV&a-%$[o=6q\"-g&it=-GuS.I\\'n>,;18tWXCtj0nd2Wl\\\\0bWH/,G>2`94d\\\\2/srpI-.EheU`jY>gbcZ#Si4T5);`F\\'QW.+eEZuZb8Q@*$b5i-9?ENLON1;2a/rI%47Z`]#SG=nP!EF,;_80Ic<\\\\)>EDZ^G6V0Cn@&-(NG#T_<U9Uu4E2M$C-qXPKUmFWkoi[Wb<_n@Vn\"Tq\\\\@\\\\X+OQGCW&W!s9kUILj<gg0:;V2tGZ27#aFC[865Zp9,c\\'\\'C\\\\Kd]7i:X@*:HB$VB+,,;=.`u\\\\\\\\9>0_@=7fHK`>O<m6DT457JsP,-Rd_geH,5[B8Ed_nasc0em1>9>U7HI<mCuR.kBpc\"YpN^W<$\"L1idRh)Ii`Gi`0Lp!Jtp)ZZ,#&MYM:K-17*arp\"tm9u$u' )))\n\nwith open('user.out', 'wb') as f:\n for i in sys.stdin:\n if i[-1] == '\\n':\n f.write(d[i[:-1]])\n else:\n f.write(d[i])\n f.write(b\"\\n\")\n_exit(0)","runtime":"24"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n \n \n def run_length_encoding(s):\n i = 0\n res = []\n \n while i < len(s):\n j = i\n run_len = 0\n while j < len(s) and s[j] == s[i]:\n j += 1\n run_len += 1\n res.append(str(run_len))\n res.append(s[i])\n i = j\n \n return res\n \n def helper(n):\n if n == 1:\n return '1'\n \n return run_length_encoding(helper(n-1))\n \n \n return ''.join(helper(n))\n","runtime":"25"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n fin = '1'\n for _ in range(1, n):\n fin = self.rle(fin)\n return fin\n\n def rle(self, numb: str) -> str:\n rle = []\n curr = numb[0]\n count = 0\n\n for char in numb: \n if char == curr: \n count += 1\n else: \n rle.append(str(count) + curr)\n count = 1\n curr = char\n rle.append(str(count) + numb[-1])\n \n \n return ''.join(rle)\n\n \n \n\n","runtime":"26"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n def helper(s,idx):\n if idx==n:\n return s\n temp=s[0]\n ans=\"\"\n count=1\n for i in range(1,len(s)):\n if s[i]==temp:\n count+=1\n else:\n ans+=str(count)+temp\n temp=s[i]\n count=1\n ans+=str(count)+temp\n return helper(ans,idx+1)\n return helper(\"1\",1)","runtime":"27"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n a = {\n 1: \"1\"\n }\n \n for i in range(2,n+1):\n prev = a[i-1]\n a[i] = \"\"\n \n g_count = 0\n g_char = None\n for c in prev:\n if c == g_char:\n g_count += 1\n else:\n a[i] += f'{g_count}{g_char}' if g_char else ''\n g_char = c\n g_count = 1\n \n a[i] += f'{g_count}{g_char}'\n \n return a[n]","runtime":"28"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n \"\"\"\n method 2, recursion\n \"\"\"\n if n == 1:\n return \"1\"\n x = self.countAndSay(n-1)\n s = \"\"\n y = x[0]\n ct = 1\n for i in range(1, len(x)):\n if x[i] == y:\n ct += 1\n else:\n s += str(ct)\n s += str(y)\n y = x[i]\n ct = 1\n s += str(ct)\n s += str(y)\n return s\n\n\n \n # \"\"\"\n # method 1\n # T =O(n^2)\n # \"\"\"\n # if n <= 0:\n # return \"\"\n \n # s = \"1\"\n # for i in range(n-1):\n # s = self.rle(s)\n # return s\n \n # def rle(self, s: str) -> str:\n # res = []\n # i = 0\n # while i < len(s):\n # curr_char = s[i]\n # start = i\n # while i < len(s) and s[i] == curr_char:\n # i += 1\n # ct = i - start\n # res.extend(str(ct))\n # res.append(curr_char)\n # return \"\".join(res)\n\n ","runtime":"29"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n result = '1'\n\n for _ in range(n-1):\n new_result = \"\"\n count =1 \n\n for i in range(1, len(result)):\n if result[i] == result[i-1]:\n count += 1\n else:\n new_result += str(count)+result[i-1]\n count = 1\n new_result += str(count)+result[-1]\n result = new_result\n return result","runtime":"30"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n answer = \"1\"\n\n for _ in range(2, n + 1):\n tmp_string = []\n counter = 0\n number = None\n for j in answer:\n if number is None:\n number = j\n counter += 1\n else:\n if j == number:\n counter += 1\n else:\n tmp_string.append(f\"{counter}{number}\")\n number = j\n counter = 1\n tmp_string.append(f\"{counter}{number}\")\n answer = \"\".join(tmp_string)\n return answer","runtime":"31"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n\n t = \"1\"\n\n for i in range(n-1):\n st = \"\"\n prev = t[0]\n c = 1\n\n for j in range(1,len(t)):\n if t[j] == prev:\n c+=1\n else:\n st += str(c) + prev\n prev = t[j]\n c = 1\n st += str(c) + prev\n t = st\n\n return t\n ","runtime":"31"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1: return \"1\"\n # if n == 2: return \"11\"\n pre_seq = self.countAndSay(n - 1)\n count = 1\n cand = pre_seq[0]\n ans = []\n for i in range(1, len(pre_seq)):\n if pre_seq[i] == cand:\n count += 1\n else:\n ans.append(str(count) + cand)\n count = 1\n cand = pre_seq[i]\n ans.append(str(count) + cand)\n return \"\".join(ans)\n\n# def reverseCountSay(s):\n# memo = defaultdict(list)\n\n# def recursive(s):\n# if len(s) == 0:\n# return [[]]\n# elif s in memo:\n# return memo[s]\n# for i in range(1, len(s)):\n# curNum, count = s[i], int(s[:i])\n# for subRes in recursive(s[i + 1:]):\n# memo[s].append([curNum * count] + subRes)\n# return memo[s]\n# recursive(s)\n# return [''.join(output) for output in memo[s]]\n\n","runtime":"32"},{"code":"from itertools import groupby\n\nclass Solution:\n def countAndSay(self, n: int) -> str:\n # using itertools groupby, inspired by Stefan Pochman.\n s = \"1\"\n for _ in range(n - 1):\n new_s = []\n for digit, group in groupby(s):\n new_s.append(str(len(list(group))))\n new_s.append(digit)\n s = ''.join(new_s)\n \n return s\n \n # def countAndSay(self, n: int) -> str:\n # # Using itertools groupby, but lazier.\n # s = \"1\"\n # for _ in range(n - 1):\n # s = ''.join(str(len(list(group))) + digit\n # for digit, group in itertools.groupby(s))\n # return s\n","runtime":"32"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n result = \"1\"\n \n for _ in range(1, n):\n current = result\n result = \"\"\n i = 0\n while i < len(current):\n count = 1 \n while i + 1 < len(current) and current[i] == current[i + 1]:\n i += 1\n count += 1\n result += str(count) + current[i]\n i += 1\n \n return result\n ","runtime":"33"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n \n def dfs(n):\n if n == 1:\n return str(1)\n \n string = dfs(n-1)\n print(\"string: {}\".format(string))\n count = 0\n last_char = \"\"\n res = []\n i = 0\n while i < len(string):\n if count == 0:\n last_char = string[i]\n count += 1\n elif last_char != string[i]:\n res.append(str(count) + str(last_char))\n last_char = string[i]\n count = 1\n else:\n count += 1\n i += 1\n \n res.append(str(count) + str(last_char))\n \n return \"\".join(res)\n \n return dfs(n)\n\n\n# 1 --> 1\n# 2 --> 11\n# 3 --> 21\n# 4 --> 1211\n# 5 --> 111221\n# 6 --> 312211\n# 7 --> 13112221","runtime":"33"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n \n def dfs(n):\n if n == 1:\n return str(1)\n \n string = dfs(n-1)\n count = 0\n last_char = \"\"\n res = []\n i = 0\n while i < len(string):\n if count == 0:\n last_char = string[i]\n count += 1\n elif last_char != string[i]:\n res.append(str(count) + str(last_char))\n last_char = string[i]\n count = 1\n else:\n count += 1\n i += 1\n \n res.append(str(count) + str(last_char))\n \n return \"\".join(res)\n \n return dfs(n)\n\n\n# 1 --> 1\n# 2 --> 11\n# 3 --> 21\n# 4 --> 1211\n# 5 --> 111221\n# 6 --> 312211\n# 7 --> 13112221","runtime":"34"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n \n prev = self.countAndSay(n - 1)\n res = \"\"\n count = 1\n digit = prev[0]\n\n for i in range(1, len(prev)):\n if prev[i] == digit:\n count += 1\n else:\n res += str(count) + digit\n count = 1\n digit = prev[i]\n res += str(count) + digit\n return res\n","runtime":"35"},{"code":"# count-and-say -> sequence of digit strings\n# - recursive formula\n# - countAndSay(1) = \"1\"\n# - countAndSay(n) = run-length encoding of countAndSay(n - 1)\n\n\n# Run-length encoding - string compression method\n# - replace consecutive identical chars\n# - repeated 2 / more times w/ concatenation of character + number marking the count of the chars (length of run)\n\n\n\n# RECURSION\n# - base case = 1 -> return \"1\"\n# - rle = recursion(n - 1) #happens after base case occurs\n# - target = rle[0]\n# - keep track of count\n# - loop through target\n# - if [i] == target -> count ++\n# - else -> rle += str(count) + target -> target = [i] -> count = 1\n# - rle += str(count) + target\n# - return rle # goes up ot next recursive call in stack\n\n\n\n\n\nclass Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n\n rle = self.countAndSay(n - 1)\n\n target = rle[0]\n count = 1\n\n new_rle = \"\"\n\n for i in range(1, len(rle)):\n if rle[i] == target:\n count += 1\n \n else:\n new_rle += str(count) + str(target)\n target = rle[i]\n count = 1\n\n new_rle += str(count) + str(target)\n\n return new_rle\n","runtime":"35"},{"code":"class Solution:\n @cache\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n else:\n prev_string = self.countAndSay(n - 1)\n element = []\n count = []\n for c in prev_string:\n if len(element) == 0 or element[-1] != c:\n element.append(c)\n count.append(1)\n else:\n count[-1] += 1\n \n sb = []\n for c, e in zip(count, element):\n sb.append(str(c))\n sb.append(e)\n\n return \"\".join(sb)\n","runtime":"36"},{"code":"class Solution:\n def rle(self, n: str) -> str:\n if len(n) == 1:\n return f\"1{n[0]}\"\n result = ''\n i = 0\n while i < len(n):\n c = 1\n d = n[i]\n i += 1\n while i < len(n) and n[i] == d:\n c += 1; i += 1\n result += f\"{c}{d}\"\n return result\n\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n return self.rle(self.countAndSay(n-1))\n \n\n ","runtime":"36"},{"code":"class Solution:\n def RLE(self, seq):\n seq2 = str(seq)\n ans = ''\n idx = 0\n count = 1\n while idx+1 < len(seq2):\n if seq2[idx] == seq2[idx+1]:\n count += 1\n idx += 1\n else:\n ans = ans + str(count) + seq2[idx]\n count = 1\n idx += 1\n ans = ans + str(count) + seq2[idx]\n return ans\n \n def countAndSay(self, n: int) -> str:\n if n == 1:\n return '1'\n arr = ['1']\n for iter in range(1, n):\n arr.append(self.RLE(arr[iter-1]))\n return arr[-1]","runtime":"37"},{"code":"\n\nclass Solution:\n def countAndSay(self, n: int) -> str:\n \"\"\"\n countAndSay(1) = \"1\"\n countAndSay(2) = RLE of \"1\" = \"11\"\n countAndSay(3) = RLE of \"11\" = \"21\"\n countAndSay(4) = RLE of \"21\" = \"1211\"\n countAndSay(5) = RLE of \"1211\" = \"111221\"\n countAndSay(6) = RLE of \"111221\" = \"312211\"\n countAndSay(7) = RLE of \"312211\" = \"13112221\"\n \"\"\"\n if n == 1:\n return \"1\"\n\n return self.rle(self.countAndSay(n-1))\n\n def rle(self, n: str):\n count = 1\n current = n[0]\n result = \"\"\n for c in n[1:]:\n if c == current:\n count += 1\n else:\n result += str(count)\n result += current\n count = 1\n current = c\n result += str(count)\n result += current\n return result\n\n\n\n\n ","runtime":"37"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n # 初始的countAndSay(1)为\"1\"\n current = \"1\"\n \n # 从2到n，逐步生成序列\n for _ in range(2, n + 1):\n next_seq = [] # 用于存储下一个序列的结果\n i = 0\n \n # 遍历当前序列\n while i < len(current):\n count = 1 # 每个字符至少出现一次\n # 统计连续相同字符的数量\n while i + 1 < len(current) and current[i] == current[i + 1]:\n i += 1\n count += 1\n # 将计数和字符加入到下一个序列中\n next_seq.append(str(count))\n next_seq.append(current[i])\n i += 1\n \n # 更新当前序列为生成的下一个序列\n current = ''.join(next_seq)\n \n # 返回第n个序列\n return current","runtime":"38"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n==1:\n return '1'\n prev = self.countAndSay(n-1)\n res = \"\"\n cnt=1\n for i in range(len(prev)):\n if i==len(prev)-1 or prev[i]!=prev[i+1]:\n res+=str(cnt)+prev[i]\n cnt=1\n else:\n cnt+=1\n\n return res","runtime":"38"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n ans = '1'\n\n for _ in range(n - 1):\n nxt = ''\n i = 0\n while i < len(ans):\n count = 1\n while i + 1 < len(ans) and ans[i] == ans[i + 1]:\n count += 1\n i += 1\n nxt += str(count) + ans[i]\n i += 1\n ans = nxt\n\n return ans","runtime":"39"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n s=\"1\"\n while n-1>0:\n cur=s[0]\n temp_s=\"\"\n count=0\n for i in s:\n if cur==i:\n count+=1\n else:\n temp_s=temp_s+str(count)+cur\n count=1\n cur=i\n temp_s=temp_s+str(count)+cur \n s=temp_s\n n-=1\n return(s) \n","runtime":"39"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n # Base case\n if n == 1:\n return \"1\"\n\n # Initialize the first term\n current = \"1\"\n\n # Iterate from 2 to n to build the sequence\n for _ in range(2, n + 1):\n next_seq = \"\"\n i = 0\n while i < len(current):\n count = 1 # At least one occurrence of the current character\n # Count consecutive identical characters\n while i + 1 < len(current) and current[i] == current[i + 1]:\n i += 1\n count += 1\n # Append character and its count as per problem's RLE definition\n next_seq += current[i] + str(count)\n i += 1 # Move to the next new character\n # Update current sequence\n current = next_seq\n\n return current[::-1]","runtime":"40"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n # Base case\n if n == 1:\n return \"1\"\n\n # Initialize the first term\n current = \"1\"\n\n # Iterate from 2 to n to build the sequence\n for _ in range(2, n + 1):\n next_seq = \"\"\n i = 0\n while i < len(current):\n count = 1 # At least one occurrence of the current character\n # Count consecutive identical characters\n while i + 1 < len(current) and current[i] == current[i + 1]:\n i += 1\n count += 1\n # Append character and its count as per problem's RLE definition\n next_seq += str(count) + current[i]\n i += 1 # Move to the next new character\n # Update current sequence\n current = next_seq\n\n return current","runtime":"40"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n s = \"1\"\n for i in range(n-1):\n # d = Counter(s)\n # tmp = \"\"\n # for key, val in d.items():\n # tmp += str(val) + key\n # s = tmp\n # d.clear()\n # prev = s[0]\n count = 1\n tmp = \"\"\n for j in range(len(s)):\n if j == len(s) - 1 or s[j] != s[j+1]:\n tmp += str(count) + s[j]\n count = 1\n else:\n count += 1\n # if s[j] == prev:\n # count += 1\n # if s[j] != prev or j == len(s)-1:\n # tmp += str(count) + prev\n # count = 0\n # prev = s[j]\n s = tmp\n return s","runtime":"41"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n \n uncompressed = self.countAndSay(n-1)\n result = \"\"\n cur_char = uncompressed[0]\n cur_count = 1\n for i in range(1,len(uncompressed)):\n digit = uncompressed[i]\n if digit != cur_char:\n result += str(cur_count)\n result += cur_char\n cur_char = digit\n cur_count = 1\n else:\n cur_count += 1\n \n result += str(cur_count)\n result += cur_char\n return result","runtime":"41"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n \n ## get the base, when n == 1, return 1\n ## call func on cur_n - 1\n ## go through the string\n ## while i < end\n ## cur, count. move until not the same. add to output\n ## return output\n\n ## Time: O(n * m) n is provided, m is the avg len of the string that's provided\n ## Space: O(n)\n\n if n == 1:\n return \"1\"\n \n prev = self.countAndSay(n-1)\n # print(prev)\n output = \"\"\n i = 0\n while i < len(prev):\n char = prev[i]\n count = 0\n\n while i < len(prev) and char == prev[i]:\n count += 1\n i += 1\n output += str(count) + char\n \n return output","runtime":"42"},{"code":"# count-and-say -> sequence of digit strings\n# - recursive formula\n# - countAndSay(1) = \"1\"\n# - countAndSay(n) = run-length encoding of countAndSay(n - 1)\n\n\n# Run-length encoding - string compression method\n# - replace consecutive identical chars\n# - repeated 2 / more times w/ concatenation of character + number marking the count of the chars (length of run)\n\n\n\n# RECURSION\n# - base case = 1 -> return \"1\"\n# - rle = recursion(n - 1) #happens after base case occurs\n# - target = rle[0]\n# - keep track of count\n# - loop through target\n# - if [i] == target -> count ++\n# - else -> rle += str(count) + target -> target = [i] -> count = 1\n# - rle += str(count) + target\n# - return rle # goes up ot next recursive call in stack\n\n\n\n\n\nclass Solution:\n def countAndSay(self, n: int) -> str:\n # if n == 1:\n # return \"1\"\n\n # rle = self.countAndSay(n - 1)\n\n # target = rle[0]\n # count = 1\n\n # new_rle = \"\"\n\n # for i in range(1, len(rle)):\n # if rle[i] == target:\n # count += 1\n \n # else:\n # new_rle += str(count) + str(target)\n # target = rle[i]\n # count = 1\n\n # new_rle += str(count) + str(target)\n\n # return new_rle\n\n res = \"1\"\n\n for i in range(1, n):\n new_res = \"\"\n count = 1\n target = res[0]\n\n for j in range(1, len(res)):\n if res[j] == target:\n count += 1\n \n else:\n new_res += str(count) + str(target)\n target = res[j]\n count = 1\n\n new_res += str(count) + str(target)\n res = new_res\n\n return res\n \n\n","runtime":"42"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n def getresult(s):\n count = 1\n res = \"\"\n n = len(s)\n i =0\n while i<n:\n count = 1\n ans = s[i]\n while i+1<n and s[i]==s[i+1]:\n count+=1\n i+=1\n res+= (str(count)+ans)\n i+=1\n return res\n\n def okay(n):\n if n==1:\n return \"1\"\n x = okay(n-1)\n val = getresult(x)\n return val\n return okay(n)\n ","runtime":"43"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n s = '1'\n s2 = \"\"\n for i in range(2, n+1):\n count = 0\n curr = s[0]\n for c in s:\n if c == curr:\n count += 1\n\n else:\n s2+=str(count) + curr\n count = 1\n curr = c\n \n s2+= str(count) + curr\n print(s2)\n s = s2\n s2 = ''\n return s","runtime":"43"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n==1:\n return \"1\"\n result=\"1\"\n for _ in range(2,n+1):\n prev=result\n result=\"\"\n count=1\n for i in range(1,len(prev)):\n if prev[i]==prev[i-1]:\n count+=1\n else:\n result+=str(count)+prev[i-1]\n count=1\n result+=str(count)+prev[-1]\n return result \n\n\n\n\n ","runtime":"44"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n result = '1'\n for j in range(2, n + 1):\n output = []\n i = 0\n while i < len(result):\n repeated = 1\n while (i + 1) < len(result) and result[i] == result[i + 1]:\n repeated += 1\n i += 1\n output.append(str(repeated))\n output.append(str(result[i]))\n if i == len(result) - 1:\n if result[i] == result[i - 1]:\n break\n i += 1\n result = output\n return ''.join(result)\n ","runtime":"44"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n==1:\n return \"1\"\n result=\"1\"\n for _ in range(2,n+1):\n prev=result\n result=\"\"\n count=1\n for i in range(1,len(prev)):\n if prev[i]==prev[i-1]:\n count+=1\n else:\n result+=str(count)+prev[i-1]\n count=1\n result+=str(count)+prev[-1]\n return result \n\n\n\n\n ","runtime":"45"},{"code":"class Solution:\n \n def countAndSay(self, n: int) -> str:\n cur = \"1\"\n temp = []\n for itr in range(n-1):\n temp.clear()\n count = 0\n for i,char in enumerate(cur):\n if i == 0:\n count += 1\n continue\n elif i != 0 and char == cur[i-1]:\n count += 1\n if i == len(cur)-1:\n temp.append(str(count))\n temp.append(cur[i])\n else:\n temp.append(str(count))\n temp.append(cur[i-1])\n if i == len(cur)-1:\n temp.append(\"1\")\n temp.append(cur[i])\n count = 1\n if len(temp) == 0:\n temp.append(str(count))\n temp.append(cur[i])\n cur = \"\"\n cur = \"\".join(temp)\n \n \n \n return cur\n \n ","runtime":"45"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n\n if n == 1:\n return \"1\"\n \n result = \"1\" # Base case\n \n for _ in range(2, n + 1):\n prev = result\n result = []\n count = 1\n \n # Loop through the previous sequence\n for i in range(1, len(prev)):\n if prev[i] == prev[i - 1]:\n count += 1\n else:\n result.append(str(count))\n result.append(prev[i - 1])\n count = 1\n \n # Append the last character group\n result.append(str(count))\n result.append(prev[-1])\n \n # Join the list into a final string\n result = ''.join(result)\n \n return result\n \n\n\n\n\n ","runtime":"46"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n\n # idea: use stack to record char and its count\n # error1: initialize stac\n # T: O(n*m)\n # S: O(m)\n\n stack = []\n s = \"1\"\n\n for _ in range(n-1):\n for char in s:\n if stack and stack[-1][0] == char:\n stack[-1][1] += 1\n else:\n stack.append([char, 1])\n s = \"\"\n for char, count in stack:\n s += str(count)\n s += char\n stack = []\n return s\n\n\n \n\n\n\n\n\n \n\n\n\n\n\n","runtime":"46"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n result = self.countAndSay(n - 1)\n i = 0\n output = []\n while i < len(result):\n repeated = 1\n while (i + 1) < len(result) and result[i] == result[i + 1]:\n repeated += 1\n i += 1\n output.append(str(repeated))\n output.append(str(result[i]))\n if i == len(result) - 1:\n if result[i] == result[i - 1]:\n break\n i += 1\n return ''.join(output)\n ","runtime":"47"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n def get_count_and_say(s: str) -> str:\n result =[]\n i = 0\n while i < len(s):\n count = 1\n while i + 1 < len(s) and s[i] == s[i + 1]:\n i += 1\n count += 1\n result.append(str(count))\n result.append(s[i])\n i += 1\n return ''.join(result)\n if n == 1:\n return \"1\"\n previous = \"1\"\n for _ in range(2, n + 1):\n previous = get_count_and_say(previous)\n return previous\n\n ","runtime":"47"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n==1:\n return \"1\"\n prev=self.countAndSay(n-1)\n result=\"\"\n count=1\n for i in range(1,len(prev)):\n if prev[i]==prev[i-1]:\n count+=1\n else:\n result+=str(count)+prev[i-1]\n count=1\n result+=str(count)+prev[-1]\n return result\n\n ","runtime":"48"},{"code":"\n\nclass Solution:\n def countAndSay(self, n: int) -> str:\n\n def count_til_diff(s: str):\n res = ''\n i = 0\n temp = ''\n while i < len(s):\n count = 1\n check = s[i]\n if (check == temp):\n break\n temp = check\n for j in range(i + 1, len(s)): \n if s[j] != check:\n i = j\n break\n \n count += 1\n\n if j == len(s) - 1:\n i = j\n break\n res += str(count) + check\n return res\n \n if n == 1:\n return '1'\n return count_til_diff(self.countAndSay(n - 1))","runtime":"48"},{"code":"\n\nclass Solution:\n def countAndSay(self, n: int) -> str:\n\n def count_til_diff(s: str):\n res = ''\n i = 0\n temp = ''\n while i < len(s):\n count = 1\n check = s[i]\n if (check == temp):\n break\n temp = check\n for j in range(i + 1, len(s)): \n if s[j] != check:\n i = j\n break\n \n count += 1\n\n if j == len(s) - 1:\n i = j\n break\n res += str(count) + check\n return res\n \n if n == 1:\n return '1'\n return count_til_diff(self.countAndSay(n - 1))","runtime":"49"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n s=\"1\"\n while n-1>0:\n cur=s[0]\n temp_s=\"\"\n count=0\n for i in s:\n if cur==i:\n count+=1\n else:\n temp_s=temp_s+str(count)+cur\n count=1\n cur=i\n temp_s=temp_s+str(count)+cur \n s=temp_s\n n-=1\n return(s) \n","runtime":"49"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n result = self.countAndSay(n - 1)\n if len(result) == 1:\n return \"11\"\n i = 0\n output = []\n while i < len(result):\n repeated = 1\n while (i + 1) < len(result) and result[i] == result[i + 1]:\n repeated += 1\n i += 1\n output.append(str(repeated))\n output.append(str(result[i]))\n if i == len(result) - 1:\n if result[i] == result[i - 1]:\n break\n i += 1\n return ''.join(output)\n ","runtime":"50"},{"code":"\n\nclass Solution:\n def countAndSay(self, n: int) -> str:\n\n def count_til_diff(s: str):\n res = ''\n i = 0\n temp = ''\n while i < len(s):\n count = 1\n check = s[i]\n if (check == temp):\n break\n temp = check\n for j in range(i + 1, len(s)): \n if s[j] != check:\n i = j\n break\n \n count += 1\n\n if j == len(s) - 1:\n i = j\n break\n res += str(count) + check\n return res\n \n if n == 1:\n return '1'\n return count_til_diff(self.countAndSay(n - 1))","runtime":"51"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n\n prev = self.countAndSay(n-1)\n result = \"\"\n count = 1\n\n for i in range(len(prev)):\n if i + 1 < len(prev) and prev[i] == prev[i + 1]:\n count += 1\n else:\n result += str(count) + prev[i]\n count = 1\n return result\n ","runtime":"51"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n def convertToRLE(rle):\n res=\"\"\n left = 0\n for i in range(1,len(rle)):\n if(rle[i]!=rle[i-1]):\n res += str(i-left)+rle[i-1]\n left = i\n if(left != len(rle)):\n res+=str(len(rle)-left) + rle[-1]\n return res\n resRle = \"1\"\n for i in range(2,n+1):\n resRle = convertToRLE(resRle)\n return resRle","runtime":"52"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n ans = '1'\n\n for _ in range(n - 1):\n nxt = ''\n i = 0\n while i < len(ans):\n count = 1\n while i + 1 < len(ans) and ans[i] == ans[i + 1]:\n count += 1\n i += 1\n nxt += str(count) + ans[i]\n i += 1\n ans = nxt\n\n return ans","runtime":"52"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n ans = '1'\n\n for _ in range(n - 1):\n nxt = ''\n i = 0\n while i < len(ans):\n count = 1\n while i + 1 < len(ans) and ans[i] == ans[i + 1]:\n count += 1\n i += 1\n nxt += str(count) + ans[i]\n i += 1\n ans = nxt\n\n return ans ","runtime":"53"}],"string":"[\n {\n \"code\": \"import gc\\ngc.disable()\\n\\nfrom os import _exit\\nfrom sys import stdin \\nimport pickle, base64, zlib\\n\\nd = pickle.loads(zlib.decompress(base64.a85decode( b'GQI294c^j[&`\\\\'!>(3BTa0X.cN(g(I`k<;$cA)^nc,;=,Q6c)7Tbeh35`9%;5nO%OC&Xeb]=k2?7Z_uijBX^&R1ZHB#0-Y1TDoH(tp\\\\\\\\-oNk*>r?kN/%;^HO5F+5NRWQ`jbgQ`#o5:Kfr$H.MQ8jlt%gl0SApQDYfIjE1+KkBq[8P=!#dSj\\\\'\\\\\\\\L4n.+e?S5,=AGF\\\\'1^D-:io(6Ff+:9(c<92m\\\"mIKm*jC/dXVm@Q[q!J9J58TEi*a$:akH&fM!rZIC=aOdj[2Q1a,jnFSpGT#hLj6dSQ\\\\'7\\\\'=P9nHJFlAJXiZmSbhRPf=$#I#m+?[O*]+]SiD;eYU8%*Z(S++9DX5G=Hdj!`e&($Eq(L=28Hl>Xfg1u?YYC\\\"QrliD_o5?.+h^SM#Qs6IZ8ZU5\\\">jf3Yn_XsLme4SF2X3f]!%\\\\'>cKnDL:1P8cD[6[US,s.9(U3YX75S4[YTP:2+;n\\\\\\\\V]<fPhY%[9brGHu%9b1Ejsh!r(]h4.R>?Vgm[S\\\\\\\\bhO;i<OMQs57.0XZ+-K\\\\\\\\!jj\\\\'%q`QK?48ujFf_JoqFX_<W(28.cYo/j\\\\\\\\$\\\\'/P\\\\\\\\i;Yrk>+>^Mi+aYXrAaVfOF@oU:.;Lg#a3W%taCNA@/Fo\\\"%!l^N!#PcJ8C<)_<Gq:6]\\\\'e\\\\'7WIM+.NT@?jWb$.Hs.Tk60h3\\\"!^\\\\\\\\l!p1+<f1bB%G3m,OTO8s7V#uMRX7u\\\\\\\\%:9F\\\"&09tP$8-F51iRB(pI2J]O\\\"g.66\\\"\\\\'?\\\"\\\\'/(_!NjK^Kd\\\".B4D\\\\\\\\Q,oIrA:E\\\\'I\\\"ir#\\\\\\\\75.PC\\\\'6!%cF?V@=5J?*)93r;\\\\\\\\(;9=`K\\\\\\\\S7r<CL/.41bO!Mo\\\\'A:G[;\\\\\\\\TiLpZ(C0I$[f66udZPc7X67=&4E+8AU+4?8.XW;-ZX8+()Gj8XG`(LZ(%0I^u_ee:WU]P8e\\\\\\\\WVs-SmOV\\\\\\\\,gVF%C5QIt<725)=<@L=iKt=^L4on)+]4+Y2HZ[gYA.rKb=Qc*<CX6O:ei`2Y\\\"Rnb7NJQ>:9?h]Hp2:ZNl%k(eI-DpJN4QZjQ9T2<Y!^ugmCR:p;i#%K;PA1=g$i:73qB9!ihZ\\\"7A2\\\"`Co6K$V7\\\\\\\\_k<\\\\'i@C@eMqpIu_j*g8g&Z@n*psL8gf(=`/?/ZD`e=16\\\"S5)f[a@T.Z1Sqrk`md$_;$`fM`W&F$PS\\\"dEGTk/=K*1Q7h^cRa3lD(,,5N;ia;P0t1@2JLohF+aQRWY$/NN42Gp*oe,Nh8sJ_$pA2@,h6;6p*urjMW(+dP@2CCmBS4.4^pREN3%>gh6off`mZpaPh<+Z&P%i10W@\\\"&,</hmQ[p0M+qRoQ=qtR9h%M_f=.YO`YBDU)A:673hsa1]`oC3$f.qf8I\\\\'u0:oAace%iP6hPjS)(UEqo)Bb/lq&t^2(-cjk&4t+mCl_%<HE9sGLG%k!sFX(W\\\"$eO8)*JZ`/-VIH8(K.=4Bhsu;?Z,Bkl9%tF8AN$)\\\\\\\\``HIVldt3+u6\\\\'$mA8NgN^\\\\\\\\TEpr:ocmuH$GK4+)opEdqAD\\\\'pJZ&TSg[HBEHQCYp/3XrH%-R+3%qIEkO[->.280&r@<,\\\\\\\\A(d@Z-\\\"D\\\\'e4V*(_1tbc[357\\\\'/6tl<(CAsQi4jDf?2@o$)04dcYl5aM_\\\"32$mRP8S#WDO5CC1-^3RUteNecOms9CQ_PC0%5_=eYi,^Q&g!8p:Jf)gK@VOFRgp./CJQ4RIBOiknAMU`^h5bE`V`0JJpuHAdD05#*E6MKc-#JckU/4r`&Y?V?i7IX%p1k(2>0,^Vo3Gg.OQ\\\\\\\\gLjn+[*R\\\\\\\\.rY?q$E2Du3q\\\\\\\\[3)llA5GeHd);#=\\\"BFp^>^42F#Wp7DhI_cl[EFh%r67f)gnn\\\\'`c.Aml/q.EN8Lh.b<1^gE*VfCFYMF*`cUtga[2rp^G#2u*J>?Za@QKqVA*/HBVW:T(@[X7!i8<4E.=HDOo+$GPB&%LV&P1@r,*?2&HUb)>0fCN&W-ZaKk*4FO\\\"\\\"T//]DRa8A\\\"bV!MoGg/Gc$@W<tn7^=?dA2=<@M6rU8ZO-tu4.dtXei2W$*l3?1s^CCHIsLQlYn3mo9SKaRNsF96ZaM7$VL1s*C>obL%ZlP1q_W$[6I,,B,+7<?<\\\\\\\\BanquQE\\\"!O(npSTHcUVBW\\\\\\\\hBH,Q.+1kUKDX`ZJs_(DK`2A,:nr(/IEVql`fW,PZ]_mKk\\\\\\\\m_ALJ5\\\\'D6Rq-@OV:IEp\\\\'j?(\\\"Z-<7K&9VPX%+rbug5DtY.<q@06)dANda625JcTmG-7@ZA<3C5tmuTpJl>=(]B`-1&%0l5A0+ibY\\\\\\\\DJhT6T=6(q7Vp(X[)p\\\\\\\\nE1:R-$hOD2hSB=*i.PIl:Pe=A\\\\\\\\BBZfch]$=T?:<$W2\\\"+quI?E^`f,EG@pn7m<UO!IXXe$1i1Pf1oF@8W1\\\\\\\\.oU6\\\\'+jH\\\\'T8lusYTsEi::+lNG6gS^(=b?bYaKr[04Sn3]B]d4T?38#_\\\"Q#\\\\\\\\bu!5!FWN+?9ZU*rkeG\\\\'NoR?Ai5>nK&6Y!]q)?UmACF8a47/7aPruA#s<L(hGr`(TO!YEnXS=KbPF]tgX`O2k\\\\\\\\.eaTO7\\\\\\\\Y,MHE8!YbbQ$KX;-Ya+muq*)(K@%QpH7]i-G\\\\'m`<7uh1nISi)0.F*!G0\\\"&;J4G>SR.C@h$I_Kfgt3T+\\\\'Q<i^lHiFFp(Vu=)HrKVt7GaLs0C!AnOP-#.N-`>RCGYUl,7/)@KWWZK$+[N3#JWP?l\\\\'34Ue$9^%9&J3\\\\\\\\7-*4QM8bi\\\\'r.[O:0A(9gSjR<n2t?WW?FIk@lKn86t,4PP]l#lphakr1tA\\\\\\\\\\\\\\\\UO4/l@Na>:aGVkY,..tXK1TA>7=6RL`tm*2TL]n:@P_mOYlCi\\\\':[eEeJQDco\\\\'m\\\\'1),J_?1hbY7MHW/dbnlC8)-.L2Sor^J[nRc>TDI?IW6!\\\\'3oIN7i&H/qBTIl+83,464m<g+@e[tX$*WBWrNC0hZ%QF2EmhB[NYj?&s69]-c?\\\"Z^Z6tl4nFWf>Tm$&Q1*Y^06(GdF%[ENs_CHpC!ac9ALp/MbR,\\\\'5D]i7fk>@GQ>9pUtZDb/[Z>;eA83=`SDNF2$e&Q1[YfYEm5drTM-`)FQs^7DE#Y55[##pj0e-%(WS!o`IsEDu4&@?6A/AY//DM_pL@7b6/VJQU\\\\'.r$E/UTH\\\"3[B&\\\\\\\\>V;O/F&fG=u8f;1H9nCJUn!\\\\\\\\bO,_R.\\\\\\\\TDQnH,d`U@$rq-#GD.9+U7=\\\\\\\\!S!Gij:aXmM!igs8CD@V!767mA_UHTRh2XQ^i0*/*A,3>d+a86/]fY$flA;1Vm$j0`t2/9rLI@CP?.]tf\\\\'$\\\\\\\\Kj\\\\\\\\U%1d@:,&d)cI6(oA^qoDEQgUd_=/a:@-J+c@oU=)d>60VV/]6aoIRFujoYOPS($)11FF*r)atBoJAEe\\\"f-W>Kg:8l(_,\\\\'IXsX;8WncNcJ<(p8S2g,p7Rm(Y7q=##>k:]__h\\\")>\\\"dVCX8WUs-IcO8\\\\\\\\F3>Uk%7>&+E.8Aj.1]5rfh/Rn,.@<TdFWik9pd4@tc[hJSq5,]fT_UE&\\\\\\\\IVijTc[ES1R9m\\\\';9-*85U=6I-k@`0g]Z)VXC`+L1\\\\\\\\o^AXe21Bm:RBVHVVibHZT#FA(%!_9;\\\\'eDJs6-#aE@4Km\\\\'[4*he>,mikBJ&N0t91,>%3cRqnBA)ONBq)M2r*IO5(Z\\\"R#J3g1FN!\\\\\\\\%+a2<l0-BV$\\\\\\\\D1a^[tjC#,g#pF$;D5eP*]`,\\\\\\\\+0hWd-Mu1+\\\\\\\\q[F=Z.GI#D%q0p7bY<d9cPXH=kt4lPO?CF;WtV#$rOPa4qs0d`pC$-a7cHM)gg&(VhOo&65!@t7sOg31gg7,W19,3N[!3>=g--`6]Q=>Y\\\\'@+DQpc%cM[\\\"nd=Ji@Ku^d@e`])3=#Zq*fA<*0R+GbC(9?pmh*-c83TFI^a1MtpaUB/WZ6ZCGVXuX3KRKE$?j+,J3W1T5P>.E335Cd\\\\\\\\,\\\"2AQ?1Tap9b)$RMl%Z+#]\\\"SeYTDm18eCA7Tb:7MA;*PhX`d.q@biAAJHoK:A0.kNL1eU8eLY;6YqF\\\\\\\\7S61nlR:eo=$X)f7.]l7K#2:bWTM5(1B)083M#fDaaMEt[)7LD#s\\\"Ie4L]D(B[X#%ca/j90(`qp9]$4AQL7>;DJ!B?=fJ1PONi07H`:Gu*1(fU9dXA[aZDkSHo=&KrEnA,ZJOFACFT5s=\\\"_(DjC`)Q<F0![E_Ua.4.bq$U,X\\\\\\\\kXQP7Bfs2;C5P.%pG<)FMS\\\\\\\\Le$]ffZ>Cn03@B$9,\\\\\\\\<-!#X2ri>EIXa=rX\\\\\\\\u1>*rYM(4>77sZ,G@b&X]W;2W!0Ni6H(Zf_@f#oiHQ-A6#]njH>Akn\\\\\\\\oY@GfBn1]+rGUl6C4FD`h[?@\\\\'HV&a-%$[o=6q\\\"-g&it=-GuS.I\\\\'n>,;18tWXCtj0nd2Wl\\\\\\\\0bWH/,G>2`94d\\\\\\\\2/srpI-.EheU`jY>gbcZ#Si4T5);`F\\\\'QW.+eEZuZb8Q@*$b5i-9?ENLON1;2a/rI%47Z`]#SG=nP!EF,;_80Ic<\\\\\\\\)>EDZ^G6V0Cn@&-(NG#T_<U9Uu4E2M$C-qXPKUmFWkoi[Wb<_n@Vn\\\"Tq\\\\\\\\@\\\\\\\\X+OQGCW&W!s9kUILj<gg0:;V2tGZ27#aFC[865Zp9,c\\\\'\\\\'C\\\\\\\\Kd]7i:X@*:HB$VB+,,;=.`u\\\\\\\\\\\\\\\\9>0_@=7fHK`>O<m6DT457JsP,-Rd_geH,5[B8Ed_nasc0em1>9>U7HI<mCuR.kBpc\\\"YpN^W<$\\\"L1idRh)Ii`Gi`0Lp!Jtp)ZZ,#&MYM:K-17*arp\\\"tm9u$u' )))\\n\\nwith open('user.out', 'wb') as f:\\n for i in sys.stdin:\\n if i[-1] == '\\\\n':\\n f.write(d[i[:-1]])\\n else:\\n f.write(d[i])\\n f.write(b\\\"\\\\n\\\")\\n_exit(0)\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n x = self.countAndSay(n - 1)\\n result = \\\"\\\"\\n character = x[0]\\n count = 1\\n for i in range(1, len(x)):\\n if x[i] == character:\\n count = count + 1\\n else:\\n result = result + str(count)\\n result = result + str(character)\\n character = x[i]\\n count = 1\\n result = result + str(count)\\n result = result + str(character)\\n\\n return result\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def process_str(self, s):\\n r = ''\\n prev = s[0]\\n c = 1\\n for el in s[1:]:\\n if el == prev:\\n c+=1\\n else:\\n r+=f'{c}{prev}'\\n prev = el\\n c=1\\n else:\\n r+=f'{c}{prev}'\\n return r\\n\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return '1'\\n return self.process_str(self.countAndSay(n-1))\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"import gc\\ngc.disable()\\n\\nfrom os import _exit\\nfrom sys import stdin \\nimport pickle, base64, zlib\\n\\nd = pickle.loads(zlib.decompress(base64.a85decode( b'GQI294c^j[&`\\\\'!>(3BTa0X.cN(g(I`k<;$cA)^nc,;=,Q6c)7Tbeh35`9%;5nO%OC&Xeb]=k2?7Z_uijBX^&R1ZHB#0-Y1TDoH(tp\\\\\\\\-oNk*>r?kN/%;^HO5F+5NRWQ`jbgQ`#o5:Kfr$H.MQ8jlt%gl0SApQDYfIjE1+KkBq[8P=!#dSj\\\\'\\\\\\\\L4n.+e?S5,=AGF\\\\'1^D-:io(6Ff+:9(c<92m\\\"mIKm*jC/dXVm@Q[q!J9J58TEi*a$:akH&fM!rZIC=aOdj[2Q1a,jnFSpGT#hLj6dSQ\\\\'7\\\\'=P9nHJFlAJXiZmSbhRPf=$#I#m+?[O*]+]SiD;eYU8%*Z(S++9DX5G=Hdj!`e&($Eq(L=28Hl>Xfg1u?YYC\\\"QrliD_o5?.+h^SM#Qs6IZ8ZU5\\\">jf3Yn_XsLme4SF2X3f]!%\\\\'>cKnDL:1P8cD[6[US,s.9(U3YX75S4[YTP:2+;n\\\\\\\\V]<fPhY%[9brGHu%9b1Ejsh!r(]h4.R>?Vgm[S\\\\\\\\bhO;i<OMQs57.0XZ+-K\\\\\\\\!jj\\\\'%q`QK?48ujFf_JoqFX_<W(28.cYo/j\\\\\\\\$\\\\'/P\\\\\\\\i;Yrk>+>^Mi+aYXrAaVfOF@oU:.;Lg#a3W%taCNA@/Fo\\\"%!l^N!#PcJ8C<)_<Gq:6]\\\\'e\\\\'7WIM+.NT@?jWb$.Hs.Tk60h3\\\"!^\\\\\\\\l!p1+<f1bB%G3m,OTO8s7V#uMRX7u\\\\\\\\%:9F\\\"&09tP$8-F51iRB(pI2J]O\\\"g.66\\\"\\\\'?\\\"\\\\'/(_!NjK^Kd\\\".B4D\\\\\\\\Q,oIrA:E\\\\'I\\\"ir#\\\\\\\\75.PC\\\\'6!%cF?V@=5J?*)93r;\\\\\\\\(;9=`K\\\\\\\\S7r<CL/.41bO!Mo\\\\'A:G[;\\\\\\\\TiLpZ(C0I$[f66udZPc7X67=&4E+8AU+4?8.XW;-ZX8+()Gj8XG`(LZ(%0I^u_ee:WU]P8e\\\\\\\\WVs-SmOV\\\\\\\\,gVF%C5QIt<725)=<@L=iKt=^L4on)+]4+Y2HZ[gYA.rKb=Qc*<CX6O:ei`2Y\\\"Rnb7NJQ>:9?h]Hp2:ZNl%k(eI-DpJN4QZjQ9T2<Y!^ugmCR:p;i#%K;PA1=g$i:73qB9!ihZ\\\"7A2\\\"`Co6K$V7\\\\\\\\_k<\\\\'i@C@eMqpIu_j*g8g&Z@n*psL8gf(=`/?/ZD`e=16\\\"S5)f[a@T.Z1Sqrk`md$_;$`fM`W&F$PS\\\"dEGTk/=K*1Q7h^cRa3lD(,,5N;ia;P0t1@2JLohF+aQRWY$/NN42Gp*oe,Nh8sJ_$pA2@,h6;6p*urjMW(+dP@2CCmBS4.4^pREN3%>gh6off`mZpaPh<+Z&P%i10W@\\\"&,</hmQ[p0M+qRoQ=qtR9h%M_f=.YO`YBDU)A:673hsa1]`oC3$f.qf8I\\\\'u0:oAace%iP6hPjS)(UEqo)Bb/lq&t^2(-cjk&4t+mCl_%<HE9sGLG%k!sFX(W\\\"$eO8)*JZ`/-VIH8(K.=4Bhsu;?Z,Bkl9%tF8AN$)\\\\\\\\``HIVldt3+u6\\\\'$mA8NgN^\\\\\\\\TEpr:ocmuH$GK4+)opEdqAD\\\\'pJZ&TSg[HBEHQCYp/3XrH%-R+3%qIEkO[->.280&r@<,\\\\\\\\A(d@Z-\\\"D\\\\'e4V*(_1tbc[357\\\\'/6tl<(CAsQi4jDf?2@o$)04dcYl5aM_\\\"32$mRP8S#WDO5CC1-^3RUteNecOms9CQ_PC0%5_=eYi,^Q&g!8p:Jf)gK@VOFRgp./CJQ4RIBOiknAMU`^h5bE`V`0JJpuHAdD05#*E6MKc-#JckU/4r`&Y?V?i7IX%p1k(2>0,^Vo3Gg.OQ\\\\\\\\gLjn+[*R\\\\\\\\.rY?q$E2Du3q\\\\\\\\[3)llA5GeHd);#=\\\"BFp^>^42F#Wp7DhI_cl[EFh%r67f)gnn\\\\'`c.Aml/q.EN8Lh.b<1^gE*VfCFYMF*`cUtga[2rp^G#2u*J>?Za@QKqVA*/HBVW:T(@[X7!i8<4E.=HDOo+$GPB&%LV&P1@r,*?2&HUb)>0fCN&W-ZaKk*4FO\\\"\\\"T//]DRa8A\\\"bV!MoGg/Gc$@W<tn7^=?dA2=<@M6rU8ZO-tu4.dtXei2W$*l3?1s^CCHIsLQlYn3mo9SKaRNsF96ZaM7$VL1s*C>obL%ZlP1q_W$[6I,,B,+7<?<\\\\\\\\BanquQE\\\"!O(npSTHcUVBW\\\\\\\\hBH,Q.+1kUKDX`ZJs_(DK`2A,:nr(/IEVql`fW,PZ]_mKk\\\\\\\\m_ALJ5\\\\'D6Rq-@OV:IEp\\\\'j?(\\\"Z-<7K&9VPX%+rbug5DtY.<q@06)dANda625JcTmG-7@ZA<3C5tmuTpJl>=(]B`-1&%0l5A0+ibY\\\\\\\\DJhT6T=6(q7Vp(X[)p\\\\\\\\nE1:R-$hOD2hSB=*i.PIl:Pe=A\\\\\\\\BBZfch]$=T?:<$W2\\\"+quI?E^`f,EG@pn7m<UO!IXXe$1i1Pf1oF@8W1\\\\\\\\.oU6\\\\'+jH\\\\'T8lusYTsEi::+lNG6gS^(=b?bYaKr[04Sn3]B]d4T?38#_\\\"Q#\\\\\\\\bu!5!FWN+?9ZU*rkeG\\\\'NoR?Ai5>nK&6Y!]q)?UmACF8a47/7aPruA#s<L(hGr`(TO!YEnXS=KbPF]tgX`O2k\\\\\\\\.eaTO7\\\\\\\\Y,MHE8!YbbQ$KX;-Ya+muq*)(K@%QpH7]i-G\\\\'m`<7uh1nISi)0.F*!G0\\\"&;J4G>SR.C@h$I_Kfgt3T+\\\\'Q<i^lHiFFp(Vu=)HrKVt7GaLs0C!AnOP-#.N-`>RCGYUl,7/)@KWWZK$+[N3#JWP?l\\\\'34Ue$9^%9&J3\\\\\\\\7-*4QM8bi\\\\'r.[O:0A(9gSjR<n2t?WW?FIk@lKn86t,4PP]l#lphakr1tA\\\\\\\\\\\\\\\\UO4/l@Na>:aGVkY,..tXK1TA>7=6RL`tm*2TL]n:@P_mOYlCi\\\\':[eEeJQDco\\\\'m\\\\'1),J_?1hbY7MHW/dbnlC8)-.L2Sor^J[nRc>TDI?IW6!\\\\'3oIN7i&H/qBTIl+83,464m<g+@e[tX$*WBWrNC0hZ%QF2EmhB[NYj?&s69]-c?\\\"Z^Z6tl4nFWf>Tm$&Q1*Y^06(GdF%[ENs_CHpC!ac9ALp/MbR,\\\\'5D]i7fk>@GQ>9pUtZDb/[Z>;eA83=`SDNF2$e&Q1[YfYEm5drTM-`)FQs^7DE#Y55[##pj0e-%(WS!o`IsEDu4&@?6A/AY//DM_pL@7b6/VJQU\\\\'.r$E/UTH\\\"3[B&\\\\\\\\>V;O/F&fG=u8f;1H9nCJUn!\\\\\\\\bO,_R.\\\\\\\\TDQnH,d`U@$rq-#GD.9+U7=\\\\\\\\!S!Gij:aXmM!igs8CD@V!767mA_UHTRh2XQ^i0*/*A,3>d+a86/]fY$flA;1Vm$j0`t2/9rLI@CP?.]tf\\\\'$\\\\\\\\Kj\\\\\\\\U%1d@:,&d)cI6(oA^qoDEQgUd_=/a:@-J+c@oU=)d>60VV/]6aoIRFujoYOPS($)11FF*r)atBoJAEe\\\"f-W>Kg:8l(_,\\\\'IXsX;8WncNcJ<(p8S2g,p7Rm(Y7q=##>k:]__h\\\")>\\\"dVCX8WUs-IcO8\\\\\\\\F3>Uk%7>&+E.8Aj.1]5rfh/Rn,.@<TdFWik9pd4@tc[hJSq5,]fT_UE&\\\\\\\\IVijTc[ES1R9m\\\\';9-*85U=6I-k@`0g]Z)VXC`+L1\\\\\\\\o^AXe21Bm:RBVHVVibHZT#FA(%!_9;\\\\'eDJs6-#aE@4Km\\\\'[4*he>,mikBJ&N0t91,>%3cRqnBA)ONBq)M2r*IO5(Z\\\"R#J3g1FN!\\\\\\\\%+a2<l0-BV$\\\\\\\\D1a^[tjC#,g#pF$;D5eP*]`,\\\\\\\\+0hWd-Mu1+\\\\\\\\q[F=Z.GI#D%q0p7bY<d9cPXH=kt4lPO?CF;WtV#$rOPa4qs0d`pC$-a7cHM)gg&(VhOo&65!@t7sOg31gg7,W19,3N[!3>=g--`6]Q=>Y\\\\'@+DQpc%cM[\\\"nd=Ji@Ku^d@e`])3=#Zq*fA<*0R+GbC(9?pmh*-c83TFI^a1MtpaUB/WZ6ZCGVXuX3KRKE$?j+,J3W1T5P>.E335Cd\\\\\\\\,\\\"2AQ?1Tap9b)$RMl%Z+#]\\\"SeYTDm18eCA7Tb:7MA;*PhX`d.q@biAAJHoK:A0.kNL1eU8eLY;6YqF\\\\\\\\7S61nlR:eo=$X)f7.]l7K#2:bWTM5(1B)083M#fDaaMEt[)7LD#s\\\"Ie4L]D(B[X#%ca/j90(`qp9]$4AQL7>;DJ!B?=fJ1PONi07H`:Gu*1(fU9dXA[aZDkSHo=&KrEnA,ZJOFACFT5s=\\\"_(DjC`)Q<F0![E_Ua.4.bq$U,X\\\\\\\\kXQP7Bfs2;C5P.%pG<)FMS\\\\\\\\Le$]ffZ>Cn03@B$9,\\\\\\\\<-!#X2ri>EIXa=rX\\\\\\\\u1>*rYM(4>77sZ,G@b&X]W;2W!0Ni6H(Zf_@f#oiHQ-A6#]njH>Akn\\\\\\\\oY@GfBn1]+rGUl6C4FD`h[?@\\\\'HV&a-%$[o=6q\\\"-g&it=-GuS.I\\\\'n>,;18tWXCtj0nd2Wl\\\\\\\\0bWH/,G>2`94d\\\\\\\\2/srpI-.EheU`jY>gbcZ#Si4T5);`F\\\\'QW.+eEZuZb8Q@*$b5i-9?ENLON1;2a/rI%47Z`]#SG=nP!EF,;_80Ic<\\\\\\\\)>EDZ^G6V0Cn@&-(NG#T_<U9Uu4E2M$C-qXPKUmFWkoi[Wb<_n@Vn\\\"Tq\\\\\\\\@\\\\\\\\X+OQGCW&W!s9kUILj<gg0:;V2tGZ27#aFC[865Zp9,c\\\\'\\\\'C\\\\\\\\Kd]7i:X@*:HB$VB+,,;=.`u\\\\\\\\\\\\\\\\9>0_@=7fHK`>O<m6DT457JsP,-Rd_geH,5[B8Ed_nasc0em1>9>U7HI<mCuR.kBpc\\\"YpN^W<$\\\"L1idRh)Ii`Gi`0Lp!Jtp)ZZ,#&MYM:K-17*arp\\\"tm9u$u' )))\\n\\nwith open('user.out', 'wb') as f:\\n for i in sys.stdin:\\n if i[-1] == '\\\\n':\\n f.write(d[i[:-1]])\\n else:\\n f.write(d[i])\\n f.write(b\\\"\\\\n\\\")\\n_exit(0)\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n \\n \\n def run_length_encoding(s):\\n i = 0\\n res = []\\n \\n while i < len(s):\\n j = i\\n run_len = 0\\n while j < len(s) and s[j] == s[i]:\\n j += 1\\n run_len += 1\\n res.append(str(run_len))\\n res.append(s[i])\\n i = j\\n \\n return res\\n \\n def helper(n):\\n if n == 1:\\n return '1'\\n \\n return run_length_encoding(helper(n-1))\\n \\n \\n return ''.join(helper(n))\\n\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n fin = '1'\\n for _ in range(1, n):\\n fin = self.rle(fin)\\n return fin\\n\\n def rle(self, numb: str) -> str:\\n rle = []\\n curr = numb[0]\\n count = 0\\n\\n for char in numb: \\n if char == curr: \\n count += 1\\n else: \\n rle.append(str(count) + curr)\\n count = 1\\n curr = char\\n rle.append(str(count) + numb[-1])\\n \\n \\n return ''.join(rle)\\n\\n \\n \\n\\n\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n def helper(s,idx):\\n if idx==n:\\n return s\\n temp=s[0]\\n ans=\\\"\\\"\\n count=1\\n for i in range(1,len(s)):\\n if s[i]==temp:\\n count+=1\\n else:\\n ans+=str(count)+temp\\n temp=s[i]\\n count=1\\n ans+=str(count)+temp\\n return helper(ans,idx+1)\\n return helper(\\\"1\\\",1)\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n a = {\\n 1: \\\"1\\\"\\n }\\n \\n for i in range(2,n+1):\\n prev = a[i-1]\\n a[i] = \\\"\\\"\\n \\n g_count = 0\\n g_char = None\\n for c in prev:\\n if c == g_char:\\n g_count += 1\\n else:\\n a[i] += f'{g_count}{g_char}' if g_char else ''\\n g_char = c\\n g_count = 1\\n \\n a[i] += f'{g_count}{g_char}'\\n \\n return a[n]\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n \\\"\\\"\\\"\\n method 2, recursion\\n \\\"\\\"\\\"\\n if n == 1:\\n return \\\"1\\\"\\n x = self.countAndSay(n-1)\\n s = \\\"\\\"\\n y = x[0]\\n ct = 1\\n for i in range(1, len(x)):\\n if x[i] == y:\\n ct += 1\\n else:\\n s += str(ct)\\n s += str(y)\\n y = x[i]\\n ct = 1\\n s += str(ct)\\n s += str(y)\\n return s\\n\\n\\n \\n # \\\"\\\"\\\"\\n # method 1\\n # T =O(n^2)\\n # \\\"\\\"\\\"\\n # if n <= 0:\\n # return \\\"\\\"\\n \\n # s = \\\"1\\\"\\n # for i in range(n-1):\\n # s = self.rle(s)\\n # return s\\n \\n # def rle(self, s: str) -> str:\\n # res = []\\n # i = 0\\n # while i < len(s):\\n # curr_char = s[i]\\n # start = i\\n # while i < len(s) and s[i] == curr_char:\\n # i += 1\\n # ct = i - start\\n # res.extend(str(ct))\\n # res.append(curr_char)\\n # return \\\"\\\".join(res)\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n result = '1'\\n\\n for _ in range(n-1):\\n new_result = \\\"\\\"\\n count =1 \\n\\n for i in range(1, len(result)):\\n if result[i] == result[i-1]:\\n count += 1\\n else:\\n new_result += str(count)+result[i-1]\\n count = 1\\n new_result += str(count)+result[-1]\\n result = new_result\\n return result\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n answer = \\\"1\\\"\\n\\n for _ in range(2, n + 1):\\n tmp_string = []\\n counter = 0\\n number = None\\n for j in answer:\\n if number is None:\\n number = j\\n counter += 1\\n else:\\n if j == number:\\n counter += 1\\n else:\\n tmp_string.append(f\\\"{counter}{number}\\\")\\n number = j\\n counter = 1\\n tmp_string.append(f\\\"{counter}{number}\\\")\\n answer = \\\"\\\".join(tmp_string)\\n return answer\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n\\n t = \\\"1\\\"\\n\\n for i in range(n-1):\\n st = \\\"\\\"\\n prev = t[0]\\n c = 1\\n\\n for j in range(1,len(t)):\\n if t[j] == prev:\\n c+=1\\n else:\\n st += str(c) + prev\\n prev = t[j]\\n c = 1\\n st += str(c) + prev\\n t = st\\n\\n return t\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1: return \\\"1\\\"\\n # if n == 2: return \\\"11\\\"\\n pre_seq = self.countAndSay(n - 1)\\n count = 1\\n cand = pre_seq[0]\\n ans = []\\n for i in range(1, len(pre_seq)):\\n if pre_seq[i] == cand:\\n count += 1\\n else:\\n ans.append(str(count) + cand)\\n count = 1\\n cand = pre_seq[i]\\n ans.append(str(count) + cand)\\n return \\\"\\\".join(ans)\\n\\n# def reverseCountSay(s):\\n# memo = defaultdict(list)\\n\\n# def recursive(s):\\n# if len(s) == 0:\\n# return [[]]\\n# elif s in memo:\\n# return memo[s]\\n# for i in range(1, len(s)):\\n# curNum, count = s[i], int(s[:i])\\n# for subRes in recursive(s[i + 1:]):\\n# memo[s].append([curNum * count] + subRes)\\n# return memo[s]\\n# recursive(s)\\n# return [''.join(output) for output in memo[s]]\\n\\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"from itertools import groupby\\n\\nclass Solution:\\n def countAndSay(self, n: int) -> str:\\n # using itertools groupby, inspired by Stefan Pochman.\\n s = \\\"1\\\"\\n for _ in range(n - 1):\\n new_s = []\\n for digit, group in groupby(s):\\n new_s.append(str(len(list(group))))\\n new_s.append(digit)\\n s = ''.join(new_s)\\n \\n return s\\n \\n # def countAndSay(self, n: int) -> str:\\n # # Using itertools groupby, but lazier.\\n # s = \\\"1\\\"\\n # for _ in range(n - 1):\\n # s = ''.join(str(len(list(group))) + digit\\n # for digit, group in itertools.groupby(s))\\n # return s\\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n result = \\\"1\\\"\\n \\n for _ in range(1, n):\\n current = result\\n result = \\\"\\\"\\n i = 0\\n while i < len(current):\\n count = 1 \\n while i + 1 < len(current) and current[i] == current[i + 1]:\\n i += 1\\n count += 1\\n result += str(count) + current[i]\\n i += 1\\n \\n return result\\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n \\n def dfs(n):\\n if n == 1:\\n return str(1)\\n \\n string = dfs(n-1)\\n print(\\\"string: {}\\\".format(string))\\n count = 0\\n last_char = \\\"\\\"\\n res = []\\n i = 0\\n while i < len(string):\\n if count == 0:\\n last_char = string[i]\\n count += 1\\n elif last_char != string[i]:\\n res.append(str(count) + str(last_char))\\n last_char = string[i]\\n count = 1\\n else:\\n count += 1\\n i += 1\\n \\n res.append(str(count) + str(last_char))\\n \\n return \\\"\\\".join(res)\\n \\n return dfs(n)\\n\\n\\n# 1 --> 1\\n# 2 --> 11\\n# 3 --> 21\\n# 4 --> 1211\\n# 5 --> 111221\\n# 6 --> 312211\\n# 7 --> 13112221\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n \\n def dfs(n):\\n if n == 1:\\n return str(1)\\n \\n string = dfs(n-1)\\n count = 0\\n last_char = \\\"\\\"\\n res = []\\n i = 0\\n while i < len(string):\\n if count == 0:\\n last_char = string[i]\\n count += 1\\n elif last_char != string[i]:\\n res.append(str(count) + str(last_char))\\n last_char = string[i]\\n count = 1\\n else:\\n count += 1\\n i += 1\\n \\n res.append(str(count) + str(last_char))\\n \\n return \\\"\\\".join(res)\\n \\n return dfs(n)\\n\\n\\n# 1 --> 1\\n# 2 --> 11\\n# 3 --> 21\\n# 4 --> 1211\\n# 5 --> 111221\\n# 6 --> 312211\\n# 7 --> 13112221\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n \\n prev = self.countAndSay(n - 1)\\n res = \\\"\\\"\\n count = 1\\n digit = prev[0]\\n\\n for i in range(1, len(prev)):\\n if prev[i] == digit:\\n count += 1\\n else:\\n res += str(count) + digit\\n count = 1\\n digit = prev[i]\\n res += str(count) + digit\\n return res\\n\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"# count-and-say -> sequence of digit strings\\n# - recursive formula\\n# - countAndSay(1) = \\\"1\\\"\\n# - countAndSay(n) = run-length encoding of countAndSay(n - 1)\\n\\n\\n# Run-length encoding - string compression method\\n# - replace consecutive identical chars\\n# - repeated 2 / more times w/ concatenation of character + number marking the count of the chars (length of run)\\n\\n\\n\\n# RECURSION\\n# - base case = 1 -> return \\\"1\\\"\\n# - rle = recursion(n - 1) #happens after base case occurs\\n# - target = rle[0]\\n# - keep track of count\\n# - loop through target\\n# - if [i] == target -> count ++\\n# - else -> rle += str(count) + target -> target = [i] -> count = 1\\n# - rle += str(count) + target\\n# - return rle # goes up ot next recursive call in stack\\n\\n\\n\\n\\n\\nclass Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n\\n rle = self.countAndSay(n - 1)\\n\\n target = rle[0]\\n count = 1\\n\\n new_rle = \\\"\\\"\\n\\n for i in range(1, len(rle)):\\n if rle[i] == target:\\n count += 1\\n \\n else:\\n new_rle += str(count) + str(target)\\n target = rle[i]\\n count = 1\\n\\n new_rle += str(count) + str(target)\\n\\n return new_rle\\n\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n @cache\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n else:\\n prev_string = self.countAndSay(n - 1)\\n element = []\\n count = []\\n for c in prev_string:\\n if len(element) == 0 or element[-1] != c:\\n element.append(c)\\n count.append(1)\\n else:\\n count[-1] += 1\\n \\n sb = []\\n for c, e in zip(count, element):\\n sb.append(str(c))\\n sb.append(e)\\n\\n return \\\"\\\".join(sb)\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def rle(self, n: str) -> str:\\n if len(n) == 1:\\n return f\\\"1{n[0]}\\\"\\n result = ''\\n i = 0\\n while i < len(n):\\n c = 1\\n d = n[i]\\n i += 1\\n while i < len(n) and n[i] == d:\\n c += 1; i += 1\\n result += f\\\"{c}{d}\\\"\\n return result\\n\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n return self.rle(self.countAndSay(n-1))\\n \\n\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def RLE(self, seq):\\n seq2 = str(seq)\\n ans = ''\\n idx = 0\\n count = 1\\n while idx+1 < len(seq2):\\n if seq2[idx] == seq2[idx+1]:\\n count += 1\\n idx += 1\\n else:\\n ans = ans + str(count) + seq2[idx]\\n count = 1\\n idx += 1\\n ans = ans + str(count) + seq2[idx]\\n return ans\\n \\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return '1'\\n arr = ['1']\\n for iter in range(1, n):\\n arr.append(self.RLE(arr[iter-1]))\\n return arr[-1]\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def countAndSay(self, n: int) -> str:\\n \\\"\\\"\\\"\\n countAndSay(1) = \\\"1\\\"\\n countAndSay(2) = RLE of \\\"1\\\" = \\\"11\\\"\\n countAndSay(3) = RLE of \\\"11\\\" = \\\"21\\\"\\n countAndSay(4) = RLE of \\\"21\\\" = \\\"1211\\\"\\n countAndSay(5) = RLE of \\\"1211\\\" = \\\"111221\\\"\\n countAndSay(6) = RLE of \\\"111221\\\" = \\\"312211\\\"\\n countAndSay(7) = RLE of \\\"312211\\\" = \\\"13112221\\\"\\n \\\"\\\"\\\"\\n if n == 1:\\n return \\\"1\\\"\\n\\n return self.rle(self.countAndSay(n-1))\\n\\n def rle(self, n: str):\\n count = 1\\n current = n[0]\\n result = \\\"\\\"\\n for c in n[1:]:\\n if c == current:\\n count += 1\\n else:\\n result += str(count)\\n result += current\\n count = 1\\n current = c\\n result += str(count)\\n result += current\\n return result\\n\\n\\n\\n\\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n # 初始的countAndSay(1)为\\\"1\\\"\\n current = \\\"1\\\"\\n \\n # 从2到n，逐步生成序列\\n for _ in range(2, n + 1):\\n next_seq = [] # 用于存储下一个序列的结果\\n i = 0\\n \\n # 遍历当前序列\\n while i < len(current):\\n count = 1 # 每个字符至少出现一次\\n # 统计连续相同字符的数量\\n while i + 1 < len(current) and current[i] == current[i + 1]:\\n i += 1\\n count += 1\\n # 将计数和字符加入到下一个序列中\\n next_seq.append(str(count))\\n next_seq.append(current[i])\\n i += 1\\n \\n # 更新当前序列为生成的下一个序列\\n current = ''.join(next_seq)\\n \\n # 返回第n个序列\\n return current\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n==1:\\n return '1'\\n prev = self.countAndSay(n-1)\\n res = \\\"\\\"\\n cnt=1\\n for i in range(len(prev)):\\n if i==len(prev)-1 or prev[i]!=prev[i+1]:\\n res+=str(cnt)+prev[i]\\n cnt=1\\n else:\\n cnt+=1\\n\\n return res\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n ans = '1'\\n\\n for _ in range(n - 1):\\n nxt = ''\\n i = 0\\n while i < len(ans):\\n count = 1\\n while i + 1 < len(ans) and ans[i] == ans[i + 1]:\\n count += 1\\n i += 1\\n nxt += str(count) + ans[i]\\n i += 1\\n ans = nxt\\n\\n return ans\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n s=\\\"1\\\"\\n while n-1>0:\\n cur=s[0]\\n temp_s=\\\"\\\"\\n count=0\\n for i in s:\\n if cur==i:\\n count+=1\\n else:\\n temp_s=temp_s+str(count)+cur\\n count=1\\n cur=i\\n temp_s=temp_s+str(count)+cur \\n s=temp_s\\n n-=1\\n return(s) \\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n # Base case\\n if n == 1:\\n return \\\"1\\\"\\n\\n # Initialize the first term\\n current = \\\"1\\\"\\n\\n # Iterate from 2 to n to build the sequence\\n for _ in range(2, n + 1):\\n next_seq = \\\"\\\"\\n i = 0\\n while i < len(current):\\n count = 1 # At least one occurrence of the current character\\n # Count consecutive identical characters\\n while i + 1 < len(current) and current[i] == current[i + 1]:\\n i += 1\\n count += 1\\n # Append character and its count as per problem's RLE definition\\n next_seq += current[i] + str(count)\\n i += 1 # Move to the next new character\\n # Update current sequence\\n current = next_seq\\n\\n return current[::-1]\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n # Base case\\n if n == 1:\\n return \\\"1\\\"\\n\\n # Initialize the first term\\n current = \\\"1\\\"\\n\\n # Iterate from 2 to n to build the sequence\\n for _ in range(2, n + 1):\\n next_seq = \\\"\\\"\\n i = 0\\n while i < len(current):\\n count = 1 # At least one occurrence of the current character\\n # Count consecutive identical characters\\n while i + 1 < len(current) and current[i] == current[i + 1]:\\n i += 1\\n count += 1\\n # Append character and its count as per problem's RLE definition\\n next_seq += str(count) + current[i]\\n i += 1 # Move to the next new character\\n # Update current sequence\\n current = next_seq\\n\\n return current\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n s = \\\"1\\\"\\n for i in range(n-1):\\n # d = Counter(s)\\n # tmp = \\\"\\\"\\n # for key, val in d.items():\\n # tmp += str(val) + key\\n # s = tmp\\n # d.clear()\\n # prev = s[0]\\n count = 1\\n tmp = \\\"\\\"\\n for j in range(len(s)):\\n if j == len(s) - 1 or s[j] != s[j+1]:\\n tmp += str(count) + s[j]\\n count = 1\\n else:\\n count += 1\\n # if s[j] == prev:\\n # count += 1\\n # if s[j] != prev or j == len(s)-1:\\n # tmp += str(count) + prev\\n # count = 0\\n # prev = s[j]\\n s = tmp\\n return s\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n \\n uncompressed = self.countAndSay(n-1)\\n result = \\\"\\\"\\n cur_char = uncompressed[0]\\n cur_count = 1\\n for i in range(1,len(uncompressed)):\\n digit = uncompressed[i]\\n if digit != cur_char:\\n result += str(cur_count)\\n result += cur_char\\n cur_char = digit\\n cur_count = 1\\n else:\\n cur_count += 1\\n \\n result += str(cur_count)\\n result += cur_char\\n return result\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n \\n ## get the base, when n == 1, return 1\\n ## call func on cur_n - 1\\n ## go through the string\\n ## while i < end\\n ## cur, count. move until not the same. add to output\\n ## return output\\n\\n ## Time: O(n * m) n is provided, m is the avg len of the string that's provided\\n ## Space: O(n)\\n\\n if n == 1:\\n return \\\"1\\\"\\n \\n prev = self.countAndSay(n-1)\\n # print(prev)\\n output = \\\"\\\"\\n i = 0\\n while i < len(prev):\\n char = prev[i]\\n count = 0\\n\\n while i < len(prev) and char == prev[i]:\\n count += 1\\n i += 1\\n output += str(count) + char\\n \\n return output\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"# count-and-say -> sequence of digit strings\\n# - recursive formula\\n# - countAndSay(1) = \\\"1\\\"\\n# - countAndSay(n) = run-length encoding of countAndSay(n - 1)\\n\\n\\n# Run-length encoding - string compression method\\n# - replace consecutive identical chars\\n# - repeated 2 / more times w/ concatenation of character + number marking the count of the chars (length of run)\\n\\n\\n\\n# RECURSION\\n# - base case = 1 -> return \\\"1\\\"\\n# - rle = recursion(n - 1) #happens after base case occurs\\n# - target = rle[0]\\n# - keep track of count\\n# - loop through target\\n# - if [i] == target -> count ++\\n# - else -> rle += str(count) + target -> target = [i] -> count = 1\\n# - rle += str(count) + target\\n# - return rle # goes up ot next recursive call in stack\\n\\n\\n\\n\\n\\nclass Solution:\\n def countAndSay(self, n: int) -> str:\\n # if n == 1:\\n # return \\\"1\\\"\\n\\n # rle = self.countAndSay(n - 1)\\n\\n # target = rle[0]\\n # count = 1\\n\\n # new_rle = \\\"\\\"\\n\\n # for i in range(1, len(rle)):\\n # if rle[i] == target:\\n # count += 1\\n \\n # else:\\n # new_rle += str(count) + str(target)\\n # target = rle[i]\\n # count = 1\\n\\n # new_rle += str(count) + str(target)\\n\\n # return new_rle\\n\\n res = \\\"1\\\"\\n\\n for i in range(1, n):\\n new_res = \\\"\\\"\\n count = 1\\n target = res[0]\\n\\n for j in range(1, len(res)):\\n if res[j] == target:\\n count += 1\\n \\n else:\\n new_res += str(count) + str(target)\\n target = res[j]\\n count = 1\\n\\n new_res += str(count) + str(target)\\n res = new_res\\n\\n return res\\n \\n\\n\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n def getresult(s):\\n count = 1\\n res = \\\"\\\"\\n n = len(s)\\n i =0\\n while i<n:\\n count = 1\\n ans = s[i]\\n while i+1<n and s[i]==s[i+1]:\\n count+=1\\n i+=1\\n res+= (str(count)+ans)\\n i+=1\\n return res\\n\\n def okay(n):\\n if n==1:\\n return \\\"1\\\"\\n x = okay(n-1)\\n val = getresult(x)\\n return val\\n return okay(n)\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n s = '1'\\n s2 = \\\"\\\"\\n for i in range(2, n+1):\\n count = 0\\n curr = s[0]\\n for c in s:\\n if c == curr:\\n count += 1\\n\\n else:\\n s2+=str(count) + curr\\n count = 1\\n curr = c\\n \\n s2+= str(count) + curr\\n print(s2)\\n s = s2\\n s2 = ''\\n return s\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n==1:\\n return \\\"1\\\"\\n result=\\\"1\\\"\\n for _ in range(2,n+1):\\n prev=result\\n result=\\\"\\\"\\n count=1\\n for i in range(1,len(prev)):\\n if prev[i]==prev[i-1]:\\n count+=1\\n else:\\n result+=str(count)+prev[i-1]\\n count=1\\n result+=str(count)+prev[-1]\\n return result \\n\\n\\n\\n\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n result = '1'\\n for j in range(2, n + 1):\\n output = []\\n i = 0\\n while i < len(result):\\n repeated = 1\\n while (i + 1) < len(result) and result[i] == result[i + 1]:\\n repeated += 1\\n i += 1\\n output.append(str(repeated))\\n output.append(str(result[i]))\\n if i == len(result) - 1:\\n if result[i] == result[i - 1]:\\n break\\n i += 1\\n result = output\\n return ''.join(result)\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n==1:\\n return \\\"1\\\"\\n result=\\\"1\\\"\\n for _ in range(2,n+1):\\n prev=result\\n result=\\\"\\\"\\n count=1\\n for i in range(1,len(prev)):\\n if prev[i]==prev[i-1]:\\n count+=1\\n else:\\n result+=str(count)+prev[i-1]\\n count=1\\n result+=str(count)+prev[-1]\\n return result \\n\\n\\n\\n\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n \\n def countAndSay(self, n: int) -> str:\\n cur = \\\"1\\\"\\n temp = []\\n for itr in range(n-1):\\n temp.clear()\\n count = 0\\n for i,char in enumerate(cur):\\n if i == 0:\\n count += 1\\n continue\\n elif i != 0 and char == cur[i-1]:\\n count += 1\\n if i == len(cur)-1:\\n temp.append(str(count))\\n temp.append(cur[i])\\n else:\\n temp.append(str(count))\\n temp.append(cur[i-1])\\n if i == len(cur)-1:\\n temp.append(\\\"1\\\")\\n temp.append(cur[i])\\n count = 1\\n if len(temp) == 0:\\n temp.append(str(count))\\n temp.append(cur[i])\\n cur = \\\"\\\"\\n cur = \\\"\\\".join(temp)\\n \\n \\n \\n return cur\\n \\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n\\n if n == 1:\\n return \\\"1\\\"\\n \\n result = \\\"1\\\" # Base case\\n \\n for _ in range(2, n + 1):\\n prev = result\\n result = []\\n count = 1\\n \\n # Loop through the previous sequence\\n for i in range(1, len(prev)):\\n if prev[i] == prev[i - 1]:\\n count += 1\\n else:\\n result.append(str(count))\\n result.append(prev[i - 1])\\n count = 1\\n \\n # Append the last character group\\n result.append(str(count))\\n result.append(prev[-1])\\n \\n # Join the list into a final string\\n result = ''.join(result)\\n \\n return result\\n \\n\\n\\n\\n\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n\\n # idea: use stack to record char and its count\\n # error1: initialize stac\\n # T: O(n*m)\\n # S: O(m)\\n\\n stack = []\\n s = \\\"1\\\"\\n\\n for _ in range(n-1):\\n for char in s:\\n if stack and stack[-1][0] == char:\\n stack[-1][1] += 1\\n else:\\n stack.append([char, 1])\\n s = \\\"\\\"\\n for char, count in stack:\\n s += str(count)\\n s += char\\n stack = []\\n return s\\n\\n\\n \\n\\n\\n\\n\\n\\n \\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n result = self.countAndSay(n - 1)\\n i = 0\\n output = []\\n while i < len(result):\\n repeated = 1\\n while (i + 1) < len(result) and result[i] == result[i + 1]:\\n repeated += 1\\n i += 1\\n output.append(str(repeated))\\n output.append(str(result[i]))\\n if i == len(result) - 1:\\n if result[i] == result[i - 1]:\\n break\\n i += 1\\n return ''.join(output)\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n def get_count_and_say(s: str) -> str:\\n result =[]\\n i = 0\\n while i < len(s):\\n count = 1\\n while i + 1 < len(s) and s[i] == s[i + 1]:\\n i += 1\\n count += 1\\n result.append(str(count))\\n result.append(s[i])\\n i += 1\\n return ''.join(result)\\n if n == 1:\\n return \\\"1\\\"\\n previous = \\\"1\\\"\\n for _ in range(2, n + 1):\\n previous = get_count_and_say(previous)\\n return previous\\n\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n==1:\\n return \\\"1\\\"\\n prev=self.countAndSay(n-1)\\n result=\\\"\\\"\\n count=1\\n for i in range(1,len(prev)):\\n if prev[i]==prev[i-1]:\\n count+=1\\n else:\\n result+=str(count)+prev[i-1]\\n count=1\\n result+=str(count)+prev[-1]\\n return result\\n\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def countAndSay(self, n: int) -> str:\\n\\n def count_til_diff(s: str):\\n res = ''\\n i = 0\\n temp = ''\\n while i < len(s):\\n count = 1\\n check = s[i]\\n if (check == temp):\\n break\\n temp = check\\n for j in range(i + 1, len(s)): \\n if s[j] != check:\\n i = j\\n break\\n \\n count += 1\\n\\n if j == len(s) - 1:\\n i = j\\n break\\n res += str(count) + check\\n return res\\n \\n if n == 1:\\n return '1'\\n return count_til_diff(self.countAndSay(n - 1))\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def countAndSay(self, n: int) -> str:\\n\\n def count_til_diff(s: str):\\n res = ''\\n i = 0\\n temp = ''\\n while i < len(s):\\n count = 1\\n check = s[i]\\n if (check == temp):\\n break\\n temp = check\\n for j in range(i + 1, len(s)): \\n if s[j] != check:\\n i = j\\n break\\n \\n count += 1\\n\\n if j == len(s) - 1:\\n i = j\\n break\\n res += str(count) + check\\n return res\\n \\n if n == 1:\\n return '1'\\n return count_til_diff(self.countAndSay(n - 1))\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n s=\\\"1\\\"\\n while n-1>0:\\n cur=s[0]\\n temp_s=\\\"\\\"\\n count=0\\n for i in s:\\n if cur==i:\\n count+=1\\n else:\\n temp_s=temp_s+str(count)+cur\\n count=1\\n cur=i\\n temp_s=temp_s+str(count)+cur \\n s=temp_s\\n n-=1\\n return(s) \\n\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n result = self.countAndSay(n - 1)\\n if len(result) == 1:\\n return \\\"11\\\"\\n i = 0\\n output = []\\n while i < len(result):\\n repeated = 1\\n while (i + 1) < len(result) and result[i] == result[i + 1]:\\n repeated += 1\\n i += 1\\n output.append(str(repeated))\\n output.append(str(result[i]))\\n if i == len(result) - 1:\\n if result[i] == result[i - 1]:\\n break\\n i += 1\\n return ''.join(output)\\n \",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def countAndSay(self, n: int) -> str:\\n\\n def count_til_diff(s: str):\\n res = ''\\n i = 0\\n temp = ''\\n while i < len(s):\\n count = 1\\n check = s[i]\\n if (check == temp):\\n break\\n temp = check\\n for j in range(i + 1, len(s)): \\n if s[j] != check:\\n i = j\\n break\\n \\n count += 1\\n\\n if j == len(s) - 1:\\n i = j\\n break\\n res += str(count) + check\\n return res\\n \\n if n == 1:\\n return '1'\\n return count_til_diff(self.countAndSay(n - 1))\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n\\n prev = self.countAndSay(n-1)\\n result = \\\"\\\"\\n count = 1\\n\\n for i in range(len(prev)):\\n if i + 1 < len(prev) and prev[i] == prev[i + 1]:\\n count += 1\\n else:\\n result += str(count) + prev[i]\\n count = 1\\n return result\\n \",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n def convertToRLE(rle):\\n res=\\\"\\\"\\n left = 0\\n for i in range(1,len(rle)):\\n if(rle[i]!=rle[i-1]):\\n res += str(i-left)+rle[i-1]\\n left = i\\n if(left != len(rle)):\\n res+=str(len(rle)-left) + rle[-1]\\n return res\\n resRle = \\\"1\\\"\\n for i in range(2,n+1):\\n resRle = convertToRLE(resRle)\\n return resRle\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n ans = '1'\\n\\n for _ in range(n - 1):\\n nxt = ''\\n i = 0\\n while i < len(ans):\\n count = 1\\n while i + 1 < len(ans) and ans[i] == ans[i + 1]:\\n count += 1\\n i += 1\\n nxt += str(count) + ans[i]\\n i += 1\\n ans = nxt\\n\\n return ans\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n ans = '1'\\n\\n for _ in range(n - 1):\\n nxt = ''\\n i = 0\\n while i < len(ans):\\n count = 1\\n while i + 1 < len(ans) and ans[i] == ans[i + 1]:\\n count += 1\\n i += 1\\n nxt += str(count) + ans[i]\\n i += 1\\n ans = nxt\\n\\n return ans \",\n \"runtime\": \"53\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":53,"string":"53"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def countAndSay(self, n: int) -> str: \n if n == 1:\n return \"1\"\n cur_sequence = \"1\"\n for _ in range(2, n + 1):\n next_sequence = \"\"\n i = 0\n while i < len(cur_sequence):\n count = 1\n while i + 1 < len(cur_sequence) and cur_sequence[i] == cur_sequence[i + 1]:\n i += 1\n count += 1\n next_sequence += str(count) + cur_sequence[i]\n i += 1\n cur_sequence = next_sequence\n \n return cur_sequence","memory":"16200"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n def rle(x):\n encoding = \"\"\n current_char = x[0]\n count = 0\n for char in x:\n if current_char == char:\n count = count + 1\n else:\n encoding = encoding + str(count) + current_char\n current_char = char\n count = 1\n encoding = encoding + str(count) + current_char\n return encoding\n\n \n res = \"1\"\n for i in range(n - 1):\n res = rle(res)\n \n return res","memory":"16300"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n \n def count_till_difference(s: str):\n res = \"\"\n i = 0\n temp = \"\"\n while i < len(s):\n count = 1\n check = s[i]\n if check == temp:\n break\n temp = check\n for j in range(i + 1, len(s)):\n if s[j] != check:\n i = j\n break\n\n count += 1\n\n if j == len(s) - 1:\n i = j\n break\n res += str(count) + check\n return res\n return count_till_difference(self.countAndSay(n-1))\n \n\n\n\n ","memory":"16400"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n result = \"1\"\n \n for _ in range(1, n):\n current = result\n result = \"\"\n i = 0\n while i < len(current):\n count = 1 \n while i + 1 < len(current) and current[i] == current[i + 1]:\n i += 1\n count += 1\n result += str(count) + current[i]\n i += 1\n \n return result\n ","memory":"16400"},{"code":"class Solution:\n \n def countAndSay(self, n: int) -> str:\n cur = \"1\"\n temp = []\n for itr in range(n-1):\n temp.clear()\n count = 0\n for i,char in enumerate(cur):\n if i == 0:\n count += 1\n continue\n elif i != 0 and char == cur[i-1]:\n count += 1\n if i == len(cur)-1:\n temp.append(str(count))\n temp.append(cur[i])\n else:\n temp.append(str(count))\n temp.append(cur[i-1])\n if i == len(cur)-1:\n temp.append(\"1\")\n temp.append(cur[i])\n count = 1\n if len(temp) == 0:\n temp.append(str(count))\n temp.append(cur[i])\n cur = \"\"\n cur = \"\".join(temp)\n \n \n \n return cur\n \n ","memory":"16700"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n result = self.countAndSay(n - 1)\n if len(result) == 1:\n return \"11\"\n i = 0\n output = []\n while i < len(result):\n repeated = 1\n while (i + 1) < len(result) and result[i] == result[i + 1]:\n repeated += 1\n i += 1\n output.append(str(repeated))\n output.append(str(result[i]))\n if i == len(result) - 1:\n if result[i] == result[i - 1]:\n break\n i += 1\n return ''.join(output)\n ","memory":"16700"},{"code":"\n\nclass Solution:\n def countAndSay(self, n: int) -> str:\n\n def count_til_diff(s: str):\n res = ''\n i = 0\n temp = ''\n while i < len(s):\n count = 1\n check = s[i]\n if (check == temp):\n break\n temp = check\n for j in range(i + 1, len(s)): \n if s[j] != check:\n i = j\n break\n \n count += 1\n\n if j == len(s) - 1:\n i = j\n break\n res += str(count) + check\n return res\n \n if n == 1:\n return '1'\n return count_til_diff(self.countAndSay(n - 1))","memory":"16800"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n\n # idea: use stack to record char and its count\n # error1: initialize stac\n # T: O(n*m)\n # S: O(m)\n\n stack = []\n s = \"1\"\n\n for _ in range(n-1):\n for char in s:\n if stack and stack[-1][0] == char:\n stack[-1][1] += 1\n else:\n stack.append([char, 1])\n s = \"\"\n for char, count in stack:\n s += str(count)\n s += char\n stack = []\n return s\n\n\n \n\n\n\n\n\n \n\n\n\n\n\n","memory":"16800"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n\n if n == 1:\n return \"1\"\n \n result = \"1\" # Base case\n \n for _ in range(2, n + 1):\n prev = result\n result = []\n count = 1\n \n # Loop through the previous sequence\n for i in range(1, len(prev)):\n if prev[i] == prev[i - 1]:\n count += 1\n else:\n result.append(str(count))\n result.append(prev[i - 1])\n count = 1\n \n # Append the last character group\n result.append(str(count))\n result.append(prev[-1])\n \n # Join the list into a final string\n result = ''.join(result)\n \n return result\n \n\n\n\n\n ","memory":"16900"},{"code":"class Solution:\n def countAndSay(self, n: int) -> str:\n if n == 1:\n return \"1\"\n result = '1'\n for j in range(2, n + 1):\n output = []\n i = 0\n while i < len(result):\n repeated = 1\n while (i + 1) < len(result) and result[i] == result[i + 1]:\n repeated += 1\n i += 1\n output.append(str(repeated))\n output.append(str(result[i]))\n if i == len(result) - 1:\n if result[i] == result[i - 1]:\n break\n i += 1\n result = output\n return ''.join(result)\n ","memory":"16900"}],"string":"[\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str: \\n if n == 1:\\n return \\\"1\\\"\\n cur_sequence = \\\"1\\\"\\n for _ in range(2, n + 1):\\n next_sequence = \\\"\\\"\\n i = 0\\n while i < len(cur_sequence):\\n count = 1\\n while i + 1 < len(cur_sequence) and cur_sequence[i] == cur_sequence[i + 1]:\\n i += 1\\n count += 1\\n next_sequence += str(count) + cur_sequence[i]\\n i += 1\\n cur_sequence = next_sequence\\n \\n return cur_sequence\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n def rle(x):\\n encoding = \\\"\\\"\\n current_char = x[0]\\n count = 0\\n for char in x:\\n if current_char == char:\\n count = count + 1\\n else:\\n encoding = encoding + str(count) + current_char\\n current_char = char\\n count = 1\\n encoding = encoding + str(count) + current_char\\n return encoding\\n\\n \\n res = \\\"1\\\"\\n for i in range(n - 1):\\n res = rle(res)\\n \\n return res\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n \\n def count_till_difference(s: str):\\n res = \\\"\\\"\\n i = 0\\n temp = \\\"\\\"\\n while i < len(s):\\n count = 1\\n check = s[i]\\n if check == temp:\\n break\\n temp = check\\n for j in range(i + 1, len(s)):\\n if s[j] != check:\\n i = j\\n break\\n\\n count += 1\\n\\n if j == len(s) - 1:\\n i = j\\n break\\n res += str(count) + check\\n return res\\n return count_till_difference(self.countAndSay(n-1))\\n \\n\\n\\n\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n result = \\\"1\\\"\\n \\n for _ in range(1, n):\\n current = result\\n result = \\\"\\\"\\n i = 0\\n while i < len(current):\\n count = 1 \\n while i + 1 < len(current) and current[i] == current[i + 1]:\\n i += 1\\n count += 1\\n result += str(count) + current[i]\\n i += 1\\n \\n return result\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n \\n def countAndSay(self, n: int) -> str:\\n cur = \\\"1\\\"\\n temp = []\\n for itr in range(n-1):\\n temp.clear()\\n count = 0\\n for i,char in enumerate(cur):\\n if i == 0:\\n count += 1\\n continue\\n elif i != 0 and char == cur[i-1]:\\n count += 1\\n if i == len(cur)-1:\\n temp.append(str(count))\\n temp.append(cur[i])\\n else:\\n temp.append(str(count))\\n temp.append(cur[i-1])\\n if i == len(cur)-1:\\n temp.append(\\\"1\\\")\\n temp.append(cur[i])\\n count = 1\\n if len(temp) == 0:\\n temp.append(str(count))\\n temp.append(cur[i])\\n cur = \\\"\\\"\\n cur = \\\"\\\".join(temp)\\n \\n \\n \\n return cur\\n \\n \",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n result = self.countAndSay(n - 1)\\n if len(result) == 1:\\n return \\\"11\\\"\\n i = 0\\n output = []\\n while i < len(result):\\n repeated = 1\\n while (i + 1) < len(result) and result[i] == result[i + 1]:\\n repeated += 1\\n i += 1\\n output.append(str(repeated))\\n output.append(str(result[i]))\\n if i == len(result) - 1:\\n if result[i] == result[i - 1]:\\n break\\n i += 1\\n return ''.join(output)\\n \",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def countAndSay(self, n: int) -> str:\\n\\n def count_til_diff(s: str):\\n res = ''\\n i = 0\\n temp = ''\\n while i < len(s):\\n count = 1\\n check = s[i]\\n if (check == temp):\\n break\\n temp = check\\n for j in range(i + 1, len(s)): \\n if s[j] != check:\\n i = j\\n break\\n \\n count += 1\\n\\n if j == len(s) - 1:\\n i = j\\n break\\n res += str(count) + check\\n return res\\n \\n if n == 1:\\n return '1'\\n return count_til_diff(self.countAndSay(n - 1))\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n\\n # idea: use stack to record char and its count\\n # error1: initialize stac\\n # T: O(n*m)\\n # S: O(m)\\n\\n stack = []\\n s = \\\"1\\\"\\n\\n for _ in range(n-1):\\n for char in s:\\n if stack and stack[-1][0] == char:\\n stack[-1][1] += 1\\n else:\\n stack.append([char, 1])\\n s = \\\"\\\"\\n for char, count in stack:\\n s += str(count)\\n s += char\\n stack = []\\n return s\\n\\n\\n \\n\\n\\n\\n\\n\\n \\n\\n\\n\\n\\n\\n\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n\\n if n == 1:\\n return \\\"1\\\"\\n \\n result = \\\"1\\\" # Base case\\n \\n for _ in range(2, n + 1):\\n prev = result\\n result = []\\n count = 1\\n \\n # Loop through the previous sequence\\n for i in range(1, len(prev)):\\n if prev[i] == prev[i - 1]:\\n count += 1\\n else:\\n result.append(str(count))\\n result.append(prev[i - 1])\\n count = 1\\n \\n # Append the last character group\\n result.append(str(count))\\n result.append(prev[-1])\\n \\n # Join the list into a final string\\n result = ''.join(result)\\n \\n return result\\n \\n\\n\\n\\n\\n \",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def countAndSay(self, n: int) -> str:\\n if n == 1:\\n return \\\"1\\\"\\n result = '1'\\n for j in range(2, n + 1):\\n output = []\\n i = 0\\n while i < len(result):\\n repeated = 1\\n while (i + 1) < len(result) and result[i] == result[i + 1]:\\n repeated += 1\\n i += 1\\n output.append(str(repeated))\\n output.append(str(result[i]))\\n if i == len(result) - 1:\\n if result[i] == result[i - 1]:\\n break\\n i += 1\\n result = output\\n return ''.join(result)\\n \",\n \"memory\": \"16900\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":10,"string":"10"}}},{"rowIdx":75,"cells":{"question_id":{"kind":"number","value":39,"string":"39"},"name":{"kind":"string","value":"combination-sum"},"content":{"kind":"string","value":"<p>Given an array of <strong>distinct</strong> integers <code>candidates</code> and a target integer <code>target</code>, return <em>a list of all <strong>unique combinations</strong> of </em><code>candidates</code><em> where the chosen numbers sum to </em><code>target</code><em>.</em> You may return the combinations in <strong>any order</strong>.</p>\n\n<p>The <strong>same</strong> number may be chosen from <code>candidates</code> an <strong>unlimited number of times</strong>. Two combinations are unique if the <span data-keyword=\"frequency-array\">frequency</span> of at least one of the chosen numbers is different.</p>\n\n<p>The test cases are generated such that the number of unique combinations that sum up to <code>target</code> is less than <code>150</code> combinations for the given input.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> candidates = [2,3,6,7], target = 7\n<strong>Output:</strong> [[2,2,3],[7]]\n<strong>Explanation:</strong>\n2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.\n7 is a candidate, and 7 = 7.\nThese are the only two combinations.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> candidates = [2,3,5], target = 8\n<strong>Output:</strong> [[2,2,2,2],[2,3,3],[3,5]]\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> candidates = [2], target = 1\n<strong>Output:</strong> []\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= candidates.length <= 30</code></li>\n\t<li><code>2 <= candidates[i] <= 40</code></li>\n\t<li>All elements of <code>candidates</code> are <strong>distinct</strong>.</li>\n\t<li><code>1 <= target <= 40</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":72.71412742401108,"string":"72.714127"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","backtracking"],"string":"[\n \"array\",\n \"backtracking\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"25\", 0.0395], [\"29\", 0.14889999999999998], [\"32\", 0.7054], [\"35\", 1.5293999999999999], [\"39\", 3.1196], [\"42\", 9.0764], [\"45\", 11.3263], [\"49\", 14.1814], [\"52\", 19.4722], [\"55\", 11.8888], [\"59\", 7.857000000000001], [\"62\", 5.324199999999999], [\"65\", 1.8092], [\"69\", 1.1251], [\"72\", 0.8878], [\"75\", 0.42869999999999997], [\"79\", 0.3071], [\"82\", 0.3345], [\"85\", 0.2129], [\"89\", 0.1399], [\"92\", 0.1945], [\"96\", 0.1459], [\"99\", 0.158], [\"102\", 0.13069999999999998], [\"106\", 0.1581], [\"109\", 0.1398], [\"112\", 0.1185], [\"116\", 0.1003], [\"119\", 0.149], [\"122\", 0.1307], [\"126\", 0.1308], [\"129\", 0.14889999999999998], [\"132\", 0.0881], [\"136\", 0.10040000000000002], [\"139\", 0.1064], [\"142\", 0.10949999999999999], [\"146\", 0.12160000000000001], [\"149\", 0.1003], [\"152\", 0.11549999999999999], [\"156\", 0.0852], [\"159\", 0.1521], [\"163\", 0.079], [\"166\", 0.0852], [\"169\", 0.07], [\"173\", 0.0608], [\"176\", 0.0731], [\"179\", 0.0669], [\"183\", 0.073], [\"186\", 0.07289999999999999], [\"189\", 0.0669], [\"193\", 0.07300000000000001], [\"196\", 0.1154], [\"199\", 0.0608], [\"203\", 0.07], [\"206\", 0.08209999999999999], [\"209\", 0.0456], [\"213\", 0.0669], [\"216\", 0.0821], [\"219\", 0.0395], [\"223\", 0.0578], [\"226\", 0.10650000000000001], [\"230\", 0.048600000000000004], [\"233\", 0.0761], [\"236\", 0.0335], [\"240\", 0.057699999999999994], [\"243\", 0.1033], [\"246\", 0.0486], [\"250\", 0.0516], [\"253\", 0.0274], [\"256\", 0.0547], [\"260\", 0.042499999999999996], [\"263\", 0.079], [\"266\", 0.0426], [\"270\", 0.048600000000000004], [\"273\", 0.0426], [\"276\", 0.0456], [\"280\", 0.0273], [\"283\", 0.057800000000000004], [\"286\", 0.0335], [\"290\", 0.0274]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16100\", 0.0091], [\"16200\", 0.0213], [\"16300\", 0.1764], [\"16400\", 2.5602], [\"16500\", 19.9678], [\"16600\", 33.7357], [\"16700\", 33.085]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n ans, path = [], []\n def backtrack(total, start_index):\n if total > target:\n return\n \n if total == target:\n ans.append(path[:])\n return\n \n for i in range(start_index, len(candidates)):\n if total + candidates[i] > target:\n break\n \n total += candidates[i]\n path.append(candidates[i])\n backtrack(total, i)\n total -= candidates[i]\n path.pop()\n candidates.sort()\n backtrack(0, 0)\n return ans\n","runtime":"25"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n result = []\n stack = [([], 0, 0)]\n \n while stack:\n current_combination, current_sum, start = stack.pop()\n \n if current_sum == target:\n result.append(current_combination)\n continue\n \n for i in range(start, len(candidates)):\n if current_sum + candidates[i] <= target:\n stack.append((current_combination + [candidates[i]], \n current_sum + candidates[i], \n i))\n \n return result","runtime":"25"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n #backtrack\n # Time:O(2^target); Space:O(target)\n res = []\n candidates.sort()\n n = len(candidates)\n\n def backtrack(idx, path, remain):\n if remain == 0:\n res.append(path[:])\n \n for i in range(idx, n):\n if candidates[i] > remain:\n return\n\n path.append(candidates[i])\n backtrack(i, path, remain-candidates[i])\n path.pop()\n \n backtrack(0, [], target)\n return res\n\n ","runtime":"29"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res, stack = [], [(0, [], 0)]\n while stack:\n sm, tmp, r = stack.pop()\n for i in range(r, len(candidates)):\n if sm + candidates[i] < target: \n stack.append((sm + candidates[i], tmp + [candidates[i]], i))\n elif sm + candidates[i] == target: \n res.append(tmp + [candidates[i]])\n return res","runtime":"29"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n n = len(candidates)\n def backtrack(cur, i, target):\n if target == 0:\n res.append(list(cur))\n return \n if i == n or target < 0:\n return\n \n for j in range(i, n):\n cur.append(candidates[j])\n backtrack(cur, j, target - candidates[j])\n cur.pop()\n backtrack([], 0, target)\n return res","runtime":"32"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combinations: List[List[int]] = []\n comb: List[int] = []\n\n def backtrack(_sum: int, start: int):\n if _sum == target:\n combinations.append(comb[:])\n return\n elif _sum > target:\n return\n\n for i in range(start, len(candidates)):\n comb.append(candidates[i])\n backtrack(_sum + candidates[i], i)\n comb.pop()\n\n backtrack(0, 0)\n return combinations\n","runtime":"32"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n def helper(nums,target,i,cur):\n if i < 0 or i>= len(nums):\n return []\n if target == nums[i]:\n return [cur+[nums[i]]] + helper(nums,target,i+1,cur)\n if target >= nums[i]:\n return helper(nums,target-nums[i],i,cur+[nums[i]]) + helper(nums,target,i+1,cur)\n else:\n return helper(nums,target,i+1,cur)\n return helper(candidates,target,0,[])","runtime":"35"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n res = []\n\n # sort candidates so that if one is already too big we don't go trying the rest of them\n candidates.sort()\n\n def backtrack(start, cur_sum, comb):\n\n if cur_sum > target:\n return\n\n if cur_sum == target:\n res.append(comb[:])\n return\n\n for i in range(start,len(candidates)):\n\n if cur_sum + candidates[i] <= target:\n comb.append(candidates[i])\n backtrack(i, cur_sum+candidates[i], comb)\n comb.pop()\n else:\n # us adding i would overshoot, we break out since all other candidates will also overshoot\n break\n\n backtrack(0, 0,[])\n return res","runtime":"35"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n def search(candidates: list[int], target: int, last: int) -> list[list[int]]:\n comb_list = [] # list of combinations that sum to target\n for c in candidates:\n if c > last: # prevent duplicates, descending chosen numbers\n break\n if c > target: # no possible combination\n break\n if c == target: # form a combination\n comb_list.append([c])\n else: # recursively search for combinations w/ smaller target\n found = search(candidates, target - c, c)\n comb_list += [[c] + combination for combination in found]\n \n return comb_list\n\n return search(candidates, target, candidates[-1])\n","runtime":"39"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]: \n res = []\n def backtrack(arr, start, s):\n nonlocal res\n\n if s == target:\n res.append(arr.copy())\n else:\n for i in range(start, len(candidates)):\n n = candidates[i]\n if s+n <= target:\n arr.append(n)\n backtrack(arr, i, s+n)\n arr.pop()\n \n backtrack([], 0, 0)\n \n return res","runtime":"39"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n ds = []\n def findCombination(idx, target):\n if idx == len(candidates):\n if target == 0:\n ans.append(ds[:])\n return\n if candidates[idx]<=target:\n ds.append(candidates[idx])\n findCombination(idx, target-candidates[idx])\n ds.pop()\n findCombination(idx+1, target)\n findCombination(0, target)\n return ans\n ","runtime":"42"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n\n def backtrack(nums, target, ind, temp):\n if target==0:\n ans.append(temp)\n return\n \n for i in range(ind,len(nums)):\n if nums[i]>target:\n continue\n backtrack(nums, target-nums[i], i, temp+[nums[i]])\n \n backtrack(candidates,target,0,[])\n return ans\n ","runtime":"42"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n ans =[]\n self.combinations(0,candidates,target,[],ans)\n return ans\n def combinations(self,index,arr,target,l,ans):\n if index>=len(arr):\n if target==0:\n ans += [l.copy()]\n return\n else:\n if target>=arr[index]:\n l +=[arr[index]]\n self.combinations(index,arr,target-arr[index],l,ans)\n l.pop()\n self.combinations(index+1,arr,target,l,ans)\n\n ","runtime":"45"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result = []\n \n # Helper function to perform backtracking\n def backtrack(comb, start, remaining):\n if remaining == 0: # If we've hit the target, add the current combination to the result\n result.append(list(comb))\n return\n elif remaining < 0: # If we've exceeded the target, stop this path\n return\n # Loop through candidates starting from 'start' index\n for i in range(start, len(candidates)): \n comb.append(candidates[i]) # Choose the candidate\n backtrack(comb, i, remaining - candidates[i]) # Recursively explore further with the reduced target\n comb.pop() # Backtrack by removing the last element\n \n candidates.sort() # Optional: sort to optimize and avoid unnecessary exploration\n backtrack([], 0, target) # Initial call to the backtracking function\n return result\n","runtime":"45"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # basically a tree problem\n # recursive dfs, each right branch contains one less candidate\n # each branch to the left replenishes what was used\n # work on a subset at a time\n\n res = []\n subset = []\n\n def dfs(candidates, curSum):\n if not candidates or curSum > target:\n return\n\n if curSum == target:\n res.append(subset.copy())\n return\n\n curSum += candidates[0]\n subset.append(candidates[0])\n dfs(candidates, curSum)\n\n curSum -= subset.pop()\n dfs(candidates[1:], curSum)\n\n dfs(candidates, 0)\n return res\n\n","runtime":"49"},{"code":"import math\n\nclass Solution:\n\n def dfs(self, curr_idx, curr_target, curr_answer):\n # if too large, return\n if curr_target < 0:\n return\n elif curr_target == 0:\n self.answers.append(list(curr_answer))\n return\n elif curr_idx == len(self.candidates):\n return\n\n num = self.candidates[curr_idx]\n for i in range(curr_idx, len(self.candidates)):\n curr_answer.append(self.candidates[i])\n self.dfs(i, curr_target - self.candidates[i], curr_answer)\n curr_answer.pop()\n\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n self.answers = []\n self.candidates = candidates\n curr_answer = []\n self.dfs(0, target, curr_answer)\n return self.answers\n ","runtime":"49"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n \n def backtrack(start,curSum,sol):\n if curSum == target:\n res.append(sol[:])\n return\n if sum(sol) > target:\n return\n for i in range(start,len(candidates)):\n sol.append(candidates[i])\n backtrack(i,curSum+candidates[i],sol)\n sol.pop()\n backtrack(0,0,[])\n return res","runtime":"52"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n def dfs(i, s, comb):\n if s == 0:\n res.append(comb)\n return\n if s < 0:\n return\n for j in range(i, len(candidates)):\n dfs(j, s - candidates[j], comb + [candidates[j]])\n\n dfs(0, target, [])\n return res\n","runtime":"52"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n ans = []\n def backtrack(remain, combo, start):\n if remain == 0:\n ans.append(list(combo))\n return\n elif remain < 0:\n return\n \n for i in range(start, len(candidates)):\n combo.append(candidates[i])\n backtrack(remain - candidates[i], combo, i)\n combo.pop()\n \n backtrack(target, [], 0)\n return ans","runtime":"55"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n def dfs(i, cur, total):\n if total == target:\n res.append(cur.copy())\n return \n if i >= len(candidates) or total > target:\n return\n cur.append(candidates[i])\n dfs(i, cur, total + candidates[i])\n cur.pop()\n dfs(i + 1, cur, total)\n dfs(0, [], 0)\n return res","runtime":"55"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n \n def dfs(cur_sum, cur_i, cur_arr):\n if (cur_i >= len(candidates)) or (cur_sum < 0):\n return\n\n cur_num = candidates[cur_i]\n \n if (cur_sum == 0):\n res.append(cur_arr)\n return\n\n dfs(cur_sum-cur_num, cur_i, cur_arr + [cur_num])\n dfs(cur_sum, cur_i+1, cur_arr)\n return\n \n dfs(target, 0, [])\n\n return res","runtime":"59"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # Solution:\n # Recursion Tree, as you go from left to right, eliminate\n # The choice of including elements from the left in the combinations.\n # Use a pointer to track which elements to include (elements to the right of pointer)\n res = []\n def dfs(i, cur, total):\n if total == target:\n res.append(cur.copy())\n return\n if i >= len(candidates) or total > target:\n return\n dfs(i, cur + [candidates[i]], total + candidates[i])\n dfs(i+1, cur, total)\n dfs(0, [], 0)\n return res\n \n ","runtime":"59"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n def dfs(i, cur, total):\n if total == target:\n res.append(cur.copy())\n return\n if i >= len(candidates) or total > target:\n return\n\n cur.append(candidates[i])\n dfs(i, cur, total + candidates[i])\n cur.pop()\n dfs(i+1, cur, total)\n dfs(0, [], 0)\n return res","runtime":"62"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n def grow_solution(candidate: int, targets): \n \"\"\"\n :param canidate: canidate number being observed \n :param target: target needed to be achieved and path to current target \n \"\"\"\n grown_solution = [] \n valid_solution = [] \n\n for target in targets: \n target_value, target_path = target \n new_targets = []\n\n for num_factor in range(0, target_value//candidate+1): \n new_target_value = target_value - num_factor * candidate \n if new_target_value < 0: \n break\n new_target_path = target_path + num_factor * [candidate]\n new_targets.append([new_target_value, new_target_path])\n\n if len(new_targets) > 0 and new_targets[-1][0] == 0: \n valid_solution.append(new_targets.pop()[1])\n grown_solution.extend(new_targets)\n\n return valid_solution, grown_solution \n \n results = [] \n targets = [[target, []]]\n\n for candidate in candidates: \n valid_results, targets = grow_solution(candidate, targets) \n if valid_results: \n results.extend(valid_results) \n return results\n","runtime":"62"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n result = []\n targets = {}\n def comSum(target):\n print(\"target\", target)\n if target in targets:\n #print(f\"target {target} from cachen = {targets[target]}\")\n return targets[target]\n r = []\n for c in candidates:\n #print(f\"target={target} cand={c}\")\n if target<c:\n break\n elif target == c:\n r.append({c: 1}) #уникальная ее не надо вычищать\n break\n else:\n #print(f\"target={target} cand={c}, started...\")\n rc = comSum(target-c)\n #print(f\"target={target} cand={c}, rc = {rc}\")\n # добавим с к каждой комбинации\n for k in range(len(rc)):\n rck = rc[k].copy()\n if c not in rck:\n rck[c]=1\n else:\n rck[c]+=1\n for rx in r:\n if rx == rck:\n break\n else:\n r.append(rck)\n #print(f\"target={target} cand={c}, res = {r}\")\n #print(f\">! s({target})={r} -> cache\")\n targets[target] = r\n return r\n\n return [[key for key, value in d.items() for _ in range(value)] for d in comSum(target)]\n","runtime":"65"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n\n def search(curPath:List[int],curVal:int,index:int):\n if(curVal > target):\n return\n elif(curVal == target):\n answers.append(curPath)\n return\n \n for i in range(index,len(candidates)):\n search(curPath+[candidates[i]],curVal + candidates[i],i)\n answers = []\n search([],0,0)\n return answers","runtime":"65"},{"code":"import math\n\nclass Solution:\n\n def dfs(self, curr_idx, curr_target, curr_answer):\n # if too large, return\n if curr_target < 0:\n return\n elif curr_target == 0:\n self.answers.append(list(curr_answer))\n return\n elif curr_idx == len(self.candidates):\n return\n\n num = self.candidates[curr_idx]\n max_mult = int(curr_target / num)\n for mult in range(max_mult + 1): # can include 0 ... max_mult times\n prev_len = len(curr_answer)\n curr_answer.extend([num] * mult) \n self.dfs(curr_idx + 1, curr_target - mult * num, curr_answer)\n curr_answer = curr_answer[:prev_len]\n\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n self.answers = []\n self.candidates = candidates\n curr_answer = []\n self.dfs(0, target, curr_answer)\n return self.answers\n ","runtime":"69"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n #base case: sum(list) == target\n ans = []\n\n\n def recurse(l, index):\n if sum(l) > target:\n return\n if sum(l) == target:\n ans.append(l.copy()) \n return\n \n if index >= len(candidates):\n return\n \n l.append(candidates[index])\n recurse(l, index)\n l.pop()\n recurse(l, index + 1)\n \n return\n\n\n\n recurse([], 0)\n return ans","runtime":"69"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n min_v = min(candidates)\n n = len(candidates)\n if(target<min_v):\n return []\n r = [[] for _ in range(target+1)]\n r[min_v].append([min_v])\n print(r)\n\n for tar in range(min_v+1, target+1):\n for i in range(n):\n tar_tmp = tar - candidates[i]\n if(tar_tmp == 0):\n r[tar].append([candidates[i]])\n if(tar_tmp<0):\n continue\n prev_comb = r[tar_tmp]\n for pc in prev_comb:\n curr_comb = pc.copy()\n curr_comb.append(candidates[i])\n curr_comb.sort()\n if(not curr_comb in r[tar]):\n r[tar].append(curr_comb)\n print('target '+str(tar))\n \n print(r[tar])\n return r[target]\n\n\n ","runtime":"72"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n def backtrack(curr, idx):\n\n if sum(curr) == target:\n res.append(curr[:])\n return\n \n if idx >= len(candidates) or sum(curr) > target:\n return\n \n curr.append(candidates[idx])\n backtrack(curr, idx)\n curr.pop()\n backtrack(curr, idx + 1)\n\n return\n \n backtrack([], 0)\n\n return res","runtime":"72"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n subset = []\n\n def dfs(i):\n if sum(subset)==target:\n res.append(subset.copy())\n return \n elif sum(subset)>target or i>=len(candidates):\n return \n else:\n subset.append(candidates[i])\n dfs(i)\n subset.pop()\n dfs(i+1)\n \n dfs(0)\n return res","runtime":"75"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n subsetList = []\n subset = []\n\n def dfs(i, target):\n if sum(subset.copy()) == target:\n subsetList.append(subset.copy())\n return\n \n if i >= len(candidates) or sum(subset.copy()) > target:\n return\n \n subset.append(candidates[i])\n dfs(i, target)\n\n subset.pop()\n dfs(i + 1, target)\n\n dfs(0, target)\n return subsetList\n","runtime":"75"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n candidates.sort()\n\n result = []\n\n temp = []\n\n\n def recurse(candidates):\n\n # print(temp)\n\n if sum(temp) == target:\n result.append(temp[:])\n return\n\n elif sum(temp) > target or candidates == []:\n return\n\n temp.append(candidates[0])\n\n recurse(candidates)\n\n temp.pop()\n\n recurse(candidates[1:])\n\n\n recurse(candidates)\n\n return result","runtime":"79"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res=[]\n check=[]\n def backtrack(i,total):\n print(total)\n if total==target:\n res.append(check.copy())\n return\n if i>=len(candidates) or total>target:\n return \n check.append(candidates[i])\n # print(check)\n backtrack(i,total+candidates[i])\n check.pop()\n # print(check)\n backtrack(i+1,total)\n backtrack(0,0)\n return res\n\n","runtime":"79"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # output: a list of all unique combos where number sums to target\n # Same number may be chosen unlimited amt\n # Mapping: recursion/backtracking\n\n # Plan: \n # Base case 1: candidates sum is > target then return\n # If equal to target add to list\n # while target - current sum is divisible current ele add current ele\n # Recursively add element in next position\n\n def sumList(ls):\n s = 0\n for i in ls:\n s += i\n return s\n\n def backtrack(pos, cur):\n if pos >= len(candidates):\n return\n elif sumList(cur) > target:\n return\n elif sumList(cur) == target and cur not in res:\n res.append(cur[:])\n \n backtrack(pos, cur + [candidates[pos]])\n backtrack(pos + 1, cur)\n\n res = []\n\n backtrack(0, [])\n return res\n\n\n ## assert(combinationSum([2,3,6,7], 7))\n ## assert(combinationSum([2,3,5], 8))\n\n\n\n","runtime":"82"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n def hash_func(l):\n l.sort()\n return tuple(l)\n return tuple([len(l),sum(l),s])\n\n if min(candidates) > target: return []\n\n candi_set = set(candidates)\n \n result = [[target]] if target in candi_set else []\n\n hash_list = set()\n for i in candi_set: hash_list.add(hash_func([i]))\n\n current_list = [[i] for i in candi_set]\n \n has_new = True\n\n while has_new:\n has_new = False\n new_list = []\n for num in candi_set:\n for llist in current_list:\n tmp = llist + [num]\n tmp_sum = sum(tmp)\n hash_key = hash_func(tmp)\n #print(tmp,hash_key)\n if tmp_sum <= target and hash_key not in hash_list:\n hash_list.add(hash_key)\n has_new = True\n if tmp_sum == target: result.append(tmp)\n else: new_list.append(tmp)\n if has_new: current_list = new_list\n\n #print(current_list)\n #print(result)\n\n return result","runtime":"82"},{"code":"from collections import deque\n\nclass Solution:\n \"\"\"\n brute force: exponential\n combine all candidates, return ones that sum to target\n\n BFS:\n perform bfs adding each candidate to all candidates, \n stop when sum is greater than or equal to target\n\n optimized BFS:\n store combos you've checked already\n \"\"\"\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combos = []\n sums = {}\n bfs_queue = deque()\n\n new_candidates = []\n for x in candidates:\n if x == target:\n combos.append([x])\n elif x < target:\n x_tup = (x,)\n sums[x_tup] = x\n bfs_queue.append(x_tup)\n new_candidates.append(x)\n\n while len(bfs_queue) > 0:\n combo = bfs_queue.popleft()\n combo_sum = sums[combo]\n for x in new_candidates:\n combo_with_x = tuple(sorted(combo + (x,)))\n new_sum = sums.get(combo_with_x)\n if new_sum is None:\n new_sum = combo_sum + x\n if new_sum == target:\n combos.append(list(combo_with_x))\n elif new_sum < target:\n bfs_queue.append(combo_with_x)\n sums[combo_with_x] = new_sum\n\n return combos","runtime":"85"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n output = []\n self.backtrack(0,candidates,[],0,target,output)\n return output\n def backtrack(self,index,candidates,path,summ,target,output):\n if summ>=target:\n print(target)\n print(path)\n if summ==target:\n print(summ)\n output.append(path.copy())\n return\n for i in range(index,len(candidates)):\n path.append(candidates[i])\n summ+=candidates[i]\n self.backtrack(i,candidates,path,summ,target,output)\n path.pop()\n summ-=candidates[i]\n\n\n\n\n \n ","runtime":"85"},{"code":"class Solution:\n\n def rec(self, cand, target):\n \n if len(cand) == 0:\n return [[]]\n\n if target < 1:\n return [[]]\n\n \n occ = target // cand[0]\n acc = []\n for i in range(occ + 1):\n lists = self.rec(cand[1:], target - i*cand[0])\n ex_lists = list(map(lambda x: [cand[0]]*(i) + x, lists))\n acc += ex_lists\n return acc\n\n\n\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates = sorted(candidates, reverse = True)\n result = self.rec(candidates, target)\n result = list(filter(lambda x: sum(x) == target, result))\n return result\n ","runtime":"89"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n stack = [(0,0,[])]\n visited = set()\n res = []\n candidates.sort()\n while stack:\n index, current_sum, current_array = stack.pop()\n if index >= len(candidates):\n continue\n current_sum += candidates[index]\n current_array.append(candidates[index])\n if tuple(current_array) in visited:\n continue\n visited.add(tuple(current_array))\n if current_sum == target:\n res.append(current_array)\n continue\n if current_sum > target:\n continue\n for i in range(index, len(candidates)):\n stack.append((i, current_sum, current_array.copy()))\n current_array.pop()\n stack.append((index+1, current_sum-candidates[index], current_array.copy()))\n return res","runtime":"89"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # backtracking: help function if remain=0, result append list(comb) and return, if remian<0, reutrn. \n # for loop from start to length, comb append i, recursion, com pop\n res = []\n def help(start = 0, comb = [], remain = target):\n if remain == 0:\n if sorted(comb) not in res:\n res.append(sorted(comb))\n return\n elif remain < 0:\n return\n for i in range(start, len(candidates)):\n comb.append(candidates[i])\n print(comb)\n help(i, comb, remain - candidates[i])\n comb.pop()\n help()\n return res\n ","runtime":"92"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n def combination(arr, sub, ans, i, target):\n \n if sum(sub) == target:\n ans.append(sub[:])\n return\n \n \n if sum(sub) > target or i >= len(arr):\n return\n\n \n sub.append(arr[i])\n combination(arr, sub, ans, i, target) \n \n sub.pop()\n combination(arr, sub, ans, i + 1, target) \n \n return ans\n\n print(combination(candidates, [], [], 0, target))\n return combination(candidates, [], [], 0, target)","runtime":"92"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n\n resultSet = []\n\n def backtrack(index, currentSet):\n currentSum = sum(currentSet)\n\n if currentSum == target:\n resultSet.append(currentSet.copy())\n return\n \n if currentSum > target:\n return\n \n if index >= len(candidates):\n return\n\n # currentSum < target:\n currentSet.append(candidates[index])\n print(currentSet)\n backtrack(index, currentSet)\n \n # back to the previous state\n currentSet.pop()\n backtrack(index + 1, currentSet)\n \n backtrack(0, [])\n return resultSet\n\n","runtime":"96"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res=[]\n def rec(i,sum,lst):\n print(lst,sum)\n\n if sum==target:\n res.append(lst.copy())\n return\n\n elif i>=len(candidates) or sum>target:\n return\n\n\n elif target-sum>=candidates[i]:\n sum+=candidates[i]\n lst.append(candidates[i])\n rec(i,sum,lst)\n lst.pop()\n sum-=candidates[i]\n \n rec(i+1,sum,lst)\n \n rec(0,0,[])\n return res","runtime":"96"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combos = []\n\n self.dfs(combos, candidates, target, [], 0, 0)\n\n return combos\n\n def dfs(self, combos, candidates, target, curr, summ, term):\n print(\"dfs\", curr, term)\n if term == len(candidates):\n return\n\n curr.append(candidates[term])\n summ += candidates[term]\n\n if summ == target:\n combos.append(curr.copy())\n elif summ < target:\n self.dfs(combos, candidates, target, curr, summ, term) \n \n curr.remove(candidates[term])\n summ -= candidates[term]\n self.dfs(combos, candidates, target, curr, summ, term + 1)\n","runtime":"99"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # sort candidates\n candidates.sort()\n \n results = []\n deq = deque([([], deque(candidates), target)])\n\n while deq:\n currN, currC, currT = deq.popleft()\n # print(currN, currC, currT)\n\n if currT == 0:\n results.append(currN)\n elif currT > 0 and currC:\n deq.append((currN + [currC[0]], currC, currT - currC[0]))\n temp = deque(currC)\n temp.popleft()\n deq.append((currN, temp, currT)) \n \n return results\n\n","runtime":"99"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = set()\n\n def dfs(ind, summ, s, target, n):\n # base case \n if summ > target:\n return \n if summ == target:\n ans.add(tuple(s[::]))\n return \n if ind >= n: return \n\n # pick and again pick\n summ += candidates[ind]\n s.append(candidates[ind])\n dfs(ind, summ, s, target, n)\n # backtrack\n # summ -= s.pop()\n # pick and pick next \n dfs(ind + 1, summ, s, target, n)\n # backtrack \n summ -= s.pop()\n dfs(ind + 1, summ, s, target, n)\n \n dfs(0, 0, [], target, len(candidates))\n\n return ans \n \n\n","runtime":"102"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n sol = []\n n = len(candidates)\n\n def Backtrack(i):\n if sum(sol) == target:\n res.append(sol[:])\n return \n \n for i in range(i,n):\n if sum(sol) <= target:\n print(sum(sol))\n sol.append(candidates[i])\n Backtrack(i)\n sol.pop()\n \n Backtrack(0)\n return res \n\n\n \n\n\n\n\n\n\n\n","runtime":"102"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = set()\n\n def rec(subset, i, curr_sum):\n if curr_sum == target:\n res.add(tuple(subset.copy()))\n return\n\n elif curr_sum > target:\n return\n\n for n in range(i, len(candidates)):\n subset.append(candidates[n])\n rec(subset, n, curr_sum + candidates[n])\n rec(subset, n+1, curr_sum + candidates[n])\n subset.pop()\n \n\n rec([], 0, 0)\n return res","runtime":"106"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n subset = []\n def dfs(i, currSet, total):\n print(currSet)\n if total == target:\n res.append(currSet.copy())\n return\n elif total > target or i >= len(candidates):\n return\n \n currSet.append(candidates[i])\n dfs(i, currSet, total+candidates[i])\n currSet.pop()\n dfs(i+1, currSet, total)\n dfs(0, [], 0)\n return res\n \n\n ","runtime":"106"},{"code":"class Solution:\n\n def __init__(self):\n self.result = []\n\n def get_sequence(self, index, arr, candidates, target):\n print(f\"index: {index}, arr: {arr}, target: {target}\")\n if index >= len(candidates):\n if 0 == target:\n print(f\"target arr: {arr}\")\n self.result.append(arr[:])\n return\n if target-candidates[index]>=0:\n arr.append(candidates[index])\n self.get_sequence(index, arr, candidates, target-candidates[index])\n arr.pop()\n self.get_sequence(index+1, arr, candidates, target)\n\n\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n self.get_sequence(0, [], candidates, target)\n return self.result\n ","runtime":"109"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result = []\n\n def dfs(index, subset, total):\n if total > target:\n return\n if index >= len(candidates):\n if total == target:\n if not result or result and subset not in result:\n result.append(subset.copy())\n return\n # include index\n candidate = candidates[index]\n subset.append(candidate)\n dfs(index + 1, subset, total + candidate)\n # include index again\n dfs(index, subset, total + candidate)\n subset.pop()\n # do not include index\n dfs(index + 1, subset, total)\n dfs(0, [], 0)\n return result\n ","runtime":"109"},{"code":"from copy import deepcopy\nfrom math import ceil\n\nclass Solution:\n\n def recur(self, candidates, target, comb, idx):\n if target < 0:\n return []\n if target == 0:\n return [deepcopy(comb)]\n if idx < 0:\n return []\n res = self.recur(candidates, target, comb, idx - 1)\n recur_target = target\n recur_comb = deepcopy(comb)\n while recur_target > 0:\n recur_target -= candidates[idx]\n recur_comb.append(candidates[idx])\n res.extend(self.recur(candidates, recur_target, recur_comb, idx - 1))\n return res\n\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n return self.recur(candidates, target, [], len(candidates) - 1)","runtime":"112"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n temp = []\n\n def dfs(i, total, res):\n print(temp)\n if total == target:\n res.append(temp.copy())\n return\n if i >= len(candidates) or total > target:\n return\n temp.append(candidates[i])\n dfs(i,total + candidates[i], res)\n\n temp.pop()\n dfs(i+1, total, res)\n\n\n dfs(0, 0, res) \n return res","runtime":"119"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = set()\n candidates.sort()\n\n def helper(current, path):\n if current == 0:\n res.add(tuple(sorted(path)))\n return\n if current < 0:\n return\n for c in candidates:\n if c <= current:\n helper(current - c, path + [c])\n else:\n break\n \n helper(target, [])\n return res","runtime":"119"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n def backtrack(i, arr, summ):\n print(arr)\n if (summ) == target:\n res.append(arr.copy())\n return \n \n if i >= len(candidates) or summ > target:\n return\n \n arr.append(candidates[i])\n \n backtrack(i, arr, summ + candidates[i])\n arr.pop(-1)\n backtrack(i + 1, arr, summ)\n backtrack(0, [], 0)\n return res\n\n","runtime":"122"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n res = []\n substack = []\n def dfs(i):\n \n if sum(substack) > target or i < 0:\n return\n if sum(substack) == target:\n if substack not in res:\n res.append(substack.copy())\n return\n substack.append(candidates[i])\n dfs(i)\n dfs(i-1)\n substack.pop(-1)\n dfs(i-1)\n return\n dfs(len(candidates)-1)\n return res\n\n","runtime":"122"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n results = set()\n candidates.sort()\n\n def aux(current_list, current_target):\n if current_target == 0:\n results.add(tuple(sorted(current_list)))\n return\n for candidate in candidates:\n if current_target - candidate < 0:\n return\n current_list.append(candidate)\n aux(current_list, current_target - candidate)\n current_list.pop()\n \n aux([], target)\n\n return results","runtime":"126"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n\n def summer(index, array, curr_sum):\n if curr_sum > target or index >= len(candidates):\n return\n if curr_sum == target:\n if array not in ans:\n ans.append(array)\n else:\n temp_array = array.copy()\n summer(index + 1, temp_array, curr_sum)\n \n temp_array.append(candidates[index])\n curr_sum += candidates[index]\n\n summer(index, temp_array, curr_sum)\n summer(index + 1, temp_array, curr_sum)\n \n summer(0, [], 0)\n return ans","runtime":"126"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \"\"\"\n :type candidates: List[int]\n :type target: int\n :rtype: List[List[int]]\n \"\"\"\n res = []\n self.recur(candidates, target, [], 0, res, 0)\n return res\n def recur(self, candidates, target, curr_combination, curr_sum, res, curr_pos):\n if curr_sum == target:\n print(f\"{curr_sum} {curr_combination}\")\n res.append(curr_combination[:])\n return\n if curr_sum > target:\n return\n for i in range(curr_pos, len(candidates)):\n print(f\"before {curr_combination}\")\n curr_combination.append(candidates[i])\n self.recur(candidates, target, curr_combination, curr_sum + candidates[i], res, i)\n curr_combination.pop()\n print(f\"after {curr_combination}\")\n","runtime":"129"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n\n # edge case: empty list\n if len(candidates) == 0:\n return []\n result = []\n currentPath = []\n\n # we cant add numbers before index i, to avoid duplicates\n def dfsHelper(i):\n print(currentPath)\n # base case: current index out of range or the current combination sum > target\n if len(candidates) <= i or sum(currentPath) > target:\n return\n # found a valid combo\n if sum(currentPath) == target:\n print(\"found a result: \", currentPath)\n result.append(currentPath.copy())\n return\n\n # explore left and right paths\n currentPath.append(candidates[i]) # add i to left subtree\n dfsHelper(i) # dont increase i, since left subtree may continue adding the same value\n currentPath.pop() # dont add i to right subtree\n dfsHelper(i+1)\n\n dfsHelper(0)\n print(result)\n return result","runtime":"129"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n res = []\n substack = []\n def dfs(i):\n if sum(substack) > target or i < 0:\n return\n if sum(substack) == target:\n if substack not in res:\n res.append(substack.copy())\n return\n substack.append(candidates[i])\n dfs(i)\n dfs(i-1)\n substack.pop(-1)\n dfs(i-1)\n return\n dfs(len(candidates)-1)\n return res\n\n","runtime":"132"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n def sums(index, sum, subsequence):\n if sum > target:\n return\n if sum == target:\n result.add(tuple(subsequence))\n return\n if index == n:\n return\n\n sums(index, sum + candidates[index], subsequence + [candidates[index]])\n sums(index + 1, sum + candidates[index], subsequence + [candidates[index]])\n\n sums(index + 1, sum, subsequence)\n \n result = set()\n n = len(candidates)\n sums(0, 0, [])\n return result","runtime":"132"},{"code":"class Solution:\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\n ans = set()\n candidates.sort()\n def backtracking(pattern = []):\n current_sum = sum(pattern)\n if current_sum == target:\n ans.add(tuple(sorted(pattern)))\n return\n for num in candidates:\n if current_sum + num > target:\n break\n pattern.append(num)\n backtracking(pattern)\n pattern.pop()\n backtracking()\n return ans","runtime":"136"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n dp = [None]*(target+1)\n\n dp[0] = [[]]\n for i in range(target+1):\n if dp[i] is None:\n continue\n for num in candidates:\n if i+num > target:\n continue\n for comb in dp[i]:\n if dp[i+num] is None:\n dp[i+num] = []\n dp[i+num].append([num]+comb)\n\n if dp[target] is None:\n return []\n return set([tuple(sorted(x)) for x in dp[target]])","runtime":"136"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result, currentPath = [], []\n\n # we cant add numbers before index i, to avoid duplicates\n def dfsHelper(i):\n print(currentPath)\n # base case: current index out of range or the current combination sum > target\n if len(candidates) <= i or sum(currentPath) > target:\n return\n # found a valid combo\n if sum(currentPath) == target:\n print(\"found a result: \", currentPath)\n result.append(currentPath.copy()) # save a deep copy to the result array, so we dont overwrite the memory\n return\n\n # explore left and right paths\n currentPath.append(candidates[i]) # add i to left subtree\n dfsHelper(i) # dont increase i, since left subtree may continue adding the same value\n currentPath.pop() # dont add i to right subtree\n dfsHelper(i+1)\n\n dfsHelper(0)\n return result","runtime":"139"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidate=sorted(candidates)\n def backtrack(temlist,re,index,candidate,target):\n temlist.append(candidate[index])\n print(temlist)\n if target-sum(temlist)<0:\n temlist.remove(candidate[index])\n return \n elif (target-sum(temlist))==0:\n re.append(temlist.copy())\n temlist.remove(candidate[index])\n return \n for i in range(index,len(candidate)):\n backtrack(temlist,re,i,candidate,target)\n temlist.pop()\n \n re=[]\n temlist=[]\n for j in range(len(candidate)):\n backtrack(temlist,re,j,candidate,target)\n print(re)\n return re","runtime":"139"},{"code":"class Solution:\n # def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # input: candidates of distinct positive integers. target.\n # output: combination of arrays with sum == target.\n candidates.sort()\n def check(start, aim) -> List[List[int]]:\n # all combination_sum == aim with nums[start] in it.\n ans = []\n if start == len(candidates) or aim == 0: return ans\n i = 0\n while aim - candidates[start] * i >= 0:\n if aim == candidates[start] * i: ans.append([candidates[start]] * i)\n tmp = check(start + 1, aim - candidates[start] * i)\n if tmp:\n tmp = [[candidates[start]] * i + cand for cand in tmp]\n ans += tmp\n i += 1\n \n print(start, aim, ans)\n return ans\n result = []\n # for i in range(candidates):\n # result += check(i, target)\n return check(0, target)","runtime":"142"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n curSet = []\n combs = []\n def dfs(i, total):\n print(curSet, total)\n if total == target:\n combs.append(curSet.copy())\n return\n if total > target:\n return\n if i >= len(candidates):\n return\n\n # repeat same number\n curSet.append(candidates[i]) \n dfs(i, total + candidates[i])\n\n # go to next number\n num = curSet.pop()\n dfs(i + 1, total - num + candidates[i]) \n\n dfs(0, 0)\n return combs\n","runtime":"142"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n curSet = []\n combs = []\n def dfs(i, total):\n print(curSet, total)\n if total == target:\n combs.append(curSet.copy())\n return\n if total > target:\n return\n if i >= len(candidates):\n return\n\n # repeat same number\n curSet.append(candidates[i]) \n dfs(i, total + candidates[i])\n\n # go to next number\n curSet.pop()\n dfs(i + 1, total) \n\n dfs(0, 0)\n return combs\n","runtime":"146"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n visited = set()\n res = []\n def backtrack(cur):\n \n if tuple(sorted(cur)) in visited:\n return\n else:\n visited.add(tuple(sorted(cur)))\n if sum(cur) > target:\n return \n if sum(cur) == target and cur not in res:\n res.append(cur)\n for digit in candidates:\n tmp_cur = cur.copy()\n tmp_cur.append(digit)\n backtrack(tmp_cur)\n backtrack([])\n return res\n \n\n \n ","runtime":"146"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # Neetcode's solution\n # res = []\n\n # def dfs(i, curr, total):\n # if total==target:\n # res.append(curr.copy())\n # return\n # if i >= len(candidates) or total > target:\n # return # break out\n\n # curr.append(candidates[i])\n # dfs(i, curr, total + candidates[i])\n # curr.pop()\n # dfs(i+1, curr, total)\n \n # dfs(0, [], 0)\n # return res\n\n # check every single combination until it exceeds target\n # (almost brute-force)\n\n # backtracking function\n def backtrack(currList, startidx, targetlen, total):\n if total > target:\n return\n elif (total==target) & (len(currList)==targetlen):\n res.append(currList)\n return\n else:\n for i in range(startidx, len(candidates)):\n backtrack(currList + [candidates[i]], i, targetlen, total+candidates[i])\n\n maxlen = target // min(candidates) # max length of combos\n targetlen = 1\n res = []\n while(targetlen <= maxlen):\n backtrack([], 0, targetlen, 0)\n targetlen += 1\n\n return res","runtime":"149"},{"code":"import copy\n\nclass Solution:\n result = None\n target_global = None\n global_candidates = None\n\n def attempt(self, current_combination, index, sum):\n if sum > self.target_global:\n return\n if sum == self.target_global:\n self.result.append(current_combination)\n return\n for i in range(index, len(self.global_candidates)):\n new_comb = copy.deepcopy(current_combination)\n new_comb.append(self.global_candidates[i])\n self.attempt(new_comb, i, sum + self.global_candidates[i])\n\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n self.target_global = target\n self.result = []\n self.global_candidates = candidates\n self.attempt([], 0, 0)\n return self.result","runtime":"149"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # res\n # cur\n # i\n # total\n res = []\n def dfs(cur, i, total):\n print(cur, i, total)\n if i >= len(candidates) or total > target:\n return\n if total == target:\n res.append(cur.copy())\n return\n \n cur.append(candidates[i])\n dfs(cur, i, total + candidates[i])\n cur.pop()\n dfs(cur, i+1, total)\n dfs([], 0, 0)\n return res","runtime":"152"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n\n combinations = []\n\n def bt(comb, combSum, i):\n\n # If we find a combination that sums to target\n if combSum == target and comb not in combinations:\n combinations.append(comb[:])\n return\n\n # Out of bounds or combination sum is greater than target\n if i >= len(candidates) or combSum > target:\n return\n \n # Our decisions are:\n # Add nums[i] combination and then go to next value\n # Or add nums[i] and stay\n # Or skip nums[i]\n\n # Adding and going next\n comb.append(candidates[i])\n bt(comb, combSum + candidates[i], i + 1)\n\n # Adding and staying\n bt(comb, combSum + candidates[i], i)\n\n # Skip nums[i]\n comb.pop()\n bt(comb, combSum, i + 1)\n\n bt([], 0, 0)\n\n return combinations\n\n\n","runtime":"152"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n candidates.sort()\n\n def backtrack(arr, pos, tar):\n if tar == 0:\n res.append(arr.copy())\n if tar <= 0:\n return\n\n for i in range(pos, len(candidates)):\n arr.append(candidates[i])\n backtrack(arr, i, tar - candidates[i])\n backtrack(arr, i+1, tar - candidates[i])\n arr.pop()\n \n backtrack([], 0, target)\n arr = []\n check = set()\n for a in res:\n t = tuple(a)\n if not t in check:\n arr.append(a)\n check.add(t)\n return arr","runtime":"156"},{"code":"class Solution:\n def combinationSum(self, c: List[int], t: int) -> List[List[int]]:\n l=[]\n def fun(c,i,t,s,m):\n if(s==t):\n l.append(m)\n return 0\n if(s>t):\n return 0\n if(i>=len(c)):\n return 0\n a=m[:]\n a.append(c[i])\n b=m[:]\n b.append(c[i])\n fun(c,i,t,s+c[i],b)\n fun(c,i+1,t,s+c[i],a)\n fun(c,i+1,t,s,m)\n z=[]\n fun(c,0,t,0,z)\n p=[]\n for i in range(len(l)):\n if(l[i] not in p):\n p.append(l[i])\n return p\n","runtime":"156"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n out = []\n\n def combhelper(cands, csum, i):\n if csum == target: # Cands has reached target\n if cands not in out:\n out.append(cands)\n return\n elif i >= len(candidates) or csum > target: # Base case(s)\n return \n \n combhelper(cands + [candidates[i]], csum + candidates[i], i)\n combhelper(cands + [candidates[i]], csum + candidates[i], i+1)\n combhelper(cands, csum, i+1)\n \n\n combhelper([], 0, 0)\n return out","runtime":"159"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n def recurse(index, currSum, currNums):\n print(index, currSum, currNums)\n\n if currSum == target:\n res.append(currNums.copy())\n return\n\n if index >= len(candidates) or currSum > target:\n return\n\n currNums.append(candidates[index])\n recurse(index, currSum + candidates[index], currNums)\n currNums.pop()\n \n \n recurse(index+1, currSum, currNums)\n\n\n recurse(0, 0, [])\n return res\n ","runtime":"159"},{"code":"import copy\n\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combinations = []\n self.helper(candidates, target, combinations, [], 0)\n return combinations\n\n def helper(self, candidates, target, combinations, combination, sum):\n # print(candidates)\n if len(candidates) == 0: return\n if (sum == target):\n combinations.append(combination)\n return\n if (sum > target):\n return\n else: \n # include the current candidate and continue using it\n copy1 = copy.deepcopy(combination)\n copy1.append(candidates[0])\n self.helper(candidates[:len(candidates)], target, combinations, copy1, sum + candidates[0])\n # include the current candidate and don't continue using it\n # self.helper(candidates[1:len(candidates)], target, combinations, copy2, sum + candidates[0])\n # don't include the current candidate and dont continue using it\n self.helper(candidates[1:len(candidates)], target, combinations, combination, sum)","runtime":"163"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n res = []\n\n def make_combination(idx, comb, total):\n print(idx,comb,total)\n if total == target:\n res.append(comb[:])\n return\n \n if total > target or idx >= len(candidates):\n return\n \n comb.append(candidates[idx])\n make_combination(idx, comb, total + candidates[idx])\n comb.pop()\n make_combination(idx+1, comb, total)\n\n return res\n\n return make_combination(0, [], 0)","runtime":"163"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n results = []\n def recurse(i, sumSoFar = 0, choices=[], parentChoices = []):\n nonlocal results\n if(i>=len(candidates)): \n print(\"Exceeded Index Stopping\", sumSoFar, choices)\n return\n if(sumSoFar > target): \n print(\"Exceeded Sum Stopping\", sumSoFar, choices)\n return\n if(sumSoFar==target):\n print(\"RESULT\", sumSoFar, choices)\n print(\"PARENTS FOR ABOVE RESULT \", parentChoices)\n results.append(choices)\n return\n \n print(choices, sumSoFar)\n recurse(i, sumSoFar + candidates[i], choices + [candidates[i]], choices[:-1])\n recurse(i+1, sumSoFar, choices[:], choices[:-1])\n recurse(0, 0, [])\n return results\n","runtime":"166"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n def recurse(index, currSum, currNums):\n print(index, currSum, currNums)\n\n if currSum == target:\n res.append(currNums)\n return\n\n if index >= len(candidates) or currSum > target:\n return\n\n #currNums.append(candidates[index])\n recurse(index, currSum + candidates[index], currNums + [candidates[index]])\n #currNums.pop()\n \n \n recurse(index+1, currSum, currNums)\n\n\n recurse(0, 0, [])\n return res\n ","runtime":"166"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n path: list[int] = []\n answ: set[tuple[int]] = set()\n candidates.sort()\n n = len(candidates)\n def backtrack(i: int, cumSum: int) -> None:\n if cumSum == target:\n answ.add(tuple(path.copy()))\n return\n if cumSum > target:\n return\n if i == n:\n return\n path.append(candidates[i])\n backtrack(i+1, cumSum+candidates[i]) # Visit next with cumSum\n backtrack(i, cumSum+candidates[i]) # Visit same\n path.pop()\n backtrack(i+1, cumSum) # visit next without including current\n backtrack(0,0)\n return answ\n \n\n ","runtime":"169"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n existed = set()\n\n def backtrack(i, nums):\n if i == len(candidates) or sum(nums) > target:\n return\n\n if sum(nums) == target :\n if \".\".join([str(i) for i in nums]) in existed:\n return \n res.append(nums.copy())\n existed.add(\".\".join([str(i) for i in nums]))\n \n \n nums.append(candidates[i])\n backtrack(i, nums)\n backtrack(i + 1, nums)\n nums.pop()\n backtrack(i + 1, nums)\n return\n \n backtrack(0, [])\n return res","runtime":"169"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n def recurse(index, currSum, currNums):\n print(index, currSum, currNums)\n\n if currSum == target:\n res.append(currNums.copy())\n return\n\n if index >= len(candidates) or currSum > target:\n return\n\n #currNums.append(candidates[index])\n recurse(index, currSum + candidates[index], currNums + [candidates[index]])\n #currNums.pop()\n \n \n recurse(index+1, currSum, currNums)\n\n\n recurse(0, 0, [])\n return res\n ","runtime":"173"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n dp = [[] for _ in range(target + 1)]\n for t in range(candidates[0], target + 1):\n combos = []\n for c in candidates:\n if t - c < 0:\n break\n if t - c > 0 and dp[t - c]:\n combos += [sorted([c] + combo) for combo in dp[t - c]]\n if t - c == 0:\n combos.append([c])\n dp[t] = combos\n \n return [list(y) for y in set([tuple(x) for x in dp[target]])]\n \n # [2,3,6,7]\n # dp [,,[2],[3],[2,2],[2,3],,,]\n # t 2\n # t 3\n # t 4\n # t 5\n ","runtime":"173"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n\n def findCombinations(current,candidates,target,solutions):\n tempSum = sum(current) if current else 0\n if tempSum == target:\n solutions.append(current)\n return solutions\n if tempSum > target:\n return solutions \n\n for i in candidates:\n if tempSum + i > target:\n return solutions\n else:\n findCombinations(current + [i], candidates, target, solutions) \n return solutions \n\n solutions = findCombinations(list(), sorted(candidates), target, list()) \n solutions = list(map(sorted,solutions))\n \n return list(set(map(tuple,solutions)))\n\n\n","runtime":"176"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n results = []\n def recurse(i, sumSoFar = 0, choices=[], parentChoices = []):\n nonlocal results\n if(i>=len(candidates)): \n print(\"Exceeded Index Stopping\", sumSoFar, choices)\n return\n if(sumSoFar > target): \n print(\"Exceeded Sum Stopping\", sumSoFar, choices)\n return\n if(sumSoFar==target):\n print(\"RESULT\", sumSoFar, choices)\n print(\"PARENTS FOR ABOVE RESULT \", parentChoices)\n results.append(choices)\n return\n choices.append(candidates[i])\n newSum = sumSoFar + candidates[i]\n print(choices[:-1], sumSoFar)\n recurse(i, newSum, choices[:], choices[:-1])\n recurse(i+1, sumSoFar, choices[:-1], choices[:-1])\n recurse(0, 0, [])\n return results\n","runtime":"176"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combination = []\n result = []\n\n if len(candidates) == 0:\n return result\n\n def backtrack(i):\n # Condition \n sum_combination = sum(combination)\n print(f\"Sum: {sum_combination}\")\n \n if sum_combination > target:\n return\n\n if i == len(candidates):\n return\n\n if sum_combination == target:\n result.append(combination.copy())\n print(f\"**Result: {result}\")\n return\n\n \n\n print(f\"Combination: {combination}\")\n # Approach 1\n combination.append(candidates[i])\n backtrack(i)\n \n print(\"Popping\")\n # Approach 2\n combination.pop()\n backtrack(i+1)\n\n backtrack(0)\n return result","runtime":"179"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n bfs = [(target, [])]\n result = []\n candidates = sorted(candidates)\n\n while bfs:\n resid, hist = bfs.pop()\n\n for elem in candidates:\n new_resid = resid - elem\n \n if new_resid == 0:\n new_hist = hist[:]\n new_hist.append(elem)\n new_hist = sorted(new_hist)\n if new_hist not in result:\n result.append(new_hist)\n\n elif new_resid > 0:\n new_hist = hist[:]\n new_hist.append(elem)\n bfs.append((new_resid, new_hist))\n \n else:\n break\n \n return result\n","runtime":"179"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = self.helper(candidates, [], target)\n \n # Use a set to store unique combinations as tuples (sorted to ensure uniqueness)\n unique_combinations = set(tuple(sorted(comb)) for comb in ans)\n \n # Convert the set of tuples back to a list of lists\n return [list(combination) for combination in unique_combinations]\n\n def helper(self, nums, ans, target):\n if target == 0:\n return [ans]\n final = []\n for i in nums:\n if i <= target:\n final.extend(self.helper(nums, ans + [i], target - i))\n return final","runtime":"183"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combinations = []\n sol = []\n def helper(s: int, n: int) -> None:\n if n == len(candidates) or len(combinations) > 150:\n print(\"done\", n, len(candidates))\n return\n\n print(s, sol)\n if s == target:\n combinations.append(sol[:])\n print(\"found sol\")\n return\n elif s > target:\n print(\"over target\")\n return\n\n for i in range(n,len(candidates)):\n print(\"next\", \"sum=\", s, \"n=\", n, \"i=\", i)\n s += candidates[i]\n sol.append(candidates[i])\n helper(s, i)\n s -= sol.pop()\n \n helper(0, 0)\n return combinations\n\n \n ","runtime":"183"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n def comb(arr: List[int], candidates: List[int], target: int):\n if target == 0:\n list.sort(arr)\n if arr not in res:\n res.append(arr)\n return\n for i in candidates:\n if i <= target:\n \n comb(arr+[i], candidates, target - i)\n \n \n comb([],candidates,target)\n\n return res\n","runtime":"186"},{"code":"from copy import deepcopy\n\nclass Solution:\n\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n m = target + 1\n n = len(candidates) + 1\n memo = [[[] for j in range(n)] for i in range(m)]\n for i in range(1, m):\n for j in range(1, n):\n memo[i][j] = deepcopy(memo[i][j-1])\n if i == candidates[j-1]:\n memo[i][j].append([candidates[j-1]])\n curr_target = i - candidates[j-1]\n if curr_target > 0:\n for sub in memo[curr_target][j]:\n my_arr = deepcopy(sub)\n my_arr.append(candidates[j-1])\n memo[i][j].append(my_arr)\n return memo[-1][-1]\n\n","runtime":"186"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates = sorted(candidates)\n # print(candidates)\n result = []\n self.get_result(candidates, target, result, [])\n # Sort each sublist and use groupby to remove duplicates\n result = [next(g) for _, g in groupby(sorted(result, key=sorted), sorted)]\n return result\n\n def get_result(self, candidates, target, result, current):\n if target < 0:\n return\n if target == 0:\n result.append(current)\n return\n for item in candidates:\n if target - item >= 0:\n self.get_result(candidates, target-item, result, current + [item])\n else:\n break\n","runtime":"189"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n cand = SortedList(candidates)\n n = len(cand)\n dic = {}\n def check(t, i) -> List[List[int]]:\n print(t, i)\n # if t in dic: return dic[t]\n # if cand[i] == t: return [[t]]\n ans = []\n # for x in range(i + 1, n):\n for j in range(1, t // cand[i] + 1):\n first = [cand[i]] * j\n # print(first)\n if t - cand[i] * j > 1 and i + 1 < n:\n rest = check(t - cand[i] * j, i + 1)\n if rest:\n for item in rest:\n ans.append(first + item)\n elif t == cand[i] * j:\n ans.append(first)\n if i + 1 < n:\n rest = check(t, i + 1)\n for item in rest:\n ans.append(item)\n dic[t] = ans\n print(t, i, ans)\n return ans\n return check(target, 0)\n # [2 3 6 7], 7\n # [2] + ( 5, 1), [2, 2] + (3, 1), [2, 2, 2] + ( 1, 1),\n # [3] + (4, 2), [3, 3] + (1, 2)\n # ","runtime":"189"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n s = set()\n total = []\n candidates.sort()\n def helper(path, cursum):\n spath = sorted(path)\n tpath = tuple(spath)\n if cursum == target and tpath not in s:\n s.add(tpath)\n total.append(spath)\n return\n for i in range(len(candidates)):\n if candidates[i] + cursum <= target:\n path.append(candidates[i])\n helper(path, candidates[i] + cursum)\n path.pop()\n else:\n break\n helper([], 0)\n return total","runtime":"193"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # check every single combination until it exceeds target\n # (almost brute-force)\n\n # backtracking function\n def backtrack(currList, startidx, targetlen):\n sumlist = sum(currList)\n if sumlist > target:\n return\n elif (sumlist==target) & (len(currList)==targetlen):\n res.append(currList)\n return\n else:\n for i in range(startidx, len(candidates)):\n backtrack(currList + [candidates[i]], i, targetlen)\n\n maxlen = target // min(candidates) # max length of combos\n targetlen = 1\n res = []\n while(targetlen <= maxlen):\n backtrack([], 0, targetlen)\n targetlen += 1\n\n return res","runtime":"193"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # check every single combination until it exceeds target\n # (almost brute-force)\n\n # backtracking function\n def backtrack(currList, startidx, targetlen):\n sumlist = sum(currList)\n if sumlist > target:\n return\n elif (sumlist==target) & (len(currList)==targetlen):\n res.append(currList)\n return\n else:\n for i in range(startidx, len(candidates)):\n backtrack(currList + [candidates[i]], i, targetlen)\n\n maxlen = target // min(candidates) # max length of combos\n targetlen = 1\n res = []\n while(targetlen <= maxlen):\n backtrack([], 0, targetlen)\n targetlen += 1\n\n return res","runtime":"196"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]: \n to_traverse = [-target]\n heapq.heapify(to_traverse)\n\n traversed = {0}\n \n hmap = defaultdict(list)\n hmap[target] = [[]]\n\n while to_traverse:\n current = -heapq.heappop(to_traverse)\n sequences = hmap[current]\n\n if current <= 0:\n return hmap[0]\n\n for cand in candidates:\n sub = current - cand\n \n if sub not in traversed:\n traversed.add(sub)\n heapq.heappush(to_traverse, -sub)\n \n for seq in sequences:\n copy = seq.copy()\n copy.append(cand)\n copy.sort()\n if copy not in hmap[sub]:\n hmap[sub].append(copy)\n \n return []\n ","runtime":"196"},{"code":"from collections import Counter\n\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n output = set()\n candidates = sorted(candidates)\n\n def helper(target: int, prefix: List[int]):\n if target == 0:\n combination = \" \".join([str(e) for e in sorted(prefix)])\n output.add(combination)\n\n for candidate in candidates:\n if candidate > target:\n break\n\n helper(target - candidate, prefix + [candidate])\n\n return\n\n helper(target, [])\n\n\n return [[int(e) for e in combination.split(\" \")] for combination in output]\n\n\n ","runtime":"199"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n def dfs(i):\n if i >= len(candidates) or sum(subset) >= target:\n if sum(subset) == target and tuple(sorted(subset.copy())) not in added:\n res.append(subset.copy())\n added.add(tuple(sorted(subset.copy())))\n return\n \n subset.append(candidates[i])\n dfs(i)\n dfs(i + 1)\n subset.pop()\n dfs(i + 1)\n \n res = []\n added = set()\n subset = []\n dfs(0)\n return res","runtime":"199"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n def cSUM(candidates, target, L):\n SL = sum(L)\n if SL == target:\n return [tuple(L)]\n \n if SL > target or len(candidates) == 0:\n return []\n \n c = candidates[-1]\n \n x1 = cSUM(candidates[:-1], target, L + [c])\n x2 = cSUM(candidates[:-1], target, L)\n x3 = cSUM(candidates, target, L + [c])\n return(list(set(x1 + x2 + x3)))\n\n\n x = cSUM(candidates, target, [])\n return [list(e) for e in x]","runtime":"203"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n\n ans = []\n\n temp = []\n\n seen = {}\n\n candidates.sort()\n\n def seenTheList(tempList):\n key = \"\"\n for item in tempList:\n key += str(item) + \"_\"\n\n if key in seen:\n return True\n else:\n seen[key] = 1\n return False\n\n\n def dfs(index, left):\n if left<0 or index>=len(candidates):\n # this is not possible, back track\n return\n\n if left == 0:\n # we have found the answer, add to the final ans set\n if not seenTheList(temp.copy()):\n ans.append(temp.copy())\n return\n\n temp.append(candidates[index])\n dfs(index+1, left-candidates[index]) # take the current item and nove to next\n\n temp.pop()\n temp.append(candidates[index])\n dfs(index, left-candidates[index]) # take the current item and try the current item as well\n\n temp.pop()\n dfs(index+1, left) # take the current item and try the current item as well\n\n dfs(0,target)\n\n\n return ans\n\n\n\n ","runtime":"203"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n\n ans = []\n\n def dfs(arr, curr):\n\n if curr == target:\n new = arr.copy()\n new.sort()\n if new in ans:\n return \n ans.append(new)\n return\n \n for i in candidates:\n if curr + i <= target:\n arr.append(i)\n dfs(arr, curr + i)\n arr.pop()\n \n dfs([], 0)\n\n return ans\n\n\n ","runtime":"206"},{"code":"class Solution:\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\n candidates.sort()\n res=[]\n curr=[]\n def dfs(i, sum_so_far):\n if i >=len(candidates):\n return\n if sum_so_far==target:\n res.append(curr.copy())\n return\n if sum_so_far<=candidates[i]+target:\n curr.append(candidates[i])\n dfs(i, sum_so_far+candidates[i])\n curr.pop()\n dfs(i+1, sum_so_far)\n dfs(0, 0)\n return res\n \n","runtime":"206"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n l=[]\n if(target in candidates):\n l.append([target])\n for i in candidates:\n if(i<target):\n L=self.combinationSum(candidates,target-i)\n if(L!=[]):\n for j in L:\n b=j.copy()\n b.append(i)\n b.sort()\n if(b not in l):\n l.append(b)\n return l\n\n\n ","runtime":"209"},{"code":"class Solution:\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\n ans = set()\n def backtracking(pattern = []):\n current_sum = sum(pattern)\n if current_sum == target:\n ans.add(tuple(sorted(pattern)))\n return\n for num in candidates:\n if current_sum + num > target:\n continue\n pattern.append(num)\n backtracking(pattern)\n pattern.pop()\n backtracking()\n return ans","runtime":"209"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n\n n = len(candidates)\n res = []\n path = []\n def search(x,total):\n if not 0<=x<n or total>target or path in res:\n return\n if total == target:\n res.append(path.copy())\n return 1\n path.append(candidates[x])\n search(x,total+candidates[x]) \n search(x+1,total+candidates[x])\n path.pop()\n search(x+1,total)\n return \n\n search(0,0)\n return res\n ","runtime":"213"},{"code":"class Solution:\n def combinationSum(self, nums: List[int], target: int) -> List[List[int]]:\n combos = []\n current_combo = []\n\n def dfs(i):\n if i >= len(nums) or sum(current_combo) > target:\n if sum(current_combo) == target and current_combo not in combos:\n combos.append(current_combo.copy())\n return\n \n # Next number to add to curr combo\n current_combo.append(nums[i])\n dfs(i + 1)\n \n # Current number to be added again\n dfs(i)\n\n # Nothing added here and move on\n current_combo.pop()\n dfs(i + 1)\n\n dfs(0)\n return combos","runtime":"213"},{"code":"class Solution:\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\n candidates.sort()\n res=[]\n curr=[]\n def dfs(i, sum_so_far):\n if i >=len(candidates):\n return\n if sum_so_far==target:\n res.append(curr.copy())\n return\n if sum_so_far<=candidates[i]+target:\n curr.append(candidates[i])\n dfs(i, sum_so_far+candidates[i])\n curr.pop()\n dfs(i+1, sum_so_far)\n dfs(0, 0)\n return res\n \n","runtime":"216"},{"code":"\"\"\"\nkey design principles\n\nTo analyze the time complexity of the given code, we can break it down into several components and steps:\n\n1. Sorting the candidates list:\npython\nCopy code\ncandidates.sort()\nSorting the list of candidates takes \n\\U0001d442\n(\n\\U0001d45b\nlog\n\n\\U0001d45b\n)\nO(nlogn), where \n\\U0001d45b\nn is the number of elements in the candidates list.\n\n2. While Loop for Popping Candidates:\npython\nCopy code\nwhile candidates and candidates[-1] > target:\n candidates.pop(-1)\nThe worst case is when the loop removes all candidates greater than the target. If there are \n\\U0001d45b\nn candidates, in the worst case, this loop would iterate \n\\U0001d45b\nn times. Each pop() operation is \n\\U0001d442\n(\n1\n)\nO(1), so this loop is \n\\U0001d442\n(\n\\U0001d45b\n)\nO(n) in the worst case.\n\n3. Depth-First Search (DFS) Function:\nThe DFS function is where the main time complexity comes from.\n\nThe function recursively explores all combinations of candidates to find sums that match the target. Each recursive call adds one candidate to current_list and checks if the sum exceeds the target.\n\nSince for each element, there are two choices (to include or not), the DFS essentially generates all possible combinations, leading to an exponential number of recursive calls. The number of possible combinations is \n\\U0001d442\n(\n2\n\\U0001d45b\n)\nO(2 \nn\n ), where \n\\U0001d45b\nn is the number of candidates.\n\nWithin each DFS call:\n\nChecking the sum of current_list takes \n\\U0001d442\n(\n\\U0001d458\n)\nO(k), where \n\\U0001d458\nk is the size of the current_list.\n\nIn the worst case, the maximum depth of recursion is \n\\U0001d442\n(\n\\U0001d45b\n)\nO(n) (if every combination is checked).\n\nThe temp_list.sort() takes \n\\U0001d442\n(\n\\U0001d458\nlog\n\n\\U0001d458\n)\nO(klogk), and checking if temp_list not in answer can take \n\\U0001d442\n(\n\\U0001d45a\n)\nO(m), where \n\\U0001d45a\nm is the size of the answer list (growing as more combinations are found).\n\n4. Overall Time Complexity:\nThe DFS generates combinations exponentially, and checking/processing each combination involves operations like summing, sorting, and checking against the answer list, which incurs additional costs.\nThe time complexity is dominated by the DFS, and since we can potentially generate all subsets, the overall time complexity is exponential:\no(2^n*klogk)\n\\U0001d442\n(\n2\n\\U0001d45b\n⋅\n\\U0001d458\nlog\n\n\\U0001d458\n)\nO(2 \nn\n ⋅klogk)\nwhere \n\\U0001d45b\nn is the number of candidates, and \n\\U0001d458\nk is the size of each combination (bounded by \n\\U0001d45b\nn in the worst case).\n\nThis exponential complexity stems from the nature of generating combinations, which inherently grows quickly as the input size increases.\n\n\n\"\"\"\n\n\n\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n answer = []\n\n while candidates and candidates[-1] > target:\n candidates.pop(-1)\n if not candidates:\n return answer\n\n\n def dfs(self,candidates,target,current_list):\n\n for candidate in candidates:\n if candidate + sum(current_list) > target:\n return\n elif candidate + sum(current_list) == target:\n current_list.append(candidate)\n temp_list = []\n for num in current_list:\n temp_list.append(num)\n temp_list.sort()\n if temp_list not in answer:\n answer.append(temp_list)\n elif candidate + sum(current_list) < target:\n #current_list.append(candidate)\n dfs(self,candidates,target,current_list +[candidate])\n\n\n\n current_list = []\n dfs(self,candidates,target,current_list)\n\n return answer","runtime":"216"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n def backtrack(arr, cur, target, candidates, curSum):\n if curSum == target:\n cur = sorted(cur)\n if cur not in arr:\n arr.append(cur)\n elif curSum < target:\n for num in candidates:\n if curSum + num <= target:\n tmp = cur.copy()\n tmp.append(num)\n backtrack(arr, tmp, target, candidates, curSum + num)\n \n\n arr = []\n\n backtrack(arr, [], target, candidates, 0)\n \n return arr","runtime":"226"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n def search(candidates: list[int], target: int) -> list[list[int]]:\n comb_list = [] # list of combinations that sum to target\n for c in candidates:\n if c > target:\n break\n if c == target: # form a combination\n comb_list.append([c])\n else: # recursively search for combinations w/ smaller target\n found = search(candidates, target - c)\n comb_list += [[c] + combination for combination in found]\n \n return comb_list\n\n # remove duplicate entries\n return list(set(tuple(sorted(c)) for c in search(candidates, target)))\n","runtime":"226"},{"code":"import numpy as np\n\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result = []\n\n def make_target (candidates, target, addends_so_far):\n if (target - candidates[0] == 0):\n addends_so_far.append(candidates[0])\n result.append(np.copy(addends_so_far))\n addends_so_far.pop()\n\n if (target - candidates[0] > 0):\n addends_so_far.append(candidates[0])\n make_target(candidates, target - candidates[0], addends_so_far)\n addends_so_far.pop()\n\n if len(candidates) > 1:\n make_target(candidates[1:], target, addends_so_far)\n\n make_target(candidates, target, [])\n\n return result\n ","runtime":"230"},{"code":"\nclass Solution:\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\n # dynamic programming\n # dp[i] = sum target = i\n dp = [0] * (target + 1)\n\n res = []\n\n def backtrack(left_target, path):\n nonlocal res\n if left_target == 0 and path not in res:\n res.append(path)\n return None\n\n for c in candidates:\n if left_target >= c:\n backtrack(left_target - c, sorted(path + [c]))\n\n \n backtrack(target, [])\n return res","runtime":"230"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # candidates.sort()\n # if target < candidates[0]:\n # return []\n \n # lo, hi = 0, len(candidates) - 1\n # while lo < hi:\n # idx = lo + (hi - lo) // 2\n # cand = candidates[idx]\n # if target < cand:\n # hi = idx - 1\n # elif target > cand:\n # lo = idx + 1\n # else:\n # while idx > 0 and candidates[idx-1] == target:\n # idx -= 1\n combinations = {}\n def loop(candidates, tgt):\n # print(list(candidates))\n if tgt < 2:\n return\n for c in candidates:\n if c == tgt:\n yield [c]\n if tgt - c < 2:\n continue\n for combination in loop(candidates, tgt - c):\n yield combination + [c]\n result = list(set(tuple(sorted(x)) for x in loop(candidates, target)))\n return result","runtime":"233"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n results = list()\n self.backtracking([], target, candidates, results)\n return results\n \n def backtracking(self, comb: list, target: int, candidates: list, results: list):\n sum_cands = sum(comb)\n if sum_cands == target:\n results.append(comb)\n return\n \n if not candidates or sum_cands > target:\n return\n\n past_num = candidates[0] - 1\n for i in range(len(candidates)):\n num = candidates[i]\n if num == past_num:\n continue\n print(num, candidates, comb)\n times = target // num\n for j in range(times):\n array = [num] * (j + 1)\n self.backtracking(comb + array, target, candidates[i + 1:], results)\n past_num = num","runtime":"233"},{"code":"\nclass Solution:\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\n # dynamic programming\n # dp[i] = sum target = i\n dp = [0] * (target + 1)\n\n res = []\n\n def backtrack(left_target, path):\n nonlocal res\n if left_target == 0 and path not in res:\n res.append(path)\n return None\n\n for c in candidates:\n if left_target >= c:\n backtrack(left_target - c, sorted(path + [c]))\n\n \n backtrack(target, [])\n return res","runtime":"236"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n queue = collections.deque()\n queue.append(([], 0))\n answered = {}\n answer = []\n while queue:\n currentList, currentSum = queue.popleft()\n if currentSum == target: \n hashThis = tuple(sorted(currentList))\n if hashThis not in answered:\n answer.append(currentList)\n answered[hashThis] = True\n continue\n for x in candidates:\n if currentSum + x > target:\n continue\n queue.append((currentList + [x], currentSum + x))\n return answer","runtime":"236"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result = set()\n self.helper(candidates, target, 0, [], result)\n return result\n \n def helper(self, candidates, target, index, slate, result):\n # Base Case\n if index == len(candidates): \n if sum(slate[:]) == target:\n if tuple(sorted(slate[:])) not in result:\n result.add(tuple(sorted(slate[:])))\n return\n \n # Pruning\n if sum(slate[:]) > target:\n return \n \n # Recursive Cases \n # Include \n slate.append(candidates[index])\n self.helper(candidates, target, index + 1, slate, result)\n slate.pop()\n # Same Character\n slate.append(candidates[index])\n self.helper(candidates, target, index, slate, result)\n slate.pop()\n # Exclude \n self.helper(candidates, target, index + 1, slate, result)\n ","runtime":"240"},{"code":"class Solution:\n def combinationSum(self, candidates, target):\n n, res = len(candidates), set()\n\n candidates.sort()\n\n def backtrack(i,path,total):\n if i == n:\n if total == target:\n res.add(tuple(sorted(path))) \n\n if total > target:\n return \n\n if i < n:\n path.append(candidates[i])\n backtrack(i+1,path,total+candidates[i])\n path.pop()\n\n if i < n:\n path.append(candidates[i])\n backtrack(i,path,total+candidates[i])\n path.pop()\n\n if i < n:\n backtrack(i+1,path,total)\n\n backtrack(0,[],0)\n return res","runtime":"240"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result = set()\n curr_result = []\n self.combinationSumInternal(target, candidates, result, curr_result)\n return result\n \n def combinationSumInternal(self, target, candidates, result, curr_result):\n if target == 0:\n result.add(tuple(sorted(curr_result)))\n \n for c in candidates:\n if target - c >= 0:\n curr_result.append(c)\n self.combinationSumInternal(target - c, candidates, result, curr_result)\n curr_result.pop()","runtime":"243"},{"code":"class Solution:\n def recur(self, i: int, comb: List[int]) -> None:\n curr_sum = sum(comb)\n if curr_sum == self.target and tuple(comb) not in self.combinations:\n self.combinations.add(tuple(comb))\n return\n \n if i >= self.n or curr_sum > self.target:\n return\n \n self.recur(i + 1, list(comb))\n comb.append(self.candidates[i])\n self.recur(i, list(comb))\n self.recur(i + 1, list(comb))\n\n \n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n self.target = target\n self.candidates = candidates\n self.n = len(candidates)\n self.combinations = set()\n\n self.recur(0, [])\n\n unique_combs = [list(t) for t in self.combinations]\n return unique_combs","runtime":"243"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n sortedCandidates = sorted(candidates)\n stack = []\n output = []\n def DFS(candidates, target):\n i = 0\n while(i < len(candidates) and candidates[i] <= target): #candidates will be sorted\n print(\"Stack, \", stack, \"\\nCandidates\", candidates, \"\\nCur Candidate\", candidates[i], \"\\nTarget\", target, \"\\nOutput\", output)\n if (candidates[i] == target):\n result = stack.copy()\n result.append(candidates[i])\n output.append(result)\n else:\n stack.append(candidates[i])\n DFS(candidates[i:], target - candidates[i])\n stack.pop()\n i += 1\n \n DFS(sortedCandidates, target)\n return output","runtime":"246"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result = set()\n curr_result = []\n self.combinationSumInternal(target, candidates, result, curr_result)\n return result\n \n def combinationSumInternal(self, target, candidates, result, curr_result):\n if target == 0:\n result.add(tuple(sorted(curr_result)))\n \n for c in candidates:\n if target - c >= 0:\n curr_result.append(c)\n self.combinationSumInternal(target - c, candidates, result, curr_result)\n curr_result.pop()","runtime":"246"},{"code":"class Solution:\n def combinationSum(self, nums: List[int], target: int) -> List[List[int]]:\n def dfs(i,lst):\n if sum(lst) == target:\n if sorted(lst) not in ans:\n ans.append(sorted(lst))\n return\n elif sum(lst) > target or i >= len(nums):\n return \n \n dfs(i,lst+[nums[i]])\n dfs(i+1,lst+[nums[i]])\n dfs(i+1,lst)\n \n ans = []\n dfs(0,[])\n return ans\n \n ","runtime":"250"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n results = []\n seen_combinations = set()\n combination = []\n\n def dfs(nums):\n if \" \".join(map(str, combination)) in seen_combinations:\n return\n if not nums:\n if sum(combination) == target:\n results.append(combination.copy())\n return\n counter = 0\n while sum(combination) <= target:\n combination.append(nums[0])\n dfs(nums[1:])\n counter += 1\n seen_combinations.add(\" \".join(map(str, combination)))\n\n for _ in range(counter):\n combination.pop()\n dfs(nums[1:])\n seen_combinations.add(\" \".join(map(str, combination)))\n\n\n dfs(candidates)\n unique_solutions = []\n for result in results:\n if result not in unique_solutions:\n unique_solutions.append(result)\n return unique_solutions\n","runtime":"250"},{"code":"import copy\n\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combinations = []\n # print(candidates[len(candidates) - 1 : len(candidates)])\n self.helper(candidates, target, combinations, [], 0)\n return combinations\n\n def helper(self, candidates, target, combinations, combination, sum):\n # print(candidates)\n if len(candidates) == 0: return\n if (sum == target):\n combinations.append(combination)\n return\n if (sum > target):\n return\n else: \n # include the current candidate and continue using it\n copy1 = copy.deepcopy(combination)\n copy1.append(candidates[0])\n copy2 = copy.deepcopy(combination)\n copy2.append(candidates[0])\n self.helper(candidates[:len(candidates)], target, combinations, copy1, sum + candidates[0])\n # include the current candidate and don't continue using it\n # self.helper(candidates[1:len(candidates)], target, combinations, copy2, sum + candidates[0])\n # don't include the current candidate and dont continue using it\n self.helper(candidates[1:len(candidates)], target, combinations, combination, sum)","runtime":"253"},{"code":"class Solution:\n \"\"\"\n [문제]\n - 유니크한 정수 배열 candidates\n - 타겟 넘버\n - 후보 숫자는 제한 없이 선택될 수 있다.\n - 후보 숫자 개수가 다르면, 다른 조합으로 간주한다.\n Q. candidates 내에서 유니크한 컴비네이션 리스트 반환\n 총합으로 타겟 넘버를 만들 수 있는...\n\n [인풋]\n - 후보 숫자 종류 : 최대 30\n - 후보 숫자 값 : 2 ~ 40\n - 타겟 : 1 ~ 40\n\n [아이디어]\n - 모든 경우 탐색해야지\n - 다만 target을 넘는 경우 바로 컷하면 된다.\n \"\"\"\n def __init__(self):\n self.for_dist = set()\n\n def combinationSum(self, cs: List[int], t: int) -> List[List[int]]:\n def search(cs: List[int], curr: int, t: int, cnt: List[int]):\n for idx, c in enumerate(cs):\n new_curr = curr + c\n if new_curr > t:\n continue\n new_cnt = cnt.copy()\n new_cnt[idx] += 1\n if new_curr == t:\n tuple_cnt = tuple(new_cnt)\n if tuple_cnt in self.for_dist:\n continue\n self.for_dist.add(tuple_cnt)\n continue\n search(cs, new_curr, t, new_cnt)\n \n cnt_init = [0 for _ in range(len(cs))]\n search(cs, 0, t, cnt_init)\n\n result = []\n for tuple_cnt in self.for_dist:\n curr_result = []\n for idx, cnt in enumerate(tuple_cnt):\n for _ in range(cnt):\n curr_result.append(cs[idx])\n result.append(curr_result)\n return result","runtime":"253"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result = set()\n curr_result = []\n self.combinationSumInternal(target, candidates, result, curr_result)\n return result\n \n def combinationSumInternal(self, target, candidates, result, curr_result):\n if target == 0:\n result.add(tuple(sorted(curr_result)))\n \n for c in candidates:\n if target - c >= 0:\n curr_result.append(c)\n self.combinationSumInternal(target - c, candidates, result, curr_result)\n curr_result.pop()","runtime":"256"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n\n res = []\n def search(candidates, target, chain):\n for i in candidates:\n sub = target - i\n if sub == 0:\n s = sorted(chain + [i])\n if s not in res:\n res.append(s)\n if sub > 0:\n chain.append(i)\n search(candidates, target - i, chain)\n chain.pop()\n\n \n \n\n search(candidates, target, [])\n\n return res","runtime":"256"},{"code":"from collections import deque\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combos = set()\n Q = deque([(target, [])])\n\n while Q:\n remaining, combo = Q.popleft()\n if remaining == 0:\n combo.sort()\n combos.add(tuple(combo))\n continue\n for num in candidates:\n if remaining - num < 0:\n continue\n Q.append((remaining - num, combo + [num]))\n\n return list(combos)","runtime":"260"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result= []\n \n def getSubsequnces(i, suma , nums, n, target):\n\n if sum(suma) == target:\n if suma not in result:\n result.append(suma)\n return\n if sum(suma) > target:\n return\n if i == n:\n return \n \n getSubsequnces(i+1, suma[:] + [nums[i]], nums, n, target)\n\n\n getSubsequnces(i+1, suma, nums, n, target)\n \n getSubsequnces(i, suma[:] + [nums[i]], nums, n, target)\n\n\n\n getSubsequnces(0, [], candidates, len(candidates), target)\n\n return result","runtime":"260"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n def signature(candidates):\n return tuple(sorted(candidates))\n res = []\n visited = set()\n stack = [([], 0)]\n while stack:\n tmp_solution, tot = stack.pop()\n if tot == target:\n sig = signature(tmp_solution) \n if signature(tmp_solution) not in visited:\n visited.add(sig)\n res.append(tmp_solution)\n for i in candidates:\n if i <= target - tot:\n stack.append((tmp_solution + [i], tot + i))\n \n return res\n","runtime":"263"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n for cand in candidates:\n diff = target - cand\n if (diff == 0):\n extended = [cand]\n if extended not in res:\n res.append(extended)\n\n elif (diff > 0):\n # recurse\n rec = self.combinationSum(candidates, diff)\n \n for r in rec:\n # r is like [3]\n #cr = copy.copy(r)\n r.extend([cand])\n r.sort()\n if r not in res:\n res.append(r)\n\n # just want unique elem - check\n return res","runtime":"263"},{"code":"from collections import deque\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combos = set()\n Q = deque([(target, ())])\n seen = set()\n\n while Q:\n remaining, combo = Q.pop()\n for num in candidates:\n if remaining - num < 0:\n continue\n new_combo = tuple(sorted(list(combo) + [num]))\n if remaining - num == 0:\n combos.add(new_combo)\n continue\n # if (remaining - num, new_combo) in seen:\n continue\n Q.append((remaining - num, new_combo))\n # seen.add((remaining - num, new_combo))\n\n return list(combos)","runtime":"266"},{"code":"from typing import List\nfrom collections import deque\n\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n\n queue = deque()\n queue.append((target, []))\n\n self.res = []\n\n while queue:\n remain, vals = queue.popleft()\n\n if remain == 0:\n self.res.append(vals)\n continue\n\n for n in candidates:\n if remain - n >= 0:\n vals.append(n)\n queue.append(\n (remain - n, vals.copy())\n )\n vals.pop()\n\n return list(map(\n list,\n set(\n tuple(sorted(option))\n for option in self.res\n )\n )\n )\n\n# candidates = [2,3,6,7]\n# target = 7\n\n# res = Solution().combinationSum(candidates, target)\n# print(res)","runtime":"266"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n global output\n output = []\n def make_combination(lis):\n val = target - sum(lis)\n if val in candidates:\n comb = lis + [val]\n comb.sort()\n if comb not in output:\n output.append(comb)\n\n poss = [can for can in candidates if can < val] \n\n for v in poss:\n new_lis = lis + [v]\n make_combination(new_lis)\n\n \n make_combination([])\n\n return(output) ","runtime":"270"},{"code":"class Solution:\n from collections import defaultdict\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n\n graph = defaultdict(list)\n stack = []\n for c in candidates:\n graph[c] = candidates\n stack.append( (c, c, [c] ) )\n \n\n \n res = []\n visited = set()\n while stack:\n\n node,summ,path = stack.pop()\n\n if summ == target and tuple(sorted(path)) not in visited:\n res.append(path)\n visited.add(tuple(sorted(path)))\n \n\n for neighbors in graph[node]:\n\n if (summ + neighbors) <= target:\n\n stack.append( (neighbors, summ + neighbors, path[:] + [neighbors]) )\n\n\n return res\n\n","runtime":"270"},{"code":"from collections import deque\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combos = set()\n Q = deque([(target, ())])\n seen = set()\n\n while Q:\n remaining, combo = Q.pop()\n for num in candidates:\n if remaining - num < 0:\n continue\n new_combo = tuple(sorted(list(combo) + [num]))\n if remaining - num == 0:\n combos.add(new_combo)\n continue\n # if (remaining - num, new_combo) in seen:\n continue\n Q.append((remaining - num, new_combo))\n # seen.add((remaining - num, new_combo))\n\n return list(combos)","runtime":"273"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n\n res = []\n def search(candidates, target, chain):\n for i in candidates:\n sub = target - i\n if sub == 0:\n s = sorted(chain + [i])\n if s not in res:\n res.append(s)\n if sub > 0:\n chain.append(i)\n search(candidates, target - i, chain)\n chain.remove(i)\n\n \n \n\n search(candidates, target, [])\n\n return res","runtime":"273"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n self.acc = []\n\n def helper(array):\n array_val = sum(array)\n if array_val == target:\n if sorted(array) not in self.acc:\n self.acc.append(sorted(array))\n\n if array_val < target:\n for c in candidates:\n if array_val + c <= target:\n new_array = copy.copy(array)\n new_array.append(c)\n helper(new_array)\n\n helper([])\n\n return self.acc\n","runtime":"276"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n result = []\n def findSum(curr, result):\n if curr == 0 and sorted(result) not in ans: \n ans.append(sorted(result[:]))\n\n for num in candidates:\n if curr - num >= 0:\n findSum(curr - num, result + [num])\n \n findSum(target, [])\n\n return ans","runtime":"276"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result = set()\n\n def dfs(i, sums, path, cache):\n if tuple(path) in cache:\n return\n if sums == target:\n result.add(tuple(sorted(path)))\n return\n if i == len(candidates):\n return\n for j in range(i, len(candidates)):\n if sums + candidates[j] <= target:\n dfs(j+1, sums + candidates[j], path + [candidates[j]], cache)\n cache.add(tuple(path + [candidates[j]]))\n \n temp = []\n for candidate in candidates:\n for _ in range(20):\n temp.append(candidate)\n candidates = temp\n dfs(0, 0, [], set())\n\n return result","runtime":"280"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n self.acc = []\n\n def helper(array):\n array_val = sum(array)\n if array_val == target:\n if sorted(array) not in self.acc:\n self.acc.append(sorted(array))\n\n if array_val < target:\n for c in candidates:\n if array_val + c <= target:\n new_array = copy.copy(array)\n new_array.append(c)\n helper(new_array)\n\n else:\n return\n\n helper([])\n\n return self.acc\n","runtime":"280"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n s = []\n for candidate in candidates:\n if candidate <= target:\n s.append((candidate, [candidate]))\n \n while s:\n cur, lst = s.pop()\n if cur == target:\n res.append(lst)\n continue\n\n for candidate in candidates:\n if cur + candidate <= target:\n s.append((cur + candidate, lst + [candidate]))\n\n res = [sorted(el) for el in res]\n m = {}\n for r in res:\n m[''.join([str(v) for v in r])] = r\n res = m.values()\n return res","runtime":"283"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n # res = []\n # def backtrack(comb, index, total):\n # if total == target:\n # res.append(comb[:])\n # return\n # if total > target or index == len(candidates):\n # return\n \n # backtrack(comb + [candidate[index]], index, total + candidate[index])\n # comb.pop()\n # backtrack(comb + [candidate[index+1]], index, total + candidate[index+1])\n # backtrack([],0,0)\n # return res\n \n \n \n \n \n \n \n \n \n \n \n \n # Stack approach, very slow\n res = []\n pos = []\n for cand in candidates:\n if cand == target:\n res.append([cand])\n pos.append(([cand], cand))\n while len(pos) != 0:\n elem = pos.pop()\n for cand in candidates:\n total = elem[1]+cand\n if total == target:\n finalArr = elem[0] + [cand]\n finalArr.sort()\n if finalArr not in res:\n res.append(finalArr)\n elif total < target:\n pos.append((elem[0] + [cand], total))\n return res\n \n","runtime":"283"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n results = []\n\n def dfs(combo):\n nonlocal target, results\n if combo:\n currSum = sum(combo)\n else:\n currSum = 0\n for candidate in candidates:\n if currSum + candidate == target:\n to_add = combo + [candidate]\n results.append(to_add)\n elif currSum + candidate > target:\n pass\n else:\n to_call = combo + [candidate]\n dfs(to_call)\n \n \n dfs([])\n results = [sorted(x) for x in results]\n to_return = []\n for x in results:\n if x not in to_return:\n to_return.append(x)\n\n return to_return\n","runtime":"286"},{"code":"from collections import deque\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n combos = set()\n Q = deque([(target, [])])\n\n while Q:\n remaining, combo = Q.popleft()\n if remaining == 0:\n combos.add(tuple(combo))\n continue\n for num in candidates:\n if remaining - num < 0:\n continue\n Q.append((remaining - num, sorted(combo + [num])))\n\n return list(combos)","runtime":"286"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n \n\n\n res = []\n current = []\n\n def dfs(index):\n\n if index == len(candidates) or sum(current) > target:\n return\n\n if current not in res and sum(current) == target:\n res.append(current.copy())\n\n \n current.append(candidates[index])\n dfs(index)\n dfs(index+1)\n\n current.pop(-1)\n dfs(index+1)\n\n dfs(0)\n\n return res\n","runtime":"290"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n bfs = [(target, [])]\n result = []\n\n while bfs:\n resid, hist = bfs.pop()\n\n for elem in candidates:\n new_resid = resid - elem\n \n if new_resid == 0:\n new_hist = hist[:]\n new_hist.append(elem)\n new_hist = sorted(new_hist)\n if new_hist not in result:\n result.append(new_hist)\n\n elif new_resid > 0:\n new_hist = hist[:]\n new_hist.append(elem)\n bfs.append((new_resid, new_hist))\n \n return result\n","runtime":"290"}],"string":"[\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans, path = [], []\\n def backtrack(total, start_index):\\n if total > target:\\n return\\n \\n if total == target:\\n ans.append(path[:])\\n return\\n \\n for i in range(start_index, len(candidates)):\\n if total + candidates[i] > target:\\n break\\n \\n total += candidates[i]\\n path.append(candidates[i])\\n backtrack(total, i)\\n total -= candidates[i]\\n path.pop()\\n candidates.sort()\\n backtrack(0, 0)\\n return ans\\n\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n result = []\\n stack = [([], 0, 0)]\\n \\n while stack:\\n current_combination, current_sum, start = stack.pop()\\n \\n if current_sum == target:\\n result.append(current_combination)\\n continue\\n \\n for i in range(start, len(candidates)):\\n if current_sum + candidates[i] <= target:\\n stack.append((current_combination + [candidates[i]], \\n current_sum + candidates[i], \\n i))\\n \\n return result\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n #backtrack\\n # Time:O(2^target); Space:O(target)\\n res = []\\n candidates.sort()\\n n = len(candidates)\\n\\n def backtrack(idx, path, remain):\\n if remain == 0:\\n res.append(path[:])\\n \\n for i in range(idx, n):\\n if candidates[i] > remain:\\n return\\n\\n path.append(candidates[i])\\n backtrack(i, path, remain-candidates[i])\\n path.pop()\\n \\n backtrack(0, [], target)\\n return res\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res, stack = [], [(0, [], 0)]\\n while stack:\\n sm, tmp, r = stack.pop()\\n for i in range(r, len(candidates)):\\n if sm + candidates[i] < target: \\n stack.append((sm + candidates[i], tmp + [candidates[i]], i))\\n elif sm + candidates[i] == target: \\n res.append(tmp + [candidates[i]])\\n return res\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n n = len(candidates)\\n def backtrack(cur, i, target):\\n if target == 0:\\n res.append(list(cur))\\n return \\n if i == n or target < 0:\\n return\\n \\n for j in range(i, n):\\n cur.append(candidates[j])\\n backtrack(cur, j, target - candidates[j])\\n cur.pop()\\n backtrack([], 0, target)\\n return res\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combinations: List[List[int]] = []\\n comb: List[int] = []\\n\\n def backtrack(_sum: int, start: int):\\n if _sum == target:\\n combinations.append(comb[:])\\n return\\n elif _sum > target:\\n return\\n\\n for i in range(start, len(candidates)):\\n comb.append(candidates[i])\\n backtrack(_sum + candidates[i], i)\\n comb.pop()\\n\\n backtrack(0, 0)\\n return combinations\\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n def helper(nums,target,i,cur):\\n if i < 0 or i>= len(nums):\\n return []\\n if target == nums[i]:\\n return [cur+[nums[i]]] + helper(nums,target,i+1,cur)\\n if target >= nums[i]:\\n return helper(nums,target-nums[i],i,cur+[nums[i]]) + helper(nums,target,i+1,cur)\\n else:\\n return helper(nums,target,i+1,cur)\\n return helper(candidates,target,0,[])\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n res = []\\n\\n # sort candidates so that if one is already too big we don't go trying the rest of them\\n candidates.sort()\\n\\n def backtrack(start, cur_sum, comb):\\n\\n if cur_sum > target:\\n return\\n\\n if cur_sum == target:\\n res.append(comb[:])\\n return\\n\\n for i in range(start,len(candidates)):\\n\\n if cur_sum + candidates[i] <= target:\\n comb.append(candidates[i])\\n backtrack(i, cur_sum+candidates[i], comb)\\n comb.pop()\\n else:\\n # us adding i would overshoot, we break out since all other candidates will also overshoot\\n break\\n\\n backtrack(0, 0,[])\\n return res\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n def search(candidates: list[int], target: int, last: int) -> list[list[int]]:\\n comb_list = [] # list of combinations that sum to target\\n for c in candidates:\\n if c > last: # prevent duplicates, descending chosen numbers\\n break\\n if c > target: # no possible combination\\n break\\n if c == target: # form a combination\\n comb_list.append([c])\\n else: # recursively search for combinations w/ smaller target\\n found = search(candidates, target - c, c)\\n comb_list += [[c] + combination for combination in found]\\n \\n return comb_list\\n\\n return search(candidates, target, candidates[-1])\\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]: \\n res = []\\n def backtrack(arr, start, s):\\n nonlocal res\\n\\n if s == target:\\n res.append(arr.copy())\\n else:\\n for i in range(start, len(candidates)):\\n n = candidates[i]\\n if s+n <= target:\\n arr.append(n)\\n backtrack(arr, i, s+n)\\n arr.pop()\\n \\n backtrack([], 0, 0)\\n \\n return res\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n ds = []\\n def findCombination(idx, target):\\n if idx == len(candidates):\\n if target == 0:\\n ans.append(ds[:])\\n return\\n if candidates[idx]<=target:\\n ds.append(candidates[idx])\\n findCombination(idx, target-candidates[idx])\\n ds.pop()\\n findCombination(idx+1, target)\\n findCombination(0, target)\\n return ans\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n\\n def backtrack(nums, target, ind, temp):\\n if target==0:\\n ans.append(temp)\\n return\\n \\n for i in range(ind,len(nums)):\\n if nums[i]>target:\\n continue\\n backtrack(nums, target-nums[i], i, temp+[nums[i]])\\n \\n backtrack(candidates,target,0,[])\\n return ans\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans =[]\\n self.combinations(0,candidates,target,[],ans)\\n return ans\\n def combinations(self,index,arr,target,l,ans):\\n if index>=len(arr):\\n if target==0:\\n ans += [l.copy()]\\n return\\n else:\\n if target>=arr[index]:\\n l +=[arr[index]]\\n self.combinations(index,arr,target-arr[index],l,ans)\\n l.pop()\\n self.combinations(index+1,arr,target,l,ans)\\n\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = []\\n \\n # Helper function to perform backtracking\\n def backtrack(comb, start, remaining):\\n if remaining == 0: # If we've hit the target, add the current combination to the result\\n result.append(list(comb))\\n return\\n elif remaining < 0: # If we've exceeded the target, stop this path\\n return\\n # Loop through candidates starting from 'start' index\\n for i in range(start, len(candidates)): \\n comb.append(candidates[i]) # Choose the candidate\\n backtrack(comb, i, remaining - candidates[i]) # Recursively explore further with the reduced target\\n comb.pop() # Backtrack by removing the last element\\n \\n candidates.sort() # Optional: sort to optimize and avoid unnecessary exploration\\n backtrack([], 0, target) # Initial call to the backtracking function\\n return result\\n\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # basically a tree problem\\n # recursive dfs, each right branch contains one less candidate\\n # each branch to the left replenishes what was used\\n # work on a subset at a time\\n\\n res = []\\n subset = []\\n\\n def dfs(candidates, curSum):\\n if not candidates or curSum > target:\\n return\\n\\n if curSum == target:\\n res.append(subset.copy())\\n return\\n\\n curSum += candidates[0]\\n subset.append(candidates[0])\\n dfs(candidates, curSum)\\n\\n curSum -= subset.pop()\\n dfs(candidates[1:], curSum)\\n\\n dfs(candidates, 0)\\n return res\\n\\n\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n\\n def dfs(self, curr_idx, curr_target, curr_answer):\\n # if too large, return\\n if curr_target < 0:\\n return\\n elif curr_target == 0:\\n self.answers.append(list(curr_answer))\\n return\\n elif curr_idx == len(self.candidates):\\n return\\n\\n num = self.candidates[curr_idx]\\n for i in range(curr_idx, len(self.candidates)):\\n curr_answer.append(self.candidates[i])\\n self.dfs(i, curr_target - self.candidates[i], curr_answer)\\n curr_answer.pop()\\n\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n self.answers = []\\n self.candidates = candidates\\n curr_answer = []\\n self.dfs(0, target, curr_answer)\\n return self.answers\\n \",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n \\n def backtrack(start,curSum,sol):\\n if curSum == target:\\n res.append(sol[:])\\n return\\n if sum(sol) > target:\\n return\\n for i in range(start,len(candidates)):\\n sol.append(candidates[i])\\n backtrack(i,curSum+candidates[i],sol)\\n sol.pop()\\n backtrack(0,0,[])\\n return res\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n def dfs(i, s, comb):\\n if s == 0:\\n res.append(comb)\\n return\\n if s < 0:\\n return\\n for j in range(i, len(candidates)):\\n dfs(j, s - candidates[j], comb + [candidates[j]])\\n\\n dfs(0, target, [])\\n return res\\n\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n ans = []\\n def backtrack(remain, combo, start):\\n if remain == 0:\\n ans.append(list(combo))\\n return\\n elif remain < 0:\\n return\\n \\n for i in range(start, len(candidates)):\\n combo.append(candidates[i])\\n backtrack(remain - candidates[i], combo, i)\\n combo.pop()\\n \\n backtrack(target, [], 0)\\n return ans\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n def dfs(i, cur, total):\\n if total == target:\\n res.append(cur.copy())\\n return \\n if i >= len(candidates) or total > target:\\n return\\n cur.append(candidates[i])\\n dfs(i, cur, total + candidates[i])\\n cur.pop()\\n dfs(i + 1, cur, total)\\n dfs(0, [], 0)\\n return res\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n \\n def dfs(cur_sum, cur_i, cur_arr):\\n if (cur_i >= len(candidates)) or (cur_sum < 0):\\n return\\n\\n cur_num = candidates[cur_i]\\n \\n if (cur_sum == 0):\\n res.append(cur_arr)\\n return\\n\\n dfs(cur_sum-cur_num, cur_i, cur_arr + [cur_num])\\n dfs(cur_sum, cur_i+1, cur_arr)\\n return\\n \\n dfs(target, 0, [])\\n\\n return res\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # Solution:\\n # Recursion Tree, as you go from left to right, eliminate\\n # The choice of including elements from the left in the combinations.\\n # Use a pointer to track which elements to include (elements to the right of pointer)\\n res = []\\n def dfs(i, cur, total):\\n if total == target:\\n res.append(cur.copy())\\n return\\n if i >= len(candidates) or total > target:\\n return\\n dfs(i, cur + [candidates[i]], total + candidates[i])\\n dfs(i+1, cur, total)\\n dfs(0, [], 0)\\n return res\\n \\n \",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n def dfs(i, cur, total):\\n if total == target:\\n res.append(cur.copy())\\n return\\n if i >= len(candidates) or total > target:\\n return\\n\\n cur.append(candidates[i])\\n dfs(i, cur, total + candidates[i])\\n cur.pop()\\n dfs(i+1, cur, total)\\n dfs(0, [], 0)\\n return res\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n def grow_solution(candidate: int, targets): \\n \\\"\\\"\\\"\\n :param canidate: canidate number being observed \\n :param target: target needed to be achieved and path to current target \\n \\\"\\\"\\\"\\n grown_solution = [] \\n valid_solution = [] \\n\\n for target in targets: \\n target_value, target_path = target \\n new_targets = []\\n\\n for num_factor in range(0, target_value//candidate+1): \\n new_target_value = target_value - num_factor * candidate \\n if new_target_value < 0: \\n break\\n new_target_path = target_path + num_factor * [candidate]\\n new_targets.append([new_target_value, new_target_path])\\n\\n if len(new_targets) > 0 and new_targets[-1][0] == 0: \\n valid_solution.append(new_targets.pop()[1])\\n grown_solution.extend(new_targets)\\n\\n return valid_solution, grown_solution \\n \\n results = [] \\n targets = [[target, []]]\\n\\n for candidate in candidates: \\n valid_results, targets = grow_solution(candidate, targets) \\n if valid_results: \\n results.extend(valid_results) \\n return results\\n\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n result = []\\n targets = {}\\n def comSum(target):\\n print(\\\"target\\\", target)\\n if target in targets:\\n #print(f\\\"target {target} from cachen = {targets[target]}\\\")\\n return targets[target]\\n r = []\\n for c in candidates:\\n #print(f\\\"target={target} cand={c}\\\")\\n if target<c:\\n break\\n elif target == c:\\n r.append({c: 1}) #уникальная ее не надо вычищать\\n break\\n else:\\n #print(f\\\"target={target} cand={c}, started...\\\")\\n rc = comSum(target-c)\\n #print(f\\\"target={target} cand={c}, rc = {rc}\\\")\\n # добавим с к каждой комбинации\\n for k in range(len(rc)):\\n rck = rc[k].copy()\\n if c not in rck:\\n rck[c]=1\\n else:\\n rck[c]+=1\\n for rx in r:\\n if rx == rck:\\n break\\n else:\\n r.append(rck)\\n #print(f\\\"target={target} cand={c}, res = {r}\\\")\\n #print(f\\\">! s({target})={r} -> cache\\\")\\n targets[target] = r\\n return r\\n\\n return [[key for key, value in d.items() for _ in range(value)] for d in comSum(target)]\\n\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n\\n def search(curPath:List[int],curVal:int,index:int):\\n if(curVal > target):\\n return\\n elif(curVal == target):\\n answers.append(curPath)\\n return\\n \\n for i in range(index,len(candidates)):\\n search(curPath+[candidates[i]],curVal + candidates[i],i)\\n answers = []\\n search([],0,0)\\n return answers\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n\\n def dfs(self, curr_idx, curr_target, curr_answer):\\n # if too large, return\\n if curr_target < 0:\\n return\\n elif curr_target == 0:\\n self.answers.append(list(curr_answer))\\n return\\n elif curr_idx == len(self.candidates):\\n return\\n\\n num = self.candidates[curr_idx]\\n max_mult = int(curr_target / num)\\n for mult in range(max_mult + 1): # can include 0 ... max_mult times\\n prev_len = len(curr_answer)\\n curr_answer.extend([num] * mult) \\n self.dfs(curr_idx + 1, curr_target - mult * num, curr_answer)\\n curr_answer = curr_answer[:prev_len]\\n\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n self.answers = []\\n self.candidates = candidates\\n curr_answer = []\\n self.dfs(0, target, curr_answer)\\n return self.answers\\n \",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n #base case: sum(list) == target\\n ans = []\\n\\n\\n def recurse(l, index):\\n if sum(l) > target:\\n return\\n if sum(l) == target:\\n ans.append(l.copy()) \\n return\\n \\n if index >= len(candidates):\\n return\\n \\n l.append(candidates[index])\\n recurse(l, index)\\n l.pop()\\n recurse(l, index + 1)\\n \\n return\\n\\n\\n\\n recurse([], 0)\\n return ans\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n min_v = min(candidates)\\n n = len(candidates)\\n if(target<min_v):\\n return []\\n r = [[] for _ in range(target+1)]\\n r[min_v].append([min_v])\\n print(r)\\n\\n for tar in range(min_v+1, target+1):\\n for i in range(n):\\n tar_tmp = tar - candidates[i]\\n if(tar_tmp == 0):\\n r[tar].append([candidates[i]])\\n if(tar_tmp<0):\\n continue\\n prev_comb = r[tar_tmp]\\n for pc in prev_comb:\\n curr_comb = pc.copy()\\n curr_comb.append(candidates[i])\\n curr_comb.sort()\\n if(not curr_comb in r[tar]):\\n r[tar].append(curr_comb)\\n print('target '+str(tar))\\n \\n print(r[tar])\\n return r[target]\\n\\n\\n \",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n def backtrack(curr, idx):\\n\\n if sum(curr) == target:\\n res.append(curr[:])\\n return\\n \\n if idx >= len(candidates) or sum(curr) > target:\\n return\\n \\n curr.append(candidates[idx])\\n backtrack(curr, idx)\\n curr.pop()\\n backtrack(curr, idx + 1)\\n\\n return\\n \\n backtrack([], 0)\\n\\n return res\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n subset = []\\n\\n def dfs(i):\\n if sum(subset)==target:\\n res.append(subset.copy())\\n return \\n elif sum(subset)>target or i>=len(candidates):\\n return \\n else:\\n subset.append(candidates[i])\\n dfs(i)\\n subset.pop()\\n dfs(i+1)\\n \\n dfs(0)\\n return res\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n subsetList = []\\n subset = []\\n\\n def dfs(i, target):\\n if sum(subset.copy()) == target:\\n subsetList.append(subset.copy())\\n return\\n \\n if i >= len(candidates) or sum(subset.copy()) > target:\\n return\\n \\n subset.append(candidates[i])\\n dfs(i, target)\\n\\n subset.pop()\\n dfs(i + 1, target)\\n\\n dfs(0, target)\\n return subsetList\\n\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n candidates.sort()\\n\\n result = []\\n\\n temp = []\\n\\n\\n def recurse(candidates):\\n\\n # print(temp)\\n\\n if sum(temp) == target:\\n result.append(temp[:])\\n return\\n\\n elif sum(temp) > target or candidates == []:\\n return\\n\\n temp.append(candidates[0])\\n\\n recurse(candidates)\\n\\n temp.pop()\\n\\n recurse(candidates[1:])\\n\\n\\n recurse(candidates)\\n\\n return result\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res=[]\\n check=[]\\n def backtrack(i,total):\\n print(total)\\n if total==target:\\n res.append(check.copy())\\n return\\n if i>=len(candidates) or total>target:\\n return \\n check.append(candidates[i])\\n # print(check)\\n backtrack(i,total+candidates[i])\\n check.pop()\\n # print(check)\\n backtrack(i+1,total)\\n backtrack(0,0)\\n return res\\n\\n\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # output: a list of all unique combos where number sums to target\\n # Same number may be chosen unlimited amt\\n # Mapping: recursion/backtracking\\n\\n # Plan: \\n # Base case 1: candidates sum is > target then return\\n # If equal to target add to list\\n # while target - current sum is divisible current ele add current ele\\n # Recursively add element in next position\\n\\n def sumList(ls):\\n s = 0\\n for i in ls:\\n s += i\\n return s\\n\\n def backtrack(pos, cur):\\n if pos >= len(candidates):\\n return\\n elif sumList(cur) > target:\\n return\\n elif sumList(cur) == target and cur not in res:\\n res.append(cur[:])\\n \\n backtrack(pos, cur + [candidates[pos]])\\n backtrack(pos + 1, cur)\\n\\n res = []\\n\\n backtrack(0, [])\\n return res\\n\\n\\n ## assert(combinationSum([2,3,6,7], 7))\\n ## assert(combinationSum([2,3,5], 8))\\n\\n\\n\\n\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n def hash_func(l):\\n l.sort()\\n return tuple(l)\\n return tuple([len(l),sum(l),s])\\n\\n if min(candidates) > target: return []\\n\\n candi_set = set(candidates)\\n \\n result = [[target]] if target in candi_set else []\\n\\n hash_list = set()\\n for i in candi_set: hash_list.add(hash_func([i]))\\n\\n current_list = [[i] for i in candi_set]\\n \\n has_new = True\\n\\n while has_new:\\n has_new = False\\n new_list = []\\n for num in candi_set:\\n for llist in current_list:\\n tmp = llist + [num]\\n tmp_sum = sum(tmp)\\n hash_key = hash_func(tmp)\\n #print(tmp,hash_key)\\n if tmp_sum <= target and hash_key not in hash_list:\\n hash_list.add(hash_key)\\n has_new = True\\n if tmp_sum == target: result.append(tmp)\\n else: new_list.append(tmp)\\n if has_new: current_list = new_list\\n\\n #print(current_list)\\n #print(result)\\n\\n return result\",\n \"runtime\": \"82\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n \\\"\\\"\\\"\\n brute force: exponential\\n combine all candidates, return ones that sum to target\\n\\n BFS:\\n perform bfs adding each candidate to all candidates, \\n stop when sum is greater than or equal to target\\n\\n optimized BFS:\\n store combos you've checked already\\n \\\"\\\"\\\"\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combos = []\\n sums = {}\\n bfs_queue = deque()\\n\\n new_candidates = []\\n for x in candidates:\\n if x == target:\\n combos.append([x])\\n elif x < target:\\n x_tup = (x,)\\n sums[x_tup] = x\\n bfs_queue.append(x_tup)\\n new_candidates.append(x)\\n\\n while len(bfs_queue) > 0:\\n combo = bfs_queue.popleft()\\n combo_sum = sums[combo]\\n for x in new_candidates:\\n combo_with_x = tuple(sorted(combo + (x,)))\\n new_sum = sums.get(combo_with_x)\\n if new_sum is None:\\n new_sum = combo_sum + x\\n if new_sum == target:\\n combos.append(list(combo_with_x))\\n elif new_sum < target:\\n bfs_queue.append(combo_with_x)\\n sums[combo_with_x] = new_sum\\n\\n return combos\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n output = []\\n self.backtrack(0,candidates,[],0,target,output)\\n return output\\n def backtrack(self,index,candidates,path,summ,target,output):\\n if summ>=target:\\n print(target)\\n print(path)\\n if summ==target:\\n print(summ)\\n output.append(path.copy())\\n return\\n for i in range(index,len(candidates)):\\n path.append(candidates[i])\\n summ+=candidates[i]\\n self.backtrack(i,candidates,path,summ,target,output)\\n path.pop()\\n summ-=candidates[i]\\n\\n\\n\\n\\n \\n \",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n\\n def rec(self, cand, target):\\n \\n if len(cand) == 0:\\n return [[]]\\n\\n if target < 1:\\n return [[]]\\n\\n \\n occ = target // cand[0]\\n acc = []\\n for i in range(occ + 1):\\n lists = self.rec(cand[1:], target - i*cand[0])\\n ex_lists = list(map(lambda x: [cand[0]]*(i) + x, lists))\\n acc += ex_lists\\n return acc\\n\\n\\n\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates = sorted(candidates, reverse = True)\\n result = self.rec(candidates, target)\\n result = list(filter(lambda x: sum(x) == target, result))\\n return result\\n \",\n \"runtime\": \"89\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n stack = [(0,0,[])]\\n visited = set()\\n res = []\\n candidates.sort()\\n while stack:\\n index, current_sum, current_array = stack.pop()\\n if index >= len(candidates):\\n continue\\n current_sum += candidates[index]\\n current_array.append(candidates[index])\\n if tuple(current_array) in visited:\\n continue\\n visited.add(tuple(current_array))\\n if current_sum == target:\\n res.append(current_array)\\n continue\\n if current_sum > target:\\n continue\\n for i in range(index, len(candidates)):\\n stack.append((i, current_sum, current_array.copy()))\\n current_array.pop()\\n stack.append((index+1, current_sum-candidates[index], current_array.copy()))\\n return res\",\n \"runtime\": \"89\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # backtracking: help function if remain=0, result append list(comb) and return, if remian<0, reutrn. \\n # for loop from start to length, comb append i, recursion, com pop\\n res = []\\n def help(start = 0, comb = [], remain = target):\\n if remain == 0:\\n if sorted(comb) not in res:\\n res.append(sorted(comb))\\n return\\n elif remain < 0:\\n return\\n for i in range(start, len(candidates)):\\n comb.append(candidates[i])\\n print(comb)\\n help(i, comb, remain - candidates[i])\\n comb.pop()\\n help()\\n return res\\n \",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n def combination(arr, sub, ans, i, target):\\n \\n if sum(sub) == target:\\n ans.append(sub[:])\\n return\\n \\n \\n if sum(sub) > target or i >= len(arr):\\n return\\n\\n \\n sub.append(arr[i])\\n combination(arr, sub, ans, i, target) \\n \\n sub.pop()\\n combination(arr, sub, ans, i + 1, target) \\n \\n return ans\\n\\n print(combination(candidates, [], [], 0, target))\\n return combination(candidates, [], [], 0, target)\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n\\n resultSet = []\\n\\n def backtrack(index, currentSet):\\n currentSum = sum(currentSet)\\n\\n if currentSum == target:\\n resultSet.append(currentSet.copy())\\n return\\n \\n if currentSum > target:\\n return\\n \\n if index >= len(candidates):\\n return\\n\\n # currentSum < target:\\n currentSet.append(candidates[index])\\n print(currentSet)\\n backtrack(index, currentSet)\\n \\n # back to the previous state\\n currentSet.pop()\\n backtrack(index + 1, currentSet)\\n \\n backtrack(0, [])\\n return resultSet\\n\\n\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res=[]\\n def rec(i,sum,lst):\\n print(lst,sum)\\n\\n if sum==target:\\n res.append(lst.copy())\\n return\\n\\n elif i>=len(candidates) or sum>target:\\n return\\n\\n\\n elif target-sum>=candidates[i]:\\n sum+=candidates[i]\\n lst.append(candidates[i])\\n rec(i,sum,lst)\\n lst.pop()\\n sum-=candidates[i]\\n \\n rec(i+1,sum,lst)\\n \\n rec(0,0,[])\\n return res\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combos = []\\n\\n self.dfs(combos, candidates, target, [], 0, 0)\\n\\n return combos\\n\\n def dfs(self, combos, candidates, target, curr, summ, term):\\n print(\\\"dfs\\\", curr, term)\\n if term == len(candidates):\\n return\\n\\n curr.append(candidates[term])\\n summ += candidates[term]\\n\\n if summ == target:\\n combos.append(curr.copy())\\n elif summ < target:\\n self.dfs(combos, candidates, target, curr, summ, term) \\n \\n curr.remove(candidates[term])\\n summ -= candidates[term]\\n self.dfs(combos, candidates, target, curr, summ, term + 1)\\n\",\n \"runtime\": \"99\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # sort candidates\\n candidates.sort()\\n \\n results = []\\n deq = deque([([], deque(candidates), target)])\\n\\n while deq:\\n currN, currC, currT = deq.popleft()\\n # print(currN, currC, currT)\\n\\n if currT == 0:\\n results.append(currN)\\n elif currT > 0 and currC:\\n deq.append((currN + [currC[0]], currC, currT - currC[0]))\\n temp = deque(currC)\\n temp.popleft()\\n deq.append((currN, temp, currT)) \\n \\n return results\\n\\n\",\n \"runtime\": \"99\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = set()\\n\\n def dfs(ind, summ, s, target, n):\\n # base case \\n if summ > target:\\n return \\n if summ == target:\\n ans.add(tuple(s[::]))\\n return \\n if ind >= n: return \\n\\n # pick and again pick\\n summ += candidates[ind]\\n s.append(candidates[ind])\\n dfs(ind, summ, s, target, n)\\n # backtrack\\n # summ -= s.pop()\\n # pick and pick next \\n dfs(ind + 1, summ, s, target, n)\\n # backtrack \\n summ -= s.pop()\\n dfs(ind + 1, summ, s, target, n)\\n \\n dfs(0, 0, [], target, len(candidates))\\n\\n return ans \\n \\n\\n\",\n \"runtime\": \"102\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n sol = []\\n n = len(candidates)\\n\\n def Backtrack(i):\\n if sum(sol) == target:\\n res.append(sol[:])\\n return \\n \\n for i in range(i,n):\\n if sum(sol) <= target:\\n print(sum(sol))\\n sol.append(candidates[i])\\n Backtrack(i)\\n sol.pop()\\n \\n Backtrack(0)\\n return res \\n\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"102\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = set()\\n\\n def rec(subset, i, curr_sum):\\n if curr_sum == target:\\n res.add(tuple(subset.copy()))\\n return\\n\\n elif curr_sum > target:\\n return\\n\\n for n in range(i, len(candidates)):\\n subset.append(candidates[n])\\n rec(subset, n, curr_sum + candidates[n])\\n rec(subset, n+1, curr_sum + candidates[n])\\n subset.pop()\\n \\n\\n rec([], 0, 0)\\n return res\",\n \"runtime\": \"106\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n subset = []\\n def dfs(i, currSet, total):\\n print(currSet)\\n if total == target:\\n res.append(currSet.copy())\\n return\\n elif total > target or i >= len(candidates):\\n return\\n \\n currSet.append(candidates[i])\\n dfs(i, currSet, total+candidates[i])\\n currSet.pop()\\n dfs(i+1, currSet, total)\\n dfs(0, [], 0)\\n return res\\n \\n\\n \",\n \"runtime\": \"106\"\n },\n {\n \"code\": \"class Solution:\\n\\n def __init__(self):\\n self.result = []\\n\\n def get_sequence(self, index, arr, candidates, target):\\n print(f\\\"index: {index}, arr: {arr}, target: {target}\\\")\\n if index >= len(candidates):\\n if 0 == target:\\n print(f\\\"target arr: {arr}\\\")\\n self.result.append(arr[:])\\n return\\n if target-candidates[index]>=0:\\n arr.append(candidates[index])\\n self.get_sequence(index, arr, candidates, target-candidates[index])\\n arr.pop()\\n self.get_sequence(index+1, arr, candidates, target)\\n\\n\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n self.get_sequence(0, [], candidates, target)\\n return self.result\\n \",\n \"runtime\": \"109\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = []\\n\\n def dfs(index, subset, total):\\n if total > target:\\n return\\n if index >= len(candidates):\\n if total == target:\\n if not result or result and subset not in result:\\n result.append(subset.copy())\\n return\\n # include index\\n candidate = candidates[index]\\n subset.append(candidate)\\n dfs(index + 1, subset, total + candidate)\\n # include index again\\n dfs(index, subset, total + candidate)\\n subset.pop()\\n # do not include index\\n dfs(index + 1, subset, total)\\n dfs(0, [], 0)\\n return result\\n \",\n \"runtime\": \"109\"\n },\n {\n \"code\": \"from copy import deepcopy\\nfrom math import ceil\\n\\nclass Solution:\\n\\n def recur(self, candidates, target, comb, idx):\\n if target < 0:\\n return []\\n if target == 0:\\n return [deepcopy(comb)]\\n if idx < 0:\\n return []\\n res = self.recur(candidates, target, comb, idx - 1)\\n recur_target = target\\n recur_comb = deepcopy(comb)\\n while recur_target > 0:\\n recur_target -= candidates[idx]\\n recur_comb.append(candidates[idx])\\n res.extend(self.recur(candidates, recur_target, recur_comb, idx - 1))\\n return res\\n\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n return self.recur(candidates, target, [], len(candidates) - 1)\",\n \"runtime\": \"112\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n temp = []\\n\\n def dfs(i, total, res):\\n print(temp)\\n if total == target:\\n res.append(temp.copy())\\n return\\n if i >= len(candidates) or total > target:\\n return\\n temp.append(candidates[i])\\n dfs(i,total + candidates[i], res)\\n\\n temp.pop()\\n dfs(i+1, total, res)\\n\\n\\n dfs(0, 0, res) \\n return res\",\n \"runtime\": \"119\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = set()\\n candidates.sort()\\n\\n def helper(current, path):\\n if current == 0:\\n res.add(tuple(sorted(path)))\\n return\\n if current < 0:\\n return\\n for c in candidates:\\n if c <= current:\\n helper(current - c, path + [c])\\n else:\\n break\\n \\n helper(target, [])\\n return res\",\n \"runtime\": \"119\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n def backtrack(i, arr, summ):\\n print(arr)\\n if (summ) == target:\\n res.append(arr.copy())\\n return \\n \\n if i >= len(candidates) or summ > target:\\n return\\n \\n arr.append(candidates[i])\\n \\n backtrack(i, arr, summ + candidates[i])\\n arr.pop(-1)\\n backtrack(i + 1, arr, summ)\\n backtrack(0, [], 0)\\n return res\\n\\n\",\n \"runtime\": \"122\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n res = []\\n substack = []\\n def dfs(i):\\n \\n if sum(substack) > target or i < 0:\\n return\\n if sum(substack) == target:\\n if substack not in res:\\n res.append(substack.copy())\\n return\\n substack.append(candidates[i])\\n dfs(i)\\n dfs(i-1)\\n substack.pop(-1)\\n dfs(i-1)\\n return\\n dfs(len(candidates)-1)\\n return res\\n\\n\",\n \"runtime\": \"122\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n results = set()\\n candidates.sort()\\n\\n def aux(current_list, current_target):\\n if current_target == 0:\\n results.add(tuple(sorted(current_list)))\\n return\\n for candidate in candidates:\\n if current_target - candidate < 0:\\n return\\n current_list.append(candidate)\\n aux(current_list, current_target - candidate)\\n current_list.pop()\\n \\n aux([], target)\\n\\n return results\",\n \"runtime\": \"126\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n\\n def summer(index, array, curr_sum):\\n if curr_sum > target or index >= len(candidates):\\n return\\n if curr_sum == target:\\n if array not in ans:\\n ans.append(array)\\n else:\\n temp_array = array.copy()\\n summer(index + 1, temp_array, curr_sum)\\n \\n temp_array.append(candidates[index])\\n curr_sum += candidates[index]\\n\\n summer(index, temp_array, curr_sum)\\n summer(index + 1, temp_array, curr_sum)\\n \\n summer(0, [], 0)\\n return ans\",\n \"runtime\": \"126\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\\"\\\"\\\"\\n :type candidates: List[int]\\n :type target: int\\n :rtype: List[List[int]]\\n \\\"\\\"\\\"\\n res = []\\n self.recur(candidates, target, [], 0, res, 0)\\n return res\\n def recur(self, candidates, target, curr_combination, curr_sum, res, curr_pos):\\n if curr_sum == target:\\n print(f\\\"{curr_sum} {curr_combination}\\\")\\n res.append(curr_combination[:])\\n return\\n if curr_sum > target:\\n return\\n for i in range(curr_pos, len(candidates)):\\n print(f\\\"before {curr_combination}\\\")\\n curr_combination.append(candidates[i])\\n self.recur(candidates, target, curr_combination, curr_sum + candidates[i], res, i)\\n curr_combination.pop()\\n print(f\\\"after {curr_combination}\\\")\\n\",\n \"runtime\": \"129\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n # edge case: empty list\\n if len(candidates) == 0:\\n return []\\n result = []\\n currentPath = []\\n\\n # we cant add numbers before index i, to avoid duplicates\\n def dfsHelper(i):\\n print(currentPath)\\n # base case: current index out of range or the current combination sum > target\\n if len(candidates) <= i or sum(currentPath) > target:\\n return\\n # found a valid combo\\n if sum(currentPath) == target:\\n print(\\\"found a result: \\\", currentPath)\\n result.append(currentPath.copy())\\n return\\n\\n # explore left and right paths\\n currentPath.append(candidates[i]) # add i to left subtree\\n dfsHelper(i) # dont increase i, since left subtree may continue adding the same value\\n currentPath.pop() # dont add i to right subtree\\n dfsHelper(i+1)\\n\\n dfsHelper(0)\\n print(result)\\n return result\",\n \"runtime\": \"129\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n res = []\\n substack = []\\n def dfs(i):\\n if sum(substack) > target or i < 0:\\n return\\n if sum(substack) == target:\\n if substack not in res:\\n res.append(substack.copy())\\n return\\n substack.append(candidates[i])\\n dfs(i)\\n dfs(i-1)\\n substack.pop(-1)\\n dfs(i-1)\\n return\\n dfs(len(candidates)-1)\\n return res\\n\\n\",\n \"runtime\": \"132\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n def sums(index, sum, subsequence):\\n if sum > target:\\n return\\n if sum == target:\\n result.add(tuple(subsequence))\\n return\\n if index == n:\\n return\\n\\n sums(index, sum + candidates[index], subsequence + [candidates[index]])\\n sums(index + 1, sum + candidates[index], subsequence + [candidates[index]])\\n\\n sums(index + 1, sum, subsequence)\\n \\n result = set()\\n n = len(candidates)\\n sums(0, 0, [])\\n return result\",\n \"runtime\": \"132\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\\n ans = set()\\n candidates.sort()\\n def backtracking(pattern = []):\\n current_sum = sum(pattern)\\n if current_sum == target:\\n ans.add(tuple(sorted(pattern)))\\n return\\n for num in candidates:\\n if current_sum + num > target:\\n break\\n pattern.append(num)\\n backtracking(pattern)\\n pattern.pop()\\n backtracking()\\n return ans\",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n dp = [None]*(target+1)\\n\\n dp[0] = [[]]\\n for i in range(target+1):\\n if dp[i] is None:\\n continue\\n for num in candidates:\\n if i+num > target:\\n continue\\n for comb in dp[i]:\\n if dp[i+num] is None:\\n dp[i+num] = []\\n dp[i+num].append([num]+comb)\\n\\n if dp[target] is None:\\n return []\\n return set([tuple(sorted(x)) for x in dp[target]])\",\n \"runtime\": \"136\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result, currentPath = [], []\\n\\n # we cant add numbers before index i, to avoid duplicates\\n def dfsHelper(i):\\n print(currentPath)\\n # base case: current index out of range or the current combination sum > target\\n if len(candidates) <= i or sum(currentPath) > target:\\n return\\n # found a valid combo\\n if sum(currentPath) == target:\\n print(\\\"found a result: \\\", currentPath)\\n result.append(currentPath.copy()) # save a deep copy to the result array, so we dont overwrite the memory\\n return\\n\\n # explore left and right paths\\n currentPath.append(candidates[i]) # add i to left subtree\\n dfsHelper(i) # dont increase i, since left subtree may continue adding the same value\\n currentPath.pop() # dont add i to right subtree\\n dfsHelper(i+1)\\n\\n dfsHelper(0)\\n return result\",\n \"runtime\": \"139\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidate=sorted(candidates)\\n def backtrack(temlist,re,index,candidate,target):\\n temlist.append(candidate[index])\\n print(temlist)\\n if target-sum(temlist)<0:\\n temlist.remove(candidate[index])\\n return \\n elif (target-sum(temlist))==0:\\n re.append(temlist.copy())\\n temlist.remove(candidate[index])\\n return \\n for i in range(index,len(candidate)):\\n backtrack(temlist,re,i,candidate,target)\\n temlist.pop()\\n \\n re=[]\\n temlist=[]\\n for j in range(len(candidate)):\\n backtrack(temlist,re,j,candidate,target)\\n print(re)\\n return re\",\n \"runtime\": \"139\"\n },\n {\n \"code\": \"class Solution:\\n # def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # input: candidates of distinct positive integers. target.\\n # output: combination of arrays with sum == target.\\n candidates.sort()\\n def check(start, aim) -> List[List[int]]:\\n # all combination_sum == aim with nums[start] in it.\\n ans = []\\n if start == len(candidates) or aim == 0: return ans\\n i = 0\\n while aim - candidates[start] * i >= 0:\\n if aim == candidates[start] * i: ans.append([candidates[start]] * i)\\n tmp = check(start + 1, aim - candidates[start] * i)\\n if tmp:\\n tmp = [[candidates[start]] * i + cand for cand in tmp]\\n ans += tmp\\n i += 1\\n \\n print(start, aim, ans)\\n return ans\\n result = []\\n # for i in range(candidates):\\n # result += check(i, target)\\n return check(0, target)\",\n \"runtime\": \"142\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n curSet = []\\n combs = []\\n def dfs(i, total):\\n print(curSet, total)\\n if total == target:\\n combs.append(curSet.copy())\\n return\\n if total > target:\\n return\\n if i >= len(candidates):\\n return\\n\\n # repeat same number\\n curSet.append(candidates[i]) \\n dfs(i, total + candidates[i])\\n\\n # go to next number\\n num = curSet.pop()\\n dfs(i + 1, total - num + candidates[i]) \\n\\n dfs(0, 0)\\n return combs\\n\",\n \"runtime\": \"142\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n curSet = []\\n combs = []\\n def dfs(i, total):\\n print(curSet, total)\\n if total == target:\\n combs.append(curSet.copy())\\n return\\n if total > target:\\n return\\n if i >= len(candidates):\\n return\\n\\n # repeat same number\\n curSet.append(candidates[i]) \\n dfs(i, total + candidates[i])\\n\\n # go to next number\\n curSet.pop()\\n dfs(i + 1, total) \\n\\n dfs(0, 0)\\n return combs\\n\",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n visited = set()\\n res = []\\n def backtrack(cur):\\n \\n if tuple(sorted(cur)) in visited:\\n return\\n else:\\n visited.add(tuple(sorted(cur)))\\n if sum(cur) > target:\\n return \\n if sum(cur) == target and cur not in res:\\n res.append(cur)\\n for digit in candidates:\\n tmp_cur = cur.copy()\\n tmp_cur.append(digit)\\n backtrack(tmp_cur)\\n backtrack([])\\n return res\\n \\n\\n \\n \",\n \"runtime\": \"146\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # Neetcode's solution\\n # res = []\\n\\n # def dfs(i, curr, total):\\n # if total==target:\\n # res.append(curr.copy())\\n # return\\n # if i >= len(candidates) or total > target:\\n # return # break out\\n\\n # curr.append(candidates[i])\\n # dfs(i, curr, total + candidates[i])\\n # curr.pop()\\n # dfs(i+1, curr, total)\\n \\n # dfs(0, [], 0)\\n # return res\\n\\n # check every single combination until it exceeds target\\n # (almost brute-force)\\n\\n # backtracking function\\n def backtrack(currList, startidx, targetlen, total):\\n if total > target:\\n return\\n elif (total==target) & (len(currList)==targetlen):\\n res.append(currList)\\n return\\n else:\\n for i in range(startidx, len(candidates)):\\n backtrack(currList + [candidates[i]], i, targetlen, total+candidates[i])\\n\\n maxlen = target // min(candidates) # max length of combos\\n targetlen = 1\\n res = []\\n while(targetlen <= maxlen):\\n backtrack([], 0, targetlen, 0)\\n targetlen += 1\\n\\n return res\",\n \"runtime\": \"149\"\n },\n {\n \"code\": \"import copy\\n\\nclass Solution:\\n result = None\\n target_global = None\\n global_candidates = None\\n\\n def attempt(self, current_combination, index, sum):\\n if sum > self.target_global:\\n return\\n if sum == self.target_global:\\n self.result.append(current_combination)\\n return\\n for i in range(index, len(self.global_candidates)):\\n new_comb = copy.deepcopy(current_combination)\\n new_comb.append(self.global_candidates[i])\\n self.attempt(new_comb, i, sum + self.global_candidates[i])\\n\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n self.target_global = target\\n self.result = []\\n self.global_candidates = candidates\\n self.attempt([], 0, 0)\\n return self.result\",\n \"runtime\": \"149\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # res\\n # cur\\n # i\\n # total\\n res = []\\n def dfs(cur, i, total):\\n print(cur, i, total)\\n if i >= len(candidates) or total > target:\\n return\\n if total == target:\\n res.append(cur.copy())\\n return\\n \\n cur.append(candidates[i])\\n dfs(cur, i, total + candidates[i])\\n cur.pop()\\n dfs(cur, i+1, total)\\n dfs([], 0, 0)\\n return res\",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n\\n combinations = []\\n\\n def bt(comb, combSum, i):\\n\\n # If we find a combination that sums to target\\n if combSum == target and comb not in combinations:\\n combinations.append(comb[:])\\n return\\n\\n # Out of bounds or combination sum is greater than target\\n if i >= len(candidates) or combSum > target:\\n return\\n \\n # Our decisions are:\\n # Add nums[i] combination and then go to next value\\n # Or add nums[i] and stay\\n # Or skip nums[i]\\n\\n # Adding and going next\\n comb.append(candidates[i])\\n bt(comb, combSum + candidates[i], i + 1)\\n\\n # Adding and staying\\n bt(comb, combSum + candidates[i], i)\\n\\n # Skip nums[i]\\n comb.pop()\\n bt(comb, combSum, i + 1)\\n\\n bt([], 0, 0)\\n\\n return combinations\\n\\n\\n\",\n \"runtime\": \"152\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n candidates.sort()\\n\\n def backtrack(arr, pos, tar):\\n if tar == 0:\\n res.append(arr.copy())\\n if tar <= 0:\\n return\\n\\n for i in range(pos, len(candidates)):\\n arr.append(candidates[i])\\n backtrack(arr, i, tar - candidates[i])\\n backtrack(arr, i+1, tar - candidates[i])\\n arr.pop()\\n \\n backtrack([], 0, target)\\n arr = []\\n check = set()\\n for a in res:\\n t = tuple(a)\\n if not t in check:\\n arr.append(a)\\n check.add(t)\\n return arr\",\n \"runtime\": \"156\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, c: List[int], t: int) -> List[List[int]]:\\n l=[]\\n def fun(c,i,t,s,m):\\n if(s==t):\\n l.append(m)\\n return 0\\n if(s>t):\\n return 0\\n if(i>=len(c)):\\n return 0\\n a=m[:]\\n a.append(c[i])\\n b=m[:]\\n b.append(c[i])\\n fun(c,i,t,s+c[i],b)\\n fun(c,i+1,t,s+c[i],a)\\n fun(c,i+1,t,s,m)\\n z=[]\\n fun(c,0,t,0,z)\\n p=[]\\n for i in range(len(l)):\\n if(l[i] not in p):\\n p.append(l[i])\\n return p\\n\",\n \"runtime\": \"156\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n out = []\\n\\n def combhelper(cands, csum, i):\\n if csum == target: # Cands has reached target\\n if cands not in out:\\n out.append(cands)\\n return\\n elif i >= len(candidates) or csum > target: # Base case(s)\\n return \\n \\n combhelper(cands + [candidates[i]], csum + candidates[i], i)\\n combhelper(cands + [candidates[i]], csum + candidates[i], i+1)\\n combhelper(cands, csum, i+1)\\n \\n\\n combhelper([], 0, 0)\\n return out\",\n \"runtime\": \"159\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n def recurse(index, currSum, currNums):\\n print(index, currSum, currNums)\\n\\n if currSum == target:\\n res.append(currNums.copy())\\n return\\n\\n if index >= len(candidates) or currSum > target:\\n return\\n\\n currNums.append(candidates[index])\\n recurse(index, currSum + candidates[index], currNums)\\n currNums.pop()\\n \\n \\n recurse(index+1, currSum, currNums)\\n\\n\\n recurse(0, 0, [])\\n return res\\n \",\n \"runtime\": \"159\"\n },\n {\n \"code\": \"import copy\\n\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combinations = []\\n self.helper(candidates, target, combinations, [], 0)\\n return combinations\\n\\n def helper(self, candidates, target, combinations, combination, sum):\\n # print(candidates)\\n if len(candidates) == 0: return\\n if (sum == target):\\n combinations.append(combination)\\n return\\n if (sum > target):\\n return\\n else: \\n # include the current candidate and continue using it\\n copy1 = copy.deepcopy(combination)\\n copy1.append(candidates[0])\\n self.helper(candidates[:len(candidates)], target, combinations, copy1, sum + candidates[0])\\n # include the current candidate and don't continue using it\\n # self.helper(candidates[1:len(candidates)], target, combinations, copy2, sum + candidates[0])\\n # don't include the current candidate and dont continue using it\\n self.helper(candidates[1:len(candidates)], target, combinations, combination, sum)\",\n \"runtime\": \"163\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n res = []\\n\\n def make_combination(idx, comb, total):\\n print(idx,comb,total)\\n if total == target:\\n res.append(comb[:])\\n return\\n \\n if total > target or idx >= len(candidates):\\n return\\n \\n comb.append(candidates[idx])\\n make_combination(idx, comb, total + candidates[idx])\\n comb.pop()\\n make_combination(idx+1, comb, total)\\n\\n return res\\n\\n return make_combination(0, [], 0)\",\n \"runtime\": \"163\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n results = []\\n def recurse(i, sumSoFar = 0, choices=[], parentChoices = []):\\n nonlocal results\\n if(i>=len(candidates)): \\n print(\\\"Exceeded Index Stopping\\\", sumSoFar, choices)\\n return\\n if(sumSoFar > target): \\n print(\\\"Exceeded Sum Stopping\\\", sumSoFar, choices)\\n return\\n if(sumSoFar==target):\\n print(\\\"RESULT\\\", sumSoFar, choices)\\n print(\\\"PARENTS FOR ABOVE RESULT \\\", parentChoices)\\n results.append(choices)\\n return\\n \\n print(choices, sumSoFar)\\n recurse(i, sumSoFar + candidates[i], choices + [candidates[i]], choices[:-1])\\n recurse(i+1, sumSoFar, choices[:], choices[:-1])\\n recurse(0, 0, [])\\n return results\\n\",\n \"runtime\": \"166\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n def recurse(index, currSum, currNums):\\n print(index, currSum, currNums)\\n\\n if currSum == target:\\n res.append(currNums)\\n return\\n\\n if index >= len(candidates) or currSum > target:\\n return\\n\\n #currNums.append(candidates[index])\\n recurse(index, currSum + candidates[index], currNums + [candidates[index]])\\n #currNums.pop()\\n \\n \\n recurse(index+1, currSum, currNums)\\n\\n\\n recurse(0, 0, [])\\n return res\\n \",\n \"runtime\": \"166\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n path: list[int] = []\\n answ: set[tuple[int]] = set()\\n candidates.sort()\\n n = len(candidates)\\n def backtrack(i: int, cumSum: int) -> None:\\n if cumSum == target:\\n answ.add(tuple(path.copy()))\\n return\\n if cumSum > target:\\n return\\n if i == n:\\n return\\n path.append(candidates[i])\\n backtrack(i+1, cumSum+candidates[i]) # Visit next with cumSum\\n backtrack(i, cumSum+candidates[i]) # Visit same\\n path.pop()\\n backtrack(i+1, cumSum) # visit next without including current\\n backtrack(0,0)\\n return answ\\n \\n\\n \",\n \"runtime\": \"169\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n existed = set()\\n\\n def backtrack(i, nums):\\n if i == len(candidates) or sum(nums) > target:\\n return\\n\\n if sum(nums) == target :\\n if \\\".\\\".join([str(i) for i in nums]) in existed:\\n return \\n res.append(nums.copy())\\n existed.add(\\\".\\\".join([str(i) for i in nums]))\\n \\n \\n nums.append(candidates[i])\\n backtrack(i, nums)\\n backtrack(i + 1, nums)\\n nums.pop()\\n backtrack(i + 1, nums)\\n return\\n \\n backtrack(0, [])\\n return res\",\n \"runtime\": \"169\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n def recurse(index, currSum, currNums):\\n print(index, currSum, currNums)\\n\\n if currSum == target:\\n res.append(currNums.copy())\\n return\\n\\n if index >= len(candidates) or currSum > target:\\n return\\n\\n #currNums.append(candidates[index])\\n recurse(index, currSum + candidates[index], currNums + [candidates[index]])\\n #currNums.pop()\\n \\n \\n recurse(index+1, currSum, currNums)\\n\\n\\n recurse(0, 0, [])\\n return res\\n \",\n \"runtime\": \"173\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n dp = [[] for _ in range(target + 1)]\\n for t in range(candidates[0], target + 1):\\n combos = []\\n for c in candidates:\\n if t - c < 0:\\n break\\n if t - c > 0 and dp[t - c]:\\n combos += [sorted([c] + combo) for combo in dp[t - c]]\\n if t - c == 0:\\n combos.append([c])\\n dp[t] = combos\\n \\n return [list(y) for y in set([tuple(x) for x in dp[target]])]\\n \\n # [2,3,6,7]\\n # dp [,,[2],[3],[2,2],[2,3],,,]\\n # t 2\\n # t 3\\n # t 4\\n # t 5\\n \",\n \"runtime\": \"173\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n def findCombinations(current,candidates,target,solutions):\\n tempSum = sum(current) if current else 0\\n if tempSum == target:\\n solutions.append(current)\\n return solutions\\n if tempSum > target:\\n return solutions \\n\\n for i in candidates:\\n if tempSum + i > target:\\n return solutions\\n else:\\n findCombinations(current + [i], candidates, target, solutions) \\n return solutions \\n\\n solutions = findCombinations(list(), sorted(candidates), target, list()) \\n solutions = list(map(sorted,solutions))\\n \\n return list(set(map(tuple,solutions)))\\n\\n\\n\",\n \"runtime\": \"176\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n results = []\\n def recurse(i, sumSoFar = 0, choices=[], parentChoices = []):\\n nonlocal results\\n if(i>=len(candidates)): \\n print(\\\"Exceeded Index Stopping\\\", sumSoFar, choices)\\n return\\n if(sumSoFar > target): \\n print(\\\"Exceeded Sum Stopping\\\", sumSoFar, choices)\\n return\\n if(sumSoFar==target):\\n print(\\\"RESULT\\\", sumSoFar, choices)\\n print(\\\"PARENTS FOR ABOVE RESULT \\\", parentChoices)\\n results.append(choices)\\n return\\n choices.append(candidates[i])\\n newSum = sumSoFar + candidates[i]\\n print(choices[:-1], sumSoFar)\\n recurse(i, newSum, choices[:], choices[:-1])\\n recurse(i+1, sumSoFar, choices[:-1], choices[:-1])\\n recurse(0, 0, [])\\n return results\\n\",\n \"runtime\": \"176\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combination = []\\n result = []\\n\\n if len(candidates) == 0:\\n return result\\n\\n def backtrack(i):\\n # Condition \\n sum_combination = sum(combination)\\n print(f\\\"Sum: {sum_combination}\\\")\\n \\n if sum_combination > target:\\n return\\n\\n if i == len(candidates):\\n return\\n\\n if sum_combination == target:\\n result.append(combination.copy())\\n print(f\\\"**Result: {result}\\\")\\n return\\n\\n \\n\\n print(f\\\"Combination: {combination}\\\")\\n # Approach 1\\n combination.append(candidates[i])\\n backtrack(i)\\n \\n print(\\\"Popping\\\")\\n # Approach 2\\n combination.pop()\\n backtrack(i+1)\\n\\n backtrack(0)\\n return result\",\n \"runtime\": \"179\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n bfs = [(target, [])]\\n result = []\\n candidates = sorted(candidates)\\n\\n while bfs:\\n resid, hist = bfs.pop()\\n\\n for elem in candidates:\\n new_resid = resid - elem\\n \\n if new_resid == 0:\\n new_hist = hist[:]\\n new_hist.append(elem)\\n new_hist = sorted(new_hist)\\n if new_hist not in result:\\n result.append(new_hist)\\n\\n elif new_resid > 0:\\n new_hist = hist[:]\\n new_hist.append(elem)\\n bfs.append((new_resid, new_hist))\\n \\n else:\\n break\\n \\n return result\\n\",\n \"runtime\": \"179\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = self.helper(candidates, [], target)\\n \\n # Use a set to store unique combinations as tuples (sorted to ensure uniqueness)\\n unique_combinations = set(tuple(sorted(comb)) for comb in ans)\\n \\n # Convert the set of tuples back to a list of lists\\n return [list(combination) for combination in unique_combinations]\\n\\n def helper(self, nums, ans, target):\\n if target == 0:\\n return [ans]\\n final = []\\n for i in nums:\\n if i <= target:\\n final.extend(self.helper(nums, ans + [i], target - i))\\n return final\",\n \"runtime\": \"183\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combinations = []\\n sol = []\\n def helper(s: int, n: int) -> None:\\n if n == len(candidates) or len(combinations) > 150:\\n print(\\\"done\\\", n, len(candidates))\\n return\\n\\n print(s, sol)\\n if s == target:\\n combinations.append(sol[:])\\n print(\\\"found sol\\\")\\n return\\n elif s > target:\\n print(\\\"over target\\\")\\n return\\n\\n for i in range(n,len(candidates)):\\n print(\\\"next\\\", \\\"sum=\\\", s, \\\"n=\\\", n, \\\"i=\\\", i)\\n s += candidates[i]\\n sol.append(candidates[i])\\n helper(s, i)\\n s -= sol.pop()\\n \\n helper(0, 0)\\n return combinations\\n\\n \\n \",\n \"runtime\": \"183\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n def comb(arr: List[int], candidates: List[int], target: int):\\n if target == 0:\\n list.sort(arr)\\n if arr not in res:\\n res.append(arr)\\n return\\n for i in candidates:\\n if i <= target:\\n \\n comb(arr+[i], candidates, target - i)\\n \\n \\n comb([],candidates,target)\\n\\n return res\\n\",\n \"runtime\": \"186\"\n },\n {\n \"code\": \"from copy import deepcopy\\n\\nclass Solution:\\n\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n m = target + 1\\n n = len(candidates) + 1\\n memo = [[[] for j in range(n)] for i in range(m)]\\n for i in range(1, m):\\n for j in range(1, n):\\n memo[i][j] = deepcopy(memo[i][j-1])\\n if i == candidates[j-1]:\\n memo[i][j].append([candidates[j-1]])\\n curr_target = i - candidates[j-1]\\n if curr_target > 0:\\n for sub in memo[curr_target][j]:\\n my_arr = deepcopy(sub)\\n my_arr.append(candidates[j-1])\\n memo[i][j].append(my_arr)\\n return memo[-1][-1]\\n\\n\",\n \"runtime\": \"186\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates = sorted(candidates)\\n # print(candidates)\\n result = []\\n self.get_result(candidates, target, result, [])\\n # Sort each sublist and use groupby to remove duplicates\\n result = [next(g) for _, g in groupby(sorted(result, key=sorted), sorted)]\\n return result\\n\\n def get_result(self, candidates, target, result, current):\\n if target < 0:\\n return\\n if target == 0:\\n result.append(current)\\n return\\n for item in candidates:\\n if target - item >= 0:\\n self.get_result(candidates, target-item, result, current + [item])\\n else:\\n break\\n\",\n \"runtime\": \"189\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n cand = SortedList(candidates)\\n n = len(cand)\\n dic = {}\\n def check(t, i) -> List[List[int]]:\\n print(t, i)\\n # if t in dic: return dic[t]\\n # if cand[i] == t: return [[t]]\\n ans = []\\n # for x in range(i + 1, n):\\n for j in range(1, t // cand[i] + 1):\\n first = [cand[i]] * j\\n # print(first)\\n if t - cand[i] * j > 1 and i + 1 < n:\\n rest = check(t - cand[i] * j, i + 1)\\n if rest:\\n for item in rest:\\n ans.append(first + item)\\n elif t == cand[i] * j:\\n ans.append(first)\\n if i + 1 < n:\\n rest = check(t, i + 1)\\n for item in rest:\\n ans.append(item)\\n dic[t] = ans\\n print(t, i, ans)\\n return ans\\n return check(target, 0)\\n # [2 3 6 7], 7\\n # [2] + ( 5, 1), [2, 2] + (3, 1), [2, 2, 2] + ( 1, 1),\\n # [3] + (4, 2), [3, 3] + (1, 2)\\n # \",\n \"runtime\": \"189\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n s = set()\\n total = []\\n candidates.sort()\\n def helper(path, cursum):\\n spath = sorted(path)\\n tpath = tuple(spath)\\n if cursum == target and tpath not in s:\\n s.add(tpath)\\n total.append(spath)\\n return\\n for i in range(len(candidates)):\\n if candidates[i] + cursum <= target:\\n path.append(candidates[i])\\n helper(path, candidates[i] + cursum)\\n path.pop()\\n else:\\n break\\n helper([], 0)\\n return total\",\n \"runtime\": \"193\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # check every single combination until it exceeds target\\n # (almost brute-force)\\n\\n # backtracking function\\n def backtrack(currList, startidx, targetlen):\\n sumlist = sum(currList)\\n if sumlist > target:\\n return\\n elif (sumlist==target) & (len(currList)==targetlen):\\n res.append(currList)\\n return\\n else:\\n for i in range(startidx, len(candidates)):\\n backtrack(currList + [candidates[i]], i, targetlen)\\n\\n maxlen = target // min(candidates) # max length of combos\\n targetlen = 1\\n res = []\\n while(targetlen <= maxlen):\\n backtrack([], 0, targetlen)\\n targetlen += 1\\n\\n return res\",\n \"runtime\": \"193\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # check every single combination until it exceeds target\\n # (almost brute-force)\\n\\n # backtracking function\\n def backtrack(currList, startidx, targetlen):\\n sumlist = sum(currList)\\n if sumlist > target:\\n return\\n elif (sumlist==target) & (len(currList)==targetlen):\\n res.append(currList)\\n return\\n else:\\n for i in range(startidx, len(candidates)):\\n backtrack(currList + [candidates[i]], i, targetlen)\\n\\n maxlen = target // min(candidates) # max length of combos\\n targetlen = 1\\n res = []\\n while(targetlen <= maxlen):\\n backtrack([], 0, targetlen)\\n targetlen += 1\\n\\n return res\",\n \"runtime\": \"196\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]: \\n to_traverse = [-target]\\n heapq.heapify(to_traverse)\\n\\n traversed = {0}\\n \\n hmap = defaultdict(list)\\n hmap[target] = [[]]\\n\\n while to_traverse:\\n current = -heapq.heappop(to_traverse)\\n sequences = hmap[current]\\n\\n if current <= 0:\\n return hmap[0]\\n\\n for cand in candidates:\\n sub = current - cand\\n \\n if sub not in traversed:\\n traversed.add(sub)\\n heapq.heappush(to_traverse, -sub)\\n \\n for seq in sequences:\\n copy = seq.copy()\\n copy.append(cand)\\n copy.sort()\\n if copy not in hmap[sub]:\\n hmap[sub].append(copy)\\n \\n return []\\n \",\n \"runtime\": \"196\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n output = set()\\n candidates = sorted(candidates)\\n\\n def helper(target: int, prefix: List[int]):\\n if target == 0:\\n combination = \\\" \\\".join([str(e) for e in sorted(prefix)])\\n output.add(combination)\\n\\n for candidate in candidates:\\n if candidate > target:\\n break\\n\\n helper(target - candidate, prefix + [candidate])\\n\\n return\\n\\n helper(target, [])\\n\\n\\n return [[int(e) for e in combination.split(\\\" \\\")] for combination in output]\\n\\n\\n \",\n \"runtime\": \"199\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n def dfs(i):\\n if i >= len(candidates) or sum(subset) >= target:\\n if sum(subset) == target and tuple(sorted(subset.copy())) not in added:\\n res.append(subset.copy())\\n added.add(tuple(sorted(subset.copy())))\\n return\\n \\n subset.append(candidates[i])\\n dfs(i)\\n dfs(i + 1)\\n subset.pop()\\n dfs(i + 1)\\n \\n res = []\\n added = set()\\n subset = []\\n dfs(0)\\n return res\",\n \"runtime\": \"199\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n def cSUM(candidates, target, L):\\n SL = sum(L)\\n if SL == target:\\n return [tuple(L)]\\n \\n if SL > target or len(candidates) == 0:\\n return []\\n \\n c = candidates[-1]\\n \\n x1 = cSUM(candidates[:-1], target, L + [c])\\n x2 = cSUM(candidates[:-1], target, L)\\n x3 = cSUM(candidates, target, L + [c])\\n return(list(set(x1 + x2 + x3)))\\n\\n\\n x = cSUM(candidates, target, [])\\n return [list(e) for e in x]\",\n \"runtime\": \"203\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n ans = []\\n\\n temp = []\\n\\n seen = {}\\n\\n candidates.sort()\\n\\n def seenTheList(tempList):\\n key = \\\"\\\"\\n for item in tempList:\\n key += str(item) + \\\"_\\\"\\n\\n if key in seen:\\n return True\\n else:\\n seen[key] = 1\\n return False\\n\\n\\n def dfs(index, left):\\n if left<0 or index>=len(candidates):\\n # this is not possible, back track\\n return\\n\\n if left == 0:\\n # we have found the answer, add to the final ans set\\n if not seenTheList(temp.copy()):\\n ans.append(temp.copy())\\n return\\n\\n temp.append(candidates[index])\\n dfs(index+1, left-candidates[index]) # take the current item and nove to next\\n\\n temp.pop()\\n temp.append(candidates[index])\\n dfs(index, left-candidates[index]) # take the current item and try the current item as well\\n\\n temp.pop()\\n dfs(index+1, left) # take the current item and try the current item as well\\n\\n dfs(0,target)\\n\\n\\n return ans\\n\\n\\n\\n \",\n \"runtime\": \"203\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n ans = []\\n\\n def dfs(arr, curr):\\n\\n if curr == target:\\n new = arr.copy()\\n new.sort()\\n if new in ans:\\n return \\n ans.append(new)\\n return\\n \\n for i in candidates:\\n if curr + i <= target:\\n arr.append(i)\\n dfs(arr, curr + i)\\n arr.pop()\\n \\n dfs([], 0)\\n\\n return ans\\n\\n\\n \",\n \"runtime\": \"206\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\\n candidates.sort()\\n res=[]\\n curr=[]\\n def dfs(i, sum_so_far):\\n if i >=len(candidates):\\n return\\n if sum_so_far==target:\\n res.append(curr.copy())\\n return\\n if sum_so_far<=candidates[i]+target:\\n curr.append(candidates[i])\\n dfs(i, sum_so_far+candidates[i])\\n curr.pop()\\n dfs(i+1, sum_so_far)\\n dfs(0, 0)\\n return res\\n \\n\",\n \"runtime\": \"206\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n l=[]\\n if(target in candidates):\\n l.append([target])\\n for i in candidates:\\n if(i<target):\\n L=self.combinationSum(candidates,target-i)\\n if(L!=[]):\\n for j in L:\\n b=j.copy()\\n b.append(i)\\n b.sort()\\n if(b not in l):\\n l.append(b)\\n return l\\n\\n\\n \",\n \"runtime\": \"209\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\\n ans = set()\\n def backtracking(pattern = []):\\n current_sum = sum(pattern)\\n if current_sum == target:\\n ans.add(tuple(sorted(pattern)))\\n return\\n for num in candidates:\\n if current_sum + num > target:\\n continue\\n pattern.append(num)\\n backtracking(pattern)\\n pattern.pop()\\n backtracking()\\n return ans\",\n \"runtime\": \"209\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n n = len(candidates)\\n res = []\\n path = []\\n def search(x,total):\\n if not 0<=x<n or total>target or path in res:\\n return\\n if total == target:\\n res.append(path.copy())\\n return 1\\n path.append(candidates[x])\\n search(x,total+candidates[x]) \\n search(x+1,total+candidates[x])\\n path.pop()\\n search(x+1,total)\\n return \\n\\n search(0,0)\\n return res\\n \",\n \"runtime\": \"213\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, nums: List[int], target: int) -> List[List[int]]:\\n combos = []\\n current_combo = []\\n\\n def dfs(i):\\n if i >= len(nums) or sum(current_combo) > target:\\n if sum(current_combo) == target and current_combo not in combos:\\n combos.append(current_combo.copy())\\n return\\n \\n # Next number to add to curr combo\\n current_combo.append(nums[i])\\n dfs(i + 1)\\n \\n # Current number to be added again\\n dfs(i)\\n\\n # Nothing added here and move on\\n current_combo.pop()\\n dfs(i + 1)\\n\\n dfs(0)\\n return combos\",\n \"runtime\": \"213\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\\n candidates.sort()\\n res=[]\\n curr=[]\\n def dfs(i, sum_so_far):\\n if i >=len(candidates):\\n return\\n if sum_so_far==target:\\n res.append(curr.copy())\\n return\\n if sum_so_far<=candidates[i]+target:\\n curr.append(candidates[i])\\n dfs(i, sum_so_far+candidates[i])\\n curr.pop()\\n dfs(i+1, sum_so_far)\\n dfs(0, 0)\\n return res\\n \\n\",\n \"runtime\": \"216\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nkey design principles\\n\\nTo analyze the time complexity of the given code, we can break it down into several components and steps:\\n\\n1. Sorting the candidates list:\\npython\\nCopy code\\ncandidates.sort()\\nSorting the list of candidates takes \\n\\\\U0001d442\\n(\\n\\\\U0001d45b\\nlog\\n\\n\\\\U0001d45b\\n)\\nO(nlogn), where \\n\\\\U0001d45b\\nn is the number of elements in the candidates list.\\n\\n2. While Loop for Popping Candidates:\\npython\\nCopy code\\nwhile candidates and candidates[-1] > target:\\n candidates.pop(-1)\\nThe worst case is when the loop removes all candidates greater than the target. If there are \\n\\\\U0001d45b\\nn candidates, in the worst case, this loop would iterate \\n\\\\U0001d45b\\nn times. Each pop() operation is \\n\\\\U0001d442\\n(\\n1\\n)\\nO(1), so this loop is \\n\\\\U0001d442\\n(\\n\\\\U0001d45b\\n)\\nO(n) in the worst case.\\n\\n3. Depth-First Search (DFS) Function:\\nThe DFS function is where the main time complexity comes from.\\n\\nThe function recursively explores all combinations of candidates to find sums that match the target. Each recursive call adds one candidate to current_list and checks if the sum exceeds the target.\\n\\nSince for each element, there are two choices (to include or not), the DFS essentially generates all possible combinations, leading to an exponential number of recursive calls. The number of possible combinations is \\n\\\\U0001d442\\n(\\n2\\n\\\\U0001d45b\\n)\\nO(2 \\nn\\n ), where \\n\\\\U0001d45b\\nn is the number of candidates.\\n\\nWithin each DFS call:\\n\\nChecking the sum of current_list takes \\n\\\\U0001d442\\n(\\n\\\\U0001d458\\n)\\nO(k), where \\n\\\\U0001d458\\nk is the size of the current_list.\\n\\nIn the worst case, the maximum depth of recursion is \\n\\\\U0001d442\\n(\\n\\\\U0001d45b\\n)\\nO(n) (if every combination is checked).\\n\\nThe temp_list.sort() takes \\n\\\\U0001d442\\n(\\n\\\\U0001d458\\nlog\\n\\n\\\\U0001d458\\n)\\nO(klogk), and checking if temp_list not in answer can take \\n\\\\U0001d442\\n(\\n\\\\U0001d45a\\n)\\nO(m), where \\n\\\\U0001d45a\\nm is the size of the answer list (growing as more combinations are found).\\n\\n4. Overall Time Complexity:\\nThe DFS generates combinations exponentially, and checking/processing each combination involves operations like summing, sorting, and checking against the answer list, which incurs additional costs.\\nThe time complexity is dominated by the DFS, and since we can potentially generate all subsets, the overall time complexity is exponential:\\no(2^n*klogk)\\n\\\\U0001d442\\n(\\n2\\n\\\\U0001d45b\\n⋅\\n\\\\U0001d458\\nlog\\n\\n\\\\U0001d458\\n)\\nO(2 \\nn\\n ⋅klogk)\\nwhere \\n\\\\U0001d45b\\nn is the number of candidates, and \\n\\\\U0001d458\\nk is the size of each combination (bounded by \\n\\\\U0001d45b\\nn in the worst case).\\n\\nThis exponential complexity stems from the nature of generating combinations, which inherently grows quickly as the input size increases.\\n\\n\\n\\\"\\\"\\\"\\n\\n\\n\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n answer = []\\n\\n while candidates and candidates[-1] > target:\\n candidates.pop(-1)\\n if not candidates:\\n return answer\\n\\n\\n def dfs(self,candidates,target,current_list):\\n\\n for candidate in candidates:\\n if candidate + sum(current_list) > target:\\n return\\n elif candidate + sum(current_list) == target:\\n current_list.append(candidate)\\n temp_list = []\\n for num in current_list:\\n temp_list.append(num)\\n temp_list.sort()\\n if temp_list not in answer:\\n answer.append(temp_list)\\n elif candidate + sum(current_list) < target:\\n #current_list.append(candidate)\\n dfs(self,candidates,target,current_list +[candidate])\\n\\n\\n\\n current_list = []\\n dfs(self,candidates,target,current_list)\\n\\n return answer\",\n \"runtime\": \"216\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n def backtrack(arr, cur, target, candidates, curSum):\\n if curSum == target:\\n cur = sorted(cur)\\n if cur not in arr:\\n arr.append(cur)\\n elif curSum < target:\\n for num in candidates:\\n if curSum + num <= target:\\n tmp = cur.copy()\\n tmp.append(num)\\n backtrack(arr, tmp, target, candidates, curSum + num)\\n \\n\\n arr = []\\n\\n backtrack(arr, [], target, candidates, 0)\\n \\n return arr\",\n \"runtime\": \"226\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n def search(candidates: list[int], target: int) -> list[list[int]]:\\n comb_list = [] # list of combinations that sum to target\\n for c in candidates:\\n if c > target:\\n break\\n if c == target: # form a combination\\n comb_list.append([c])\\n else: # recursively search for combinations w/ smaller target\\n found = search(candidates, target - c)\\n comb_list += [[c] + combination for combination in found]\\n \\n return comb_list\\n\\n # remove duplicate entries\\n return list(set(tuple(sorted(c)) for c in search(candidates, target)))\\n\",\n \"runtime\": \"226\"\n },\n {\n \"code\": \"import numpy as np\\n\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = []\\n\\n def make_target (candidates, target, addends_so_far):\\n if (target - candidates[0] == 0):\\n addends_so_far.append(candidates[0])\\n result.append(np.copy(addends_so_far))\\n addends_so_far.pop()\\n\\n if (target - candidates[0] > 0):\\n addends_so_far.append(candidates[0])\\n make_target(candidates, target - candidates[0], addends_so_far)\\n addends_so_far.pop()\\n\\n if len(candidates) > 1:\\n make_target(candidates[1:], target, addends_so_far)\\n\\n make_target(candidates, target, [])\\n\\n return result\\n \",\n \"runtime\": \"230\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\\n # dynamic programming\\n # dp[i] = sum target = i\\n dp = [0] * (target + 1)\\n\\n res = []\\n\\n def backtrack(left_target, path):\\n nonlocal res\\n if left_target == 0 and path not in res:\\n res.append(path)\\n return None\\n\\n for c in candidates:\\n if left_target >= c:\\n backtrack(left_target - c, sorted(path + [c]))\\n\\n \\n backtrack(target, [])\\n return res\",\n \"runtime\": \"230\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # candidates.sort()\\n # if target < candidates[0]:\\n # return []\\n \\n # lo, hi = 0, len(candidates) - 1\\n # while lo < hi:\\n # idx = lo + (hi - lo) // 2\\n # cand = candidates[idx]\\n # if target < cand:\\n # hi = idx - 1\\n # elif target > cand:\\n # lo = idx + 1\\n # else:\\n # while idx > 0 and candidates[idx-1] == target:\\n # idx -= 1\\n combinations = {}\\n def loop(candidates, tgt):\\n # print(list(candidates))\\n if tgt < 2:\\n return\\n for c in candidates:\\n if c == tgt:\\n yield [c]\\n if tgt - c < 2:\\n continue\\n for combination in loop(candidates, tgt - c):\\n yield combination + [c]\\n result = list(set(tuple(sorted(x)) for x in loop(candidates, target)))\\n return result\",\n \"runtime\": \"233\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n results = list()\\n self.backtracking([], target, candidates, results)\\n return results\\n \\n def backtracking(self, comb: list, target: int, candidates: list, results: list):\\n sum_cands = sum(comb)\\n if sum_cands == target:\\n results.append(comb)\\n return\\n \\n if not candidates or sum_cands > target:\\n return\\n\\n past_num = candidates[0] - 1\\n for i in range(len(candidates)):\\n num = candidates[i]\\n if num == past_num:\\n continue\\n print(num, candidates, comb)\\n times = target // num\\n for j in range(times):\\n array = [num] * (j + 1)\\n self.backtracking(comb + array, target, candidates[i + 1:], results)\\n past_num = num\",\n \"runtime\": \"233\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:\\n # dynamic programming\\n # dp[i] = sum target = i\\n dp = [0] * (target + 1)\\n\\n res = []\\n\\n def backtrack(left_target, path):\\n nonlocal res\\n if left_target == 0 and path not in res:\\n res.append(path)\\n return None\\n\\n for c in candidates:\\n if left_target >= c:\\n backtrack(left_target - c, sorted(path + [c]))\\n\\n \\n backtrack(target, [])\\n return res\",\n \"runtime\": \"236\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n queue = collections.deque()\\n queue.append(([], 0))\\n answered = {}\\n answer = []\\n while queue:\\n currentList, currentSum = queue.popleft()\\n if currentSum == target: \\n hashThis = tuple(sorted(currentList))\\n if hashThis not in answered:\\n answer.append(currentList)\\n answered[hashThis] = True\\n continue\\n for x in candidates:\\n if currentSum + x > target:\\n continue\\n queue.append((currentList + [x], currentSum + x))\\n return answer\",\n \"runtime\": \"236\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = set()\\n self.helper(candidates, target, 0, [], result)\\n return result\\n \\n def helper(self, candidates, target, index, slate, result):\\n # Base Case\\n if index == len(candidates): \\n if sum(slate[:]) == target:\\n if tuple(sorted(slate[:])) not in result:\\n result.add(tuple(sorted(slate[:])))\\n return\\n \\n # Pruning\\n if sum(slate[:]) > target:\\n return \\n \\n # Recursive Cases \\n # Include \\n slate.append(candidates[index])\\n self.helper(candidates, target, index + 1, slate, result)\\n slate.pop()\\n # Same Character\\n slate.append(candidates[index])\\n self.helper(candidates, target, index, slate, result)\\n slate.pop()\\n # Exclude \\n self.helper(candidates, target, index + 1, slate, result)\\n \",\n \"runtime\": \"240\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates, target):\\n n, res = len(candidates), set()\\n\\n candidates.sort()\\n\\n def backtrack(i,path,total):\\n if i == n:\\n if total == target:\\n res.add(tuple(sorted(path))) \\n\\n if total > target:\\n return \\n\\n if i < n:\\n path.append(candidates[i])\\n backtrack(i+1,path,total+candidates[i])\\n path.pop()\\n\\n if i < n:\\n path.append(candidates[i])\\n backtrack(i,path,total+candidates[i])\\n path.pop()\\n\\n if i < n:\\n backtrack(i+1,path,total)\\n\\n backtrack(0,[],0)\\n return res\",\n \"runtime\": \"240\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = set()\\n curr_result = []\\n self.combinationSumInternal(target, candidates, result, curr_result)\\n return result\\n \\n def combinationSumInternal(self, target, candidates, result, curr_result):\\n if target == 0:\\n result.add(tuple(sorted(curr_result)))\\n \\n for c in candidates:\\n if target - c >= 0:\\n curr_result.append(c)\\n self.combinationSumInternal(target - c, candidates, result, curr_result)\\n curr_result.pop()\",\n \"runtime\": \"243\"\n },\n {\n \"code\": \"class Solution:\\n def recur(self, i: int, comb: List[int]) -> None:\\n curr_sum = sum(comb)\\n if curr_sum == self.target and tuple(comb) not in self.combinations:\\n self.combinations.add(tuple(comb))\\n return\\n \\n if i >= self.n or curr_sum > self.target:\\n return\\n \\n self.recur(i + 1, list(comb))\\n comb.append(self.candidates[i])\\n self.recur(i, list(comb))\\n self.recur(i + 1, list(comb))\\n\\n \\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n self.target = target\\n self.candidates = candidates\\n self.n = len(candidates)\\n self.combinations = set()\\n\\n self.recur(0, [])\\n\\n unique_combs = [list(t) for t in self.combinations]\\n return unique_combs\",\n \"runtime\": \"243\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n sortedCandidates = sorted(candidates)\\n stack = []\\n output = []\\n def DFS(candidates, target):\\n i = 0\\n while(i < len(candidates) and candidates[i] <= target): #candidates will be sorted\\n print(\\\"Stack, \\\", stack, \\\"\\\\nCandidates\\\", candidates, \\\"\\\\nCur Candidate\\\", candidates[i], \\\"\\\\nTarget\\\", target, \\\"\\\\nOutput\\\", output)\\n if (candidates[i] == target):\\n result = stack.copy()\\n result.append(candidates[i])\\n output.append(result)\\n else:\\n stack.append(candidates[i])\\n DFS(candidates[i:], target - candidates[i])\\n stack.pop()\\n i += 1\\n \\n DFS(sortedCandidates, target)\\n return output\",\n \"runtime\": \"246\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = set()\\n curr_result = []\\n self.combinationSumInternal(target, candidates, result, curr_result)\\n return result\\n \\n def combinationSumInternal(self, target, candidates, result, curr_result):\\n if target == 0:\\n result.add(tuple(sorted(curr_result)))\\n \\n for c in candidates:\\n if target - c >= 0:\\n curr_result.append(c)\\n self.combinationSumInternal(target - c, candidates, result, curr_result)\\n curr_result.pop()\",\n \"runtime\": \"246\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, nums: List[int], target: int) -> List[List[int]]:\\n def dfs(i,lst):\\n if sum(lst) == target:\\n if sorted(lst) not in ans:\\n ans.append(sorted(lst))\\n return\\n elif sum(lst) > target or i >= len(nums):\\n return \\n \\n dfs(i,lst+[nums[i]])\\n dfs(i+1,lst+[nums[i]])\\n dfs(i+1,lst)\\n \\n ans = []\\n dfs(0,[])\\n return ans\\n \\n \",\n \"runtime\": \"250\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n results = []\\n seen_combinations = set()\\n combination = []\\n\\n def dfs(nums):\\n if \\\" \\\".join(map(str, combination)) in seen_combinations:\\n return\\n if not nums:\\n if sum(combination) == target:\\n results.append(combination.copy())\\n return\\n counter = 0\\n while sum(combination) <= target:\\n combination.append(nums[0])\\n dfs(nums[1:])\\n counter += 1\\n seen_combinations.add(\\\" \\\".join(map(str, combination)))\\n\\n for _ in range(counter):\\n combination.pop()\\n dfs(nums[1:])\\n seen_combinations.add(\\\" \\\".join(map(str, combination)))\\n\\n\\n dfs(candidates)\\n unique_solutions = []\\n for result in results:\\n if result not in unique_solutions:\\n unique_solutions.append(result)\\n return unique_solutions\\n\",\n \"runtime\": \"250\"\n },\n {\n \"code\": \"import copy\\n\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combinations = []\\n # print(candidates[len(candidates) - 1 : len(candidates)])\\n self.helper(candidates, target, combinations, [], 0)\\n return combinations\\n\\n def helper(self, candidates, target, combinations, combination, sum):\\n # print(candidates)\\n if len(candidates) == 0: return\\n if (sum == target):\\n combinations.append(combination)\\n return\\n if (sum > target):\\n return\\n else: \\n # include the current candidate and continue using it\\n copy1 = copy.deepcopy(combination)\\n copy1.append(candidates[0])\\n copy2 = copy.deepcopy(combination)\\n copy2.append(candidates[0])\\n self.helper(candidates[:len(candidates)], target, combinations, copy1, sum + candidates[0])\\n # include the current candidate and don't continue using it\\n # self.helper(candidates[1:len(candidates)], target, combinations, copy2, sum + candidates[0])\\n # don't include the current candidate and dont continue using it\\n self.helper(candidates[1:len(candidates)], target, combinations, combination, sum)\",\n \"runtime\": \"253\"\n },\n {\n \"code\": \"class Solution:\\n \\\"\\\"\\\"\\n [문제]\\n - 유니크한 정수 배열 candidates\\n - 타겟 넘버\\n - 후보 숫자는 제한 없이 선택될 수 있다.\\n - 후보 숫자 개수가 다르면, 다른 조합으로 간주한다.\\n Q. candidates 내에서 유니크한 컴비네이션 리스트 반환\\n 총합으로 타겟 넘버를 만들 수 있는...\\n\\n [인풋]\\n - 후보 숫자 종류 : 최대 30\\n - 후보 숫자 값 : 2 ~ 40\\n - 타겟 : 1 ~ 40\\n\\n [아이디어]\\n - 모든 경우 탐색해야지\\n - 다만 target을 넘는 경우 바로 컷하면 된다.\\n \\\"\\\"\\\"\\n def __init__(self):\\n self.for_dist = set()\\n\\n def combinationSum(self, cs: List[int], t: int) -> List[List[int]]:\\n def search(cs: List[int], curr: int, t: int, cnt: List[int]):\\n for idx, c in enumerate(cs):\\n new_curr = curr + c\\n if new_curr > t:\\n continue\\n new_cnt = cnt.copy()\\n new_cnt[idx] += 1\\n if new_curr == t:\\n tuple_cnt = tuple(new_cnt)\\n if tuple_cnt in self.for_dist:\\n continue\\n self.for_dist.add(tuple_cnt)\\n continue\\n search(cs, new_curr, t, new_cnt)\\n \\n cnt_init = [0 for _ in range(len(cs))]\\n search(cs, 0, t, cnt_init)\\n\\n result = []\\n for tuple_cnt in self.for_dist:\\n curr_result = []\\n for idx, cnt in enumerate(tuple_cnt):\\n for _ in range(cnt):\\n curr_result.append(cs[idx])\\n result.append(curr_result)\\n return result\",\n \"runtime\": \"253\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = set()\\n curr_result = []\\n self.combinationSumInternal(target, candidates, result, curr_result)\\n return result\\n \\n def combinationSumInternal(self, target, candidates, result, curr_result):\\n if target == 0:\\n result.add(tuple(sorted(curr_result)))\\n \\n for c in candidates:\\n if target - c >= 0:\\n curr_result.append(c)\\n self.combinationSumInternal(target - c, candidates, result, curr_result)\\n curr_result.pop()\",\n \"runtime\": \"256\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n\\n res = []\\n def search(candidates, target, chain):\\n for i in candidates:\\n sub = target - i\\n if sub == 0:\\n s = sorted(chain + [i])\\n if s not in res:\\n res.append(s)\\n if sub > 0:\\n chain.append(i)\\n search(candidates, target - i, chain)\\n chain.pop()\\n\\n \\n \\n\\n search(candidates, target, [])\\n\\n return res\",\n \"runtime\": \"256\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combos = set()\\n Q = deque([(target, [])])\\n\\n while Q:\\n remaining, combo = Q.popleft()\\n if remaining == 0:\\n combo.sort()\\n combos.add(tuple(combo))\\n continue\\n for num in candidates:\\n if remaining - num < 0:\\n continue\\n Q.append((remaining - num, combo + [num]))\\n\\n return list(combos)\",\n \"runtime\": \"260\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result= []\\n \\n def getSubsequnces(i, suma , nums, n, target):\\n\\n if sum(suma) == target:\\n if suma not in result:\\n result.append(suma)\\n return\\n if sum(suma) > target:\\n return\\n if i == n:\\n return \\n \\n getSubsequnces(i+1, suma[:] + [nums[i]], nums, n, target)\\n\\n\\n getSubsequnces(i+1, suma, nums, n, target)\\n \\n getSubsequnces(i, suma[:] + [nums[i]], nums, n, target)\\n\\n\\n\\n getSubsequnces(0, [], candidates, len(candidates), target)\\n\\n return result\",\n \"runtime\": \"260\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n def signature(candidates):\\n return tuple(sorted(candidates))\\n res = []\\n visited = set()\\n stack = [([], 0)]\\n while stack:\\n tmp_solution, tot = stack.pop()\\n if tot == target:\\n sig = signature(tmp_solution) \\n if signature(tmp_solution) not in visited:\\n visited.add(sig)\\n res.append(tmp_solution)\\n for i in candidates:\\n if i <= target - tot:\\n stack.append((tmp_solution + [i], tot + i))\\n \\n return res\\n\",\n \"runtime\": \"263\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n for cand in candidates:\\n diff = target - cand\\n if (diff == 0):\\n extended = [cand]\\n if extended not in res:\\n res.append(extended)\\n\\n elif (diff > 0):\\n # recurse\\n rec = self.combinationSum(candidates, diff)\\n \\n for r in rec:\\n # r is like [3]\\n #cr = copy.copy(r)\\n r.extend([cand])\\n r.sort()\\n if r not in res:\\n res.append(r)\\n\\n # just want unique elem - check\\n return res\",\n \"runtime\": \"263\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combos = set()\\n Q = deque([(target, ())])\\n seen = set()\\n\\n while Q:\\n remaining, combo = Q.pop()\\n for num in candidates:\\n if remaining - num < 0:\\n continue\\n new_combo = tuple(sorted(list(combo) + [num]))\\n if remaining - num == 0:\\n combos.add(new_combo)\\n continue\\n # if (remaining - num, new_combo) in seen:\\n continue\\n Q.append((remaining - num, new_combo))\\n # seen.add((remaining - num, new_combo))\\n\\n return list(combos)\",\n \"runtime\": \"266\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import deque\\n\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n queue = deque()\\n queue.append((target, []))\\n\\n self.res = []\\n\\n while queue:\\n remain, vals = queue.popleft()\\n\\n if remain == 0:\\n self.res.append(vals)\\n continue\\n\\n for n in candidates:\\n if remain - n >= 0:\\n vals.append(n)\\n queue.append(\\n (remain - n, vals.copy())\\n )\\n vals.pop()\\n\\n return list(map(\\n list,\\n set(\\n tuple(sorted(option))\\n for option in self.res\\n )\\n )\\n )\\n\\n# candidates = [2,3,6,7]\\n# target = 7\\n\\n# res = Solution().combinationSum(candidates, target)\\n# print(res)\",\n \"runtime\": \"266\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n global output\\n output = []\\n def make_combination(lis):\\n val = target - sum(lis)\\n if val in candidates:\\n comb = lis + [val]\\n comb.sort()\\n if comb not in output:\\n output.append(comb)\\n\\n poss = [can for can in candidates if can < val] \\n\\n for v in poss:\\n new_lis = lis + [v]\\n make_combination(new_lis)\\n\\n \\n make_combination([])\\n\\n return(output) \",\n \"runtime\": \"270\"\n },\n {\n \"code\": \"class Solution:\\n from collections import defaultdict\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n\\n graph = defaultdict(list)\\n stack = []\\n for c in candidates:\\n graph[c] = candidates\\n stack.append( (c, c, [c] ) )\\n \\n\\n \\n res = []\\n visited = set()\\n while stack:\\n\\n node,summ,path = stack.pop()\\n\\n if summ == target and tuple(sorted(path)) not in visited:\\n res.append(path)\\n visited.add(tuple(sorted(path)))\\n \\n\\n for neighbors in graph[node]:\\n\\n if (summ + neighbors) <= target:\\n\\n stack.append( (neighbors, summ + neighbors, path[:] + [neighbors]) )\\n\\n\\n return res\\n\\n\",\n \"runtime\": \"270\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combos = set()\\n Q = deque([(target, ())])\\n seen = set()\\n\\n while Q:\\n remaining, combo = Q.pop()\\n for num in candidates:\\n if remaining - num < 0:\\n continue\\n new_combo = tuple(sorted(list(combo) + [num]))\\n if remaining - num == 0:\\n combos.add(new_combo)\\n continue\\n # if (remaining - num, new_combo) in seen:\\n continue\\n Q.append((remaining - num, new_combo))\\n # seen.add((remaining - num, new_combo))\\n\\n return list(combos)\",\n \"runtime\": \"273\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n\\n res = []\\n def search(candidates, target, chain):\\n for i in candidates:\\n sub = target - i\\n if sub == 0:\\n s = sorted(chain + [i])\\n if s not in res:\\n res.append(s)\\n if sub > 0:\\n chain.append(i)\\n search(candidates, target - i, chain)\\n chain.remove(i)\\n\\n \\n \\n\\n search(candidates, target, [])\\n\\n return res\",\n \"runtime\": \"273\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n self.acc = []\\n\\n def helper(array):\\n array_val = sum(array)\\n if array_val == target:\\n if sorted(array) not in self.acc:\\n self.acc.append(sorted(array))\\n\\n if array_val < target:\\n for c in candidates:\\n if array_val + c <= target:\\n new_array = copy.copy(array)\\n new_array.append(c)\\n helper(new_array)\\n\\n helper([])\\n\\n return self.acc\\n\",\n \"runtime\": \"276\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n result = []\\n def findSum(curr, result):\\n if curr == 0 and sorted(result) not in ans: \\n ans.append(sorted(result[:]))\\n\\n for num in candidates:\\n if curr - num >= 0:\\n findSum(curr - num, result + [num])\\n \\n findSum(target, [])\\n\\n return ans\",\n \"runtime\": \"276\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = set()\\n\\n def dfs(i, sums, path, cache):\\n if tuple(path) in cache:\\n return\\n if sums == target:\\n result.add(tuple(sorted(path)))\\n return\\n if i == len(candidates):\\n return\\n for j in range(i, len(candidates)):\\n if sums + candidates[j] <= target:\\n dfs(j+1, sums + candidates[j], path + [candidates[j]], cache)\\n cache.add(tuple(path + [candidates[j]]))\\n \\n temp = []\\n for candidate in candidates:\\n for _ in range(20):\\n temp.append(candidate)\\n candidates = temp\\n dfs(0, 0, [], set())\\n\\n return result\",\n \"runtime\": \"280\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n self.acc = []\\n\\n def helper(array):\\n array_val = sum(array)\\n if array_val == target:\\n if sorted(array) not in self.acc:\\n self.acc.append(sorted(array))\\n\\n if array_val < target:\\n for c in candidates:\\n if array_val + c <= target:\\n new_array = copy.copy(array)\\n new_array.append(c)\\n helper(new_array)\\n\\n else:\\n return\\n\\n helper([])\\n\\n return self.acc\\n\",\n \"runtime\": \"280\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n s = []\\n for candidate in candidates:\\n if candidate <= target:\\n s.append((candidate, [candidate]))\\n \\n while s:\\n cur, lst = s.pop()\\n if cur == target:\\n res.append(lst)\\n continue\\n\\n for candidate in candidates:\\n if cur + candidate <= target:\\n s.append((cur + candidate, lst + [candidate]))\\n\\n res = [sorted(el) for el in res]\\n m = {}\\n for r in res:\\n m[''.join([str(v) for v in r])] = r\\n res = m.values()\\n return res\",\n \"runtime\": \"283\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n # res = []\\n # def backtrack(comb, index, total):\\n # if total == target:\\n # res.append(comb[:])\\n # return\\n # if total > target or index == len(candidates):\\n # return\\n \\n # backtrack(comb + [candidate[index]], index, total + candidate[index])\\n # comb.pop()\\n # backtrack(comb + [candidate[index+1]], index, total + candidate[index+1])\\n # backtrack([],0,0)\\n # return res\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n # Stack approach, very slow\\n res = []\\n pos = []\\n for cand in candidates:\\n if cand == target:\\n res.append([cand])\\n pos.append(([cand], cand))\\n while len(pos) != 0:\\n elem = pos.pop()\\n for cand in candidates:\\n total = elem[1]+cand\\n if total == target:\\n finalArr = elem[0] + [cand]\\n finalArr.sort()\\n if finalArr not in res:\\n res.append(finalArr)\\n elif total < target:\\n pos.append((elem[0] + [cand], total))\\n return res\\n \\n\",\n \"runtime\": \"283\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n results = []\\n\\n def dfs(combo):\\n nonlocal target, results\\n if combo:\\n currSum = sum(combo)\\n else:\\n currSum = 0\\n for candidate in candidates:\\n if currSum + candidate == target:\\n to_add = combo + [candidate]\\n results.append(to_add)\\n elif currSum + candidate > target:\\n pass\\n else:\\n to_call = combo + [candidate]\\n dfs(to_call)\\n \\n \\n dfs([])\\n results = [sorted(x) for x in results]\\n to_return = []\\n for x in results:\\n if x not in to_return:\\n to_return.append(x)\\n\\n return to_return\\n\",\n \"runtime\": \"286\"\n },\n {\n \"code\": \"from collections import deque\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n combos = set()\\n Q = deque([(target, [])])\\n\\n while Q:\\n remaining, combo = Q.popleft()\\n if remaining == 0:\\n combos.add(tuple(combo))\\n continue\\n for num in candidates:\\n if remaining - num < 0:\\n continue\\n Q.append((remaining - num, sorted(combo + [num])))\\n\\n return list(combos)\",\n \"runtime\": \"286\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n\\n\\n res = []\\n current = []\\n\\n def dfs(index):\\n\\n if index == len(candidates) or sum(current) > target:\\n return\\n\\n if current not in res and sum(current) == target:\\n res.append(current.copy())\\n\\n \\n current.append(candidates[index])\\n dfs(index)\\n dfs(index+1)\\n\\n current.pop(-1)\\n dfs(index+1)\\n\\n dfs(0)\\n\\n return res\\n\",\n \"runtime\": \"290\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n bfs = [(target, [])]\\n result = []\\n\\n while bfs:\\n resid, hist = bfs.pop()\\n\\n for elem in candidates:\\n new_resid = resid - elem\\n \\n if new_resid == 0:\\n new_hist = hist[:]\\n new_hist.append(elem)\\n new_hist = sorted(new_hist)\\n if new_hist not in result:\\n result.append(new_hist)\\n\\n elif new_resid > 0:\\n new_hist = hist[:]\\n new_hist.append(elem)\\n bfs.append((new_resid, new_hist))\\n \\n return result\\n\",\n \"runtime\": \"290\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":153,"string":"153"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n result = []\n subset = []\n def _combinationSum(i):\n if sum(subset) > target or i >= len(candidates):\n return\n if sum(subset) == target:\n result.append(subset.copy())\n return\n\n subset.append(candidates[i])\n _combinationSum(i)\n\n subset.pop()\n _combinationSum(i + 1)\n\n _combinationSum(0)\n return result\n","memory":"16100"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n combination = []\n\n def dfs(i, total):\n if total == target:\n res.append(combination.copy())\n return\n if i == len(candidates) or total > target:\n return\n \n combination.append(candidates[i])\n dfs(i, total + candidates[i])\n\n combination.pop()\n dfs(i+1, total)\n \n dfs(0,0)\n return res\n ","memory":"16200"},{"code":"'''\n 2 3 6 7\n\n\n'''\nclass Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n\n # candidates.sort()\n\n def backtrack(rem, combo, start):\n if rem == 0:\n result.append(combo.copy())\n return\n if rem < 0:\n return\n \n for i in range(start, n):\n num = candidates[i]\n\n combo.append(num)\n backtrack(rem - num, combo, i)\n\n combo.pop()\n\n n = len(candidates)\n result = []\n\n backtrack(target, [], 0)\n\n return result\n","memory":"16300"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n self.dfs(res, [], candidates, target, 0)\n return res\n \n\n def dfs(self, res, temp, candidates, target, idx):\n # if target < 0:\n # return\n if sum(temp) > target:\n return\n\n if sum(temp) == target:\n res.append(temp[:])\n return\n \n for idx in range(idx, len(candidates)):\n temp.append(candidates[idx])\n # self.dfs(res, temp, candidates, target-candidates[idx], idx)\n self.dfs(res, temp, candidates, target, idx)\n temp.pop()\n","memory":"16300"},{"code":"class Solution:\n def combinationSum(self, c : List[int], t : int) -> List[List[int]]:\n def find(c,ind,ans,temp,s,t):\n if s == t :\n ans.append(temp.copy())\n return\n if s > t or ind == len(c):\n return\n temp.append(c[ind])\n find(c,ind,ans,temp,s+c[ind],t)\n temp.pop()\n find(c,ind+1,ans,temp,s,t)\n\n ans = []\n temp = []\n find(c,0,ans,temp,0,t)\n return ans","memory":"16400"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n len_cand = len(candidates)\n \n def find_combinations(j, current_comb):\n if current_comb[0] == target:\n return [current_comb]\n new_combs = []\n for i in range(j, len_cand):\n new_comb_ar = current_comb[1] + [candidates[i]]\n new_comb_sum = current_comb[0] + candidates[i]\n\n if new_comb_sum <= target:\n res = find_combinations(i, (new_comb_sum, new_comb_ar))\n if res:\n new_combs += res\n \n return new_combs\n \n results = []\n\n for i in range(len(candidates)):\n result = find_combinations(i, (candidates[i], [candidates[i]]))\n if result:\n results += result\n\n return [a[1] for a in results]\n","memory":"16400"},{"code":"class Solution:\n def checkTarget(self, nums, target):\n total = 0\n for num in nums:\n total += num\n if total > target:\n break\n return total\n \n\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n total_sol = []\n\n def backtrack(solution, start):\n totalSum = self.checkTarget(solution, target)\n\n if totalSum == target:\n total_sol.append(solution[:])\n return\n \n while totalSum < target and start < len(candidates):\n solution.append(candidates[start])\n backtrack(solution, start)\n solution.pop()\n start +=1\n\n backtrack([], 0)\n return total_sol\n\n\n \n\n ","memory":"16500"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n n = len(candidates)\n path = []\n ans = []\n\n def backtrack(index, preSum):\n if preSum > target:\n return\n if preSum == target:\n ans.append(path[:])\n return\n for i in range(index, n):\n preSum += candidates[i]\n # if preSum > target: break\n path.append(candidates[i])\n backtrack(i, preSum)\n preSum -= candidates[i]\n path.pop()\n \n backtrack(0, 0)\n return ans","memory":"16500"},{"code":"class Solution:\n # Method: DFS(combination) -> T = O(n^2)\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n results = [] \n self.dfs(candidates, 0, [], results, target)\n return results \n \n # recursion_1: define\n def dfs(self, A, start, result, results, target):\n # recursion_3: exit \n if target == 0:\n results.append(list(result))\n return \n \n # for this question, it has constraints that both target and all elements in candidates are positive \n if target < 0 or start == len(A): \n return \n \n # recursion_2: divide \n for i in range(start, len(A)):\n result.append(A[i])\n self.dfs(A, i, result, results, target - A[i])\n\n # recursion_4: backtracing \n result.pop() \n \n\n \n","memory":"16600"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates = sorted(candidates, reverse=True) \n\n ans = []\n self.solve(candidates, 0, target, [], ans) \n return ans \n \n def solve(self, candidates, idx, target, curr, ans): \n if target == 0: \n ans.append(curr.copy())\n return \n \n if target < 0 or idx >= len(candidates): \n return \n \n for i in range(idx, len(candidates)): \n curr.append(candidates[i])\n self.solve(candidates, i, target - candidates[i], curr, ans)\n curr.pop()\n \n \n\n","memory":"16600"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n # def dfs(nums, target, path=[], total=0):\n # if total == target:\n # res.append(path)\n # return\n # elif total > target:\n # return\n \n # for i in range(len(nums)):\n # dfs(nums[i:], target, path + [nums[i]], total + nums[i])\n\n # dfs(0, candidates, target)\n # return res\n\n def dfs(i, target, path=[]):\n if target == 0:\n res.append(path)\n return\n elif target < 0 or i >= len(candidates):\n return\n\n # path.append(candidates[i])\n dfs(i, target - candidates[i], path + [candidates[i]])\n dfs(i + 1, target, path)\n \n dfs(0, target)\n return res","memory":"16700"},{"code":"class Solution:\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n # def dfs(nums, target, path=[], total=0):\n # if total == target:\n # res.append(path)\n # return\n # elif total > target:\n # return\n \n # for i in range(len(nums)):\n # dfs(nums[i:], target, path + [nums[i]], total + nums[i])\n\n # dfs(0, candidates, target)\n # return res\n\n def dfs(i, target, path=[]):\n if target == 0:\n res.append(path)\n return\n elif target < 0 or i >= len(candidates):\n return\n\n path.append(candidates[i])\n dfs(i, target - candidates[i], path.copy())\n path.pop()\n dfs(i + 1, target, path)\n \n dfs(0, target)\n return res","memory":"16700"}],"string":"[\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = []\\n subset = []\\n def _combinationSum(i):\\n if sum(subset) > target or i >= len(candidates):\\n return\\n if sum(subset) == target:\\n result.append(subset.copy())\\n return\\n\\n subset.append(candidates[i])\\n _combinationSum(i)\\n\\n subset.pop()\\n _combinationSum(i + 1)\\n\\n _combinationSum(0)\\n return result\\n\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n combination = []\\n\\n def dfs(i, total):\\n if total == target:\\n res.append(combination.copy())\\n return\\n if i == len(candidates) or total > target:\\n return\\n \\n combination.append(candidates[i])\\n dfs(i, total + candidates[i])\\n\\n combination.pop()\\n dfs(i+1, total)\\n \\n dfs(0,0)\\n return res\\n \",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"'''\\n 2 3 6 7\\n\\n\\n'''\\nclass Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n # candidates.sort()\\n\\n def backtrack(rem, combo, start):\\n if rem == 0:\\n result.append(combo.copy())\\n return\\n if rem < 0:\\n return\\n \\n for i in range(start, n):\\n num = candidates[i]\\n\\n combo.append(num)\\n backtrack(rem - num, combo, i)\\n\\n combo.pop()\\n\\n n = len(candidates)\\n result = []\\n\\n backtrack(target, [], 0)\\n\\n return result\\n\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n self.dfs(res, [], candidates, target, 0)\\n return res\\n \\n\\n def dfs(self, res, temp, candidates, target, idx):\\n # if target < 0:\\n # return\\n if sum(temp) > target:\\n return\\n\\n if sum(temp) == target:\\n res.append(temp[:])\\n return\\n \\n for idx in range(idx, len(candidates)):\\n temp.append(candidates[idx])\\n # self.dfs(res, temp, candidates, target-candidates[idx], idx)\\n self.dfs(res, temp, candidates, target, idx)\\n temp.pop()\\n\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, c : List[int], t : int) -> List[List[int]]:\\n def find(c,ind,ans,temp,s,t):\\n if s == t :\\n ans.append(temp.copy())\\n return\\n if s > t or ind == len(c):\\n return\\n temp.append(c[ind])\\n find(c,ind,ans,temp,s+c[ind],t)\\n temp.pop()\\n find(c,ind+1,ans,temp,s,t)\\n\\n ans = []\\n temp = []\\n find(c,0,ans,temp,0,t)\\n return ans\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n len_cand = len(candidates)\\n \\n def find_combinations(j, current_comb):\\n if current_comb[0] == target:\\n return [current_comb]\\n new_combs = []\\n for i in range(j, len_cand):\\n new_comb_ar = current_comb[1] + [candidates[i]]\\n new_comb_sum = current_comb[0] + candidates[i]\\n\\n if new_comb_sum <= target:\\n res = find_combinations(i, (new_comb_sum, new_comb_ar))\\n if res:\\n new_combs += res\\n \\n return new_combs\\n \\n results = []\\n\\n for i in range(len(candidates)):\\n result = find_combinations(i, (candidates[i], [candidates[i]]))\\n if result:\\n results += result\\n\\n return [a[1] for a in results]\\n\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def checkTarget(self, nums, target):\\n total = 0\\n for num in nums:\\n total += num\\n if total > target:\\n break\\n return total\\n \\n\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n total_sol = []\\n\\n def backtrack(solution, start):\\n totalSum = self.checkTarget(solution, target)\\n\\n if totalSum == target:\\n total_sol.append(solution[:])\\n return\\n \\n while totalSum < target and start < len(candidates):\\n solution.append(candidates[start])\\n backtrack(solution, start)\\n solution.pop()\\n start +=1\\n\\n backtrack([], 0)\\n return total_sol\\n\\n\\n \\n\\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n n = len(candidates)\\n path = []\\n ans = []\\n\\n def backtrack(index, preSum):\\n if preSum > target:\\n return\\n if preSum == target:\\n ans.append(path[:])\\n return\\n for i in range(index, n):\\n preSum += candidates[i]\\n # if preSum > target: break\\n path.append(candidates[i])\\n backtrack(i, preSum)\\n preSum -= candidates[i]\\n path.pop()\\n \\n backtrack(0, 0)\\n return ans\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n # Method: DFS(combination) -> T = O(n^2)\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n results = [] \\n self.dfs(candidates, 0, [], results, target)\\n return results \\n \\n # recursion_1: define\\n def dfs(self, A, start, result, results, target):\\n # recursion_3: exit \\n if target == 0:\\n results.append(list(result))\\n return \\n \\n # for this question, it has constraints that both target and all elements in candidates are positive \\n if target < 0 or start == len(A): \\n return \\n \\n # recursion_2: divide \\n for i in range(start, len(A)):\\n result.append(A[i])\\n self.dfs(A, i, result, results, target - A[i])\\n\\n # recursion_4: backtracing \\n result.pop() \\n \\n\\n \\n\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates = sorted(candidates, reverse=True) \\n\\n ans = []\\n self.solve(candidates, 0, target, [], ans) \\n return ans \\n \\n def solve(self, candidates, idx, target, curr, ans): \\n if target == 0: \\n ans.append(curr.copy())\\n return \\n \\n if target < 0 or idx >= len(candidates): \\n return \\n \\n for i in range(idx, len(candidates)): \\n curr.append(candidates[i])\\n self.solve(candidates, i, target - candidates[i], curr, ans)\\n curr.pop()\\n \\n \\n\\n\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n # def dfs(nums, target, path=[], total=0):\\n # if total == target:\\n # res.append(path)\\n # return\\n # elif total > target:\\n # return\\n \\n # for i in range(len(nums)):\\n # dfs(nums[i:], target, path + [nums[i]], total + nums[i])\\n\\n # dfs(0, candidates, target)\\n # return res\\n\\n def dfs(i, target, path=[]):\\n if target == 0:\\n res.append(path)\\n return\\n elif target < 0 or i >= len(candidates):\\n return\\n\\n # path.append(candidates[i])\\n dfs(i, target - candidates[i], path + [candidates[i]])\\n dfs(i + 1, target, path)\\n \\n dfs(0, target)\\n return res\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n # def dfs(nums, target, path=[], total=0):\\n # if total == target:\\n # res.append(path)\\n # return\\n # elif total > target:\\n # return\\n \\n # for i in range(len(nums)):\\n # dfs(nums[i:], target, path + [nums[i]], total + nums[i])\\n\\n # dfs(0, candidates, target)\\n # return res\\n\\n def dfs(i, target, path=[]):\\n if target == 0:\\n res.append(path)\\n return\\n elif target < 0 or i >= len(candidates):\\n return\\n\\n path.append(candidates[i])\\n dfs(i, target - candidates[i], path.copy())\\n path.pop()\\n dfs(i + 1, target, path)\\n \\n dfs(0, target)\\n return res\",\n \"memory\": \"16700\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":12,"string":"12"}}},{"rowIdx":76,"cells":{"question_id":{"kind":"number","value":40,"string":"40"},"name":{"kind":"string","value":"combination-sum-ii"},"content":{"kind":"string","value":"<p>Given a collection of candidate numbers (<code>candidates</code>) and a target number (<code>target</code>), find all unique combinations in <code>candidates</code> where the candidate numbers sum to <code>target</code>.</p>\n\n<p>Each number in <code>candidates</code> may only be used <strong>once</strong> in the combination.</p>\n\n<p><strong>Note:</strong> The solution set must not contain duplicate combinations.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> candidates = [10,1,2,7,6,1,5], target = 8\n<strong>Output:</strong> \n[\n[1,1,6],\n[1,2,5],\n[1,7],\n[2,6]\n]\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> candidates = [2,5,2,1,2], target = 5\n<strong>Output:</strong> \n[\n[1,2,2],\n[5]\n]\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= candidates.length <= 100</code></li>\n\t<li><code>1 <= candidates[i] <= 50</code></li>\n\t<li><code>1 <= target <= 30</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":56.43094949533659,"string":"56.430949"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","backtracking"],"string":"[\n \"array\",\n \"backtracking\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"21\", 0.013400000000000002], [\"22\", 0.0053], [\"23\", 0.0027], [\"24\", 0.0321], [\"25\", 0.0267], [\"26\", 0.0534], [\"27\", 0.0641], [\"28\", 0.1363], [\"29\", 0.1683], [\"30\", 0.1576], [\"31\", 0.2351], [\"32\", 0.4355], [\"33\", 0.4729], [\"34\", 0.5664], [\"35\", 0.7855], [\"36\", 1.1996], [\"37\", 1.0954], [\"38\", 1.2049], [\"39\", 1.5148], [\"40\", 1.9156], [\"42\", 1.6137], [\"43\", 1.766], [\"44\", 1.9423], [\"45\", 2.0305], [\"46\", 1.8408], [\"47\", 1.6137], [\"48\", 1.603], [\"49\", 1.6564], [\"50\", 1.6484], [\"51\", 1.3732], [\"52\", 1.4614], [\"53\", 1.4587], [\"54\", 1.6778], [\"55\", 1.6938], [\"56\", 2.1053], [\"57\", 2.2656], [\"58\", 2.6182], [\"59\", 2.9148], [\"60\", 2.9442], [\"61\", 3.1953], [\"62\", 6.6578], [\"63\", 3.2754], [\"64\", 3.3663], [\"65\", 3.2995], [\"66\", 2.9335], [\"67\", 2.7224], [\"68\", 2.7518], [\"69\", 2.3671], [\"70\", 2.1988], [\"71\", 1.9129], [\"72\", 1.9022], [\"73\", 1.4667], [\"74\", 1.44], [\"75\", 1.2851], [\"76\", 1.1221], [\"77\", 0.9671], [\"78\", 0.8629], [\"79\", 0.6091], [\"80\", 0.4943], [\"81\", 0.4061], [\"83\", 0.3901], [\"84\", 0.2805], [\"85\", 0.334], [\"86\", 0.2404], [\"87\", 0.187], [\"88\", 0.179], [\"89\", 0.2084], [\"90\", 0.187], [\"91\", 0.187], [\"92\", 0.1817], [\"93\", 0.1523], [\"94\", 0.1176], [\"95\", 0.1256], [\"96\", 0.1149], [\"97\", 0.0962], [\"98\", 0.0989], [\"99\", 0.0989], [\"100\", 0.0801], [\"101\", 0.0748], [\"102\", 0.1015]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15900\", 0.0053], [\"16100\", 0.0027], [\"16200\", 0.0347], [\"16300\", 0.5263], [\"16400\", 5.8429], [\"16500\", 22.8881], [\"16600\", 36.42], [\"16700\", 25.9898]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n results = []\n\n def backtracking(index, path, remainingSum):\n if remainingSum == 0:\n results.append(list(path))\n return\n previous = -1\n for i in range(index, len(candidates)):\n c = candidates[i]\n if c == previous:\n continue\n if c > remainingSum:\n break\n path.append(c)\n backtracking(i+1, path, remainingSum - c)\n path.pop()\n previous = c\n\n \n backtracking(0, [], target)\n return results\n \n \n\n\n ","runtime":"21"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans=[]\n ds=[]\n candidates.sort()\n def com(ind,target):\n if target==0:\n ans.append(ds[:])\n return\n for i in range(ind,len(candidates)):\n if(ind<i and candidates[i]==candidates[i-1]):\n continue\n if candidates[i]>target:\n break\n ds.append(candidates[i])\n com(i+1,target-candidates[i])\n ds.pop()\n com(0,target)\n return ans\n ","runtime":"21"},{"code":"class Solution(object):\n def combinationSum2(self, candidates, target):\n ans = []\n ds = []\n candidates.sort()\n\n\n def findCombination(ind, target):\n if target == 0:\n ans.append(ds[:])\n return\n for i in range(ind, len(candidates)):\n if i > ind and candidates[i] == candidates[i - 1]:\n continue\n if candidates[i] > target:\n break\n ds.append(candidates[i])\n findCombination(i + 1, target - candidates[i])\n ds.pop()\n\n\n findCombination(0, target)\n return ans\n ","runtime":"22"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res = []\n\n def dfs(target, start, comb):\n if target < 0:\n return\n if target == 0:\n res.append(comb)\n return\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i-1]:\n continue\n if candidates[i] > target:\n break\n dfs(target-candidates[i], i+1, comb+[candidates[i]])\n\n dfs(target, 0, [])\n return res","runtime":"23"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n\n candidates.sort()\n\n comb = []\n def dfs(i, sum):\n\n for num in range(i, len(candidates)):\n if num > i and candidates[num] == candidates[num - 1]:\n continue\n comb.append(candidates[num])\n next_sum = sum + candidates[num]\n if next_sum == target:\n output.append(comb[:])\n comb.pop(-1)\n return\n elif next_sum > target:\n comb.pop(-1)\n return\n else:\n dfs(num + 1, next_sum)\n comb.pop(-1)\n \n output = []\n dfs(0, 0)\n return output","runtime":"24"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n def backtrack(state, target, choices, start, res):\n if target == 0:\n res.append(list(state))\n return\n for i in range(start, len(choices)):\n if target - choices[i] < 0:\n break\n if i > start and choices[i] == choices[i-1]:\n continue\n state.append(choices[i])\n backtrack(state, target - choices[i], choices, i+1, res)\n state.pop()\n state = []\n candidates.sort()\n start = 0\n res = []\n backtrack(state, target, candidates, start, res)\n return res\n ","runtime":"25"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n ans = []\n self.rec(candidates, 0, target, ans, [])\n return ans\n \n def rec(self, candidates, start, target, ans, curr):\n if target == 0:\n ans.append(curr.copy())\n return\n if target < 0 or start == len(candidates):\n return\n\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i-1]:\n continue\n\n\n if candidates[i] > target:\n break\n \n\n\n curr.append(candidates[i])\n self.rec(candidates, i + 1, target - candidates[i], ans, curr)\n curr.pop()\n return","runtime":"26"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n stack = []\n candidates.sort()\n def findCombinations(ind, target):\n if target == 0:\n ans.append(stack[:])\n return\n for i in range(ind, len(candidates)):\n if i>ind and candidates[i] == candidates[i-1]:\n continue\n if candidates[i] > target:\n break\n stack.append(candidates[i])\n findCombinations(i+1, target- candidates[i])\n stack.pop()\n findCombinations(0, target)\n return ans\n","runtime":"29"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n n = len(candidates)\n path = []\n ans = []\n def dfs(i, value):\n if value == 0: #这个要放在下面哪个if前面，因为即使i==n，我们还要考虑之前所有的element加起来的值是否可以等于target。\n ans.append(path.copy())\n return \n if i == n or value < candidates[i]:\n return \n \n path.append(candidates[i])\n dfs(i + 1, value - candidates[i])\n while i + 1 < n and candidates[i] == candidates[i + 1]:\n i += 1\n path.pop()\n dfs(i + 1, value)\n dfs(0, target)\n return ans\n ","runtime":"30"},{"code":"class Solution(object):\n def combinationSum2(self, candidates, target):\n sum2combination=[]\n sizeCandidates=len(candidates)\n candidates.sort()\n def solve(idx,candidateList,sum): \n if sum==target:\n sum2combination.append(candidateList)\n return \n for candidate in range(idx,sizeCandidates):\n candidatesTraverse=candidates[candidate]\n sumCandidates=sum+candidatesTraverse\n if candidate>idx and candidatesTraverse==candidates[candidate-1]:\n continue\n if sumCandidates>target:\n break\n solve(candidate+1,candidateList+[candidatesTraverse],sumCandidates)\n solve(0,[],0)\n return sum2combination\n ","runtime":"31"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res = []\n\n def dfs(target, start, comb):\n if target < 0:\n return\n if target == 0:\n res.append(comb)\n return\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i-1]:\n continue\n if candidates[i] > target:\n break\n dfs(target-candidates[i], i+1, comb+[candidates[i]])\n\n dfs(target, 0, [])\n return res","runtime":"32"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res=[]\n candidates.sort()\n def subsets(ind, targetSum, ds):\n if targetSum == 0:\n res.append(ds.copy())\n return\n \n if ind >= len(candidates) or targetSum-candidates[ind]<0:\n return\n ds.append(candidates[ind])\n subsets(ind+1,targetSum-candidates[ind],ds)\n ds.pop()\n while ind+1<len(candidates) and candidates[ind]==candidates[ind+1]:\n ind = ind +1\n subsets(ind+1,targetSum,ds)\n subsets(0,target,[])\n return res","runtime":"33"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates = sorted(candidates)\n res = []\n subset = []\n\n def backtrack(i, total):\n if total==target:\n res.append(subset.copy())\n return\n \n prev = -1\n for j in range(i, len(candidates)):\n if candidates[j]==prev:\n continue\n elif total+candidates[j]>target:\n return\n subset.append(candidates[j])\n backtrack(j+1, total + candidates[j])\n subset.pop()\n prev = candidates[j]\n\n\n backtrack(0, 0)\n return res","runtime":"34"},{"code":"class Solution:\n def dfs(self, start_index, path, remaining, ans, candidates):\n if remaining==0:\n ans.append(path[:])\n # return\n for i in range(start_index, len(candidates)):\n if candidates[i]>remaining:\n break\n elif i!=start_index and candidates[i]==candidates[i-1]:\n continue\n path.append(candidates[i])\n self.dfs(i+1, path, remaining-candidates[i], ans, candidates)\n path.pop()\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n\n candidates.sort()\n ans = []\n self.dfs(0, [], target, ans, candidates)\n return ans\n\n # def dfs(start_index, path, remaining):\n # if remaining == 0:\n # ans.append(path[:])\n # for i in range(start_index, len(candidates)):\n # if remaining - candidates[i] < 0: # avoid results exceeding target\n # break\n # elif i != start_index and candidates[i] == candidates[i-1]: # avoid duplicates\n # continue\n # path.append(candidates[i])\n # dfs(i+1, path, remaining - candidates[i])\n # path.pop()\n # candidates.sort()\n # ans = []\n # dfs(0, [], target)\n # return ans","runtime":"35"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n n = len(candidates)\n candidates.sort()\n #[1,1,2,5,6,7,10]\n def f(i,arr,curr):\n if curr == target:\n return [arr]\n elif curr > target:\n return []\n \n res = []\n for j in range(i,n,1):\n if candidates[j] + curr > target:\n break\n if j==i or candidates[j] != candidates[j-1]:\n temp = f(j+1,arr+[candidates[j]],curr+candidates[j])\n res += temp\n \n return res\n \n return f(0,[],0)\n ","runtime":"36"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n result = []\n candidates.sort()\n\n def backtrack(curr, total, start):\n if total == target:\n result.append(curr.copy())\n return\n \n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i - 1]:\n continue\n\n if total + candidates[i] > target:\n break\n\n curr.append(candidates[i])\n backtrack(curr, total + candidates[i], i + 1)\n curr.pop()\n \n backtrack([], 0, 0)\n return result","runtime":"36"},{"code":"class Solution:\n def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:\n nums.sort()\n n = len(nums)\n result = []\n self.findSum(result, nums, [], 0, n, target)\n return result\n\n def findSum(self, result: List[List[int]], nums: List[int], currentnums: List[int], i: int, n: int, target: int) -> None:\n if nums[i] > target:\n return\n\n target -= nums[i]\n currentnums.append(nums[i])\n if target == 0:\n result.append(copy.deepcopy(currentnums))\n elif i + 1 < n:\n self.findSum(result, nums, currentnums, i+1, n, target)\n \n target += nums[i]\n currentnums.pop()\n while i + 1 < n and nums[i+1] == nums[i]:\n i += 1\n \n if i + 1 < n:\n self.findSum(result, nums, currentnums, i+1, n, target)\n","runtime":"37"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n\n\n ans = []\n candidates.sort()\n def backtrack(remain, comb, start):\n if remain == 0:\n ans.append(list(comb))\n return\n \n \n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i-1]:\n continue\n if candidates[i] > remain:\n break\n\n comb.append(candidates[i])\n backtrack( remain - candidates[i], comb, i + 1)\n comb.pop()\n\n backtrack(target, [], 0)\n\n return ans\n ","runtime":"38"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort() # Sort the array to manage duplicates\n result = []\n \n def backtrack(start, target, current):\n if target == 0: # Base case: if we hit the target, add the current combination to the result\n result.append(list(current))\n return\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i - 1]:\n continue # Skip duplicates\n if candidates[i] > target:\n break # If the candidate exceeds the target, stop the loop\n current.append(candidates[i])\n backtrack(i + 1, target - candidates[i], current) # Move to the next candidate\n current.pop() # Backtrack by removing the last candidate\n \n backtrack(0, target, [])\n return result","runtime":"38"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res=[]\n def dfs(target,start,comb):\n if target<0:\n return \n if target==0:\n res.append(comb)\n return \n for i in range(start,len(candidates)):\n if i>start and candidates[i]==candidates[i-1]:\n continue\n if candidates[i]>target:\n break\n dfs(target-candidates[i],i+1,comb+[candidates[i]])\n dfs(target,0,[])\n return res\n ","runtime":"39"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res = []\n\n def dfs(target, start, comb):\n if target < 0:\n return\n if target == 0:\n res.append(comb)\n return\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i-1]:\n continue\n if candidates[i] > target:\n break\n dfs(target-candidates[i], i+1, comb+[candidates[i]])\n\n dfs(target, 0, [])\n return res","runtime":"39"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n ans = []\n\n def backtrack(index, target, currArr):\n if target == 0:\n ans.append(list(currArr))\n return\n \n for i in range(index, len(candidates)):\n if i > index and candidates[i] == candidates[i-1]: continue\n if candidates[i] > target: break\n \n currArr.append(candidates[i])\n backtrack(i + 1, target - candidates[i], currArr)\n currArr.pop()\n\n backtrack(0, target, [])\n return ans","runtime":"40"},{"code":"class Solution:\n def comb2(self, ind, arr, target, main, res):\n if target == 0:\n main.append(list(res))\n return main\n for i in range(ind, len(arr)):\n if i!= ind and arr[i] == arr[i-1]:\n continue\n if arr[i] > target:\n break\n res.append(arr[i])\n self.comb2(i+1, arr, target-arr[i], main, res)\n res.pop()\n \n\n\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n main = []\n candidates.sort()\n self.comb2(0, candidates, target, main, [])\n return main\n \n","runtime":"40"},{"code":"#Python3 Code\nclass Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort() # Sort the candidates to handle duplicates and make it easier to skip them\n results = []\n \n def backtrack(start, target, path):\n if target == 0:\n results.append(path)\n return\n if target < 0:\n return\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i - 1]:\n continue\n if candidates[i] > target:\n break\n backtrack(i + 1, target - candidates[i], path + [candidates[i]])\n \n backtrack(0, target, [])\n return results","runtime":"42"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort() # Sort the array to manage duplicates\n result = []\n \n def backtrack(start, target, current):\n if target == 0: # Base case: if we hit the target, add the current combination to the result\n result.append(list(current))\n return\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i - 1]:\n continue # Skip duplicates\n if candidates[i] > target:\n break # If the candidate exceeds the target, stop the loop\n current.append(candidates[i])\n backtrack(i + 1, target - candidates[i], current) # Move to the next candidate\n current.pop() # Backtrack by removing the last candidate\n \n backtrack(0, target, [])\n return result","runtime":"43"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n result = []\n \n def backtrack(start, target, path):\n if target == 0:\n result.append(tuple(path))\n return\n if target < 0:\n return\n \n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i - 1]:\n continue\n if candidates[i] > target:\n break\n path.append(candidates[i])\n backtrack(i + 1, target - candidates[i], path)\n path.pop()\n \n backtrack(0, target, [])\n return result","runtime":"43"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n final_combination = self.find_distinct_combinations(0, candidates, target, [])\n \n return final_combination\n \n def find_distinct_combinations(self, index, candidates, target, local_list):\n sol = []\n if target == 0:\n val = local_list.copy()\n sol.append(val)\n return sol\n \n for val in range(index, len(candidates)):\n if val > index and candidates[val] == candidates[val-1]:\n continue\n if candidates[val] > target:\n return sol\n local_list.append(candidates[val])\n taken_solution_list = self.find_distinct_combinations(val+1, candidates, target-candidates[val], local_list)\n local_list.pop()\n sol.extend(taken_solution_list)\n \n return sol","runtime":"44"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n n = len(candidates)\n candidates.sort()\n #[1,1,2,5,6,7,10]\n def f(i,arr,curr):\n if curr == target:\n return [arr]\n \n res = []\n for j in range(i,n,1):\n if candidates[j] + curr > target:\n break\n if j==i or candidates[j] != candidates[j-1]:\n temp = f(j+1,arr+[candidates[j]],curr+candidates[j])\n res += temp\n \n return res\n \n return f(0,[],0)\n ","runtime":"44"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n final_combination = self.find_distinct_combinations(0, candidates, target, [])\n \n return final_combination\n \n def find_distinct_combinations(self, index, candidates, target, local_list):\n sol = []\n if target == 0:\n val = local_list.copy()\n sol.append(val)\n return sol\n \n for val in range(index, len(candidates)):\n if val > index and candidates[val] == candidates[val-1]:\n continue\n if candidates[val] > target: # if this condtion is not applied, then we run in to time limit exceeded\n return sol\n local_list.append(candidates[val])\n taken_solution_list = self.find_distinct_combinations(val+1, candidates, target-candidates[val], local_list)\n local_list.pop()\n sol.extend(taken_solution_list)\n \n return sol","runtime":"45"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n if sum(candidates) < target:\n return []\n\n candidates.sort(reverse=True)\n candcounts = []\n currcand = None\n currcount = 0\n for cand in candidates:\n if currcand is None:\n currcand = cand\n \n if cand == currcand:\n currcount += 1\n else:\n candcounts.append((currcount, currcand))\n currcand = cand\n currcount = 1\n\n if currcand is not None:\n candcounts.append((currcount, currcand))\n\n sets = set()\n curr = []\n\n def backtrack(total, left):\n if total > target:\n return\n\n if total == target:\n sets.add(tuple(curr))\n return\n\n for i in range(left, len(candcounts)):\n count, cand = candcounts[i]\n\n for amt in range(1, count+1):\n num = cand * amt\n if total + num <= target:\n total += num\n\n for j in range(amt):\n curr.append(cand)\n\n backtrack(total, i+1)\n\n for j in range(amt):\n curr.pop()\n\n total -= num\n\n backtrack(0, 0)\n\n return [[t for t in st] for st in sets]\n","runtime":"45"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n def backtrack(start, target, path, lis):\n\n if target == 0:\n lis.append(path)\n return\n \n for i in range(start, len(candidates)):\n if i>start and candidates[i] == candidates[i-1]:\n continue\n if candidates[i]>target:\n break\n backtrack(i+1, target-candidates[i], path + [candidates[i]], res)\n\n candidates.sort() # Sort to handle duplicates and optimize the search\n res = []\n backtrack(0, target, [], res)\n return res\n","runtime":"46"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n result = []\n\n def dfs(i: int, curr: List[int], curr_sum: int) -> None:\n if curr_sum == target:\n result.append(curr)\n return\n \n if i == len(candidates) or curr_sum + candidates[i] > target:\n return\n\n # Include\n dfs(i+1, [*curr, candidates[i]], curr_sum + candidates[i])\n\n # Exclude, but then also exclude duplicates.\n x = candidates[i]\n i = i+1\n while i < len(candidates) and candidates[i] == x:\n i = i+1\n dfs(i, [*curr], curr_sum)\n \n dfs(0, [], 0)\n return result\n","runtime":"46"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res = []\n def dfs(target, start, comb):\n if target < 0:\n return\n if target == 0:\n res.append(comb)\n return\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i-1]:\n continue\n if candidates[i] > target:\n break\n dfs(target-candidates[i], i+1, comb+[candidates[i]])\n\n dfs(target, 0, [])\n return res","runtime":"47"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n n = len(candidates)\n result = []\n\n def backtrack(start, curr_sum, path):\n if curr_sum == target:\n result.append(path)\n\n for i in range(start, n):\n if i > start and candidates[i] == candidates[i - 1]:\n continue\n \n c = candidates[i]\n if curr_sum + c > target:\n break\n\n backtrack(i + 1, curr_sum + c, path + [c])\n \n backtrack(0, 0, [])\n return result ","runtime":"47"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans=[]\n ds=[]\n candidates.sort()\n\n def findCombination(ind:int,target:int):\n if target == 0:\n ans.append(ds[:])\n return\n for i in range(ind,len(candidates)):\n if i>ind and candidates[i]==candidates[i-1]:\n continue\n if candidates[i]>target:\n break\n ds.append(candidates[i])\n findCombination(i+1,target-candidates[i])\n ds.pop()\n findCombination(0,target)\n return ans ","runtime":"48"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n def backtrack(start, target, path):\n if target == 0:\n result.append(path)\n return\n\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i-1]:\n continue # Skip duplicate elements\n if candidates[i] > target:\n return # Early termination\n backtrack(i+1, target - candidates[i], path + [candidates[i]])\n\n result = []\n candidates.sort()\n backtrack(0, target, [])\n return result","runtime":"48"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n ds = []\n candidates.sort()\n\n def findCombination(ind, target):\n if target == 0:\n ans.append(ds[:])\n return \n for i in range(ind, len(candidates)):\n if i > ind and candidates[i] == candidates[i - 1]:\n continue\n if candidates[i] > target:\n break\n\n ds.append(candidates[i]) \n findCombination(i + 1, target - candidates[i])\n ds.pop()\n\n findCombination(0, target)\n return ans","runtime":"49"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates = sorted(candidates)\n res = []\n subset = []\n\n def backtrack(i, total):\n if total==target:\n res.append(subset.copy())\n return\n elif total>target:\n return\n\n prev = -1\n for i in range(i, len(candidates)):\n if candidates[i] == prev:\n continue\n subset.append(candidates[i])\n backtrack(i + 1, total + candidates[i])\n subset.pop()\n prev = candidates[i]\n\n\n backtrack(0, 0)\n return res","runtime":"49"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n def combi2(arr, ind, target, sub, ans):\n if sum(sub) == target:\n ans.append(sub[:])\n return\n\n\n else:\n for i in range(ind, len(arr)):\n if sum(sub) + arr[i] > target:\n break\n if arr[i] == arr[i - 1] and i > ind:\n continue\n sub.append(arr[i])\n combi2(arr, i + 1, target, sub, ans)\n sub.pop()\n return ans\n \n\n candidates.sort()\n return(combi2(candidates, 0, target, [], []))\n","runtime":"50"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res = []\n\n def dfs(target, start, comb):\n if target < 0:\n return\n if target == 0:\n res.append(comb)\n return\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i-1]:\n continue\n if candidates[i] > target:\n break\n dfs(target-candidates[i], i+1, comb+[candidates[i]])\n\n dfs(target, 0, [])\n return res","runtime":"50"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n ans, c = [], Counter(candidates)\n\n def dfs(s, n, res):\n if s == target: return ans.append(res)\n if s > target or n < 1: return\n for i in range(0, c[n]+1): dfs(s+i*n, n-1, res+[n]*i)\n\n dfs(0, 50, [])\n return ans","runtime":"51"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n\n res = []\n\n def backtrack(curr, pos, target):\n prev = -1\n\n if target == 0:\n res.append(curr[:])\n return\n\n if target < 0: return\n\n for i in range(pos, len(candidates)):\n if prev == candidates[i]:\n continue\n \n curr.append(candidates[i])\n backtrack(curr, i + 1, target - candidates[i])\n curr.pop()\n\n prev = candidates[i]\n\n backtrack([], 0, target)\n return res","runtime":"52"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n if not candidates:\n return [[]]\n candidates.sort()\n\n res = []\n\n curr = []\n\n def dfs(i, target):\n if target == 0:\n res.append(curr.copy())\n return\n for j in range(i,len(candidates)):\n if candidates[j] > target or( j>i and candidates[j] == candidates[j-1]):\n continue\n\n curr.append(candidates[j])\n dfs(j+1, target-candidates[j])\n curr.pop()\n dfs(0,target)\n return res \n ","runtime":"52"},{"code":"from typing import List\n\nclass Solution:\n def combinationSum2(self, arr: List[int], target: int) -> List[List[int]]:\n def backtrack(start, target, path):\n if target == 0:\n # Found a valid combination\n ans.append(path.copy())\n return\n if target < 0:\n # Exceeded the target, no need to continue\n return\n \n for i in range(start, len(arr)):\n # Skip duplicate elements\n if i > start and arr[i] == arr[i - 1]:\n continue\n \n # Include arr[i] in the current combination\n path.append(arr[i])\n # Recur with updated parameters\n backtrack(i + 1, target - arr[i], path)\n # Backtrack by removing the last element\n path.pop()\n \n arr.sort() # Sort to handle duplicates\n ans = []\n backtrack(0, target, [])\n return ans\n","runtime":"53"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n c = candidates\n res, sub = [], []\n c.sort()\n\n def bt(i, total):\n if total == target: return res.append(sub[:])\n if total > target or i == len(c): return\n sub.append(c[i])\n bt(i+1, total+c[i])\n sub.pop()\n while i+1 < len(c) and c[i] == c[i+1]: i += 1\n bt(i+1, total)\n \n bt(0, 0)\n return res","runtime":"53"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n n = len(candidates)\n candidates.sort()\n\n def dfs(ind, goal, subset):\n if goal == 0:\n ans.append(subset[::])\n if goal < 0:\n return\n \n prev = -1 \n for i in range(ind, n):\n if candidates[i] != prev:\n prev = candidates[i]\n subset.append(candidates[i])\n dfs(i + 1, goal - candidates[i], subset)\n # backtrack\n subset.pop()\n\n\n dfs(0, target, [])\n return ans ","runtime":"54"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n result = []\n candidates.sort()\n allIndSet = list(range(len(candidates)))\n stack = [(target, allIndSet, tuple())]\n processed = set()\n while stack:\n # print(stack)\n remTarget, remIndSet, curTuple = stack.pop()\n if remTarget == 0:\n result.append(curTuple)\n else:\n for i, nxtInd in enumerate(remIndSet):\n nxt = candidates[nxtInd]\n newRemTarget = remTarget - nxt\n if newRemTarget >= 0:\n nxtTuple = list(curTuple)\n nxtTuple.append(nxt)\n nxtTuple.sort()\n nxtTuple = tuple(nxtTuple)\n \n if nxtTuple not in processed:\n processed.add(nxtTuple)\n nxtIndSet = remIndSet[:i]\n nxtIndSet.extend(remIndSet[i + 1:]) \n stack.append((newRemTarget, nxtIndSet, nxtTuple))\n else:\n break\n \n return result","runtime":"54"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n target_to_combination_sums: dict[int, set[tuple[int]]] = {}\n\n for num in candidates:\n if num > target:\n continue\n to_add: dict[int, set[tuple[int]]] = {num:set([(num,)])}\n for sub_target, sub_values in target_to_combination_sums.items():\n new_target = num + sub_target\n if new_target > target:\n continue\n assert new_target not in to_add, new_target\n to_add[new_target] = set()\n for sub_value in sub_values:\n to_add[new_target].add(tuple(sorted(list(sub_value) + [num])))\n for key, value in to_add.items():\n if key not in target_to_combination_sums:\n target_to_combination_sums[key] = set()\n target_to_combination_sums[key] = target_to_combination_sums[key].union(value)\n \n return target_to_combination_sums[target] if target in target_to_combination_sums else []\n","runtime":"55"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n curr=[]\n res=[]\n def rec(index, target):\n if target==0:\n res.append(curr[:])\n return\n if target<0 or index>=len(candidates):\n return\n for i in range(index, len(candidates)):\n if i!=index and candidates[i]==candidates[i-1]:\n continue\n curr.append(candidates[i])\n rec(i+1, target-candidates[i])\n curr.pop()\n \n candidates.sort()\n rec(0, target)\n return res\n ","runtime":"55"},{"code":"class Solution:\n def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:\n nums.sort()\n n = len(nums)\n \n for i in range(n - 1, -1, -1):\n if nums[i] <= target:\n break\n \n nums, n = nums[:i+1], i + 1\n result = []\n self.findSum(result, nums, [], 0, n, target)\n return result\n\n def findSum(self, result: List[List[int]], nums: List[int], currentnums: List[int], i: int, n: int, target: int) -> None:\n if nums[i] > target:\n return\n\n target -= nums[i]\n currentnums.append(nums[i])\n if target == 0:\n result.append(copy.deepcopy(currentnums))\n elif i + 1 < n:\n self.findSum(result, nums, currentnums, i+1, n, target)\n \n target += nums[i]\n currentnums.pop()\n while i + 1 < n and nums[i+1] == nums[i]:\n i += 1\n \n if i + 1 < n:\n self.findSum(result, nums, currentnums, i+1, n, target)\n","runtime":"56"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n candidates.sort() # now must sort\n return self.helper(0, [], [], candidates, target)\n\n def helper(self, i, subresult, result, candidates, target):\n\n if target == 0:\n result.append(subresult[:])\n return\n\n if i == len(candidates) or target < 0:\n return\n\n # either take or dont take\n for idx in range(i, len(candidates)):\n if idx > i and candidates[idx] == candidates[idx-1]: # now must now allow duplicates, so we only allow 1 repeat max per occurrence\n continue\n subresult.append(candidates[idx])\n self.helper(idx+1, subresult, result, candidates, target-candidates[idx]) # now idx+1 because can only use once\n subresult.pop()\n \n return result","runtime":"56"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n candidates.sort()\n return self.helper(0, [], [], candidates, target)\n\n def helper(self, i, subresult, result, candidates, target):\n\n if target == 0:\n result.append(subresult[:])\n return\n\n if i == len(candidates) or target < 0:\n return\n\n # either take or dont take\n for idx in range(i, len(candidates)):\n if idx > i and candidates[idx] == candidates[idx-1]:\n continue\n subresult.append(candidates[idx])\n self.helper(idx+1, subresult, result, candidates, target-candidates[idx]) # now idx+1 because can only use once\n subresult.pop()\n \n return result","runtime":"57"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n candidates.sort()\n return self.helper(0, [], [], candidates, target)\n\n def helper(self, i, subresult, result, candidates, target):\n\n if target == 0:\n result.append(subresult[:])\n return\n\n if i == len(candidates) or target < 0:\n return\n\n # either take or dont take\n for idx in range(i, len(candidates)):\n if idx > i and candidates[idx] == candidates[idx-1]: # now must now allow duplicates, so we only allow 1 repeat max per occurrence\n continue\n subresult.append(candidates[idx])\n self.helper(idx+1, subresult, result, candidates, target-candidates[idx]) # now idx+1 because can only use once\n subresult.pop()\n \n return result","runtime":"57"},{"code":"class Solution:\n def combinationSum2(selt, candidates: list[int], target: int) -> list[list[int]]:\n candidates.sort()\n l = []\n def recursive(idx, total, ds):\n if total == 0:\n l.append(ds)\n return\n if idx >= len(candidates) or total < 0:\n return\n for i in range(idx, len(candidates)):\n if i > idx and candidates[i] == candidates[i-1]:\n continue\n if candidates[i] > target:\n break\n recursive(i+1, total-candidates[i], ds+[candidates[i]])\n recursive(0, target, [])\n return l","runtime":"58"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n ans, c = [], Counter(candidates)\n\n def dfs(s, n, res):\n if s == target: return ans.append(res)\n if s > target or n < 1: return\n for i in range(0, c[n]+1): dfs(s+i*n, n-1, res+[n]*i)\n\n dfs(0, 50, [])\n return ans","runtime":"58"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n path = []\n n = len(candidates)\n candidates.sort()\n self.cur_sum = 0\n\n def dfs(i):\n if self.cur_sum == target:\n ans.append(path.copy()) # 这种加法的又全部整数和sort了，因为等于的后续一定会大过tgt，可以直接return\n return\n\n if self.cur_sum > target: # 这个是为了 假设target=8 cur_sum=6,加上下一个直接超过8了\n return \n\n for j in range(i, n):\n if j> i and candidates[j]==candidates[j-1]:\n continue\n path.append(candidates[j])\n self.cur_sum += candidates[j]\n dfs(j+1)\n path.pop()\n self.cur_sum -= candidates[j]\n dfs(0)\n return ans \n\n ","runtime":"59"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n candidates.sort() # Sorting helps in handling duplicates\n\n def back(lst, remain, curr):\n if remain == 0:\n res.append(lst[:]) # Found a valid combination\n return\n if remain < 0:\n return # Exceeded the target, stop the recursion\n\n for i in range(curr, len(candidates)):\n # Skip duplicates (only proceed if it's the first occurrence in this position)\n if i > curr and candidates[i] == candidates[i - 1]:\n continue\n\n # Include the current candidate\n lst.append(candidates[i])\n\n # Recur with the remaining target and move to the next candidate (i + 1)\n back(lst, remain - candidates[i], i + 1)\n\n # Backtrack and remove the last candidate\n lst.pop()\n\n # Start the backtracking process\n back([], target, 0)\n return res\n\n ","runtime":"59"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n def backtrack(start, target, path):\n # If we hit the target, add the current path to the result\n if target == 0:\n result.append(list(path))\n return\n # If target goes below 0, there's no point in continuing\n if target < 0:\n return\n \n # Explore further by trying out each candidate\n for i in range(start, len(candidates)):\n # Skip duplicates\n if i > start and candidates[i] == candidates[i - 1]:\n continue\n \n # Choose the candidate and move to the next one\n path.append(candidates[i])\n # Recurse with updated target and starting index\n backtrack(i + 1, target - candidates[i], path)\n # Backtrack to explore other possibilities\n path.pop()\n\n candidates.sort() # Sort to easily skip duplicates\n result = []\n backtrack(0, target, [])\n return result\n","runtime":"60"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n candidates.sort()\n\n def BT(temp, st, curr_sum):\n if curr_sum == target:\n ans.append(temp.copy())\n temp = list()\n return\n if curr_sum > target:\n return\n \n for i in range(st, len(candidates)):\n \n # print(f\"temp: {temp}, st: {st}, i: {i}, curr_sum: {curr_sum}\")\n if i>st and candidates[i] == candidates[i-1]:\n continue\n temp.append(candidates[i])\n BT(temp, i+1, curr_sum + candidates[i])\n temp.pop()\n\n BT(list(), 0, 0)\n \n return ans","runtime":"61"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n def backtrack(start, target, path):\n if target == 0:\n result.append(path)\n return\n if target < 0:\n return\n \n for i in range(start, len(candidates)):\n # 跳过重复的数字\n if i > start and candidates[i] == candidates[i - 1]:\n continue\n num = candidates[i]\n # 递归调用，尝试包括当前数字\n backtrack(i + 1, target - num, path + [num])\n \n result = []\n candidates.sort() # 排序，方便跳过重复数字\n backtrack(0, target, [])\n return result","runtime":"61"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n path = []\n n = len(candidates)\n candidates.sort()\n self.cur_sum = 0\n\n def dfs(i):\n if self.cur_sum == target:\n ans.append(path.copy())\n return\n\n if self.cur_sum > target: #没有这个会time limit exceed\n return \n\n for j in range(i, n):\n if j> i and candidates[j]==candidates[j-1]:\n continue\n path.append(candidates[j])\n self.cur_sum += candidates[j]\n dfs(j+1)\n path.pop()\n self.cur_sum -= candidates[j]\n dfs(0)\n return ans \n\n ","runtime":"62"},{"code":"class Solution:\n def combinationSum2(self, cand, target):\n cand.sort()\n res = []\n path = []\n self.dfs(cand, 0, target, path, res)\n return res\n \n def dfs(self, cand, cur, target, path, res):\n if target == 0:\n res.append(path.copy())\n return\n if target < 0:\n return\n \n for i in range(cur, len(cand)):\n if i > cur and cand[i] == cand[i - 1]: # Skip duplicates\n continue\n path.append(cand[i])\n self.dfs(cand, i + 1, target - cand[i], path, res)\n path.pop() # Backtrack","runtime":"62"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n visited = set()\n candidates.sort()\n def dfs(start,combo,target):\n if target == 0:\n if tuple(combo) not in visited:\n ans.append(combo[:])\n visited.add(tuple(combo))\n return \n if target<0 : \n return \n for i in range(start,len(candidates)):\n if i > start and candidates[i] == candidates[i -1]:\n continue\n dfs(i+1,combo + [candidates[i]],target - candidates[i])\n \n dfs(0,[],target)\n return ans","runtime":"63"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n c = candidates\n c.sort()\n tmp = []\n res = []\n\n def dfs(start):\n # base\n if sum(tmp) > target:\n return\n if sum(tmp) == target:\n res.append(tmp[:])\n return\n \n\n for i in range(start, len(c)):\n if i > start and c[i-1] == c[i]:\n continue\n tmp.append(c[i])\n dfs(i + 1)\n tmp.pop()\n dfs(0)\n return res\n","runtime":"63"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n sonuc=[]\n candidates.sort()\n def sol(list1,int1,lp):\n if lp==len(candidates):\n return\n c=list1.copy()\n t=int1\n c.append(candidates[lp])\n t+=candidates[lp]\n if t==target:\n c.sort()\n if c not in sonuc:\n sonuc.append(c)\n elif t<target:\n sol(c,t,lp+1)\n k=lp\n while k<len(candidates)-1:\n if candidates[k+1]==candidates[k]:\n k+=1\n else:\n break\n sol(list1,int1,k+1)\n sol([],0,0)\n return sonuc\n \n ","runtime":"64"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n result = []\n candidates.sort()\n\n def generate(i, total, path):\n if total == target:\n result.append(path.copy())\n return\n\n if total > target or i >= len(candidates):\n return\n\n for j in range(i, len(candidates)):\n if j - 1 >= i and candidates[j] == candidates[j - 1]:\n continue\n path.append(candidates[j])\n generate(j + 1, total + candidates[j], path)\n path.pop()\n\n generate(0, 0, [])\n return result\n\"\"\"\n[1,1,2,5,6,7,10]\n\"\"\"","runtime":"64"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n # visit = set()\n res = []\n current = []\n def helper(i,target):\n if target < 0:\n return\n if target == 0:\n res.append(current.copy())\n return\n if i == len(candidates):\n return\n current.append(candidates[i])\n helper(i+1,target - candidates[i])\n current.pop()\n while i< len(candidates)-1 and candidates[i+1] == candidates[i]:\n i += 1\n helper(i+1,target)\n \n helper(0,target)\n return res","runtime":"65"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n visited = set()\n candidates.sort()\n def dfs(start,combo,target):\n if target == 0:\n if tuple(combo) not in visited:\n ans.append(combo[:])\n visited.add(tuple(combo))\n return \n if target<0 : \n return \n for i in range(start,len(candidates)):\n if i == start or candidates[i] != candidates[i -1]:\n # continue\n dfs(i+1,combo + [candidates[i]],target - candidates[i])\n \n dfs(0,[],target)\n return ans","runtime":"66"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n\n res = []\n\n # [1, 1, 2, 5, 6, 7, 10]\n def backtrack(i, cur, total):\n if total == target:\n res.append(cur.copy())\n return\n\n if i >= len(candidates) or total > target:\n return\n\n cur.append(candidates[i])\n backtrack(i + 1, cur, total + candidates[i])\n cur.pop()\n while i + 1 < len(candidates) and candidates[i] == candidates[i + 1]:\n i += 1\n backtrack(i + 1, cur, total)\n\n backtrack(0, [], 0)\n\n return res\n\n","runtime":"66"},{"code":"class Solution:\n def combinationSum2(self, candidates: list[int],\n target: int) -> list[list[int]]:\n ans = []\n\n def dfs(s: int, target: int, path: list[int]) -> None:\n if target < 0:\n return\n if target == 0:\n ans.append(path.copy())\n return\n\n for i in range(s, len(candidates)):\n if i > s and candidates[i] == candidates[i - 1]:\n continue\n path.append(candidates[i])\n dfs(i + 1, target - candidates[i], path)\n path.pop()\n\n candidates.sort()\n dfs(0, target, [])\n return ans","runtime":"67"},{"code":"class Solution:\n \n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: \n\n retSet = set()\n candidates = sorted(candidates)\n def dfs(currPath, rem, start):\n if rem == 0:\n retSet.add(tuple(currPath))\n if start > len(candidates) or rem < 0:\n return\n \n i = start\n while i < len(candidates):\n if i > start and candidates[i] == candidates[i-1]:\n i+=1\n continue\n currPath.append(candidates[i])\n dfs(currPath, rem - candidates[i], i + 1)\n currPath.pop()\n i += 1\n \n dfs([], target, 0)\n return list(retSet)\n\n\n \n \n \n \n \n '''dp = [set() for _ in range(target + 1)]\n candidates.sort()\n\n for cand in candidates:'''\n \n\n\n\n\n\n\n '''dp = [[] for _ in range (target + 1)]\n cand_dict = {}\n for cand in candidates:\n if 0 < cand <= target:\n dp[cand] = [set([cand])]\n cand_dict[cand] = 1 if cand not in cand_dict else cand_dict[cand] + 1\n\n\n for i in range(1, target + 1):\n for cand in candidates:\n if i - cand < 0:\n continue\n \n for combo in dp[i - cand]:\n if cand in combo:\n continue\n newcombo = set(combo)\n newcombo.add(cand)\n if newcombo in dp[i]:\n continue\n dp[i] += [newcombo]\n return dp[target]'''\n '''candidates.sort()\n dp = [set() for _ in range(target + 1)]\n dp[0].add(())\n \n for candidate in candidates:\n print(dp, candidate)\n for i in range(target, candidate - 1, -1):\n for combo in dp[i - candidate]:\n new_combo = tuple(sorted(list(combo) + [candidate]))\n dp[i].add(new_combo)\n \n return list(dp[target])'''\n\n \n \n \n \n\n","runtime":"67"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n n = len(candidates)\n candidates.sort()\n def f(i,arr,curr):\n if i >= n:\n if curr == target:\n return [arr]\n else:\n return []\n \n take = []\n dontTake = []\n if curr + candidates[i] <= target:\n take = f(i+1,arr+[candidates[i]],curr+candidates[i])\n for j in range(i+1,n+1,1):\n if j == n or candidates[j] != candidates[i]:\n dontTake = f(j,arr,curr)\n break\n \n return take + dontTake\n \n return f(0,[],0)\n ","runtime":"68"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n sonuc=[]\n candidates.sort()\n def sol(list1,int1,lp):\n if lp==len(candidates):\n return\n c=list1.copy()\n t=int1\n c.append(candidates[lp])\n t+=candidates[lp]\n if t==target:\n c.sort()\n if c not in sonuc:\n sonuc.append(c)\n elif t<target:\n sol(c,t,lp+1)\n while lp<len(candidates)-1:\n if candidates[lp+1]==candidates[lp]:\n lp+=1\n else:\n break\n sol(list1,int1,lp+1)\n sol([],0,0)\n return sonuc\n \n ","runtime":"68"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n n = len(candidates)\n ans = set()\n cur = []\n\n def comb(i, tot, prev):\n if tot == target:\n ans.add(tuple(sorted(cur)))\n return\n if i == n or tot > target:\n return\n \n if candidates[i] <= target and prev != candidates[i]:\n cur.append(candidates[i])\n comb(i+1, tot + candidates[i], None)\n cur.pop(-1)\n comb(i+1, tot, candidates[i])\n\n return\n\n comb(0, 0, None)\n return ans","runtime":"69"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res=[]\n stack=[]\n def backtrack(i,total):\n if total==target:\n res.append(stack.copy())\n return \n if i>=len(candidates) or total>target:\n return\n stack.append(candidates[i])\n backtrack(i+1,total+candidates[i])\n stack.pop()\n while i<len(candidates)-1 and candidates[i]==candidates[i+1]:\n i+=1\n backtrack(i+1,total)\n backtrack(0,0)\n return res","runtime":"69"},{"code":"class Solution:\n \n def backtrack(self, start_i, candidates, target, cur_lst, cur_sum, res):\n if cur_sum > target:\n return \n if cur_sum == target:\n res.append(cur_lst[:])\n return \n \n for i in range(start_i, len(candidates)):\n if i > start_i and candidates[i] == candidates[i-1]:\n continue\n cur_lst.append(candidates[i])\n self.backtrack(i+1, candidates, target, cur_lst, cur_sum+candidates[i], res)\n cur_lst.pop()\n return \n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n candidates.sort()\n self.backtrack(0, candidates, target, [], 0, res)\n return res\n \n ","runtime":"70"},{"code":"from collections import Counter\n\nclass Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n counts = Counter(candidates)\n\n def generateCombos(combo, target):\n if target == 0:\n ans.append(list(combo))\n return\n elif target < 0:\n return\n\n for num in counts:\n if combo and num < combo[-1]:\n continue\n elif counts[num] > 0:\n combo.append(num)\n counts[num] -= 1\n generateCombos(combo, target - num)\n combo.pop()\n counts[num] += 1\n \n generateCombos([], target)\n return ans","runtime":"70"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n n = len(candidates)\n result=[]\n candidates.sort()\n ans = []\n def dfs(i,temp):\n\n if temp==0:\n result.append(ans[::])\n return\n \n if i==n or temp<0:\n return\n temp-=(candidates[i])\n ans.append(candidates[i])\n dfs(i+1,temp)\n temp+=(candidates[i])\n ans.pop()\n while i<n-1 and candidates[i]==candidates[i+1]:\n i+=1\n dfs(i+1,temp)\n\n dfs(0,target)\n return result","runtime":"71"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n\n candidates.sort()\n\n res = []\n\n def backtrack(i,cur,sum):\n if sum == target:\n res.append(cur)\n return\n\n if i >= len(candidates) or sum > target:\n return\n\n backtrack(i+1,cur+[candidates[i]],sum+candidates[i])\n\n while i + 1 < len(candidates) and candidates[i] == candidates[i+1]:\n i += 1\n \n backtrack(i+1,cur,sum)\n\n backtrack(0,[],0)\n return res","runtime":"72"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res = []\n\n def backtrack(i,cur,cursum):\n if cursum == target:\n res.append(cur.copy())\n return\n \n if i >= len(candidates) or cursum > target:\n return\n \n cur.append(candidates[i])\n backtrack(i+1,cur,cursum+candidates[i])\n cur.pop()\n\n while i+1 < len(candidates) and candidates[i+1] == candidates[i]:\n i+=1\n backtrack(i+1,cur,cursum)\n \n backtrack(0,[],0)\n return res\n\n ","runtime":"72"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n result = []\n candidates.sort()\n\n def generate(i, total, path):\n if total == target:\n result.append(path.copy())\n return\n\n if total > target or i >= len(candidates):\n return\n\n path.append(candidates[i])\n generate(i + 1, total + candidates[i], path)\n path.pop()\n \n count = 1\n while i + count < len(candidates) and candidates[i] == candidates[i + count]:\n count += 1\n generate(i + count, total, path)\n \n generate(0, 0, [])\n\n return result\n\"\"\"\n[1,1,2,5,6,7,10]\n\"\"\"","runtime":"73"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n candidates.sort()\n\n res = []\n\n def backtrack(start, comb, curr_sum):\n\n if curr_sum > target:\n return\n if curr_sum == target:\n res.append(comb.copy())\n\n for i in range(start, len(candidates)):\n\n if i > start and candidates[i] == candidates[i-1]:\n continue\n \n comb.append(candidates[i])\n backtrack(i+1, comb, curr_sum + candidates[i])\n comb.pop()\n\n \n backtrack(0, [], 0)\n\n return res\n","runtime":"73"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n combs = []\n curSet = []\n candidates.sort()\n def dfs(i, total):\n if total == target:\n combs.append(curSet.copy())\n return\n if i >= len(candidates):\n return\n if total > target:\n return\n \n # add cur num\n curSet.append(candidates[i])\n dfs(i + 1, total + candidates[i])\n\n # skip cur num and dont add duplicate\n curSet.pop()\n while i + 1 < len(candidates) and candidates[i] == candidates[i + 1]:\n i += 1\n dfs(i + 1, total)\n \n dfs(0, 0)\n return combs","runtime":"74"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n path = []\n n = len(candidates)\n candidates.sort()\n self.cur_sum = 0\n\n def dfs(i):\n if self.cur_sum == target:\n ans.append(path.copy()) # 这种加法的又全部整数和sort了，因为等于的后续一定会大过tgt，可以直接return\n return\n\n if self.cur_sum > target: # 这个是为了 假设target=8 cur_sum=6,加上下一个直接超过8了\n return \n\n for j in range(i, n):\n if j> i and candidates[j]==candidates[j-1]:\n continue\n path.append(candidates[j])\n self.cur_sum += candidates[j]\n dfs(j+1)\n path.pop()\n self.cur_sum -= candidates[j]\n dfs(0)\n return ans \n\n ","runtime":"74"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res = []\n stack = []\n def comb(i,tot):\n if tot == target:\n res.append(stack.copy())\n return\n elif i >= len(candidates) or tot > target:\n return\n \n stack.append(candidates[i])\n comb(i+1,tot+candidates[i])\n stack.pop()\n cur = candidates[i]\n i += 1\n while(i < len(candidates) and candidates[i] == cur):\n i += 1\n comb(i,tot)\n \n comb(0,0)\n\n\n\n return res","runtime":"75"},{"code":"class Solution:\n def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:\n res=[]\n a=[]\n nums.sort()\n def helper(a,i,sum):\n if sum==target:\n res.append(a.copy())\n return\n if i >= len(nums) or sum > target: \n return\n\n \n a.append(nums[i])\n helper(a, i + 1, sum + nums[i])\n a.pop() # Backtrack\n\n \n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\n i += 1\n\n \n helper(a, i + 1, sum)\n \n helper(a,0,0)\n \n return res\n \n ","runtime":"75"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res=[]\n candidates.sort()\n\n def dfs(i,cur,total):\n if total==target:\n res.append(cur.copy())\n return\n\n if total>target or i==len(candidates):\n return\n \n #include the candidates\n cur.append(candidates[i])\n dfs(i+1,cur,total+candidates[i])\n cur.pop()\n \n #skip duplicates\n while i+1<len(candidates) and candidates[i]==candidates[i+1]:\n i+=1\n dfs(i+1,cur,total)\n\n dfs(0,[],0)\n return res","runtime":"76"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = set()\n explored = set()\n\n def dfs(choices, cur): \n hashable = tuple(sorted([candidates[i] for i in choices]))\n if hashable in explored:\n return\n explored.add(hashable)\n\n if cur == target:\n res.add(hashable)\n\n for i in range(len(candidates)):\n if i in choices:\n continue\n\n if candidates[i] + cur <= target:\n choices.add(i)\n dfs(choices, candidates[i] + cur)\n choices.remove(i)\n \n dfs(set(), 0)\n return [list(e) for e in res]\n \n","runtime":"76"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n curr = []\n res = []\n\n def dfs(i, currSum): \n if currSum == target:\n res.append(curr.copy())\n return\n \n if i >= len(candidates) or currSum > target:\n return\n \n curr.append(candidates[i])\n dfs(i + 1, currSum + candidates[i])\n\n while i < len(candidates) - 1 and candidates[i] == candidates[i + 1]:\n i += 1\n\n curr.pop()\n dfs(i + 1, currSum)\n \n dfs(0, 0)\n return res","runtime":"77"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort() \n res = []\n def dfs(i, subset, total):\n if total == target:\n res.append(subset.copy())\n return\n if total > target or i==len(candidates):\n return\n\n # if we add curr to subset\n subset.append(candidates[i])\n dfs(i + 1, subset, total + candidates[i])\n\n # if we don't add curr to subset\n subset.pop()\n while i+1<len(candidates) and candidates[i+1] == candidates[i]:\n i += 1\n dfs(i+1, subset, total)\n \n dfs(0, [], 0)\n return res\n","runtime":"77"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n def dfs(i, cur, sum):\n if sum == target:\n res.append(deepcopy(cur))\n return\n elif sum > target or i >= len(candidates):\n return\n num = candidates[i]\n cur.append(num)\n dfs(i+1, cur, sum + num)\n cur.pop()\n\n while i < len(candidates) - 1 and candidates[i] == candidates[i+1]:\n i += 1\n dfs(i+1, cur, sum)\n candidates.sort()\n dfs(0, [], 0)\n return res","runtime":"78"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = set()\n explored = set()\n\n def dfs(choices, cur): \n hashable = tuple(sorted([candidates[i] for i in choices]))\n if hashable in explored:\n return\n explored.add(hashable)\n\n if cur == target:\n res.add(hashable)\n\n for i in range(len(candidates)):\n if i in choices:\n continue\n\n if candidates[i] + cur <= target:\n choices.add(i)\n dfs(choices, candidates[i] + cur)\n choices.remove(i)\n \n dfs(set(), 0)\n return [list(e) for e in res]\n \n","runtime":"78"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = set()\n explored = set()\n candidates.sort()\n\n def dfs(choices, cur): \n hashable = tuple(sorted([candidates[i] for i in choices]))\n if hashable in explored:\n return\n explored.add(hashable)\n\n if cur == target:\n res.add(hashable)\n\n for i in range(len(candidates)):\n if i in choices:\n continue\n\n if candidates[i] + cur <= target:\n choices.add(i)\n dfs(choices, candidates[i] + cur)\n choices.remove(i)\n \n dfs(set(), 0)\n return [list(e) for e in res]\n \n","runtime":"79"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n\n def backtrack(combination, total, i):\n if total == target:\n combinations.append(combination.copy())\n return\n \n if i == len(candidates) or total > target:\n return\n \n combination.append(candidates[i])\n backtrack(combination, total + candidates[i], i + 1)\n combination.pop()\n while i + 1 < len(candidates) and candidates[i] == candidates[i + 1]:\n i += 1\n backtrack(combination, total, i + 1)\n \n\n \n combinations = []\n candidates.sort()\n backtrack([], 0, 0)\n return combinations\n\n ","runtime":"80"},{"code":"from typing import Set, Tuple, List\n\nclass Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n vs: Set[Tuple[int]] = set()\n candidates.sort()\n\n def backtrack(i: int, curcomb: List[int], cursum: int):\n if (cursum > target):\n return\n elif (i == len(candidates)):\n if (cursum == target):\n vs.add(tuple(curcomb))\n return\n backtrack(i + 1, curcomb + [candidates[i]], cursum + candidates[i])\n while i < len(candidates) - 1 and (candidates[i] == candidates[i + 1]):\n i += 1 \n backtrack(i + 1, curcomb, cursum)\n\n backtrack(0, [], 0)\n return [list(comb) for comb in vs]\n\n \n","runtime":"80"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n path = []\n n = len(candidates)\n candidates.sort()\n self.cur_sum = 0\n\n def dfs(i):\n if self.cur_sum == target:\n ans.append(path.copy())\n\n if self.cur_sum > target:\n return \n\n for j in range(i, n):\n if j> i and candidates[j]==candidates[j-1]:\n continue\n path.append(candidates[j])\n self.cur_sum += candidates[j]\n dfs(j+1)\n path.pop()\n self.cur_sum -= candidates[j]\n dfs(0)\n return ans \n\n ","runtime":"81"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = set()\n explored = set()\n candidates.sort()\n\n def dfs(choices, cur): \n hashable = tuple(sorted([candidates[i] for i in choices]))\n if hashable in explored:\n return\n explored.add(hashable)\n\n if cur == target:\n res.add(hashable)\n\n for i in range(len(candidates)):\n if i in choices:\n continue\n\n if candidates[i] + cur <= target:\n choices.add(i)\n dfs(choices, candidates[i] + cur)\n choices.remove(i)\n \n dfs(set(), 0)\n return [list(e) for e in res]\n \n","runtime":"81"},{"code":"class Solution:\n \n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: \n\n retSet = set()\n candidates = sorted(candidates)\n def dfs(currPath, rem, start):\n currTuple = tuple(currPath)\n if rem == 0:\n retSet.add(tuple(currPath))\n if start > len(candidates) or rem < 0:\n return\n \n i = start\n while i < len(candidates):\n if i > start and candidates[i] == candidates[i-1]:\n i+=1\n continue\n currPath.append(candidates[i])\n dfs(currPath, rem - candidates[i], i + 1)\n currPath.pop()\n i += 1\n \n dfs([], target, 0)\n return list(retSet)\n\n\n \n \n \n \n \n '''dp = [set() for _ in range(target + 1)]\n candidates.sort()\n\n for cand in candidates:'''\n \n\n\n\n\n\n\n '''dp = [[] for _ in range (target + 1)]\n cand_dict = {}\n for cand in candidates:\n if 0 < cand <= target:\n dp[cand] = [set([cand])]\n cand_dict[cand] = 1 if cand not in cand_dict else cand_dict[cand] + 1\n\n\n for i in range(1, target + 1):\n for cand in candidates:\n if i - cand < 0:\n continue\n \n for combo in dp[i - cand]:\n if cand in combo:\n continue\n newcombo = set(combo)\n newcombo.add(cand)\n if newcombo in dp[i]:\n continue\n dp[i] += [newcombo]\n return dp[target]'''\n '''candidates.sort()\n dp = [set() for _ in range(target + 1)]\n dp[0].add(())\n \n for candidate in candidates:\n print(dp, candidate)\n for i in range(target, candidate - 1, -1):\n for combo in dp[i - candidate]:\n new_combo = tuple(sorted(list(combo) + [candidate]))\n dp[i].add(new_combo)\n \n return list(dp[target])'''\n\n \n \n \n \n\n","runtime":"83"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n res = []\n candidates = sorted(candidates)\n def dfs(i, subset, total):\n if total == target:\n res.append(subset.copy())\n return\n if i == len(candidates) or sum(subset) > target:\n return\n subset.append(candidates[i])\n dfs(i+1, subset, total+candidates[i])\n subset.pop()\n while i+1 < len(candidates) and candidates[i] == candidates[i+1]:\n i += 1\n dfs(i+1, subset, total)\n dfs(0, [], 0)\n return res","runtime":"84"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n result = []\n res_set = set()\n searched_list = []\n def backtracking(res, i):\n if sum(res) == target:\n result.append(res)\n searched_list.append(res)\n return True\n elif sum(res) > target:\n searched_list.append(res)\n return False\n for j, candidate in enumerate(candidates[i:]):\n new_res = res + [candidate]\n if new_res not in searched_list:\n searched_list.append(new_res)\n val = backtracking(new_res, i + j + 1)\n if not val:\n return True\n return True\n \n candidates.sort()\n backtracking([], 0)\n return result\n","runtime":"85"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n output = []\n candidates.sort()\n\n def backtrack(i, arr, target):\n if target == 0:\n output.append(arr[:])\n return\n \n if i >= len(candidates) or target < 0:\n return\n\n arr.append(candidates[i])\n backtrack(i + 1, arr, target - candidates[i])\n arr.pop()\n\n while i + 1 < len(candidates) and candidates[i] == candidates[i + 1]:\n i += 1\n backtrack(i + 1, arr, target)\n backtrack(0, [], target)\n \n return output\n \n","runtime":"86"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n candidates.sort()\n \n def combinations(index, curCandidates):\n nonlocal res\n\n if index >= len(candidates):\n if sum(curCandidates) == target:\n res.append(curCandidates)\n\n return\n if sum(curCandidates) > target:\n return\n \n # recursive case where we include the current number\n combinations(index + 1, curCandidates + [candidates[index]])\n while index + 1 < len(candidates) and candidates[index] == candidates[index+1]:\n index += 1\n\n # recursive case where we dont include the current number\n combinations(index + 1, curCandidates)\n\n combinations(0, [])\n return res","runtime":"86"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n res = []\n dict = {}\n subset = []\n candidates = sorted(candidates)\n def dfs(i):\n if sum(subset) == target:\n tmp = sorted(subset.copy())\n tmp = [str(i) for i in tmp]\n tmp = \"\".join(tmp)\n if tmp not in dict:\n res.append(subset.copy())\n dict[tmp] = 0\n return\n if i == len(candidates) or sum(subset) > target:\n return\n subset.append(candidates[i])\n dfs(i+1)\n subset.pop()\n while i+1 < len(candidates) and candidates[i] == candidates[i+1]:\n i += 1\n dfs(i+1)\n dfs(0)\n return res","runtime":"87"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res = []\n\n def backtrack(curr, total, i):\n if i == len(candidates):\n if total == target:\n res.append(curr.copy())\n return\n if total > target:\n return\n \n curr.append(candidates[i])\n backtrack(curr, total+candidates[i], i+1)\n curr.pop()\n\n k = 1\n while i+k <= len(candidates)-1 and candidates[i+k] == candidates[i+k-1]:\n k += 1\n backtrack(curr, total, i+k)\n \n backtrack([], 0, 0)\n return res\n \n ","runtime":"87"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n result = []\n candidates.sort()\n self.combinationSum2Helper(candidates, [], target, result)\n return result\n\n def combinationSum2Helper(self, inp, out, target, result):\n\n if target == 0:\n if out not in result:\n result.append(out.copy())\n return\n\n if len(inp) == 0:\n return\n\n if target < 0:\n return\n\n self.combinationSum2Helper(inp[1:], out + [inp[0]], target - inp[0], result)\n c = 1\n while c < len(inp) and inp[c] == inp[c-1]:\n c += 1\n self.combinationSum2Helper(inp[c:], out, target, result)\n","runtime":"88"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n subset = []\n candidates.sort()\n def dfs(i):\n if sum(subset)>target:\n return\n if sum(subset)==target:\n res.append(subset.copy())\n return\n if i >= len(candidates):\n return\n \n \n\n subset.append(candidates[i])\n dfs(i+1)\n subset.pop()\n\n while i+1<len(candidates) and candidates[i]==candidates[i+1] :\n i+=1\n dfs(i+1)\n \n dfs(0)\n return res","runtime":"89"},{"code":"class Solution:\n \n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: \n retSet = set()\n candidates = sorted(candidates)\n seen = set()\n def dfs(currPath, rem, start):\n pathTup = tuple(currPath)\n if pathTup in seen:\n return\n if rem == 0:\n retSet.add(pathTup)\n if start > len(candidates) or rem < 0:\n return\n \n i = start\n while i < len(candidates):\n if i > start and candidates[i] == candidates[i-1]:\n i+=1\n continue\n currPath.append(candidates[i])\n dfs(currPath, rem - candidates[i], i + 1)\n seen.add(pathTup)\n currPath.pop()\n i += 1\n \n dfs([], target, 0)\n return list(retSet)\n\n\n\n \n \n \n \n \n '''dp = [set() for _ in range(target + 1)]\n candidates.sort()\n\n for cand in candidates:'''\n \n\n\n\n\n\n\n '''dp = [[] for _ in range (target + 1)]\n cand_dict = {}\n for cand in candidates:\n if 0 < cand <= target:\n dp[cand] = [set([cand])]\n cand_dict[cand] = 1 if cand not in cand_dict else cand_dict[cand] + 1\n\n\n for i in range(1, target + 1):\n for cand in candidates:\n if i - cand < 0:\n continue\n \n for combo in dp[i - cand]:\n if cand in combo:\n continue\n newcombo = set(combo)\n newcombo.add(cand)\n if newcombo in dp[i]:\n continue\n dp[i] += [newcombo]\n return dp[target]'''\n '''candidates.sort()\n dp = [set() for _ in range(target + 1)]\n dp[0].add(())\n \n for candidate in candidates:\n print(dp, candidate)\n for i in range(target, candidate - 1, -1):\n for combo in dp[i - candidate]:\n new_combo = tuple(sorted(list(combo) + [candidate]))\n dp[i].add(new_combo)\n \n return list(dp[target])'''\n\n \n \n \n \n\n","runtime":"90"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n sol = []\n candidates.sort()\n \n def dfs(curr, i):\n if sum(curr) == target:\n sol.append(curr.copy())\n return\n if sum(curr) > target or i >= len(candidates):\n return \n \n curr.append(candidates[i])\n dfs(curr, i+1)\n curr.pop()\n num = candidates[i]\n while i+1 < len(candidates) and num == candidates[i+1]:\n i += 1\n dfs(curr, i+1)\n \n dfs([], 0)\n return sol","runtime":"91"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n out = []\n candidates.sort()\n def helper(i, nums):\n if sum(nums) == target:\n out.append(nums.copy())\n return\n if i >= len(candidates) or sum(nums) > target:\n return\n\n y = i\n while y < len(candidates) and candidates[y] == candidates[i] :\n y+= 1\n helper(y, nums.copy())\n\n nums.append(candidates[i])\n helper(i+1, nums.copy())\n\n\n helper(0, [])\n return out","runtime":"92"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n output = [] \n\n def dfs(remain, comb, index):\n if remain == 0:\n res = sorted(comb)\n if res not in output:\n output.append(res)\n elif remain < 0:\n return\n \n for i in range(index, len(candidates)):\n if i > index and candidates[i - 1] == candidates[i]:\n continue\n\n new_remain = remain - candidates[i]\n if new_remain < 0:\n continue\n \n comb.append(candidates[i])\n dfs(remain - candidates[i], comb, i + 1)\n comb.pop()\n \n dfs(target, [], 0)\n\n return output\n \n","runtime":"92"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n \n res = []\n subset = []\n candidates = sorted(candidates)\n def dfs(i):\n if sum(subset) == target:\n res.append(subset.copy())\n return\n if i == len(candidates) or sum(subset) > target:\n return\n subset.append(candidates[i])\n dfs(i+1)\n subset.pop()\n while i+1 < len(candidates) and candidates[i] == candidates[i+1]:\n i += 1\n dfs(i+1)\n dfs(0)\n return res","runtime":"93"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res = []\n def backtrack(comb, idx):\n if sum(comb) == target:\n res.append(comb[:])\n return\n if sum(comb) > target or idx == len(candidates):\n return\n comb.append(candidates[idx])\n backtrack(comb, idx+1)\n comb.pop()\n while idx+1 < len(candidates) and candidates[idx] == candidates[idx+1]:\n idx += 1\n backtrack(comb, idx+1)\n backtrack([], 0)\n return res","runtime":"93"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n candidates.sort()\n \n def combinations(index, curCandidates):\n nonlocal res\n\n if index >= len(candidates):\n if sum(curCandidates) == target:\n if curCandidates not in res:\n res.append(curCandidates)\n return\n if sum(curCandidates) > target:\n return\n \n # recursive case where we include the current number\n combinations(index + 1, curCandidates + [candidates[index]])\n while index + 1 < len(candidates) and candidates[index] == candidates[index+1]:\n index += 1\n\n # recursive case where we dont include the current number\n combinations(index + 1, curCandidates)\n\n combinations(0, [])\n return res","runtime":"94"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n result = []\n self.backtrack(candidates, target, 0, [], result)\n return result\n \n def backtrack(self, candidates, target, start, path, result):\n if sum(path) == target:\n result.append(path[:])\n return\n\n for i in range(start, len(candidates)):\n if sum(path) > target:\n break\n if i > start and candidates[i] == candidates[i - 1]:\n continue\n path.append(candidates[i])\n self.backtrack(candidates, target, i + 1, path, result)\n path.pop()","runtime":"95"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n\n def backtrack(i, sub, total, discarded):\n if total == target:\n res.append(sub.copy())\n return\n \n if i == len(candidates) or total > target:\n return\n \n if candidates[i] not in discarded and candidates[i] <= target:\n sub.append(candidates[i])\n backtrack(i+1, sub, total+candidates[i], discarded.copy())\n sub.pop()\n\n discarded.add(candidates[i])\n backtrack(i+1, sub, total, discarded.copy())\n backtrack(0, [], 0, set())\n return res","runtime":"96"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n if sum(candidates)==target:\n return [candidates]\n if sum(candidates)<target:\n return []\n if sum(candidates)==len(candidates):\n return [[1 for x in range(target)]]\n if sum(candidates)==len(candidates)+1 and target>2:\n l = [1 for x in range(target-2)]\n l.append(2)\n return [[1 for x in range(target)], l]\n newcand = [x for x in candidates if x <= target]\n #print(newcand)\n ans = set()\n def rec(l, r, cur):\n for i in range(l, r):\n if newcand[i]+sum(cur) == target:\n cur2 = cur[:]\n cur2.append(newcand[i])\n cur2.sort()\n ans.add(tuple(cur2))\n continue\n elif newcand[i]+sum(cur) > target:\n continue\n else:\n cur2 = cur[:]\n cur2.append(newcand[i])\n rec(i+1, r, cur2)\n rec(0, len(newcand), [])\n return list(ans)\n\n \n\n\n \n \n return [[]]","runtime":"96"},{"code":"class Solution:\n\n def combinationSum2Helper(self, candidates, target, cur_list, cur_sum, last_added):\n if tuple(cur_list) in self.paths:\n return\n self.paths.add(tuple(cur_list))\n if cur_sum == target:\n self.ans.append(cur_list)\n print(cur_list, target)\n elif cur_sum < target:\n for i in range(last_added + 1, len(candidates)):\n self.combinationSum2Helper(candidates, target, cur_list + [candidates[i]], cur_sum + candidates[i], i)\n\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n self.ans = []\n self.paths = set()\n candidates.sort()\n self.combinationSum2Helper(candidates, target, [], 0, -1)\n return self.ans","runtime":"97"},{"code":"class Solution:\n \n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: \n retSet = set()\n candidates = sorted(candidates)\n seen = set()\n def dfs(currPath, rem, i):\n pathTup = tuple(currPath)\n if pathTup in seen:\n return\n if rem == 0:\n retSet.add(pathTup)\n if i > len(candidates) or rem < 0:\n return\n \n while i < len(candidates):\n currPath.append(candidates[i])\n dfs(currPath, rem - candidates[i], i + 1)\n seen.add(pathTup)\n currPath.pop()\n i += 1\n \n dfs([], target, 0)\n return list(retSet)\n\n\n\n \n \n \n \n \n '''dp = [set() for _ in range(target + 1)]\n candidates.sort()\n\n for cand in candidates:'''\n \n\n\n\n\n\n\n '''dp = [[] for _ in range (target + 1)]\n cand_dict = {}\n for cand in candidates:\n if 0 < cand <= target:\n dp[cand] = [set([cand])]\n cand_dict[cand] = 1 if cand not in cand_dict else cand_dict[cand] + 1\n\n\n for i in range(1, target + 1):\n for cand in candidates:\n if i - cand < 0:\n continue\n \n for combo in dp[i - cand]:\n if cand in combo:\n continue\n newcombo = set(combo)\n newcombo.add(cand)\n if newcombo in dp[i]:\n continue\n dp[i] += [newcombo]\n return dp[target]'''\n '''candidates.sort()\n dp = [set() for _ in range(target + 1)]\n dp[0].add(())\n \n for candidate in candidates:\n print(dp, candidate)\n for i in range(target, candidate - 1, -1):\n for combo in dp[i - candidate]:\n new_combo = tuple(sorted(list(combo) + [candidate]))\n dp[i].add(new_combo)\n \n return list(dp[target])'''\n\n \n \n \n \n\n","runtime":"98"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n res = []\n stack = []\n def comb(i,tot):\n if tot == target:\n res.append(stack.copy())\n return\n elif i >= len(candidates) or tot > target:\n return\n \n stack.append(candidates[i])\n comb(i+1,tot+candidates[i])\n stack.pop()\n cur = candidates[i]\n i += 1\n while(i < len(candidates) and candidates[i] == cur):\n print(candidates[i])\n i += 1\n comb(i,tot)\n \n comb(0,0)\n\n\n\n return res","runtime":"99"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans=[]\n candidates.sort()\n def back(candidates,path,curr,index):\n if curr>target:\n return\n if target==curr and path not in ans:\n ans.append(path)\n return\n for i in range(index,len(candidates)):\n if i >index and candidates[i]==candidates[i-1]:\n continue\n back(candidates[:i]+candidates[i+1:],path+[candidates[i]],curr+candidates[i],i)\n back(candidates,[],0,0)\n return ans","runtime":"100"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n candidates.sort()\n\n def dfs(i,cur):\n if sum(cur)==target:\n res.append(cur)\n return\n if sum(cur)<target and i<len(candidates):\n x = candidates[i]\n dfs(i+1, cur+[x])\n while i<len(candidates) and x==candidates[i]:\n i +=1\n dfs(i, cur)\n \n\n dfs(0, [])\n return res","runtime":"101"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n if sum(candidates) < target:\n return []\n elif sum(candidates) == target:\n return [candidates]\n\n final = []\n candidates.sort()\n def gencomb(i, curr):\n if sum(curr) == target:\n final.append(curr[:])\n return\n elif sum(curr) < target:\n if i<len(candidates):\n curr.append(candidates[i])\n gencomb(i+1, curr[:])\n pos = bisect.bisect_left(candidates, curr[-1]+1)\n curr.pop()\n if pos<len(candidates): gencomb(pos, curr[:])\n\n return\n\n gencomb(0, [])\n #seen = set()\n #for i in final:\n # seen.add(tuple(i))\n\n #ans = []\n #for s in seen:\n # ans.append(list(s))\n\n return final\n\n\n\n ","runtime":"102"}],"string":"[\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n results = []\\n\\n def backtracking(index, path, remainingSum):\\n if remainingSum == 0:\\n results.append(list(path))\\n return\\n previous = -1\\n for i in range(index, len(candidates)):\\n c = candidates[i]\\n if c == previous:\\n continue\\n if c > remainingSum:\\n break\\n path.append(c)\\n backtracking(i+1, path, remainingSum - c)\\n path.pop()\\n previous = c\\n\\n \\n backtracking(0, [], target)\\n return results\\n \\n \\n\\n\\n \",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans=[]\\n ds=[]\\n candidates.sort()\\n def com(ind,target):\\n if target==0:\\n ans.append(ds[:])\\n return\\n for i in range(ind,len(candidates)):\\n if(ind<i and candidates[i]==candidates[i-1]):\\n continue\\n if candidates[i]>target:\\n break\\n ds.append(candidates[i])\\n com(i+1,target-candidates[i])\\n ds.pop()\\n com(0,target)\\n return ans\\n \",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution(object):\\n def combinationSum2(self, candidates, target):\\n ans = []\\n ds = []\\n candidates.sort()\\n\\n\\n def findCombination(ind, target):\\n if target == 0:\\n ans.append(ds[:])\\n return\\n for i in range(ind, len(candidates)):\\n if i > ind and candidates[i] == candidates[i - 1]:\\n continue\\n if candidates[i] > target:\\n break\\n ds.append(candidates[i])\\n findCombination(i + 1, target - candidates[i])\\n ds.pop()\\n\\n\\n findCombination(0, target)\\n return ans\\n \",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res = []\\n\\n def dfs(target, start, comb):\\n if target < 0:\\n return\\n if target == 0:\\n res.append(comb)\\n return\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i-1]:\\n continue\\n if candidates[i] > target:\\n break\\n dfs(target-candidates[i], i+1, comb+[candidates[i]])\\n\\n dfs(target, 0, [])\\n return res\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n candidates.sort()\\n\\n comb = []\\n def dfs(i, sum):\\n\\n for num in range(i, len(candidates)):\\n if num > i and candidates[num] == candidates[num - 1]:\\n continue\\n comb.append(candidates[num])\\n next_sum = sum + candidates[num]\\n if next_sum == target:\\n output.append(comb[:])\\n comb.pop(-1)\\n return\\n elif next_sum > target:\\n comb.pop(-1)\\n return\\n else:\\n dfs(num + 1, next_sum)\\n comb.pop(-1)\\n \\n output = []\\n dfs(0, 0)\\n return output\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n def backtrack(state, target, choices, start, res):\\n if target == 0:\\n res.append(list(state))\\n return\\n for i in range(start, len(choices)):\\n if target - choices[i] < 0:\\n break\\n if i > start and choices[i] == choices[i-1]:\\n continue\\n state.append(choices[i])\\n backtrack(state, target - choices[i], choices, i+1, res)\\n state.pop()\\n state = []\\n candidates.sort()\\n start = 0\\n res = []\\n backtrack(state, target, candidates, start, res)\\n return res\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n ans = []\\n self.rec(candidates, 0, target, ans, [])\\n return ans\\n \\n def rec(self, candidates, start, target, ans, curr):\\n if target == 0:\\n ans.append(curr.copy())\\n return\\n if target < 0 or start == len(candidates):\\n return\\n\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i-1]:\\n continue\\n\\n\\n if candidates[i] > target:\\n break\\n \\n\\n\\n curr.append(candidates[i])\\n self.rec(candidates, i + 1, target - candidates[i], ans, curr)\\n curr.pop()\\n return\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n stack = []\\n candidates.sort()\\n def findCombinations(ind, target):\\n if target == 0:\\n ans.append(stack[:])\\n return\\n for i in range(ind, len(candidates)):\\n if i>ind and candidates[i] == candidates[i-1]:\\n continue\\n if candidates[i] > target:\\n break\\n stack.append(candidates[i])\\n findCombinations(i+1, target- candidates[i])\\n stack.pop()\\n findCombinations(0, target)\\n return ans\\n\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n n = len(candidates)\\n path = []\\n ans = []\\n def dfs(i, value):\\n if value == 0: #这个要放在下面哪个if前面，因为即使i==n，我们还要考虑之前所有的element加起来的值是否可以等于target。\\n ans.append(path.copy())\\n return \\n if i == n or value < candidates[i]:\\n return \\n \\n path.append(candidates[i])\\n dfs(i + 1, value - candidates[i])\\n while i + 1 < n and candidates[i] == candidates[i + 1]:\\n i += 1\\n path.pop()\\n dfs(i + 1, value)\\n dfs(0, target)\\n return ans\\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution(object):\\n def combinationSum2(self, candidates, target):\\n sum2combination=[]\\n sizeCandidates=len(candidates)\\n candidates.sort()\\n def solve(idx,candidateList,sum): \\n if sum==target:\\n sum2combination.append(candidateList)\\n return \\n for candidate in range(idx,sizeCandidates):\\n candidatesTraverse=candidates[candidate]\\n sumCandidates=sum+candidatesTraverse\\n if candidate>idx and candidatesTraverse==candidates[candidate-1]:\\n continue\\n if sumCandidates>target:\\n break\\n solve(candidate+1,candidateList+[candidatesTraverse],sumCandidates)\\n solve(0,[],0)\\n return sum2combination\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res = []\\n\\n def dfs(target, start, comb):\\n if target < 0:\\n return\\n if target == 0:\\n res.append(comb)\\n return\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i-1]:\\n continue\\n if candidates[i] > target:\\n break\\n dfs(target-candidates[i], i+1, comb+[candidates[i]])\\n\\n dfs(target, 0, [])\\n return res\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res=[]\\n candidates.sort()\\n def subsets(ind, targetSum, ds):\\n if targetSum == 0:\\n res.append(ds.copy())\\n return\\n \\n if ind >= len(candidates) or targetSum-candidates[ind]<0:\\n return\\n ds.append(candidates[ind])\\n subsets(ind+1,targetSum-candidates[ind],ds)\\n ds.pop()\\n while ind+1<len(candidates) and candidates[ind]==candidates[ind+1]:\\n ind = ind +1\\n subsets(ind+1,targetSum,ds)\\n subsets(0,target,[])\\n return res\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates = sorted(candidates)\\n res = []\\n subset = []\\n\\n def backtrack(i, total):\\n if total==target:\\n res.append(subset.copy())\\n return\\n \\n prev = -1\\n for j in range(i, len(candidates)):\\n if candidates[j]==prev:\\n continue\\n elif total+candidates[j]>target:\\n return\\n subset.append(candidates[j])\\n backtrack(j+1, total + candidates[j])\\n subset.pop()\\n prev = candidates[j]\\n\\n\\n backtrack(0, 0)\\n return res\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def dfs(self, start_index, path, remaining, ans, candidates):\\n if remaining==0:\\n ans.append(path[:])\\n # return\\n for i in range(start_index, len(candidates)):\\n if candidates[i]>remaining:\\n break\\n elif i!=start_index and candidates[i]==candidates[i-1]:\\n continue\\n path.append(candidates[i])\\n self.dfs(i+1, path, remaining-candidates[i], ans, candidates)\\n path.pop()\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n\\n candidates.sort()\\n ans = []\\n self.dfs(0, [], target, ans, candidates)\\n return ans\\n\\n # def dfs(start_index, path, remaining):\\n # if remaining == 0:\\n # ans.append(path[:])\\n # for i in range(start_index, len(candidates)):\\n # if remaining - candidates[i] < 0: # avoid results exceeding target\\n # break\\n # elif i != start_index and candidates[i] == candidates[i-1]: # avoid duplicates\\n # continue\\n # path.append(candidates[i])\\n # dfs(i+1, path, remaining - candidates[i])\\n # path.pop()\\n # candidates.sort()\\n # ans = []\\n # dfs(0, [], target)\\n # return ans\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n n = len(candidates)\\n candidates.sort()\\n #[1,1,2,5,6,7,10]\\n def f(i,arr,curr):\\n if curr == target:\\n return [arr]\\n elif curr > target:\\n return []\\n \\n res = []\\n for j in range(i,n,1):\\n if candidates[j] + curr > target:\\n break\\n if j==i or candidates[j] != candidates[j-1]:\\n temp = f(j+1,arr+[candidates[j]],curr+candidates[j])\\n res += temp\\n \\n return res\\n \\n return f(0,[],0)\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = []\\n candidates.sort()\\n\\n def backtrack(curr, total, start):\\n if total == target:\\n result.append(curr.copy())\\n return\\n \\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i - 1]:\\n continue\\n\\n if total + candidates[i] > target:\\n break\\n\\n curr.append(candidates[i])\\n backtrack(curr, total + candidates[i], i + 1)\\n curr.pop()\\n \\n backtrack([], 0, 0)\\n return result\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:\\n nums.sort()\\n n = len(nums)\\n result = []\\n self.findSum(result, nums, [], 0, n, target)\\n return result\\n\\n def findSum(self, result: List[List[int]], nums: List[int], currentnums: List[int], i: int, n: int, target: int) -> None:\\n if nums[i] > target:\\n return\\n\\n target -= nums[i]\\n currentnums.append(nums[i])\\n if target == 0:\\n result.append(copy.deepcopy(currentnums))\\n elif i + 1 < n:\\n self.findSum(result, nums, currentnums, i+1, n, target)\\n \\n target += nums[i]\\n currentnums.pop()\\n while i + 1 < n and nums[i+1] == nums[i]:\\n i += 1\\n \\n if i + 1 < n:\\n self.findSum(result, nums, currentnums, i+1, n, target)\\n\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n\\n ans = []\\n candidates.sort()\\n def backtrack(remain, comb, start):\\n if remain == 0:\\n ans.append(list(comb))\\n return\\n \\n \\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i-1]:\\n continue\\n if candidates[i] > remain:\\n break\\n\\n comb.append(candidates[i])\\n backtrack( remain - candidates[i], comb, i + 1)\\n comb.pop()\\n\\n backtrack(target, [], 0)\\n\\n return ans\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort() # Sort the array to manage duplicates\\n result = []\\n \\n def backtrack(start, target, current):\\n if target == 0: # Base case: if we hit the target, add the current combination to the result\\n result.append(list(current))\\n return\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i - 1]:\\n continue # Skip duplicates\\n if candidates[i] > target:\\n break # If the candidate exceeds the target, stop the loop\\n current.append(candidates[i])\\n backtrack(i + 1, target - candidates[i], current) # Move to the next candidate\\n current.pop() # Backtrack by removing the last candidate\\n \\n backtrack(0, target, [])\\n return result\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res=[]\\n def dfs(target,start,comb):\\n if target<0:\\n return \\n if target==0:\\n res.append(comb)\\n return \\n for i in range(start,len(candidates)):\\n if i>start and candidates[i]==candidates[i-1]:\\n continue\\n if candidates[i]>target:\\n break\\n dfs(target-candidates[i],i+1,comb+[candidates[i]])\\n dfs(target,0,[])\\n return res\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res = []\\n\\n def dfs(target, start, comb):\\n if target < 0:\\n return\\n if target == 0:\\n res.append(comb)\\n return\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i-1]:\\n continue\\n if candidates[i] > target:\\n break\\n dfs(target-candidates[i], i+1, comb+[candidates[i]])\\n\\n dfs(target, 0, [])\\n return res\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n ans = []\\n\\n def backtrack(index, target, currArr):\\n if target == 0:\\n ans.append(list(currArr))\\n return\\n \\n for i in range(index, len(candidates)):\\n if i > index and candidates[i] == candidates[i-1]: continue\\n if candidates[i] > target: break\\n \\n currArr.append(candidates[i])\\n backtrack(i + 1, target - candidates[i], currArr)\\n currArr.pop()\\n\\n backtrack(0, target, [])\\n return ans\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def comb2(self, ind, arr, target, main, res):\\n if target == 0:\\n main.append(list(res))\\n return main\\n for i in range(ind, len(arr)):\\n if i!= ind and arr[i] == arr[i-1]:\\n continue\\n if arr[i] > target:\\n break\\n res.append(arr[i])\\n self.comb2(i+1, arr, target-arr[i], main, res)\\n res.pop()\\n \\n\\n\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n main = []\\n candidates.sort()\\n self.comb2(0, candidates, target, main, [])\\n return main\\n \\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"#Python3 Code\\nclass Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort() # Sort the candidates to handle duplicates and make it easier to skip them\\n results = []\\n \\n def backtrack(start, target, path):\\n if target == 0:\\n results.append(path)\\n return\\n if target < 0:\\n return\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i - 1]:\\n continue\\n if candidates[i] > target:\\n break\\n backtrack(i + 1, target - candidates[i], path + [candidates[i]])\\n \\n backtrack(0, target, [])\\n return results\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort() # Sort the array to manage duplicates\\n result = []\\n \\n def backtrack(start, target, current):\\n if target == 0: # Base case: if we hit the target, add the current combination to the result\\n result.append(list(current))\\n return\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i - 1]:\\n continue # Skip duplicates\\n if candidates[i] > target:\\n break # If the candidate exceeds the target, stop the loop\\n current.append(candidates[i])\\n backtrack(i + 1, target - candidates[i], current) # Move to the next candidate\\n current.pop() # Backtrack by removing the last candidate\\n \\n backtrack(0, target, [])\\n return result\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n result = []\\n \\n def backtrack(start, target, path):\\n if target == 0:\\n result.append(tuple(path))\\n return\\n if target < 0:\\n return\\n \\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i - 1]:\\n continue\\n if candidates[i] > target:\\n break\\n path.append(candidates[i])\\n backtrack(i + 1, target - candidates[i], path)\\n path.pop()\\n \\n backtrack(0, target, [])\\n return result\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n final_combination = self.find_distinct_combinations(0, candidates, target, [])\\n \\n return final_combination\\n \\n def find_distinct_combinations(self, index, candidates, target, local_list):\\n sol = []\\n if target == 0:\\n val = local_list.copy()\\n sol.append(val)\\n return sol\\n \\n for val in range(index, len(candidates)):\\n if val > index and candidates[val] == candidates[val-1]:\\n continue\\n if candidates[val] > target:\\n return sol\\n local_list.append(candidates[val])\\n taken_solution_list = self.find_distinct_combinations(val+1, candidates, target-candidates[val], local_list)\\n local_list.pop()\\n sol.extend(taken_solution_list)\\n \\n return sol\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n n = len(candidates)\\n candidates.sort()\\n #[1,1,2,5,6,7,10]\\n def f(i,arr,curr):\\n if curr == target:\\n return [arr]\\n \\n res = []\\n for j in range(i,n,1):\\n if candidates[j] + curr > target:\\n break\\n if j==i or candidates[j] != candidates[j-1]:\\n temp = f(j+1,arr+[candidates[j]],curr+candidates[j])\\n res += temp\\n \\n return res\\n \\n return f(0,[],0)\\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n final_combination = self.find_distinct_combinations(0, candidates, target, [])\\n \\n return final_combination\\n \\n def find_distinct_combinations(self, index, candidates, target, local_list):\\n sol = []\\n if target == 0:\\n val = local_list.copy()\\n sol.append(val)\\n return sol\\n \\n for val in range(index, len(candidates)):\\n if val > index and candidates[val] == candidates[val-1]:\\n continue\\n if candidates[val] > target: # if this condtion is not applied, then we run in to time limit exceeded\\n return sol\\n local_list.append(candidates[val])\\n taken_solution_list = self.find_distinct_combinations(val+1, candidates, target-candidates[val], local_list)\\n local_list.pop()\\n sol.extend(taken_solution_list)\\n \\n return sol\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n if sum(candidates) < target:\\n return []\\n\\n candidates.sort(reverse=True)\\n candcounts = []\\n currcand = None\\n currcount = 0\\n for cand in candidates:\\n if currcand is None:\\n currcand = cand\\n \\n if cand == currcand:\\n currcount += 1\\n else:\\n candcounts.append((currcount, currcand))\\n currcand = cand\\n currcount = 1\\n\\n if currcand is not None:\\n candcounts.append((currcount, currcand))\\n\\n sets = set()\\n curr = []\\n\\n def backtrack(total, left):\\n if total > target:\\n return\\n\\n if total == target:\\n sets.add(tuple(curr))\\n return\\n\\n for i in range(left, len(candcounts)):\\n count, cand = candcounts[i]\\n\\n for amt in range(1, count+1):\\n num = cand * amt\\n if total + num <= target:\\n total += num\\n\\n for j in range(amt):\\n curr.append(cand)\\n\\n backtrack(total, i+1)\\n\\n for j in range(amt):\\n curr.pop()\\n\\n total -= num\\n\\n backtrack(0, 0)\\n\\n return [[t for t in st] for st in sets]\\n\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n def backtrack(start, target, path, lis):\\n\\n if target == 0:\\n lis.append(path)\\n return\\n \\n for i in range(start, len(candidates)):\\n if i>start and candidates[i] == candidates[i-1]:\\n continue\\n if candidates[i]>target:\\n break\\n backtrack(i+1, target-candidates[i], path + [candidates[i]], res)\\n\\n candidates.sort() # Sort to handle duplicates and optimize the search\\n res = []\\n backtrack(0, target, [], res)\\n return res\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n result = []\\n\\n def dfs(i: int, curr: List[int], curr_sum: int) -> None:\\n if curr_sum == target:\\n result.append(curr)\\n return\\n \\n if i == len(candidates) or curr_sum + candidates[i] > target:\\n return\\n\\n # Include\\n dfs(i+1, [*curr, candidates[i]], curr_sum + candidates[i])\\n\\n # Exclude, but then also exclude duplicates.\\n x = candidates[i]\\n i = i+1\\n while i < len(candidates) and candidates[i] == x:\\n i = i+1\\n dfs(i, [*curr], curr_sum)\\n \\n dfs(0, [], 0)\\n return result\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res = []\\n def dfs(target, start, comb):\\n if target < 0:\\n return\\n if target == 0:\\n res.append(comb)\\n return\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i-1]:\\n continue\\n if candidates[i] > target:\\n break\\n dfs(target-candidates[i], i+1, comb+[candidates[i]])\\n\\n dfs(target, 0, [])\\n return res\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n n = len(candidates)\\n result = []\\n\\n def backtrack(start, curr_sum, path):\\n if curr_sum == target:\\n result.append(path)\\n\\n for i in range(start, n):\\n if i > start and candidates[i] == candidates[i - 1]:\\n continue\\n \\n c = candidates[i]\\n if curr_sum + c > target:\\n break\\n\\n backtrack(i + 1, curr_sum + c, path + [c])\\n \\n backtrack(0, 0, [])\\n return result \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans=[]\\n ds=[]\\n candidates.sort()\\n\\n def findCombination(ind:int,target:int):\\n if target == 0:\\n ans.append(ds[:])\\n return\\n for i in range(ind,len(candidates)):\\n if i>ind and candidates[i]==candidates[i-1]:\\n continue\\n if candidates[i]>target:\\n break\\n ds.append(candidates[i])\\n findCombination(i+1,target-candidates[i])\\n ds.pop()\\n findCombination(0,target)\\n return ans \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n def backtrack(start, target, path):\\n if target == 0:\\n result.append(path)\\n return\\n\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i-1]:\\n continue # Skip duplicate elements\\n if candidates[i] > target:\\n return # Early termination\\n backtrack(i+1, target - candidates[i], path + [candidates[i]])\\n\\n result = []\\n candidates.sort()\\n backtrack(0, target, [])\\n return result\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n ds = []\\n candidates.sort()\\n\\n def findCombination(ind, target):\\n if target == 0:\\n ans.append(ds[:])\\n return \\n for i in range(ind, len(candidates)):\\n if i > ind and candidates[i] == candidates[i - 1]:\\n continue\\n if candidates[i] > target:\\n break\\n\\n ds.append(candidates[i]) \\n findCombination(i + 1, target - candidates[i])\\n ds.pop()\\n\\n findCombination(0, target)\\n return ans\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates = sorted(candidates)\\n res = []\\n subset = []\\n\\n def backtrack(i, total):\\n if total==target:\\n res.append(subset.copy())\\n return\\n elif total>target:\\n return\\n\\n prev = -1\\n for i in range(i, len(candidates)):\\n if candidates[i] == prev:\\n continue\\n subset.append(candidates[i])\\n backtrack(i + 1, total + candidates[i])\\n subset.pop()\\n prev = candidates[i]\\n\\n\\n backtrack(0, 0)\\n return res\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n def combi2(arr, ind, target, sub, ans):\\n if sum(sub) == target:\\n ans.append(sub[:])\\n return\\n\\n\\n else:\\n for i in range(ind, len(arr)):\\n if sum(sub) + arr[i] > target:\\n break\\n if arr[i] == arr[i - 1] and i > ind:\\n continue\\n sub.append(arr[i])\\n combi2(arr, i + 1, target, sub, ans)\\n sub.pop()\\n return ans\\n \\n\\n candidates.sort()\\n return(combi2(candidates, 0, target, [], []))\\n\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res = []\\n\\n def dfs(target, start, comb):\\n if target < 0:\\n return\\n if target == 0:\\n res.append(comb)\\n return\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i-1]:\\n continue\\n if candidates[i] > target:\\n break\\n dfs(target-candidates[i], i+1, comb+[candidates[i]])\\n\\n dfs(target, 0, [])\\n return res\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n ans, c = [], Counter(candidates)\\n\\n def dfs(s, n, res):\\n if s == target: return ans.append(res)\\n if s > target or n < 1: return\\n for i in range(0, c[n]+1): dfs(s+i*n, n-1, res+[n]*i)\\n\\n dfs(0, 50, [])\\n return ans\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n\\n res = []\\n\\n def backtrack(curr, pos, target):\\n prev = -1\\n\\n if target == 0:\\n res.append(curr[:])\\n return\\n\\n if target < 0: return\\n\\n for i in range(pos, len(candidates)):\\n if prev == candidates[i]:\\n continue\\n \\n curr.append(candidates[i])\\n backtrack(curr, i + 1, target - candidates[i])\\n curr.pop()\\n\\n prev = candidates[i]\\n\\n backtrack([], 0, target)\\n return res\",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n if not candidates:\\n return [[]]\\n candidates.sort()\\n\\n res = []\\n\\n curr = []\\n\\n def dfs(i, target):\\n if target == 0:\\n res.append(curr.copy())\\n return\\n for j in range(i,len(candidates)):\\n if candidates[j] > target or( j>i and candidates[j] == candidates[j-1]):\\n continue\\n\\n curr.append(candidates[j])\\n dfs(j+1, target-candidates[j])\\n curr.pop()\\n dfs(0,target)\\n return res \\n \",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def combinationSum2(self, arr: List[int], target: int) -> List[List[int]]:\\n def backtrack(start, target, path):\\n if target == 0:\\n # Found a valid combination\\n ans.append(path.copy())\\n return\\n if target < 0:\\n # Exceeded the target, no need to continue\\n return\\n \\n for i in range(start, len(arr)):\\n # Skip duplicate elements\\n if i > start and arr[i] == arr[i - 1]:\\n continue\\n \\n # Include arr[i] in the current combination\\n path.append(arr[i])\\n # Recur with updated parameters\\n backtrack(i + 1, target - arr[i], path)\\n # Backtrack by removing the last element\\n path.pop()\\n \\n arr.sort() # Sort to handle duplicates\\n ans = []\\n backtrack(0, target, [])\\n return ans\\n\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n c = candidates\\n res, sub = [], []\\n c.sort()\\n\\n def bt(i, total):\\n if total == target: return res.append(sub[:])\\n if total > target or i == len(c): return\\n sub.append(c[i])\\n bt(i+1, total+c[i])\\n sub.pop()\\n while i+1 < len(c) and c[i] == c[i+1]: i += 1\\n bt(i+1, total)\\n \\n bt(0, 0)\\n return res\",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n n = len(candidates)\\n candidates.sort()\\n\\n def dfs(ind, goal, subset):\\n if goal == 0:\\n ans.append(subset[::])\\n if goal < 0:\\n return\\n \\n prev = -1 \\n for i in range(ind, n):\\n if candidates[i] != prev:\\n prev = candidates[i]\\n subset.append(candidates[i])\\n dfs(i + 1, goal - candidates[i], subset)\\n # backtrack\\n subset.pop()\\n\\n\\n dfs(0, target, [])\\n return ans \",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = []\\n candidates.sort()\\n allIndSet = list(range(len(candidates)))\\n stack = [(target, allIndSet, tuple())]\\n processed = set()\\n while stack:\\n # print(stack)\\n remTarget, remIndSet, curTuple = stack.pop()\\n if remTarget == 0:\\n result.append(curTuple)\\n else:\\n for i, nxtInd in enumerate(remIndSet):\\n nxt = candidates[nxtInd]\\n newRemTarget = remTarget - nxt\\n if newRemTarget >= 0:\\n nxtTuple = list(curTuple)\\n nxtTuple.append(nxt)\\n nxtTuple.sort()\\n nxtTuple = tuple(nxtTuple)\\n \\n if nxtTuple not in processed:\\n processed.add(nxtTuple)\\n nxtIndSet = remIndSet[:i]\\n nxtIndSet.extend(remIndSet[i + 1:]) \\n stack.append((newRemTarget, nxtIndSet, nxtTuple))\\n else:\\n break\\n \\n return result\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n target_to_combination_sums: dict[int, set[tuple[int]]] = {}\\n\\n for num in candidates:\\n if num > target:\\n continue\\n to_add: dict[int, set[tuple[int]]] = {num:set([(num,)])}\\n for sub_target, sub_values in target_to_combination_sums.items():\\n new_target = num + sub_target\\n if new_target > target:\\n continue\\n assert new_target not in to_add, new_target\\n to_add[new_target] = set()\\n for sub_value in sub_values:\\n to_add[new_target].add(tuple(sorted(list(sub_value) + [num])))\\n for key, value in to_add.items():\\n if key not in target_to_combination_sums:\\n target_to_combination_sums[key] = set()\\n target_to_combination_sums[key] = target_to_combination_sums[key].union(value)\\n \\n return target_to_combination_sums[target] if target in target_to_combination_sums else []\\n\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n curr=[]\\n res=[]\\n def rec(index, target):\\n if target==0:\\n res.append(curr[:])\\n return\\n if target<0 or index>=len(candidates):\\n return\\n for i in range(index, len(candidates)):\\n if i!=index and candidates[i]==candidates[i-1]:\\n continue\\n curr.append(candidates[i])\\n rec(i+1, target-candidates[i])\\n curr.pop()\\n \\n candidates.sort()\\n rec(0, target)\\n return res\\n \",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:\\n nums.sort()\\n n = len(nums)\\n \\n for i in range(n - 1, -1, -1):\\n if nums[i] <= target:\\n break\\n \\n nums, n = nums[:i+1], i + 1\\n result = []\\n self.findSum(result, nums, [], 0, n, target)\\n return result\\n\\n def findSum(self, result: List[List[int]], nums: List[int], currentnums: List[int], i: int, n: int, target: int) -> None:\\n if nums[i] > target:\\n return\\n\\n target -= nums[i]\\n currentnums.append(nums[i])\\n if target == 0:\\n result.append(copy.deepcopy(currentnums))\\n elif i + 1 < n:\\n self.findSum(result, nums, currentnums, i+1, n, target)\\n \\n target += nums[i]\\n currentnums.pop()\\n while i + 1 < n and nums[i+1] == nums[i]:\\n i += 1\\n \\n if i + 1 < n:\\n self.findSum(result, nums, currentnums, i+1, n, target)\\n\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n candidates.sort() # now must sort\\n return self.helper(0, [], [], candidates, target)\\n\\n def helper(self, i, subresult, result, candidates, target):\\n\\n if target == 0:\\n result.append(subresult[:])\\n return\\n\\n if i == len(candidates) or target < 0:\\n return\\n\\n # either take or dont take\\n for idx in range(i, len(candidates)):\\n if idx > i and candidates[idx] == candidates[idx-1]: # now must now allow duplicates, so we only allow 1 repeat max per occurrence\\n continue\\n subresult.append(candidates[idx])\\n self.helper(idx+1, subresult, result, candidates, target-candidates[idx]) # now idx+1 because can only use once\\n subresult.pop()\\n \\n return result\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n candidates.sort()\\n return self.helper(0, [], [], candidates, target)\\n\\n def helper(self, i, subresult, result, candidates, target):\\n\\n if target == 0:\\n result.append(subresult[:])\\n return\\n\\n if i == len(candidates) or target < 0:\\n return\\n\\n # either take or dont take\\n for idx in range(i, len(candidates)):\\n if idx > i and candidates[idx] == candidates[idx-1]:\\n continue\\n subresult.append(candidates[idx])\\n self.helper(idx+1, subresult, result, candidates, target-candidates[idx]) # now idx+1 because can only use once\\n subresult.pop()\\n \\n return result\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n candidates.sort()\\n return self.helper(0, [], [], candidates, target)\\n\\n def helper(self, i, subresult, result, candidates, target):\\n\\n if target == 0:\\n result.append(subresult[:])\\n return\\n\\n if i == len(candidates) or target < 0:\\n return\\n\\n # either take or dont take\\n for idx in range(i, len(candidates)):\\n if idx > i and candidates[idx] == candidates[idx-1]: # now must now allow duplicates, so we only allow 1 repeat max per occurrence\\n continue\\n subresult.append(candidates[idx])\\n self.helper(idx+1, subresult, result, candidates, target-candidates[idx]) # now idx+1 because can only use once\\n subresult.pop()\\n \\n return result\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(selt, candidates: list[int], target: int) -> list[list[int]]:\\n candidates.sort()\\n l = []\\n def recursive(idx, total, ds):\\n if total == 0:\\n l.append(ds)\\n return\\n if idx >= len(candidates) or total < 0:\\n return\\n for i in range(idx, len(candidates)):\\n if i > idx and candidates[i] == candidates[i-1]:\\n continue\\n if candidates[i] > target:\\n break\\n recursive(i+1, total-candidates[i], ds+[candidates[i]])\\n recursive(0, target, [])\\n return l\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n ans, c = [], Counter(candidates)\\n\\n def dfs(s, n, res):\\n if s == target: return ans.append(res)\\n if s > target or n < 1: return\\n for i in range(0, c[n]+1): dfs(s+i*n, n-1, res+[n]*i)\\n\\n dfs(0, 50, [])\\n return ans\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n path = []\\n n = len(candidates)\\n candidates.sort()\\n self.cur_sum = 0\\n\\n def dfs(i):\\n if self.cur_sum == target:\\n ans.append(path.copy()) # 这种加法的又全部整数和sort了，因为等于的后续一定会大过tgt，可以直接return\\n return\\n\\n if self.cur_sum > target: # 这个是为了 假设target=8 cur_sum=6,加上下一个直接超过8了\\n return \\n\\n for j in range(i, n):\\n if j> i and candidates[j]==candidates[j-1]:\\n continue\\n path.append(candidates[j])\\n self.cur_sum += candidates[j]\\n dfs(j+1)\\n path.pop()\\n self.cur_sum -= candidates[j]\\n dfs(0)\\n return ans \\n\\n \",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n candidates.sort() # Sorting helps in handling duplicates\\n\\n def back(lst, remain, curr):\\n if remain == 0:\\n res.append(lst[:]) # Found a valid combination\\n return\\n if remain < 0:\\n return # Exceeded the target, stop the recursion\\n\\n for i in range(curr, len(candidates)):\\n # Skip duplicates (only proceed if it's the first occurrence in this position)\\n if i > curr and candidates[i] == candidates[i - 1]:\\n continue\\n\\n # Include the current candidate\\n lst.append(candidates[i])\\n\\n # Recur with the remaining target and move to the next candidate (i + 1)\\n back(lst, remain - candidates[i], i + 1)\\n\\n # Backtrack and remove the last candidate\\n lst.pop()\\n\\n # Start the backtracking process\\n back([], target, 0)\\n return res\\n\\n \",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n def backtrack(start, target, path):\\n # If we hit the target, add the current path to the result\\n if target == 0:\\n result.append(list(path))\\n return\\n # If target goes below 0, there's no point in continuing\\n if target < 0:\\n return\\n \\n # Explore further by trying out each candidate\\n for i in range(start, len(candidates)):\\n # Skip duplicates\\n if i > start and candidates[i] == candidates[i - 1]:\\n continue\\n \\n # Choose the candidate and move to the next one\\n path.append(candidates[i])\\n # Recurse with updated target and starting index\\n backtrack(i + 1, target - candidates[i], path)\\n # Backtrack to explore other possibilities\\n path.pop()\\n\\n candidates.sort() # Sort to easily skip duplicates\\n result = []\\n backtrack(0, target, [])\\n return result\\n\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n candidates.sort()\\n\\n def BT(temp, st, curr_sum):\\n if curr_sum == target:\\n ans.append(temp.copy())\\n temp = list()\\n return\\n if curr_sum > target:\\n return\\n \\n for i in range(st, len(candidates)):\\n \\n # print(f\\\"temp: {temp}, st: {st}, i: {i}, curr_sum: {curr_sum}\\\")\\n if i>st and candidates[i] == candidates[i-1]:\\n continue\\n temp.append(candidates[i])\\n BT(temp, i+1, curr_sum + candidates[i])\\n temp.pop()\\n\\n BT(list(), 0, 0)\\n \\n return ans\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n def backtrack(start, target, path):\\n if target == 0:\\n result.append(path)\\n return\\n if target < 0:\\n return\\n \\n for i in range(start, len(candidates)):\\n # 跳过重复的数字\\n if i > start and candidates[i] == candidates[i - 1]:\\n continue\\n num = candidates[i]\\n # 递归调用，尝试包括当前数字\\n backtrack(i + 1, target - num, path + [num])\\n \\n result = []\\n candidates.sort() # 排序，方便跳过重复数字\\n backtrack(0, target, [])\\n return result\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n path = []\\n n = len(candidates)\\n candidates.sort()\\n self.cur_sum = 0\\n\\n def dfs(i):\\n if self.cur_sum == target:\\n ans.append(path.copy())\\n return\\n\\n if self.cur_sum > target: #没有这个会time limit exceed\\n return \\n\\n for j in range(i, n):\\n if j> i and candidates[j]==candidates[j-1]:\\n continue\\n path.append(candidates[j])\\n self.cur_sum += candidates[j]\\n dfs(j+1)\\n path.pop()\\n self.cur_sum -= candidates[j]\\n dfs(0)\\n return ans \\n\\n \",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, cand, target):\\n cand.sort()\\n res = []\\n path = []\\n self.dfs(cand, 0, target, path, res)\\n return res\\n \\n def dfs(self, cand, cur, target, path, res):\\n if target == 0:\\n res.append(path.copy())\\n return\\n if target < 0:\\n return\\n \\n for i in range(cur, len(cand)):\\n if i > cur and cand[i] == cand[i - 1]: # Skip duplicates\\n continue\\n path.append(cand[i])\\n self.dfs(cand, i + 1, target - cand[i], path, res)\\n path.pop() # Backtrack\",\n \"runtime\": \"62\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n visited = set()\\n candidates.sort()\\n def dfs(start,combo,target):\\n if target == 0:\\n if tuple(combo) not in visited:\\n ans.append(combo[:])\\n visited.add(tuple(combo))\\n return \\n if target<0 : \\n return \\n for i in range(start,len(candidates)):\\n if i > start and candidates[i] == candidates[i -1]:\\n continue\\n dfs(i+1,combo + [candidates[i]],target - candidates[i])\\n \\n dfs(0,[],target)\\n return ans\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n c = candidates\\n c.sort()\\n tmp = []\\n res = []\\n\\n def dfs(start):\\n # base\\n if sum(tmp) > target:\\n return\\n if sum(tmp) == target:\\n res.append(tmp[:])\\n return\\n \\n\\n for i in range(start, len(c)):\\n if i > start and c[i-1] == c[i]:\\n continue\\n tmp.append(c[i])\\n dfs(i + 1)\\n tmp.pop()\\n dfs(0)\\n return res\\n\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n sonuc=[]\\n candidates.sort()\\n def sol(list1,int1,lp):\\n if lp==len(candidates):\\n return\\n c=list1.copy()\\n t=int1\\n c.append(candidates[lp])\\n t+=candidates[lp]\\n if t==target:\\n c.sort()\\n if c not in sonuc:\\n sonuc.append(c)\\n elif t<target:\\n sol(c,t,lp+1)\\n k=lp\\n while k<len(candidates)-1:\\n if candidates[k+1]==candidates[k]:\\n k+=1\\n else:\\n break\\n sol(list1,int1,k+1)\\n sol([],0,0)\\n return sonuc\\n \\n \",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = []\\n candidates.sort()\\n\\n def generate(i, total, path):\\n if total == target:\\n result.append(path.copy())\\n return\\n\\n if total > target or i >= len(candidates):\\n return\\n\\n for j in range(i, len(candidates)):\\n if j - 1 >= i and candidates[j] == candidates[j - 1]:\\n continue\\n path.append(candidates[j])\\n generate(j + 1, total + candidates[j], path)\\n path.pop()\\n\\n generate(0, 0, [])\\n return result\\n\\\"\\\"\\\"\\n[1,1,2,5,6,7,10]\\n\\\"\\\"\\\"\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n # visit = set()\\n res = []\\n current = []\\n def helper(i,target):\\n if target < 0:\\n return\\n if target == 0:\\n res.append(current.copy())\\n return\\n if i == len(candidates):\\n return\\n current.append(candidates[i])\\n helper(i+1,target - candidates[i])\\n current.pop()\\n while i< len(candidates)-1 and candidates[i+1] == candidates[i]:\\n i += 1\\n helper(i+1,target)\\n \\n helper(0,target)\\n return res\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n visited = set()\\n candidates.sort()\\n def dfs(start,combo,target):\\n if target == 0:\\n if tuple(combo) not in visited:\\n ans.append(combo[:])\\n visited.add(tuple(combo))\\n return \\n if target<0 : \\n return \\n for i in range(start,len(candidates)):\\n if i == start or candidates[i] != candidates[i -1]:\\n # continue\\n dfs(i+1,combo + [candidates[i]],target - candidates[i])\\n \\n dfs(0,[],target)\\n return ans\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n\\n res = []\\n\\n # [1, 1, 2, 5, 6, 7, 10]\\n def backtrack(i, cur, total):\\n if total == target:\\n res.append(cur.copy())\\n return\\n\\n if i >= len(candidates) or total > target:\\n return\\n\\n cur.append(candidates[i])\\n backtrack(i + 1, cur, total + candidates[i])\\n cur.pop()\\n while i + 1 < len(candidates) and candidates[i] == candidates[i + 1]:\\n i += 1\\n backtrack(i + 1, cur, total)\\n\\n backtrack(0, [], 0)\\n\\n return res\\n\\n\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: list[int],\\n target: int) -> list[list[int]]:\\n ans = []\\n\\n def dfs(s: int, target: int, path: list[int]) -> None:\\n if target < 0:\\n return\\n if target == 0:\\n ans.append(path.copy())\\n return\\n\\n for i in range(s, len(candidates)):\\n if i > s and candidates[i] == candidates[i - 1]:\\n continue\\n path.append(candidates[i])\\n dfs(i + 1, target - candidates[i], path)\\n path.pop()\\n\\n candidates.sort()\\n dfs(0, target, [])\\n return ans\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n \\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: \\n\\n retSet = set()\\n candidates = sorted(candidates)\\n def dfs(currPath, rem, start):\\n if rem == 0:\\n retSet.add(tuple(currPath))\\n if start > len(candidates) or rem < 0:\\n return\\n \\n i = start\\n while i < len(candidates):\\n if i > start and candidates[i] == candidates[i-1]:\\n i+=1\\n continue\\n currPath.append(candidates[i])\\n dfs(currPath, rem - candidates[i], i + 1)\\n currPath.pop()\\n i += 1\\n \\n dfs([], target, 0)\\n return list(retSet)\\n\\n\\n \\n \\n \\n \\n \\n '''dp = [set() for _ in range(target + 1)]\\n candidates.sort()\\n\\n for cand in candidates:'''\\n \\n\\n\\n\\n\\n\\n\\n '''dp = [[] for _ in range (target + 1)]\\n cand_dict = {}\\n for cand in candidates:\\n if 0 < cand <= target:\\n dp[cand] = [set([cand])]\\n cand_dict[cand] = 1 if cand not in cand_dict else cand_dict[cand] + 1\\n\\n\\n for i in range(1, target + 1):\\n for cand in candidates:\\n if i - cand < 0:\\n continue\\n \\n for combo in dp[i - cand]:\\n if cand in combo:\\n continue\\n newcombo = set(combo)\\n newcombo.add(cand)\\n if newcombo in dp[i]:\\n continue\\n dp[i] += [newcombo]\\n return dp[target]'''\\n '''candidates.sort()\\n dp = [set() for _ in range(target + 1)]\\n dp[0].add(())\\n \\n for candidate in candidates:\\n print(dp, candidate)\\n for i in range(target, candidate - 1, -1):\\n for combo in dp[i - candidate]:\\n new_combo = tuple(sorted(list(combo) + [candidate]))\\n dp[i].add(new_combo)\\n \\n return list(dp[target])'''\\n\\n \\n \\n \\n \\n\\n\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n n = len(candidates)\\n candidates.sort()\\n def f(i,arr,curr):\\n if i >= n:\\n if curr == target:\\n return [arr]\\n else:\\n return []\\n \\n take = []\\n dontTake = []\\n if curr + candidates[i] <= target:\\n take = f(i+1,arr+[candidates[i]],curr+candidates[i])\\n for j in range(i+1,n+1,1):\\n if j == n or candidates[j] != candidates[i]:\\n dontTake = f(j,arr,curr)\\n break\\n \\n return take + dontTake\\n \\n return f(0,[],0)\\n \",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n sonuc=[]\\n candidates.sort()\\n def sol(list1,int1,lp):\\n if lp==len(candidates):\\n return\\n c=list1.copy()\\n t=int1\\n c.append(candidates[lp])\\n t+=candidates[lp]\\n if t==target:\\n c.sort()\\n if c not in sonuc:\\n sonuc.append(c)\\n elif t<target:\\n sol(c,t,lp+1)\\n while lp<len(candidates)-1:\\n if candidates[lp+1]==candidates[lp]:\\n lp+=1\\n else:\\n break\\n sol(list1,int1,lp+1)\\n sol([],0,0)\\n return sonuc\\n \\n \",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n n = len(candidates)\\n ans = set()\\n cur = []\\n\\n def comb(i, tot, prev):\\n if tot == target:\\n ans.add(tuple(sorted(cur)))\\n return\\n if i == n or tot > target:\\n return\\n \\n if candidates[i] <= target and prev != candidates[i]:\\n cur.append(candidates[i])\\n comb(i+1, tot + candidates[i], None)\\n cur.pop(-1)\\n comb(i+1, tot, candidates[i])\\n\\n return\\n\\n comb(0, 0, None)\\n return ans\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res=[]\\n stack=[]\\n def backtrack(i,total):\\n if total==target:\\n res.append(stack.copy())\\n return \\n if i>=len(candidates) or total>target:\\n return\\n stack.append(candidates[i])\\n backtrack(i+1,total+candidates[i])\\n stack.pop()\\n while i<len(candidates)-1 and candidates[i]==candidates[i+1]:\\n i+=1\\n backtrack(i+1,total)\\n backtrack(0,0)\\n return res\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n \\n def backtrack(self, start_i, candidates, target, cur_lst, cur_sum, res):\\n if cur_sum > target:\\n return \\n if cur_sum == target:\\n res.append(cur_lst[:])\\n return \\n \\n for i in range(start_i, len(candidates)):\\n if i > start_i and candidates[i] == candidates[i-1]:\\n continue\\n cur_lst.append(candidates[i])\\n self.backtrack(i+1, candidates, target, cur_lst, cur_sum+candidates[i], res)\\n cur_lst.pop()\\n return \\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n candidates.sort()\\n self.backtrack(0, candidates, target, [], 0, res)\\n return res\\n \\n \",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n counts = Counter(candidates)\\n\\n def generateCombos(combo, target):\\n if target == 0:\\n ans.append(list(combo))\\n return\\n elif target < 0:\\n return\\n\\n for num in counts:\\n if combo and num < combo[-1]:\\n continue\\n elif counts[num] > 0:\\n combo.append(num)\\n counts[num] -= 1\\n generateCombos(combo, target - num)\\n combo.pop()\\n counts[num] += 1\\n \\n generateCombos([], target)\\n return ans\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n n = len(candidates)\\n result=[]\\n candidates.sort()\\n ans = []\\n def dfs(i,temp):\\n\\n if temp==0:\\n result.append(ans[::])\\n return\\n \\n if i==n or temp<0:\\n return\\n temp-=(candidates[i])\\n ans.append(candidates[i])\\n dfs(i+1,temp)\\n temp+=(candidates[i])\\n ans.pop()\\n while i<n-1 and candidates[i]==candidates[i+1]:\\n i+=1\\n dfs(i+1,temp)\\n\\n dfs(0,target)\\n return result\",\n \"runtime\": \"71\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n candidates.sort()\\n\\n res = []\\n\\n def backtrack(i,cur,sum):\\n if sum == target:\\n res.append(cur)\\n return\\n\\n if i >= len(candidates) or sum > target:\\n return\\n\\n backtrack(i+1,cur+[candidates[i]],sum+candidates[i])\\n\\n while i + 1 < len(candidates) and candidates[i] == candidates[i+1]:\\n i += 1\\n \\n backtrack(i+1,cur,sum)\\n\\n backtrack(0,[],0)\\n return res\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res = []\\n\\n def backtrack(i,cur,cursum):\\n if cursum == target:\\n res.append(cur.copy())\\n return\\n \\n if i >= len(candidates) or cursum > target:\\n return\\n \\n cur.append(candidates[i])\\n backtrack(i+1,cur,cursum+candidates[i])\\n cur.pop()\\n\\n while i+1 < len(candidates) and candidates[i+1] == candidates[i]:\\n i+=1\\n backtrack(i+1,cur,cursum)\\n \\n backtrack(0,[],0)\\n return res\\n\\n \",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = []\\n candidates.sort()\\n\\n def generate(i, total, path):\\n if total == target:\\n result.append(path.copy())\\n return\\n\\n if total > target or i >= len(candidates):\\n return\\n\\n path.append(candidates[i])\\n generate(i + 1, total + candidates[i], path)\\n path.pop()\\n \\n count = 1\\n while i + count < len(candidates) and candidates[i] == candidates[i + count]:\\n count += 1\\n generate(i + count, total, path)\\n \\n generate(0, 0, [])\\n\\n return result\\n\\\"\\\"\\\"\\n[1,1,2,5,6,7,10]\\n\\\"\\\"\\\"\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n candidates.sort()\\n\\n res = []\\n\\n def backtrack(start, comb, curr_sum):\\n\\n if curr_sum > target:\\n return\\n if curr_sum == target:\\n res.append(comb.copy())\\n\\n for i in range(start, len(candidates)):\\n\\n if i > start and candidates[i] == candidates[i-1]:\\n continue\\n \\n comb.append(candidates[i])\\n backtrack(i+1, comb, curr_sum + candidates[i])\\n comb.pop()\\n\\n \\n backtrack(0, [], 0)\\n\\n return res\\n\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n combs = []\\n curSet = []\\n candidates.sort()\\n def dfs(i, total):\\n if total == target:\\n combs.append(curSet.copy())\\n return\\n if i >= len(candidates):\\n return\\n if total > target:\\n return\\n \\n # add cur num\\n curSet.append(candidates[i])\\n dfs(i + 1, total + candidates[i])\\n\\n # skip cur num and dont add duplicate\\n curSet.pop()\\n while i + 1 < len(candidates) and candidates[i] == candidates[i + 1]:\\n i += 1\\n dfs(i + 1, total)\\n \\n dfs(0, 0)\\n return combs\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n path = []\\n n = len(candidates)\\n candidates.sort()\\n self.cur_sum = 0\\n\\n def dfs(i):\\n if self.cur_sum == target:\\n ans.append(path.copy()) # 这种加法的又全部整数和sort了，因为等于的后续一定会大过tgt，可以直接return\\n return\\n\\n if self.cur_sum > target: # 这个是为了 假设target=8 cur_sum=6,加上下一个直接超过8了\\n return \\n\\n for j in range(i, n):\\n if j> i and candidates[j]==candidates[j-1]:\\n continue\\n path.append(candidates[j])\\n self.cur_sum += candidates[j]\\n dfs(j+1)\\n path.pop()\\n self.cur_sum -= candidates[j]\\n dfs(0)\\n return ans \\n\\n \",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res = []\\n stack = []\\n def comb(i,tot):\\n if tot == target:\\n res.append(stack.copy())\\n return\\n elif i >= len(candidates) or tot > target:\\n return\\n \\n stack.append(candidates[i])\\n comb(i+1,tot+candidates[i])\\n stack.pop()\\n cur = candidates[i]\\n i += 1\\n while(i < len(candidates) and candidates[i] == cur):\\n i += 1\\n comb(i,tot)\\n \\n comb(0,0)\\n\\n\\n\\n return res\",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:\\n res=[]\\n a=[]\\n nums.sort()\\n def helper(a,i,sum):\\n if sum==target:\\n res.append(a.copy())\\n return\\n if i >= len(nums) or sum > target: \\n return\\n\\n \\n a.append(nums[i])\\n helper(a, i + 1, sum + nums[i])\\n a.pop() # Backtrack\\n\\n \\n while i + 1 < len(nums) and nums[i] == nums[i + 1]:\\n i += 1\\n\\n \\n helper(a, i + 1, sum)\\n \\n helper(a,0,0)\\n \\n return res\\n \\n \",\n \"runtime\": \"75\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res=[]\\n candidates.sort()\\n\\n def dfs(i,cur,total):\\n if total==target:\\n res.append(cur.copy())\\n return\\n\\n if total>target or i==len(candidates):\\n return\\n \\n #include the candidates\\n cur.append(candidates[i])\\n dfs(i+1,cur,total+candidates[i])\\n cur.pop()\\n \\n #skip duplicates\\n while i+1<len(candidates) and candidates[i]==candidates[i+1]:\\n i+=1\\n dfs(i+1,cur,total)\\n\\n dfs(0,[],0)\\n return res\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = set()\\n explored = set()\\n\\n def dfs(choices, cur): \\n hashable = tuple(sorted([candidates[i] for i in choices]))\\n if hashable in explored:\\n return\\n explored.add(hashable)\\n\\n if cur == target:\\n res.add(hashable)\\n\\n for i in range(len(candidates)):\\n if i in choices:\\n continue\\n\\n if candidates[i] + cur <= target:\\n choices.add(i)\\n dfs(choices, candidates[i] + cur)\\n choices.remove(i)\\n \\n dfs(set(), 0)\\n return [list(e) for e in res]\\n \\n\",\n \"runtime\": \"76\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n curr = []\\n res = []\\n\\n def dfs(i, currSum): \\n if currSum == target:\\n res.append(curr.copy())\\n return\\n \\n if i >= len(candidates) or currSum > target:\\n return\\n \\n curr.append(candidates[i])\\n dfs(i + 1, currSum + candidates[i])\\n\\n while i < len(candidates) - 1 and candidates[i] == candidates[i + 1]:\\n i += 1\\n\\n curr.pop()\\n dfs(i + 1, currSum)\\n \\n dfs(0, 0)\\n return res\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort() \\n res = []\\n def dfs(i, subset, total):\\n if total == target:\\n res.append(subset.copy())\\n return\\n if total > target or i==len(candidates):\\n return\\n\\n # if we add curr to subset\\n subset.append(candidates[i])\\n dfs(i + 1, subset, total + candidates[i])\\n\\n # if we don't add curr to subset\\n subset.pop()\\n while i+1<len(candidates) and candidates[i+1] == candidates[i]:\\n i += 1\\n dfs(i+1, subset, total)\\n \\n dfs(0, [], 0)\\n return res\\n\",\n \"runtime\": \"77\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n def dfs(i, cur, sum):\\n if sum == target:\\n res.append(deepcopy(cur))\\n return\\n elif sum > target or i >= len(candidates):\\n return\\n num = candidates[i]\\n cur.append(num)\\n dfs(i+1, cur, sum + num)\\n cur.pop()\\n\\n while i < len(candidates) - 1 and candidates[i] == candidates[i+1]:\\n i += 1\\n dfs(i+1, cur, sum)\\n candidates.sort()\\n dfs(0, [], 0)\\n return res\",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = set()\\n explored = set()\\n\\n def dfs(choices, cur): \\n hashable = tuple(sorted([candidates[i] for i in choices]))\\n if hashable in explored:\\n return\\n explored.add(hashable)\\n\\n if cur == target:\\n res.add(hashable)\\n\\n for i in range(len(candidates)):\\n if i in choices:\\n continue\\n\\n if candidates[i] + cur <= target:\\n choices.add(i)\\n dfs(choices, candidates[i] + cur)\\n choices.remove(i)\\n \\n dfs(set(), 0)\\n return [list(e) for e in res]\\n \\n\",\n \"runtime\": \"78\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = set()\\n explored = set()\\n candidates.sort()\\n\\n def dfs(choices, cur): \\n hashable = tuple(sorted([candidates[i] for i in choices]))\\n if hashable in explored:\\n return\\n explored.add(hashable)\\n\\n if cur == target:\\n res.add(hashable)\\n\\n for i in range(len(candidates)):\\n if i in choices:\\n continue\\n\\n if candidates[i] + cur <= target:\\n choices.add(i)\\n dfs(choices, candidates[i] + cur)\\n choices.remove(i)\\n \\n dfs(set(), 0)\\n return [list(e) for e in res]\\n \\n\",\n \"runtime\": \"79\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n\\n def backtrack(combination, total, i):\\n if total == target:\\n combinations.append(combination.copy())\\n return\\n \\n if i == len(candidates) or total > target:\\n return\\n \\n combination.append(candidates[i])\\n backtrack(combination, total + candidates[i], i + 1)\\n combination.pop()\\n while i + 1 < len(candidates) and candidates[i] == candidates[i + 1]:\\n i += 1\\n backtrack(combination, total, i + 1)\\n \\n\\n \\n combinations = []\\n candidates.sort()\\n backtrack([], 0, 0)\\n return combinations\\n\\n \",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"from typing import Set, Tuple, List\\n\\nclass Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n vs: Set[Tuple[int]] = set()\\n candidates.sort()\\n\\n def backtrack(i: int, curcomb: List[int], cursum: int):\\n if (cursum > target):\\n return\\n elif (i == len(candidates)):\\n if (cursum == target):\\n vs.add(tuple(curcomb))\\n return\\n backtrack(i + 1, curcomb + [candidates[i]], cursum + candidates[i])\\n while i < len(candidates) - 1 and (candidates[i] == candidates[i + 1]):\\n i += 1 \\n backtrack(i + 1, curcomb, cursum)\\n\\n backtrack(0, [], 0)\\n return [list(comb) for comb in vs]\\n\\n \\n\",\n \"runtime\": \"80\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n path = []\\n n = len(candidates)\\n candidates.sort()\\n self.cur_sum = 0\\n\\n def dfs(i):\\n if self.cur_sum == target:\\n ans.append(path.copy())\\n\\n if self.cur_sum > target:\\n return \\n\\n for j in range(i, n):\\n if j> i and candidates[j]==candidates[j-1]:\\n continue\\n path.append(candidates[j])\\n self.cur_sum += candidates[j]\\n dfs(j+1)\\n path.pop()\\n self.cur_sum -= candidates[j]\\n dfs(0)\\n return ans \\n\\n \",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = set()\\n explored = set()\\n candidates.sort()\\n\\n def dfs(choices, cur): \\n hashable = tuple(sorted([candidates[i] for i in choices]))\\n if hashable in explored:\\n return\\n explored.add(hashable)\\n\\n if cur == target:\\n res.add(hashable)\\n\\n for i in range(len(candidates)):\\n if i in choices:\\n continue\\n\\n if candidates[i] + cur <= target:\\n choices.add(i)\\n dfs(choices, candidates[i] + cur)\\n choices.remove(i)\\n \\n dfs(set(), 0)\\n return [list(e) for e in res]\\n \\n\",\n \"runtime\": \"81\"\n },\n {\n \"code\": \"class Solution:\\n \\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: \\n\\n retSet = set()\\n candidates = sorted(candidates)\\n def dfs(currPath, rem, start):\\n currTuple = tuple(currPath)\\n if rem == 0:\\n retSet.add(tuple(currPath))\\n if start > len(candidates) or rem < 0:\\n return\\n \\n i = start\\n while i < len(candidates):\\n if i > start and candidates[i] == candidates[i-1]:\\n i+=1\\n continue\\n currPath.append(candidates[i])\\n dfs(currPath, rem - candidates[i], i + 1)\\n currPath.pop()\\n i += 1\\n \\n dfs([], target, 0)\\n return list(retSet)\\n\\n\\n \\n \\n \\n \\n \\n '''dp = [set() for _ in range(target + 1)]\\n candidates.sort()\\n\\n for cand in candidates:'''\\n \\n\\n\\n\\n\\n\\n\\n '''dp = [[] for _ in range (target + 1)]\\n cand_dict = {}\\n for cand in candidates:\\n if 0 < cand <= target:\\n dp[cand] = [set([cand])]\\n cand_dict[cand] = 1 if cand not in cand_dict else cand_dict[cand] + 1\\n\\n\\n for i in range(1, target + 1):\\n for cand in candidates:\\n if i - cand < 0:\\n continue\\n \\n for combo in dp[i - cand]:\\n if cand in combo:\\n continue\\n newcombo = set(combo)\\n newcombo.add(cand)\\n if newcombo in dp[i]:\\n continue\\n dp[i] += [newcombo]\\n return dp[target]'''\\n '''candidates.sort()\\n dp = [set() for _ in range(target + 1)]\\n dp[0].add(())\\n \\n for candidate in candidates:\\n print(dp, candidate)\\n for i in range(target, candidate - 1, -1):\\n for combo in dp[i - candidate]:\\n new_combo = tuple(sorted(list(combo) + [candidate]))\\n dp[i].add(new_combo)\\n \\n return list(dp[target])'''\\n\\n \\n \\n \\n \\n\\n\",\n \"runtime\": \"83\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n res = []\\n candidates = sorted(candidates)\\n def dfs(i, subset, total):\\n if total == target:\\n res.append(subset.copy())\\n return\\n if i == len(candidates) or sum(subset) > target:\\n return\\n subset.append(candidates[i])\\n dfs(i+1, subset, total+candidates[i])\\n subset.pop()\\n while i+1 < len(candidates) and candidates[i] == candidates[i+1]:\\n i += 1\\n dfs(i+1, subset, total)\\n dfs(0, [], 0)\\n return res\",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n result = []\\n res_set = set()\\n searched_list = []\\n def backtracking(res, i):\\n if sum(res) == target:\\n result.append(res)\\n searched_list.append(res)\\n return True\\n elif sum(res) > target:\\n searched_list.append(res)\\n return False\\n for j, candidate in enumerate(candidates[i:]):\\n new_res = res + [candidate]\\n if new_res not in searched_list:\\n searched_list.append(new_res)\\n val = backtracking(new_res, i + j + 1)\\n if not val:\\n return True\\n return True\\n \\n candidates.sort()\\n backtracking([], 0)\\n return result\\n\",\n \"runtime\": \"85\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n output = []\\n candidates.sort()\\n\\n def backtrack(i, arr, target):\\n if target == 0:\\n output.append(arr[:])\\n return\\n \\n if i >= len(candidates) or target < 0:\\n return\\n\\n arr.append(candidates[i])\\n backtrack(i + 1, arr, target - candidates[i])\\n arr.pop()\\n\\n while i + 1 < len(candidates) and candidates[i] == candidates[i + 1]:\\n i += 1\\n backtrack(i + 1, arr, target)\\n backtrack(0, [], target)\\n \\n return output\\n \\n\",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n candidates.sort()\\n \\n def combinations(index, curCandidates):\\n nonlocal res\\n\\n if index >= len(candidates):\\n if sum(curCandidates) == target:\\n res.append(curCandidates)\\n\\n return\\n if sum(curCandidates) > target:\\n return\\n \\n # recursive case where we include the current number\\n combinations(index + 1, curCandidates + [candidates[index]])\\n while index + 1 < len(candidates) and candidates[index] == candidates[index+1]:\\n index += 1\\n\\n # recursive case where we dont include the current number\\n combinations(index + 1, curCandidates)\\n\\n combinations(0, [])\\n return res\",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n res = []\\n dict = {}\\n subset = []\\n candidates = sorted(candidates)\\n def dfs(i):\\n if sum(subset) == target:\\n tmp = sorted(subset.copy())\\n tmp = [str(i) for i in tmp]\\n tmp = \\\"\\\".join(tmp)\\n if tmp not in dict:\\n res.append(subset.copy())\\n dict[tmp] = 0\\n return\\n if i == len(candidates) or sum(subset) > target:\\n return\\n subset.append(candidates[i])\\n dfs(i+1)\\n subset.pop()\\n while i+1 < len(candidates) and candidates[i] == candidates[i+1]:\\n i += 1\\n dfs(i+1)\\n dfs(0)\\n return res\",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res = []\\n\\n def backtrack(curr, total, i):\\n if i == len(candidates):\\n if total == target:\\n res.append(curr.copy())\\n return\\n if total > target:\\n return\\n \\n curr.append(candidates[i])\\n backtrack(curr, total+candidates[i], i+1)\\n curr.pop()\\n\\n k = 1\\n while i+k <= len(candidates)-1 and candidates[i+k] == candidates[i+k-1]:\\n k += 1\\n backtrack(curr, total, i+k)\\n \\n backtrack([], 0, 0)\\n return res\\n \\n \",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n result = []\\n candidates.sort()\\n self.combinationSum2Helper(candidates, [], target, result)\\n return result\\n\\n def combinationSum2Helper(self, inp, out, target, result):\\n\\n if target == 0:\\n if out not in result:\\n result.append(out.copy())\\n return\\n\\n if len(inp) == 0:\\n return\\n\\n if target < 0:\\n return\\n\\n self.combinationSum2Helper(inp[1:], out + [inp[0]], target - inp[0], result)\\n c = 1\\n while c < len(inp) and inp[c] == inp[c-1]:\\n c += 1\\n self.combinationSum2Helper(inp[c:], out, target, result)\\n\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n subset = []\\n candidates.sort()\\n def dfs(i):\\n if sum(subset)>target:\\n return\\n if sum(subset)==target:\\n res.append(subset.copy())\\n return\\n if i >= len(candidates):\\n return\\n \\n \\n\\n subset.append(candidates[i])\\n dfs(i+1)\\n subset.pop()\\n\\n while i+1<len(candidates) and candidates[i]==candidates[i+1] :\\n i+=1\\n dfs(i+1)\\n \\n dfs(0)\\n return res\",\n \"runtime\": \"89\"\n },\n {\n \"code\": \"class Solution:\\n \\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: \\n retSet = set()\\n candidates = sorted(candidates)\\n seen = set()\\n def dfs(currPath, rem, start):\\n pathTup = tuple(currPath)\\n if pathTup in seen:\\n return\\n if rem == 0:\\n retSet.add(pathTup)\\n if start > len(candidates) or rem < 0:\\n return\\n \\n i = start\\n while i < len(candidates):\\n if i > start and candidates[i] == candidates[i-1]:\\n i+=1\\n continue\\n currPath.append(candidates[i])\\n dfs(currPath, rem - candidates[i], i + 1)\\n seen.add(pathTup)\\n currPath.pop()\\n i += 1\\n \\n dfs([], target, 0)\\n return list(retSet)\\n\\n\\n\\n \\n \\n \\n \\n \\n '''dp = [set() for _ in range(target + 1)]\\n candidates.sort()\\n\\n for cand in candidates:'''\\n \\n\\n\\n\\n\\n\\n\\n '''dp = [[] for _ in range (target + 1)]\\n cand_dict = {}\\n for cand in candidates:\\n if 0 < cand <= target:\\n dp[cand] = [set([cand])]\\n cand_dict[cand] = 1 if cand not in cand_dict else cand_dict[cand] + 1\\n\\n\\n for i in range(1, target + 1):\\n for cand in candidates:\\n if i - cand < 0:\\n continue\\n \\n for combo in dp[i - cand]:\\n if cand in combo:\\n continue\\n newcombo = set(combo)\\n newcombo.add(cand)\\n if newcombo in dp[i]:\\n continue\\n dp[i] += [newcombo]\\n return dp[target]'''\\n '''candidates.sort()\\n dp = [set() for _ in range(target + 1)]\\n dp[0].add(())\\n \\n for candidate in candidates:\\n print(dp, candidate)\\n for i in range(target, candidate - 1, -1):\\n for combo in dp[i - candidate]:\\n new_combo = tuple(sorted(list(combo) + [candidate]))\\n dp[i].add(new_combo)\\n \\n return list(dp[target])'''\\n\\n \\n \\n \\n \\n\\n\",\n \"runtime\": \"90\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n sol = []\\n candidates.sort()\\n \\n def dfs(curr, i):\\n if sum(curr) == target:\\n sol.append(curr.copy())\\n return\\n if sum(curr) > target or i >= len(candidates):\\n return \\n \\n curr.append(candidates[i])\\n dfs(curr, i+1)\\n curr.pop()\\n num = candidates[i]\\n while i+1 < len(candidates) and num == candidates[i+1]:\\n i += 1\\n dfs(curr, i+1)\\n \\n dfs([], 0)\\n return sol\",\n \"runtime\": \"91\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n out = []\\n candidates.sort()\\n def helper(i, nums):\\n if sum(nums) == target:\\n out.append(nums.copy())\\n return\\n if i >= len(candidates) or sum(nums) > target:\\n return\\n\\n y = i\\n while y < len(candidates) and candidates[y] == candidates[i] :\\n y+= 1\\n helper(y, nums.copy())\\n\\n nums.append(candidates[i])\\n helper(i+1, nums.copy())\\n\\n\\n helper(0, [])\\n return out\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n output = [] \\n\\n def dfs(remain, comb, index):\\n if remain == 0:\\n res = sorted(comb)\\n if res not in output:\\n output.append(res)\\n elif remain < 0:\\n return\\n \\n for i in range(index, len(candidates)):\\n if i > index and candidates[i - 1] == candidates[i]:\\n continue\\n\\n new_remain = remain - candidates[i]\\n if new_remain < 0:\\n continue\\n \\n comb.append(candidates[i])\\n dfs(remain - candidates[i], comb, i + 1)\\n comb.pop()\\n \\n dfs(target, [], 0)\\n\\n return output\\n \\n\",\n \"runtime\": \"92\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n \\n res = []\\n subset = []\\n candidates = sorted(candidates)\\n def dfs(i):\\n if sum(subset) == target:\\n res.append(subset.copy())\\n return\\n if i == len(candidates) or sum(subset) > target:\\n return\\n subset.append(candidates[i])\\n dfs(i+1)\\n subset.pop()\\n while i+1 < len(candidates) and candidates[i] == candidates[i+1]:\\n i += 1\\n dfs(i+1)\\n dfs(0)\\n return res\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res = []\\n def backtrack(comb, idx):\\n if sum(comb) == target:\\n res.append(comb[:])\\n return\\n if sum(comb) > target or idx == len(candidates):\\n return\\n comb.append(candidates[idx])\\n backtrack(comb, idx+1)\\n comb.pop()\\n while idx+1 < len(candidates) and candidates[idx] == candidates[idx+1]:\\n idx += 1\\n backtrack(comb, idx+1)\\n backtrack([], 0)\\n return res\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n candidates.sort()\\n \\n def combinations(index, curCandidates):\\n nonlocal res\\n\\n if index >= len(candidates):\\n if sum(curCandidates) == target:\\n if curCandidates not in res:\\n res.append(curCandidates)\\n return\\n if sum(curCandidates) > target:\\n return\\n \\n # recursive case where we include the current number\\n combinations(index + 1, curCandidates + [candidates[index]])\\n while index + 1 < len(candidates) and candidates[index] == candidates[index+1]:\\n index += 1\\n\\n # recursive case where we dont include the current number\\n combinations(index + 1, curCandidates)\\n\\n combinations(0, [])\\n return res\",\n \"runtime\": \"94\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n result = []\\n self.backtrack(candidates, target, 0, [], result)\\n return result\\n \\n def backtrack(self, candidates, target, start, path, result):\\n if sum(path) == target:\\n result.append(path[:])\\n return\\n\\n for i in range(start, len(candidates)):\\n if sum(path) > target:\\n break\\n if i > start and candidates[i] == candidates[i - 1]:\\n continue\\n path.append(candidates[i])\\n self.backtrack(candidates, target, i + 1, path, result)\\n path.pop()\",\n \"runtime\": \"95\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n\\n def backtrack(i, sub, total, discarded):\\n if total == target:\\n res.append(sub.copy())\\n return\\n \\n if i == len(candidates) or total > target:\\n return\\n \\n if candidates[i] not in discarded and candidates[i] <= target:\\n sub.append(candidates[i])\\n backtrack(i+1, sub, total+candidates[i], discarded.copy())\\n sub.pop()\\n\\n discarded.add(candidates[i])\\n backtrack(i+1, sub, total, discarded.copy())\\n backtrack(0, [], 0, set())\\n return res\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n if sum(candidates)==target:\\n return [candidates]\\n if sum(candidates)<target:\\n return []\\n if sum(candidates)==len(candidates):\\n return [[1 for x in range(target)]]\\n if sum(candidates)==len(candidates)+1 and target>2:\\n l = [1 for x in range(target-2)]\\n l.append(2)\\n return [[1 for x in range(target)], l]\\n newcand = [x for x in candidates if x <= target]\\n #print(newcand)\\n ans = set()\\n def rec(l, r, cur):\\n for i in range(l, r):\\n if newcand[i]+sum(cur) == target:\\n cur2 = cur[:]\\n cur2.append(newcand[i])\\n cur2.sort()\\n ans.add(tuple(cur2))\\n continue\\n elif newcand[i]+sum(cur) > target:\\n continue\\n else:\\n cur2 = cur[:]\\n cur2.append(newcand[i])\\n rec(i+1, r, cur2)\\n rec(0, len(newcand), [])\\n return list(ans)\\n\\n \\n\\n\\n \\n \\n return [[]]\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n\\n def combinationSum2Helper(self, candidates, target, cur_list, cur_sum, last_added):\\n if tuple(cur_list) in self.paths:\\n return\\n self.paths.add(tuple(cur_list))\\n if cur_sum == target:\\n self.ans.append(cur_list)\\n print(cur_list, target)\\n elif cur_sum < target:\\n for i in range(last_added + 1, len(candidates)):\\n self.combinationSum2Helper(candidates, target, cur_list + [candidates[i]], cur_sum + candidates[i], i)\\n\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n self.ans = []\\n self.paths = set()\\n candidates.sort()\\n self.combinationSum2Helper(candidates, target, [], 0, -1)\\n return self.ans\",\n \"runtime\": \"97\"\n },\n {\n \"code\": \"class Solution:\\n \\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: \\n retSet = set()\\n candidates = sorted(candidates)\\n seen = set()\\n def dfs(currPath, rem, i):\\n pathTup = tuple(currPath)\\n if pathTup in seen:\\n return\\n if rem == 0:\\n retSet.add(pathTup)\\n if i > len(candidates) or rem < 0:\\n return\\n \\n while i < len(candidates):\\n currPath.append(candidates[i])\\n dfs(currPath, rem - candidates[i], i + 1)\\n seen.add(pathTup)\\n currPath.pop()\\n i += 1\\n \\n dfs([], target, 0)\\n return list(retSet)\\n\\n\\n\\n \\n \\n \\n \\n \\n '''dp = [set() for _ in range(target + 1)]\\n candidates.sort()\\n\\n for cand in candidates:'''\\n \\n\\n\\n\\n\\n\\n\\n '''dp = [[] for _ in range (target + 1)]\\n cand_dict = {}\\n for cand in candidates:\\n if 0 < cand <= target:\\n dp[cand] = [set([cand])]\\n cand_dict[cand] = 1 if cand not in cand_dict else cand_dict[cand] + 1\\n\\n\\n for i in range(1, target + 1):\\n for cand in candidates:\\n if i - cand < 0:\\n continue\\n \\n for combo in dp[i - cand]:\\n if cand in combo:\\n continue\\n newcombo = set(combo)\\n newcombo.add(cand)\\n if newcombo in dp[i]:\\n continue\\n dp[i] += [newcombo]\\n return dp[target]'''\\n '''candidates.sort()\\n dp = [set() for _ in range(target + 1)]\\n dp[0].add(())\\n \\n for candidate in candidates:\\n print(dp, candidate)\\n for i in range(target, candidate - 1, -1):\\n for combo in dp[i - candidate]:\\n new_combo = tuple(sorted(list(combo) + [candidate]))\\n dp[i].add(new_combo)\\n \\n return list(dp[target])'''\\n\\n \\n \\n \\n \\n\\n\",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n res = []\\n stack = []\\n def comb(i,tot):\\n if tot == target:\\n res.append(stack.copy())\\n return\\n elif i >= len(candidates) or tot > target:\\n return\\n \\n stack.append(candidates[i])\\n comb(i+1,tot+candidates[i])\\n stack.pop()\\n cur = candidates[i]\\n i += 1\\n while(i < len(candidates) and candidates[i] == cur):\\n print(candidates[i])\\n i += 1\\n comb(i,tot)\\n \\n comb(0,0)\\n\\n\\n\\n return res\",\n \"runtime\": \"99\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans=[]\\n candidates.sort()\\n def back(candidates,path,curr,index):\\n if curr>target:\\n return\\n if target==curr and path not in ans:\\n ans.append(path)\\n return\\n for i in range(index,len(candidates)):\\n if i >index and candidates[i]==candidates[i-1]:\\n continue\\n back(candidates[:i]+candidates[i+1:],path+[candidates[i]],curr+candidates[i],i)\\n back(candidates,[],0,0)\\n return ans\",\n \"runtime\": \"100\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n candidates.sort()\\n\\n def dfs(i,cur):\\n if sum(cur)==target:\\n res.append(cur)\\n return\\n if sum(cur)<target and i<len(candidates):\\n x = candidates[i]\\n dfs(i+1, cur+[x])\\n while i<len(candidates) and x==candidates[i]:\\n i +=1\\n dfs(i, cur)\\n \\n\\n dfs(0, [])\\n return res\",\n \"runtime\": \"101\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n if sum(candidates) < target:\\n return []\\n elif sum(candidates) == target:\\n return [candidates]\\n\\n final = []\\n candidates.sort()\\n def gencomb(i, curr):\\n if sum(curr) == target:\\n final.append(curr[:])\\n return\\n elif sum(curr) < target:\\n if i<len(candidates):\\n curr.append(candidates[i])\\n gencomb(i+1, curr[:])\\n pos = bisect.bisect_left(candidates, curr[-1]+1)\\n curr.pop()\\n if pos<len(candidates): gencomb(pos, curr[:])\\n\\n return\\n\\n gencomb(0, [])\\n #seen = set()\\n #for i in final:\\n # seen.add(tuple(i))\\n\\n #ans = []\\n #for s in seen:\\n # ans.append(list(s))\\n\\n return final\\n\\n\\n\\n \",\n \"runtime\": \"102\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":122,"string":"122"},"mm_list":{"kind":"list like","value":[{"code":"class Solution(object):\n def combinationSum2(self, candidates, target):\n ans = []\n ds = []\n candidates.sort()\n\n\n def findCombination(ind, target):\n if target == 0:\n ans.append(ds[:])\n return\n for i in range(ind, len(candidates)):\n if i > ind and candidates[i] == candidates[i - 1]:\n continue\n if candidates[i] > target:\n break\n ds.append(candidates[i])\n findCombination(i + 1, target - candidates[i])\n ds.pop()\n\n\n findCombination(0, target)\n return ans","memory":"15900"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n n = len(candidates)\n candidates.sort()\n def backTrack(index, curSum, arr):\n if curSum == target:\n res.append(arr)\n return\n for i in range(index, n):\n if i > index and candidates[i] == candidates[i-1]:\n continue\n newSum = curSum + candidates[i]\n if newSum <= target:\n backTrack(i +1, newSum, arr + [candidates[i]])\n backTrack(0, 0, [])\n return res","memory":"16100"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n res = []\n candidates.sort()\n\n def dfs(i, cur, total):\n if total == target:\n res.append(cur.copy())\n return\n if i >= len(candidates) or total > target:\n return\n cur.append(candidates[i])\n dfs(i + 1, cur, total + candidates[i])\n cur.pop()\n\n while i + 1 < len(candidates) and candidates[i+1] == candidates[i]:\n i += 1\n dfs(i + 1, cur, total)\n \n dfs(0, [], 0)\n return res","memory":"16200"},{"code":"class Solution:\n def comboinationSum2Helper(self, candidates, target, path):\n if target < 0:\n return\n\n if target == 0:\n if path not in self.res:\n self.res.append(path)\n return\n\n if not candidates:\n return \n\n for i in range(len(candidates)):\n if i != 0 and candidates[i] == candidates[i-1]:\n continue\n else:\n self.comboinationSum2Helper(candidates[i+1:], target - candidates[i], path + [candidates[i]])\n\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n self.res = []\n candidates.sort()\n\n self.comboinationSum2Helper(candidates, target, [])\n\n return self.res\n\n ","memory":"16300"},{"code":"class Solution:\n def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:\n nums.sort()\n n = len(nums)\n \n for i in range(n - 1, -1, -1):\n if nums[i] <= target:\n break\n \n nums, n = nums[:i+1], i + 1\n result = []\n self.findSum(result, nums, [], 0, n, target)\n return result\n\n def findSum(self, result: List[List[int]], nums: List[int], currentnums: List[int], i: int, n: int, target: int) -> None:\n if nums[i] > target:\n return\n\n target -= nums[i]\n currentnums.append(nums[i])\n if target == 0:\n result.append(copy.deepcopy(currentnums))\n elif i + 1 < n:\n self.findSum(result, nums, currentnums, i+1, n, target)\n \n target += nums[i]\n currentnums.pop()\n while i + 1 < n and nums[i+1] == nums[i]:\n i += 1\n \n if i + 1 < n:\n self.findSum(result, nums, currentnums, i+1, n, target)\n","memory":"16400"},{"code":"class Solution:\n def combinationSum2(self, cand, target):\n cand.sort()\n res = []\n path = []\n self.dfs(cand, 0, target, path, res)\n return res\n \n def dfs(self, cand, cur, target, path, res):\n if target == 0:\n res.append(path.copy())\n return\n if target < 0:\n return\n \n for i in range(cur, len(cand)):\n if i > cur and cand[i] == cand[i - 1]: # Skip duplicates\n continue\n path.append(cand[i])\n self.dfs(cand, i + 1, target - cand[i], path, res)\n path.pop() # Backtrack","memory":"16500"},{"code":"#Python3 Code\nclass Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort() # Sort the candidates to handle duplicates and make it easier to skip them\n results = []\n \n def backtrack(start, target, path):\n if target == 0:\n results.append(path)\n return\n if target < 0:\n return\n for i in range(start, len(candidates)):\n if i > start and candidates[i] == candidates[i - 1]:\n continue\n if candidates[i] > target:\n break\n backtrack(i + 1, target - candidates[i], path + [candidates[i]])\n \n backtrack(0, target, [])\n return results","memory":"16500"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n candidates.sort()\n \n result = []\n\n def backtracking(remaining, result, start, selection):\n if remaining == 0:\n result.append(selection.copy())\n return\n \n for idx in range(start, len(candidates)):\n value = candidates[idx]\n\n if idx > start and candidates[idx] == candidates[idx - 1]:\n continue\n\n if value <= remaining:\n selection += [value]\n backtracking(remaining - value, result, idx + 1, selection)\n selection.pop()\n return\n\n backtracking(target, result, 0, [])\n return result\n ","memory":"16600"},{"code":"class Solution:\n def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:\n def backtrack(templist,remain,start):\n if remain<0:\n return\n if remain==0:\n res.append(list(templist))\n else:\n for i in range(start,n):\n if i>start and nums[i]==nums[i-1]:\n continue\n templist.append(nums[i])\n backtrack(templist,remain-nums[i],i+1)\n templist.pop()\n res=[]\n nums.sort()\n n=len(nums)\n backtrack([],target,0)\n return res\n","memory":"16600"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n path = []\n n = len(candidates)\n candidates.sort()\n self.cur_sum = 0\n\n def dfs(i):\n if self.cur_sum == target:\n ans.append(path.copy())\n\n if self.cur_sum > target:\n return \n\n for j in range(i, n):\n if j> i and candidates[j]==candidates[j-1]:\n continue\n path.append(candidates[j])\n self.cur_sum += candidates[j]\n dfs(j+1)\n path.pop()\n self.cur_sum -= candidates[j]\n dfs(0)\n return ans \n\n ","memory":"16700"},{"code":"class Solution:\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\n ans = []\n path = []\n n = len(candidates)\n candidates.sort()\n self.cur_sum = 0\n\n def dfs(i):\n if self.cur_sum == target:\n ans.append(path.copy())\n return\n\n if self.cur_sum > target: #没有这个会time limit exceed\n return \n\n for j in range(i, n):\n if j> i and candidates[j]==candidates[j-1]:\n continue\n path.append(candidates[j])\n self.cur_sum += candidates[j]\n dfs(j+1)\n path.pop()\n self.cur_sum -= candidates[j]\n dfs(0)\n return ans \n\n ","memory":"16700"}],"string":"[\n {\n \"code\": \"class Solution(object):\\n def combinationSum2(self, candidates, target):\\n ans = []\\n ds = []\\n candidates.sort()\\n\\n\\n def findCombination(ind, target):\\n if target == 0:\\n ans.append(ds[:])\\n return\\n for i in range(ind, len(candidates)):\\n if i > ind and candidates[i] == candidates[i - 1]:\\n continue\\n if candidates[i] > target:\\n break\\n ds.append(candidates[i])\\n findCombination(i + 1, target - candidates[i])\\n ds.pop()\\n\\n\\n findCombination(0, target)\\n return ans\",\n \"memory\": \"15900\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n n = len(candidates)\\n candidates.sort()\\n def backTrack(index, curSum, arr):\\n if curSum == target:\\n res.append(arr)\\n return\\n for i in range(index, n):\\n if i > index and candidates[i] == candidates[i-1]:\\n continue\\n newSum = curSum + candidates[i]\\n if newSum <= target:\\n backTrack(i +1, newSum, arr + [candidates[i]])\\n backTrack(0, 0, [])\\n return res\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n res = []\\n candidates.sort()\\n\\n def dfs(i, cur, total):\\n if total == target:\\n res.append(cur.copy())\\n return\\n if i >= len(candidates) or total > target:\\n return\\n cur.append(candidates[i])\\n dfs(i + 1, cur, total + candidates[i])\\n cur.pop()\\n\\n while i + 1 < len(candidates) and candidates[i+1] == candidates[i]:\\n i += 1\\n dfs(i + 1, cur, total)\\n \\n dfs(0, [], 0)\\n return res\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def comboinationSum2Helper(self, candidates, target, path):\\n if target < 0:\\n return\\n\\n if target == 0:\\n if path not in self.res:\\n self.res.append(path)\\n return\\n\\n if not candidates:\\n return \\n\\n for i in range(len(candidates)):\\n if i != 0 and candidates[i] == candidates[i-1]:\\n continue\\n else:\\n self.comboinationSum2Helper(candidates[i+1:], target - candidates[i], path + [candidates[i]])\\n\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n self.res = []\\n candidates.sort()\\n\\n self.comboinationSum2Helper(candidates, target, [])\\n\\n return self.res\\n\\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:\\n nums.sort()\\n n = len(nums)\\n \\n for i in range(n - 1, -1, -1):\\n if nums[i] <= target:\\n break\\n \\n nums, n = nums[:i+1], i + 1\\n result = []\\n self.findSum(result, nums, [], 0, n, target)\\n return result\\n\\n def findSum(self, result: List[List[int]], nums: List[int], currentnums: List[int], i: int, n: int, target: int) -> None:\\n if nums[i] > target:\\n return\\n\\n target -= nums[i]\\n currentnums.append(nums[i])\\n if target == 0:\\n result.append(copy.deepcopy(currentnums))\\n elif i + 1 < n:\\n self.findSum(result, nums, currentnums, i+1, n, target)\\n \\n target += nums[i]\\n currentnums.pop()\\n while i + 1 < n and nums[i+1] == nums[i]:\\n i += 1\\n \\n if i + 1 < n:\\n self.findSum(result, nums, currentnums, i+1, n, target)\\n\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, cand, target):\\n cand.sort()\\n res = []\\n path = []\\n self.dfs(cand, 0, target, path, res)\\n return res\\n \\n def dfs(self, cand, cur, target, path, res):\\n if target == 0:\\n res.append(path.copy())\\n return\\n if target < 0:\\n return\\n \\n for i in range(cur, len(cand)):\\n if i > cur and cand[i] == cand[i - 1]: # Skip duplicates\\n continue\\n path.append(cand[i])\\n self.dfs(cand, i + 1, target - cand[i], path, res)\\n path.pop() # Backtrack\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"#Python3 Code\\nclass Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort() # Sort the candidates to handle duplicates and make it easier to skip them\\n results = []\\n \\n def backtrack(start, target, path):\\n if target == 0:\\n results.append(path)\\n return\\n if target < 0:\\n return\\n for i in range(start, len(candidates)):\\n if i > start and candidates[i] == candidates[i - 1]:\\n continue\\n if candidates[i] > target:\\n break\\n backtrack(i + 1, target - candidates[i], path + [candidates[i]])\\n \\n backtrack(0, target, [])\\n return results\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n candidates.sort()\\n \\n result = []\\n\\n def backtracking(remaining, result, start, selection):\\n if remaining == 0:\\n result.append(selection.copy())\\n return\\n \\n for idx in range(start, len(candidates)):\\n value = candidates[idx]\\n\\n if idx > start and candidates[idx] == candidates[idx - 1]:\\n continue\\n\\n if value <= remaining:\\n selection += [value]\\n backtracking(remaining - value, result, idx + 1, selection)\\n selection.pop()\\n return\\n\\n backtracking(target, result, 0, [])\\n return result\\n \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:\\n def backtrack(templist,remain,start):\\n if remain<0:\\n return\\n if remain==0:\\n res.append(list(templist))\\n else:\\n for i in range(start,n):\\n if i>start and nums[i]==nums[i-1]:\\n continue\\n templist.append(nums[i])\\n backtrack(templist,remain-nums[i],i+1)\\n templist.pop()\\n res=[]\\n nums.sort()\\n n=len(nums)\\n backtrack([],target,0)\\n return res\\n\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n path = []\\n n = len(candidates)\\n candidates.sort()\\n self.cur_sum = 0\\n\\n def dfs(i):\\n if self.cur_sum == target:\\n ans.append(path.copy())\\n\\n if self.cur_sum > target:\\n return \\n\\n for j in range(i, n):\\n if j> i and candidates[j]==candidates[j-1]:\\n continue\\n path.append(candidates[j])\\n self.cur_sum += candidates[j]\\n dfs(j+1)\\n path.pop()\\n self.cur_sum -= candidates[j]\\n dfs(0)\\n return ans \\n\\n \",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:\\n ans = []\\n path = []\\n n = len(candidates)\\n candidates.sort()\\n self.cur_sum = 0\\n\\n def dfs(i):\\n if self.cur_sum == target:\\n ans.append(path.copy())\\n return\\n\\n if self.cur_sum > target: #没有这个会time limit exceed\\n return \\n\\n for j in range(i, n):\\n if j> i and candidates[j]==candidates[j-1]:\\n continue\\n path.append(candidates[j])\\n self.cur_sum += candidates[j]\\n dfs(j+1)\\n path.pop()\\n self.cur_sum -= candidates[j]\\n dfs(0)\\n return ans \\n\\n \",\n \"memory\": \"16700\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":11,"string":"11"}}},{"rowIdx":77,"cells":{"question_id":{"kind":"number","value":191,"string":"191"},"name":{"kind":"string","value":"number-of-1-bits"},"content":{"kind":"string","value":"<p>Write a function that takes the binary representation of a positive integer and returns the number of <span data-keyword=\"set-bit\">set bits</span> it has (also known as the <a href=\"http://en.wikipedia.org/wiki/Hamming_weight\" target=\"_blank\">Hamming weight</a>).</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">n = 11</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">3</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The input binary string <strong>1011</strong> has a total of three set bits.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">n = 128</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">1</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The input binary string <strong>10000000</strong> has a total of one set bit.</p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">n = 2147483645</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">30</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The input binary string <strong>1111111111111111111111111111101</strong> has a total of thirty set bits.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n <= 2<sup>31</sup> - 1</code></li>\n</ul>\n\n<p> </p>\n<strong>Follow up:</strong> If this function is called many times, how would you optimize it?"},"acRate":{"kind":"number","value":72.42336509770652,"string":"72.423365"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["divide-and-conquer","bit-manipulation"],"string":"[\n \"divide-and-conquer\",\n \"bit-manipulation\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"12\", 0.0062], [\"14\", 0.0062], [\"15\", 0.0437], [\"16\", 0.0062], [\"17\", 0.0062], [\"18\", 0.0375], [\"19\", 0.2187], [\"20\", 0.1437], [\"21\", 0.1187], [\"22\", 0.2374], [\"23\", 1.0622], [\"24\", 0.4936], [\"25\", 0.6186], [\"26\", 1.2246], [\"27\", 3.3677], [\"28\", 1.8807], [\"29\", 1.8994], [\"30\", 3.9675], [\"31\", 6.9853], [\"32\", 4.2799], [\"33\", 4.2299], [\"34\", 7.6226], [\"35\", 9.3471], [\"36\", 6.6479], [\"37\", 5.3608], [\"38\", 7.8538], [\"39\", 8.0162], [\"40\", 5.5295], [\"41\", 4.1924], [\"42\", 4.3112], [\"43\", 3.6114]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15900\", 0.0062], [\"16000\", 0.0187], [\"16100\", 0.0062], [\"16200\", 0.4873], [\"16300\", 6.1981], [\"16400\", 25.5545], [\"16500\", 43.349]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n n_bin = str(bin(n))\n count = 0\n for i in n_bin:\n if i == \"1\":\n count += 1\n return count\n","runtime":"12"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n s=format(n,\"b\")\n s1=str(s) \n return s1.count(\"1\")","runtime":"14"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n res = 0\n\n for i in range(32):\n if (n >> i) & 1:\n res += 1\n\n return res","runtime":"15"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n\n count = Counter(bin(n)[2:])\n\n return count['1']\n ","runtime":"16"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n s = 0\n while n:\n s += (n & 1)\n n >>= 1\n return s","runtime":"17"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n count = 0\n while n:\n count = count + n % 2\n n = n >> 1\n return count","runtime":"18"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n # 方法二:\n res = 0\n while n:\n n &= n - 1\n res += 1\n return res\n\n # # 方法一: Time: O(32)\n # res = 0\n # while n:\n # # if n ends with 1, res += 1\n # # if n ends with 0, res += 0 (keep as same)\n # res += n % 2\n # # remove the last digit, and keep the remaining.\n # n = n >> 1\n # return res","runtime":"19"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n # #approach 1\n # return bin(n).count('1')\n \n # #approach 2\n # # if you do n & n-1 it would remove the last 1 bit from right side\n # count=0\n # while n!=0:\n # count+=1\n # n=n&n-1\n # return count\n \n #approach 3\n #using shift operator\n\n count=0\n # i=31\n # while i>=0:\n for i in range(31,-1,-1):\n if n>>i & 1==1:\n count+=1\n # i-=1\n return count\n","runtime":"20"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n \n cnt = 0\n while n!=0:\n cnt += (n % 2)\n n >>= 1\n return cnt","runtime":"21"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n count = 0\n\n while n > 0:\n count += n&1\n n >>= 1\n \n return count","runtime":"22"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n b=''\n while n > 0:\n b = str(n%2)+b\n n = n//2\n return b.count('1')","runtime":"23"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n c = 0\n b = bin(n)\n for i in b:\n if i == '1':\n c+=1\n return c \n\n ","runtime":"23"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n return int.bit_count(n)","runtime":"24"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n c = 0\n while(n):\n n = n & (n-1)\n c+=1\n return c ","runtime":"24"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n \n h_weight = 0\n for i in range(32, -1, -1):\n exp = 2**i\n if exp <= n:\n n = n - exp\n h_weight += 1\n \n return h_weight\n\n\n # log = 0\n # while 2**log < n:\n # log += 1\n# \n # h_weight = 0\n # \n # for i in range(log, -1, -1):\n # if 2**i <= n:\n # n = n - 2**i\n # h_weight += 1\n # \n # return h_weight\n \n ","runtime":"25"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n # doign a bitwise AND of n and n - 1 flips the least significant 1 bit to 0\n ret = 0\n while n > 0:\n ret += 1\n n &= (n - 1)\n return ret","runtime":"25"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n ans=0\n while n:\n if n%2 == 1:\n ans+=1\n n//=2\n return ans\n ","runtime":"26"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n count = 0\n while n > 0:\n if n & 1 == 1:\n count += 1\n n = n >> 1\n return count","runtime":"26"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n bits = 0\n while n != 0:\n n &= (n - 1)\n bits += 1\n return bits","runtime":"27"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n bits = 0\n while n > 1:\n if n%2 == 1:\n bits += 1\n n = n // 2\n bits+= 1\n return bits","runtime":"27"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n count = 0\n while n!=0:\n n = n & (n-1)\n count+=1\n return count\n ","runtime":"28"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n c=0\n while n:\n c+=n&1\n n>>=1\n return c\n ","runtime":"28"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n nset = 0\n while n > 0:\n nset += n & 0b1\n n >>= 1\n return nset","runtime":"29"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n return n.bit_count()","runtime":"30"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n c=0\n while n>0:\n if n & 1 == 1:\n c=c+1\n n=n>>1\n return c","runtime":"30"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n count=0\n while n:\n n = n & (n-1)\n count+=1\n return count","runtime":"31"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n res=0\n while n>0:\n res=res+n%2\n \n n>>=1\n return res\n ","runtime":"31"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n count = 0\n while(n!=0):\n n = n&(n-1)\n count += 1\n return count\n \n","runtime":"32"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n out = 0\n while n > 0:\n if n % 2 == 1: out += 1\n n = n // 2\n return out","runtime":"32"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n return list(bin(n)).count('1') \n ","runtime":"33"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n \n log = 0\n while 2**log < n:\n log += 1\n\n h_weight = 0\n \n for i in range(log, -1, -1):\n if 2**i <= n:\n n = n - 2**i\n h_weight += 1\n \n return h_weight\n \n ","runtime":"33"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n b = '{0:032b}'.format(n)\n return sum([1 for x in b if x=='1'])","runtime":"34"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n res = 0\n while n:\n res += n & 1\n n >>= 1\n return res\n ","runtime":"34"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n res = 0 \n while n:\n temp = n\n n = n - 1\n n = temp & n\n res += 1\n return res \n\n\n # Alternate Sln 1 \n # res = 0 \n # while n:\n # res += n % 2\n # n = n >> 1\n # return res \n\n ","runtime":"35"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n s=''\n k=0\n while n>0:\n if n%2==1:\n k+=1\n n=n//2\n return k","runtime":"35"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n s=bin(n)\n count=0\n for i in range(0, len(s)):\n if s[i] == '1':\n count+=1\n return count","runtime":"36"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n ans = []\n while(n!=0):\n rem = n%2\n if rem==1:\n ans.append(rem)\n n = n//2\n return len(ans)\n \n","runtime":"36"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n x = bin(n)\n x = list(x)[2:]\n c = Counter(x)\n c = dict(c)\n print(c['1'])\n return c['1']","runtime":"37"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n \n h_weight = 0\n for i in range(32, -1, -1):\n exp = 2**i\n if exp <= n:\n n = n - exp\n h_weight += 1\n \n return h_weight\n\n\n # log = 0\n # while 2**log < n:\n # log += 1\n# \n # h_weight = 0\n # \n # for i in range(log, -1, -1):\n # if 2**i <= n:\n # n = n - 2**i\n # h_weight += 1\n # \n # return h_weight\n \n ","runtime":"37"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n s=str(bin(n))\n return s.count(\"1\")\n ","runtime":"38"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n ans = 0\n while n>0:\n if n & 1:\n ans+=1\n n = n >> 1\n return ans\n ","runtime":"38"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n count = 0\n while n != 0:\n n &= (n - 1)\n count += 1\n return count","runtime":"39"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n ans=0\n while n:\n if n%2 == 1:\n ans+=1\n n//=2\n return ans\n ","runtime":"39"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n count = 0\n while(n!=0):\n rem = n%2\n if rem==1:\n count += 1\n n = n//2\n return count\n \n","runtime":"40"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n ans = 0\n while n:\n n &= n - 1\n ans += 1\n return ans","runtime":"40"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n return bin(n).count('1')","runtime":"41"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n x = bin(n)\n x = list(x)[2:]\n c = Counter(x)\n c = dict(c)\n print(c['1'])\n return c['1']","runtime":"41"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n one_count = 0\n while n>0:\n one_count += (n%2)\n n= n//2\n \n return one_count\n ","runtime":"42"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n return bin(n).count('1')\n ","runtime":"42"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n ans = []\n while(n!=0):\n rem = n%2\n if rem==1:\n ans.append(rem)\n n = n//2\n return len(ans)\n \n","runtime":"43"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n ''' sol no 1 '''\n # res = 0\n # while n:\n # res += n % 2\n # n = n >> 1\n # return res\n\n ''' sol no 2 '''\n # count = 0\n # while n:\n # count += n & 1\n # n >>= 1\n # return count\n\n ''' sol no 3 '''\n res = 0\n while n:\n res += 1\n n &= (n - 1)\n return res","runtime":"43"}],"string":"[\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n n_bin = str(bin(n))\\n count = 0\\n for i in n_bin:\\n if i == \\\"1\\\":\\n count += 1\\n return count\\n\",\n \"runtime\": \"12\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n s=format(n,\\\"b\\\")\\n s1=str(s) \\n return s1.count(\\\"1\\\")\",\n \"runtime\": \"14\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n res = 0\\n\\n for i in range(32):\\n if (n >> i) & 1:\\n res += 1\\n\\n return res\",\n \"runtime\": \"15\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n\\n count = Counter(bin(n)[2:])\\n\\n return count['1']\\n \",\n \"runtime\": \"16\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n s = 0\\n while n:\\n s += (n & 1)\\n n >>= 1\\n return s\",\n \"runtime\": \"17\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n count = 0\\n while n:\\n count = count + n % 2\\n n = n >> 1\\n return count\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n # 方法二:\\n res = 0\\n while n:\\n n &= n - 1\\n res += 1\\n return res\\n\\n # # 方法一: Time: O(32)\\n # res = 0\\n # while n:\\n # # if n ends with 1, res += 1\\n # # if n ends with 0, res += 0 (keep as same)\\n # res += n % 2\\n # # remove the last digit, and keep the remaining.\\n # n = n >> 1\\n # return res\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n # #approach 1\\n # return bin(n).count('1')\\n \\n # #approach 2\\n # # if you do n & n-1 it would remove the last 1 bit from right side\\n # count=0\\n # while n!=0:\\n # count+=1\\n # n=n&n-1\\n # return count\\n \\n #approach 3\\n #using shift operator\\n\\n count=0\\n # i=31\\n # while i>=0:\\n for i in range(31,-1,-1):\\n if n>>i & 1==1:\\n count+=1\\n # i-=1\\n return count\\n\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n \\n cnt = 0\\n while n!=0:\\n cnt += (n % 2)\\n n >>= 1\\n return cnt\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n count = 0\\n\\n while n > 0:\\n count += n&1\\n n >>= 1\\n \\n return count\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n b=''\\n while n > 0:\\n b = str(n%2)+b\\n n = n//2\\n return b.count('1')\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n c = 0\\n b = bin(n)\\n for i in b:\\n if i == '1':\\n c+=1\\n return c \\n\\n \",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n return int.bit_count(n)\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n c = 0\\n while(n):\\n n = n & (n-1)\\n c+=1\\n return c \",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n \\n h_weight = 0\\n for i in range(32, -1, -1):\\n exp = 2**i\\n if exp <= n:\\n n = n - exp\\n h_weight += 1\\n \\n return h_weight\\n\\n\\n # log = 0\\n # while 2**log < n:\\n # log += 1\\n# \\n # h_weight = 0\\n # \\n # for i in range(log, -1, -1):\\n # if 2**i <= n:\\n # n = n - 2**i\\n # h_weight += 1\\n # \\n # return h_weight\\n \\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n # doign a bitwise AND of n and n - 1 flips the least significant 1 bit to 0\\n ret = 0\\n while n > 0:\\n ret += 1\\n n &= (n - 1)\\n return ret\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n ans=0\\n while n:\\n if n%2 == 1:\\n ans+=1\\n n//=2\\n return ans\\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n count = 0\\n while n > 0:\\n if n & 1 == 1:\\n count += 1\\n n = n >> 1\\n return count\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n bits = 0\\n while n != 0:\\n n &= (n - 1)\\n bits += 1\\n return bits\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n bits = 0\\n while n > 1:\\n if n%2 == 1:\\n bits += 1\\n n = n // 2\\n bits+= 1\\n return bits\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n count = 0\\n while n!=0:\\n n = n & (n-1)\\n count+=1\\n return count\\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n c=0\\n while n:\\n c+=n&1\\n n>>=1\\n return c\\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n nset = 0\\n while n > 0:\\n nset += n & 0b1\\n n >>= 1\\n return nset\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n return n.bit_count()\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n c=0\\n while n>0:\\n if n & 1 == 1:\\n c=c+1\\n n=n>>1\\n return c\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n count=0\\n while n:\\n n = n & (n-1)\\n count+=1\\n return count\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n res=0\\n while n>0:\\n res=res+n%2\\n \\n n>>=1\\n return res\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n count = 0\\n while(n!=0):\\n n = n&(n-1)\\n count += 1\\n return count\\n \\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n out = 0\\n while n > 0:\\n if n % 2 == 1: out += 1\\n n = n // 2\\n return out\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n return list(bin(n)).count('1') \\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n \\n log = 0\\n while 2**log < n:\\n log += 1\\n\\n h_weight = 0\\n \\n for i in range(log, -1, -1):\\n if 2**i <= n:\\n n = n - 2**i\\n h_weight += 1\\n \\n return h_weight\\n \\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n b = '{0:032b}'.format(n)\\n return sum([1 for x in b if x=='1'])\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n res = 0\\n while n:\\n res += n & 1\\n n >>= 1\\n return res\\n \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n res = 0 \\n while n:\\n temp = n\\n n = n - 1\\n n = temp & n\\n res += 1\\n return res \\n\\n\\n # Alternate Sln 1 \\n # res = 0 \\n # while n:\\n # res += n % 2\\n # n = n >> 1\\n # return res \\n\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n s=''\\n k=0\\n while n>0:\\n if n%2==1:\\n k+=1\\n n=n//2\\n return k\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n s=bin(n)\\n count=0\\n for i in range(0, len(s)):\\n if s[i] == '1':\\n count+=1\\n return count\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n ans = []\\n while(n!=0):\\n rem = n%2\\n if rem==1:\\n ans.append(rem)\\n n = n//2\\n return len(ans)\\n \\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n x = bin(n)\\n x = list(x)[2:]\\n c = Counter(x)\\n c = dict(c)\\n print(c['1'])\\n return c['1']\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n \\n h_weight = 0\\n for i in range(32, -1, -1):\\n exp = 2**i\\n if exp <= n:\\n n = n - exp\\n h_weight += 1\\n \\n return h_weight\\n\\n\\n # log = 0\\n # while 2**log < n:\\n # log += 1\\n# \\n # h_weight = 0\\n # \\n # for i in range(log, -1, -1):\\n # if 2**i <= n:\\n # n = n - 2**i\\n # h_weight += 1\\n # \\n # return h_weight\\n \\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n s=str(bin(n))\\n return s.count(\\\"1\\\")\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n ans = 0\\n while n>0:\\n if n & 1:\\n ans+=1\\n n = n >> 1\\n return ans\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n count = 0\\n while n != 0:\\n n &= (n - 1)\\n count += 1\\n return count\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n ans=0\\n while n:\\n if n%2 == 1:\\n ans+=1\\n n//=2\\n return ans\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n count = 0\\n while(n!=0):\\n rem = n%2\\n if rem==1:\\n count += 1\\n n = n//2\\n return count\\n \\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n ans = 0\\n while n:\\n n &= n - 1\\n ans += 1\\n return ans\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n return bin(n).count('1')\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n x = bin(n)\\n x = list(x)[2:]\\n c = Counter(x)\\n c = dict(c)\\n print(c['1'])\\n return c['1']\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n one_count = 0\\n while n>0:\\n one_count += (n%2)\\n n= n//2\\n \\n return one_count\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n return bin(n).count('1')\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n ans = []\\n while(n!=0):\\n rem = n%2\\n if rem==1:\\n ans.append(rem)\\n n = n//2\\n return len(ans)\\n \\n\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n ''' sol no 1 '''\\n # res = 0\\n # while n:\\n # res += n % 2\\n # n = n >> 1\\n # return res\\n\\n ''' sol no 2 '''\\n # count = 0\\n # while n:\\n # count += n & 1\\n # n >>= 1\\n # return count\\n\\n ''' sol no 3 '''\\n res = 0\\n while n:\\n res += 1\\n n &= (n - 1)\\n return res\",\n \"runtime\": \"43\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":51,"string":"51"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n binary_rep = bin(n)[2:]\n ones_count = binary_rep.count('1')\n return ones_count\n ","memory":"15900"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n ans = []\n while(n!=0):\n rem = n%2\n if rem==1:\n ans.append(rem)\n n = n//2\n return len(ans)\n \n","memory":"16000"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n result = 0\n \n for char in str(bin(n)):\n if char == \"1\":\n result += 1\n\n return result","memory":"16100"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n # First real bit problem\n res = 0\n # So you just take every number and mod it by 2 and if it equals 1 you add that to res, you then shift your number to the right by 1 so you can mod it again\n while n:\n res += n % 2\n n = n >> 1\n return res","memory":"16200"},{"code":"class Solution:\n # M-1: In-built BIN()\n def hammingWeight(self, n: int) -> int:\n bin_string = bin(n)\n count = 0\n for s in bin_string[2:]:\n if s==\"1\":\n count += 1\n \n return count\n\n # M-2: Divmod\n def hammingWeight(self, n: int) -> int:\n count = 0\n while n > 0:\n n, rem = divmod(n, 2)\n count += rem\n \n return count\n \n # M-3: Mask\n \n def hammingWeight(self, n: int) -> int:\n count = 0\n mask = 1 # 0000 0000 0000 0000 0000 0000 0000 0001\n\n for _ in range(32): # Left shift mask 32 times!!\n and_result = n & mask\n\n count = count if and_result == 0 else count + 1\n mask = mask << 1\n \n return count","memory":"16200"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n count=0\n while n:\n n = n & (n-1)\n count+=1\n return count","memory":"16300"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n return list(bin(n)).count('1') \n ","memory":"16300"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n bits_so_far = 0 # the value we will return \n while n > 0: # Until we exhaust n\n power_so_far = 0\n x = n # another variable initialized to n\n while x != 1:\n x = x // 2\n power_so_far += 1\n n = n - (2 ** power_so_far)\n bits_so_far += 1\n return bits_so_far\n\n\n \n ","memory":"16400"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n hamming_weight = 0\n binary_num_as_list = list(bin(n)[2:])\n for i in binary_num_as_list:\n if i == \"1\":\n hamming_weight += 1\n \n return hamming_weight\n ","memory":"16400"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n cnt = 0\n\n while n > 0:\n if n & 1 == 1:\n cnt += 1\n n = n >> 1\n\n return cnt","memory":"16500"},{"code":"class Solution:\n def hammingWeight(self, n: int) -> int:\n result = 0\n for i in range(32):\n if (n >> i) & 1:\n result = result + 1\n return result\n\n ","memory":"16500"}],"string":"[\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n binary_rep = bin(n)[2:]\\n ones_count = binary_rep.count('1')\\n return ones_count\\n \",\n \"memory\": \"15900\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n ans = []\\n while(n!=0):\\n rem = n%2\\n if rem==1:\\n ans.append(rem)\\n n = n//2\\n return len(ans)\\n \\n\",\n \"memory\": \"16000\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n result = 0\\n \\n for char in str(bin(n)):\\n if char == \\\"1\\\":\\n result += 1\\n\\n return result\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n # First real bit problem\\n res = 0\\n # So you just take every number and mod it by 2 and if it equals 1 you add that to res, you then shift your number to the right by 1 so you can mod it again\\n while n:\\n res += n % 2\\n n = n >> 1\\n return res\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n # M-1: In-built BIN()\\n def hammingWeight(self, n: int) -> int:\\n bin_string = bin(n)\\n count = 0\\n for s in bin_string[2:]:\\n if s==\\\"1\\\":\\n count += 1\\n \\n return count\\n\\n # M-2: Divmod\\n def hammingWeight(self, n: int) -> int:\\n count = 0\\n while n > 0:\\n n, rem = divmod(n, 2)\\n count += rem\\n \\n return count\\n \\n # M-3: Mask\\n \\n def hammingWeight(self, n: int) -> int:\\n count = 0\\n mask = 1 # 0000 0000 0000 0000 0000 0000 0000 0001\\n\\n for _ in range(32): # Left shift mask 32 times!!\\n and_result = n & mask\\n\\n count = count if and_result == 0 else count + 1\\n mask = mask << 1\\n \\n return count\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n count=0\\n while n:\\n n = n & (n-1)\\n count+=1\\n return count\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n return list(bin(n)).count('1') \\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n bits_so_far = 0 # the value we will return \\n while n > 0: # Until we exhaust n\\n power_so_far = 0\\n x = n # another variable initialized to n\\n while x != 1:\\n x = x // 2\\n power_so_far += 1\\n n = n - (2 ** power_so_far)\\n bits_so_far += 1\\n return bits_so_far\\n\\n\\n \\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n hamming_weight = 0\\n binary_num_as_list = list(bin(n)[2:])\\n for i in binary_num_as_list:\\n if i == \\\"1\\\":\\n hamming_weight += 1\\n \\n return hamming_weight\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n cnt = 0\\n\\n while n > 0:\\n if n & 1 == 1:\\n cnt += 1\\n n = n >> 1\\n\\n return cnt\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def hammingWeight(self, n: int) -> int:\\n result = 0\\n for i in range(32):\\n if (n >> i) & 1:\\n result = result + 1\\n return result\\n\\n \",\n \"memory\": \"16500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":11,"string":"11"}}},{"rowIdx":78,"cells":{"question_id":{"kind":"number","value":198,"string":"198"},"name":{"kind":"string","value":"house-robber"},"content":{"kind":"string","value":"<p>You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and <b>it will automatically contact the police if two adjacent houses were broken into on the same night</b>.</p>\n\n<p>Given an integer array <code>nums</code> representing the amount of money of each house, return <em>the maximum amount of money you can rob tonight <b>without alerting the police</b></em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [1,2,3,1]\n<strong>Output:</strong> 4\n<strong>Explanation:</strong> Rob house 1 (money = 1) and then rob house 3 (money = 3).\nTotal amount you can rob = 1 + 3 = 4.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [2,7,9,3,1]\n<strong>Output:</strong> 12\n<strong>Explanation:</strong> Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).\nTotal amount you can rob = 2 + 9 + 1 = 12.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 100</code></li>\n\t<li><code>0 <= nums[i] <= 400</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":51.487545616749856,"string":"51.487546"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","dynamic-programming"],"string":"[\n \"array\",\n \"dynamic-programming\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"12\", 0.0028], [\"14\", 0.0113], [\"15\", 0.0169], [\"16\", 0.0225], [\"17\", 0.031], [\"18\", 0.0281], [\"19\", 0.1717], [\"20\", 0.0535], [\"21\", 0.197], [\"22\", 0.3096], [\"23\", 0.774], [\"24\", 0.3828], [\"25\", 0.667], [\"26\", 1.6859], [\"27\", 2.4007], [\"28\", 1.4579], [\"29\", 2.1868], [\"30\", 4.8662], [\"31\", 5.657], [\"32\", 3.6109], [\"33\", 4.3286], [\"34\", 9.2342], [\"35\", 8.5615], [\"36\", 5.4572], [\"37\", 5.8231], [\"38\", 9.4622], [\"39\", 7.8495], [\"40\", 5.2883], [\"41\", 4.3117], [\"42\", 4.7142], [\"43\", 3.6588]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15900\", 0.0056], [\"16000\", 0.0028], [\"16100\", 0.0394], [\"16200\", 0.4278], [\"16300\", 6.6618], [\"16400\", 24.1367], [\"16500\", 42.864], [\"16600\", 20.3006]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n\n def house(i,nums, dp):\n if i == 0:\n return nums[0]\n if i == 1:\n return max(nums[0], nums[1])\n if dp[i] != -1:\n return dp[i] \n\n s1 = nums[i] + house(i-2, nums, dp)\n s2 = house(i-1, nums, dp)\n dp[i] = max(s1,s2)\n\n return dp[i]\n n = len(nums)\n dp = [-1]*n\n return house(len(nums)-1, nums, dp)\n ","runtime":"12"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n if not nums:\n return 0\n if len(nums) == 1:\n return nums[0]\n\n dp = [nums[0], max(nums[0], nums[1])]\n\n for i in range(2, len(nums)):\n dp.append(max(dp[-1], dp[-2] + nums[i]))\n dp.pop(0)\n\n return dp[-1]","runtime":"14"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n prev, curr = 0, 0\n for n in nums:\n tmp = curr\n curr = max(curr, n + prev)\n prev = tmp\n return curr","runtime":"15"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n rob1, rob2 = 0, 0\n\n for n in nums:\n robNew = max(rob2, rob1 + n)\n rob1 = rob2\n rob2 = robNew\n return rob2","runtime":"16"},{"code":"class Solution:\n def __init__(self):\n self.max_profit = {}\n\n def rob_from_idx(self, nums: List[int], start_idx: int) -> int:\n if start_idx in self.max_profit:\n return self.max_profit[start_idx]\n \n if start_idx == len(nums) - 1:\n return nums[start_idx]\n elif start_idx == len(nums) - 2:\n return max(nums[start_idx], nums[start_idx + 1])\n \n max_profit = max(nums[start_idx] + self.rob_from_idx(nums, start_idx + 2), self.rob_from_idx(nums, start_idx + 1))\n self.max_profit[start_idx] = max_profit\n\n return max_profit\n\n def rob(self, nums: List[int]) -> int:\n # rob(nums, 0) = max(nums[0] + rob(nums, 2), rob(nums, 1))\n return self.rob_from_idx(nums, 0)\n ","runtime":"17"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n \n rob1, rob2 = 0, 0\n \n for num in nums:\n rob1, rob2 = max(num + rob2, rob1), rob1\n \n return rob1","runtime":"18"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n=len(nums)\n dp=[-1]*n\n def helper(lev):\n if lev>=n:\n return 0\n if dp[lev]!=-1: return dp[lev]\n maxrob=nums[lev]+helper(lev+2)\n maxrob=max(maxrob,helper(lev+1))\n dp[lev]=maxrob\n return maxrob\n return helper(0)","runtime":"19"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n T = [0 for _ in range(len(nums) + 1)]\n T[0] = 0\n T[1] = nums[0]\n max_r = T[1]\n for i in range(1, len(nums)):\n T[i + 1] = max(T[i], T[i - 1] + nums[i])\n max_r = max(max_r, T[i + 1])\n return max_r","runtime":"19"},{"code":"from typing import List\n\nclass Solution:\n def rob(self, nums: List[int]) -> int:\n if len(nums) == 0:\n return 0\n if len(nums) == 1:\n return nums[0]\n \n dp = [-1] * len(nums)\n dp[0] = nums[0]\n dp[1] = max(nums[0], nums[1])\n \n for i in range(2, len(nums)):\n left = nums[i] + dp[i-2]\n right = dp[i-1]\n dp[i] = max(left, right)\n \n return dp[len(nums)-1]\n","runtime":"20"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [0 for i in range(n)]\n dp[0] = nums[0]\n if n > 1:\n dp[1] = max(nums[0], nums[1])\n for i in range(2, n):\n dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])\n return dp[n - 1]\n","runtime":"21"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n if not nums:\n return 0\n if len(nums)<3:\n return max(nums)\n pre=nums[0]\n cur=max(nums[0], nums[1])\n for k in range(2, len(nums)):\n tp=cur\n cur=max(cur, pre+nums[k])\n pre=tp\n return cur","runtime":"21"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [0] * (n+1)\n dp[1] = nums[0]\n\n for i in range(2, n + 1): \n dp[i] = max(dp[i-1], dp[i-2] + nums[i-1])\n \n return dp[n]","runtime":"22"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n rob1, rob2 = 0, 0\n \n for num in nums:\n temp = rob2\n # get the max rob value\n # set that to rob2\n rob2 = max(rob2, rob1 + num)\n # set rob1 to prev value of rob2\n rob1 = temp\n \n return rob2\n","runtime":"22"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n rob1,rob2=0,0\n for n in nums:\n temp=max(n+rob1,rob2)\n rob1=rob2\n rob2=temp\n return rob2\n\n","runtime":"23"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n \n memo = {}\n\n def robFrom(i):\n if i >= len(nums):\n return 0\n \n if i in memo:\n return memo[i]\n \n res = max(robFrom(i+1), robFrom(i+2) + nums[i])\n memo[i] = res\n return res\n return robFrom(0)\n\n\n\n ","runtime":"23"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n rob1, rob2 = 0, 0\n\n for n in nums:\n temp = max(rob1 + n, rob2)\n rob1 = rob2\n rob2 = temp\n return rob2","runtime":"24"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n length = len(nums)\n a = b = c = 0\n index = 0\n while index < length:\n c = max(nums[index] + a, b)\n a = b \n b = c\n index += 1\n return c","runtime":"24"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n \n rob1, rob2 =0,0\n res = 0\n \n # You can make two decisions\n # [1,2,3,1]\n \n for i in nums:\n res = max(rob2+i, rob1)\n rob2 = rob1\n rob1 = res\n return res\n ","runtime":"25"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n prev1, prev2 = 0, 0\n # prev2, prev1, nums[i], ..., nums[n]\n \n for n in nums:\n tmp = prev1\n prev1 = max(n + prev2, prev1)\n prev2 = tmp\n\n return prev1","runtime":"25"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n memo = [0]*n\n \n if n > 0:\n memo[0] = nums[0]\n if n > 1:\n memo[1] = max(nums[0], nums[1])\n if n > 2:\n memo[2] = max(nums[1], memo[0]+nums[2])\n \n for i in range(3, n):\n memo[i] = max(memo[i-1], memo[i-2]+nums[i])\n \n return memo[-1]","runtime":"26"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n=len(nums)\n if n==0:\n return 0\n if n==1:\n return nums[0]\n if n==2:\n return max(nums[0],nums[1])\n def helper(arr):\n dp=[0]*n\n dp[0]=nums[0]\n dp[1]=max(nums[0],nums[1])\n for i in range(2,len(arr)):\n dp[i]=max(dp[i-1],dp[i-2]+arr[i])\n return dp[-1]\n return helper(nums)\n\n\n\n ","runtime":"28"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n\n # add robbale money to i-2 and i-3. Whichever is bigger we store that. In the end, we can return len(nums) or len(nums) - 1\n\n # nums[i-2], nums[i-3] nums[3] = nums[1] + nums[0]\n\n if len(nums) == 1:\n return nums[0]\n\n result = [0] * (len(nums) + 1)\n result[0] = 0\n result[1] = nums[0]\n result[2] = nums[1]\n\n for i in range(2, len(nums)):\n result[i+1] = max(result[i-1] + nums[i], result[i-2] + nums[i])\n \n return max(result[len(nums)], result[len(nums)-1])\n\n \n\n ","runtime":"28"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n if len(nums) <= 2:\n return max(nums)\n amounts = [nums[0]]\n for i in range(1, len(nums)):\n prev = amounts[i-1]\n prev_prev = amounts[i-2] if i-2 >= 0 else 0\n amounts.append(max(prev_prev + nums[i], amounts[i-1]))\n return amounts[-1]","runtime":"29"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n\n if n <= 2:\n return max(nums)\n\n res = [0] * n\n res[0] = nums[0]\n res[1] = max(nums[0], nums[1])\n\n for i in range(2, n):\n res[i] = max(res[i - 1], res[i - 2] + nums[i])\n \n return res[-1]\n\n ","runtime":"29"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n r1, r2 = 0,0\n for n in nums:\n temp = max(n+r1, r2)\n r1 = r2\n r2 = temp\n \n return r2\n","runtime":"30"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n prev, curr = 0, 0\n\n for money in nums:\n tmp = curr\n curr = max(money + prev, curr)\n prev = tmp\n \n return curr\n \n\n \n\n\n\n \n ","runtime":"30"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n curr, prev = 0, 0\n for n in nums:\n curr, prev = max(curr, prev + n), curr\n return curr","runtime":"31"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n dp = [0 for _ in range(len(nums))]\n for i in range(len(nums)):\n if i == 0:\n dp[i] = nums[0]\n elif i==1:\n dp[i] = max(nums[:2])\n else:\n dp[i] = max(dp[i-2]+nums[i], dp[i-1])\n return dp[-1]\n ","runtime":"31"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n if n <= 2:\n return max(nums)\n dp = [0] * n\n dp[0] = nums[0]\n dp[1] = max(nums[0], nums[1])\n for i in range(2, n):\n dp[i] = max(dp[i-2] + nums[i], dp[i-1])\n return dp[-1]","runtime":"32"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n # If there are no houses, you can't rob anything\n if not nums:\n return 0\n \n # If there's only one house, rob it\n if len(nums) == 1:\n return nums[0]\n \n # Initialize the first two values\n prev2 = 0 # This is dp[i-2], initially 0 because no houses have been robbed\n prev1 = nums[0] # This is dp[i-1], initially the value of the first house\n \n # Iterate over the rest of the houses\n for i in range(1, len(nums)):\n # Compute the current value as the max of robbing or skipping the current house\n current = max(prev1, prev2 + nums[i])\n \n # Move the window: prev2 becomes prev1, prev1 becomes the current value\n prev2 = prev1\n prev1 = current\n \n # The result is the last computed value, i.e., the max amount of money we can rob\n return prev1","runtime":"32"},{"code":"class Solution:\n def rob(self, nums):\n n = len(nums)\n if n == 0:\n return 0\n\n s0, s1 = [0, 0], [0, 0]\n s1[0] = nums[0]\n\n for i in range(1, n):\n s0[i % 2] = max(s0[(i - 1) % 2], s1[(i - 1) % 2])\n s1[i % 2] = s0[(i - 1) % 2] + nums[i]\n\n return max(s0[(n - 1) % 2], s1[(n - 1) % 2])\n\n","runtime":"33"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n if len(nums) == 0:\n return 0\n if len(nums)==1:\n return nums[0]\n dp = [0]*(len(nums)+1 )# dp[i] = maximum robbing considering i homes\n dp[0] = 0\n dp[1] = nums[0]\n dp[2] = max(nums[0], nums[1])\n for i in range(2, len(nums)):\n dp[i+1] = max(dp[i-1]+nums[i], dp[i] + 0)\n return dp[-1]\n\n\n \n ","runtime":"33"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n\n # at each step we need to find the max amount of robbable money in the [0,i-1) subarray and add nums[i] to it. Now if that does not exist then the max robbable amount is just nums[i]. \n\n # nums[i-2], nums[i-3] nums[3] = nums[1] + nums[0]\n\n if len(nums) == 1:\n return nums[0]\n\n result = [0] * (len(nums) + 1)\n result[0] = 0\n result[1] = nums[0]\n result[2] = nums[1]\n\n for i in range(2, len(nums)):\n result[i+1] = max(result[i-1] + nums[i], result[i-2] + nums[i])\n \n return max(result)\n\n \n\n ","runtime":"34"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n rob1, rob2 = 0, 0\n\n for n in nums:\n temp = rob2\n rob2 = max(n + rob1, rob2)\n rob1 = temp\n\n return max(rob1, rob2)","runtime":"34"},{"code":"class Solution:\n def rob(self, nums: List[int], start = 0, memoize = None) -> int:\n # [a, b, c, d]\n # [x, x, c, d] if rob a\n # [x, x, x, d] if rob b\n # if rob c, no reason not to also rob a\n l = len(nums) - start\n\n if l == 0:\n return 0\n\n if not memoize and len(nums) > 10:\n memoize = [-1] * len(nums)\n elif memoize and memoize[start] >= 0:\n return memoize[start]\n\n rob_a = nums[start]\n if l > 2:\n rob_a += self.rob(nums, start+2, memoize)\n\n if not (l > 1):\n return rob_a\n\n rob_b = nums[start+1]\n if l > 3:\n rob_b += self.rob(nums, start+3, memoize)\n\n decision = max(rob_a, rob_b)\n\n if memoize:\n memoize[start] = decision\n\n return decision","runtime":"35"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n \n if n == 1:\n return nums[0]\n \n dp = [0] * n\n \n dp[0] = nums[0]\n dp[1] = max(nums[0], nums[1])\n \n for i in range(2, n):\n dp[i] = max(dp[i-1], nums[i] + dp[i-2])\n \n return dp[-1] ","runtime":"35"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n \n if (len(nums) == 0):\n return 0\n elif (len(nums) == 1):\n return nums[0]\n elif (len(nums) == 2):\n return max(nums)\n \n dp = [0]* len(nums)\n dp[0] = nums[0]\n dp[1] = max(nums[0:2])\n \n \n for i in range(2, len(nums)):\n dp[i] = max(dp[i-1], dp[i-2]+nums[i])\n return dp[-1]","runtime":"36"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n \n def robb(nums, ind, dp):\n if ind == 0:\n return nums[0]\n if ind < 0:\n return 0\n if dp[ind] != -1:\n return dp[ind]\n two = nums[ind] + robb(nums, ind-2, dp)\n nextt = robb(nums, ind-1, dp)\n\n dp[ind] = max(two, nextt)\n return dp[ind]\n\n dp = [-1] * len(nums)\n return robb(nums, len(nums)-1, dp)\n","runtime":"36"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n \n if n == 1:\n return nums[0]\n \n dp = [0] * n\n \n dp[0] = nums[0]\n dp[1] = max(nums[0], nums[1])\n \n for i in range(2, n):\n dp[i] = max(dp[i-1], nums[i] + dp[i-2])\n \n return dp[-1] ","runtime":"37"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n=len(nums)\n if n==1:\n return nums[0]\n x=[0]*n\n x[0],x[1]=nums[0],nums[1]\n if n>=3:\n x[2]=nums[2]+x[0]\n if n>3:\n for i in range(3,n):\n x[i]=nums[i]+max(x[i-2],x[i-3])\n return max(x[-1],x[-2])","runtime":"37"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n=len(nums)\n memo=defaultdict(lambda:-1)\n def checker(index):\n if index<0:\n return 0\n if index==0:\n return nums[0]\n if memo[index] !=-1:\n return memo[index]\n\n result=max(nums[index]+checker(index-2),checker(index-1))\n memo[index]=result\n return result\n\n\n\n\n\n\n\n return checker(n-1)\n \n \n\n \n\n ","runtime":"38"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n if len(nums) <= 2:\n return max(nums)\n \n maxx = max(nums[0], nums[1])\n for i in range(2, len(nums)):\n curmax = 0\n for j in range(i-1):\n curmax = max(curmax, nums[i]+nums[j])\n nums[i] = curmax\n maxx = max(maxx, curmax)\n return maxx","runtime":"38"},{"code":"class Solution:\n def rob(self, nums: List [int]) -> int:\n maxes = {}\n if len(nums) == 1:\n return nums[0]\n elif len(nums) == 2:\n return max(nums[0], nums[1])\n elif len(nums) == 3:\n return max(nums[0] + nums[2], nums[1])\n for i in range(3, len(nums),2):\n if i < 4:\n nums[i-1] = nums[i-3] + nums[i-1]\n else:\n nums[i-1] = max(nums[i-3] + nums[i-1], nums[i-1] + nums[i-4])\n nums[i] = max(nums[i-3]+nums[i], nums[i-2]+ nums[i])\n print(nums)\n if len(nums) % 2 == 0:\n return max(nums[-2],nums[-1])\n else:\n return max(nums[-1] + nums[-3], nums[-2], nums[-1]+nums[-4]) \n \n\n \n \n\n\n\n \n ","runtime":"39"},{"code":"\"\"\"\n\n\"\"\"\nclass Solution:\n def rob(self, nums: List[int]) -> int:\n def dp(i):\n if i <= 0:\n return nums[0]\n if i == 1:\n return max(nums[0], nums[1])\n \n if i in memo:\n return memo[i]\n \n memo[i] = max(dp(i-1), dp(i-2) + nums[i])\n return memo[i]\n\n memo = {}\n return dp(len(nums) - 1)\n\n ","runtime":"39"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n # dp - O(N) time, O(1) space\n minus_two = 0\n minus_one = nums[0]\n profit = minus_one\n for i in range(1, len(nums)):\n profit = max(minus_two + nums[i], minus_one)\n minus_two = minus_one\n minus_one = profit\n \n return profit\n\n # recursion w/ memoization - O(N) time, O(N) space\n # memo = {}\n # def _rob(idx):\n # if idx >= len(nums):\n # return 0\n # elif idx not in memo:\n # rob_current_house = nums[idx] + _rob(idx + 2)\n # skip_current_house = _rob(idx + 1)\n # memo[idx] = max(rob_current_house, skip_current_house)\n # return memo[idx]\n \n # return _rob(0)","runtime":"40"},{"code":"def robHouse(index, nums, dp):\n if index == 0:\n return nums[0]\n \n if index < 0:\n return 0\n\n if dp[index] != -1:\n return dp[index]\n\n pick = nums[index] + robHouse(index-2, nums, dp)\n not_pick = robHouse(index-1, nums, dp)\n\n dp[index] = max(pick, not_pick)\n return dp[index]\n\nclass Solution:\n def rob(self, nums: List[int]) -> int:\n if len(nums) == 1:\n return nums[0]\n dp = [-1] * len(nums)\n \n # robHouse(len(nums)-1, nums, dp)\n dp[0] = nums[0]\n for i in range(1, len(nums)):\n if i > 1:\n take = nums[i] + dp[i-2]\n else:\n take = nums[i]\n\n non_take = dp[i-1]\n dp[i] = max(take, non_take)\n\n \n return dp[-1]\n","runtime":"40"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n dp_table=[]\n if len(nums)==1:\n return nums[0]\n dp_table.append(nums[0])\n dp_table.append(max(nums[0],nums[1]))\n if len(nums)>2:\n for i in range(2,len(nums)):\n dp_table.append(max(dp_table[i-1],dp_table[i-2]+nums[i]))\n \n return dp_table[-1]","runtime":"41"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n\n withPrev = 0\n withoutPrev =0\n for c in nums:\n curSelect = c + withoutPrev\n withoutPrev = max(withoutPrev,withPrev)\n withPrev=curSelect\n \n return max(withPrev,withoutPrev)\n\n\n ","runtime":"41"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [0]*(n+2)\n dp[0] = 0\n dp[1] = 0\n for i in range(len(nums)):\n dp[i+2] = max(dp[i]+nums[i],dp[i+1])\n return dp[n+1]","runtime":"42"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n if len(nums) <= 2:\n return max(nums)\n \n total_amount = [0] * len(nums)\n total_amount[0] = nums[0]\n total_amount[1] = max(nums[0], nums[1])\n\n for i in range(2, len(nums)):\n total_amount[i] = max(total_amount[i-1], total_amount[i-2] + nums[i])\n return total_amount[-1] ","runtime":"42"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n\n\n if len(nums) == 0:\n return 0\n elif len(nums) == 1:\n return nums[0]\n\n money = [0, nums[0]]\n\n for house in range(2, len(nums) + 1):\n\n # Rob house\n temp1 = money[house - 2] + nums[house - 1]\n\n # Don't rob house\n temp2 = money[house - 1]\n\n money.append(max(temp1, temp2))\n\n return money[len(nums)]","runtime":"43"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n \n self.cache = {}\n def dp(nums, until):\n if until in self.cache:\n return self.cache[until]\n \n if until == 0:\n return nums[0]\n if until == 1:\n return max(nums[0], nums[1])\n \n max_rob = max(nums[until] + dp(nums, until-2), dp(nums, until-1))\n self.cache[until] = max_rob\n return max_rob\n \n return dp(nums, len(nums)-1)\n \n ","runtime":"43"}],"string":"[\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n\\n def house(i,nums, dp):\\n if i == 0:\\n return nums[0]\\n if i == 1:\\n return max(nums[0], nums[1])\\n if dp[i] != -1:\\n return dp[i] \\n\\n s1 = nums[i] + house(i-2, nums, dp)\\n s2 = house(i-1, nums, dp)\\n dp[i] = max(s1,s2)\\n\\n return dp[i]\\n n = len(nums)\\n dp = [-1]*n\\n return house(len(nums)-1, nums, dp)\\n \",\n \"runtime\": \"12\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n if not nums:\\n return 0\\n if len(nums) == 1:\\n return nums[0]\\n\\n dp = [nums[0], max(nums[0], nums[1])]\\n\\n for i in range(2, len(nums)):\\n dp.append(max(dp[-1], dp[-2] + nums[i]))\\n dp.pop(0)\\n\\n return dp[-1]\",\n \"runtime\": \"14\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n prev, curr = 0, 0\\n for n in nums:\\n tmp = curr\\n curr = max(curr, n + prev)\\n prev = tmp\\n return curr\",\n \"runtime\": \"15\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n rob1, rob2 = 0, 0\\n\\n for n in nums:\\n robNew = max(rob2, rob1 + n)\\n rob1 = rob2\\n rob2 = robNew\\n return rob2\",\n \"runtime\": \"16\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.max_profit = {}\\n\\n def rob_from_idx(self, nums: List[int], start_idx: int) -> int:\\n if start_idx in self.max_profit:\\n return self.max_profit[start_idx]\\n \\n if start_idx == len(nums) - 1:\\n return nums[start_idx]\\n elif start_idx == len(nums) - 2:\\n return max(nums[start_idx], nums[start_idx + 1])\\n \\n max_profit = max(nums[start_idx] + self.rob_from_idx(nums, start_idx + 2), self.rob_from_idx(nums, start_idx + 1))\\n self.max_profit[start_idx] = max_profit\\n\\n return max_profit\\n\\n def rob(self, nums: List[int]) -> int:\\n # rob(nums, 0) = max(nums[0] + rob(nums, 2), rob(nums, 1))\\n return self.rob_from_idx(nums, 0)\\n \",\n \"runtime\": \"17\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n \\n rob1, rob2 = 0, 0\\n \\n for num in nums:\\n rob1, rob2 = max(num + rob2, rob1), rob1\\n \\n return rob1\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n=len(nums)\\n dp=[-1]*n\\n def helper(lev):\\n if lev>=n:\\n return 0\\n if dp[lev]!=-1: return dp[lev]\\n maxrob=nums[lev]+helper(lev+2)\\n maxrob=max(maxrob,helper(lev+1))\\n dp[lev]=maxrob\\n return maxrob\\n return helper(0)\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n T = [0 for _ in range(len(nums) + 1)]\\n T[0] = 0\\n T[1] = nums[0]\\n max_r = T[1]\\n for i in range(1, len(nums)):\\n T[i + 1] = max(T[i], T[i - 1] + nums[i])\\n max_r = max(max_r, T[i + 1])\\n return max_r\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def rob(self, nums: List[int]) -> int:\\n if len(nums) == 0:\\n return 0\\n if len(nums) == 1:\\n return nums[0]\\n \\n dp = [-1] * len(nums)\\n dp[0] = nums[0]\\n dp[1] = max(nums[0], nums[1])\\n \\n for i in range(2, len(nums)):\\n left = nums[i] + dp[i-2]\\n right = dp[i-1]\\n dp[i] = max(left, right)\\n \\n return dp[len(nums)-1]\\n\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [0 for i in range(n)]\\n dp[0] = nums[0]\\n if n > 1:\\n dp[1] = max(nums[0], nums[1])\\n for i in range(2, n):\\n dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])\\n return dp[n - 1]\\n\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n if not nums:\\n return 0\\n if len(nums)<3:\\n return max(nums)\\n pre=nums[0]\\n cur=max(nums[0], nums[1])\\n for k in range(2, len(nums)):\\n tp=cur\\n cur=max(cur, pre+nums[k])\\n pre=tp\\n return cur\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [0] * (n+1)\\n dp[1] = nums[0]\\n\\n for i in range(2, n + 1): \\n dp[i] = max(dp[i-1], dp[i-2] + nums[i-1])\\n \\n return dp[n]\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n rob1, rob2 = 0, 0\\n \\n for num in nums:\\n temp = rob2\\n # get the max rob value\\n # set that to rob2\\n rob2 = max(rob2, rob1 + num)\\n # set rob1 to prev value of rob2\\n rob1 = temp\\n \\n return rob2\\n\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n rob1,rob2=0,0\\n for n in nums:\\n temp=max(n+rob1,rob2)\\n rob1=rob2\\n rob2=temp\\n return rob2\\n\\n\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n \\n memo = {}\\n\\n def robFrom(i):\\n if i >= len(nums):\\n return 0\\n \\n if i in memo:\\n return memo[i]\\n \\n res = max(robFrom(i+1), robFrom(i+2) + nums[i])\\n memo[i] = res\\n return res\\n return robFrom(0)\\n\\n\\n\\n \",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n rob1, rob2 = 0, 0\\n\\n for n in nums:\\n temp = max(rob1 + n, rob2)\\n rob1 = rob2\\n rob2 = temp\\n return rob2\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n length = len(nums)\\n a = b = c = 0\\n index = 0\\n while index < length:\\n c = max(nums[index] + a, b)\\n a = b \\n b = c\\n index += 1\\n return c\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n \\n rob1, rob2 =0,0\\n res = 0\\n \\n # You can make two decisions\\n # [1,2,3,1]\\n \\n for i in nums:\\n res = max(rob2+i, rob1)\\n rob2 = rob1\\n rob1 = res\\n return res\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n prev1, prev2 = 0, 0\\n # prev2, prev1, nums[i], ..., nums[n]\\n \\n for n in nums:\\n tmp = prev1\\n prev1 = max(n + prev2, prev1)\\n prev2 = tmp\\n\\n return prev1\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n memo = [0]*n\\n \\n if n > 0:\\n memo[0] = nums[0]\\n if n > 1:\\n memo[1] = max(nums[0], nums[1])\\n if n > 2:\\n memo[2] = max(nums[1], memo[0]+nums[2])\\n \\n for i in range(3, n):\\n memo[i] = max(memo[i-1], memo[i-2]+nums[i])\\n \\n return memo[-1]\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n=len(nums)\\n if n==0:\\n return 0\\n if n==1:\\n return nums[0]\\n if n==2:\\n return max(nums[0],nums[1])\\n def helper(arr):\\n dp=[0]*n\\n dp[0]=nums[0]\\n dp[1]=max(nums[0],nums[1])\\n for i in range(2,len(arr)):\\n dp[i]=max(dp[i-1],dp[i-2]+arr[i])\\n return dp[-1]\\n return helper(nums)\\n\\n\\n\\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n\\n # add robbale money to i-2 and i-3. Whichever is bigger we store that. In the end, we can return len(nums) or len(nums) - 1\\n\\n # nums[i-2], nums[i-3] nums[3] = nums[1] + nums[0]\\n\\n if len(nums) == 1:\\n return nums[0]\\n\\n result = [0] * (len(nums) + 1)\\n result[0] = 0\\n result[1] = nums[0]\\n result[2] = nums[1]\\n\\n for i in range(2, len(nums)):\\n result[i+1] = max(result[i-1] + nums[i], result[i-2] + nums[i])\\n \\n return max(result[len(nums)], result[len(nums)-1])\\n\\n \\n\\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n if len(nums) <= 2:\\n return max(nums)\\n amounts = [nums[0]]\\n for i in range(1, len(nums)):\\n prev = amounts[i-1]\\n prev_prev = amounts[i-2] if i-2 >= 0 else 0\\n amounts.append(max(prev_prev + nums[i], amounts[i-1]))\\n return amounts[-1]\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n\\n if n <= 2:\\n return max(nums)\\n\\n res = [0] * n\\n res[0] = nums[0]\\n res[1] = max(nums[0], nums[1])\\n\\n for i in range(2, n):\\n res[i] = max(res[i - 1], res[i - 2] + nums[i])\\n \\n return res[-1]\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n r1, r2 = 0,0\\n for n in nums:\\n temp = max(n+r1, r2)\\n r1 = r2\\n r2 = temp\\n \\n return r2\\n\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n prev, curr = 0, 0\\n\\n for money in nums:\\n tmp = curr\\n curr = max(money + prev, curr)\\n prev = tmp\\n \\n return curr\\n \\n\\n \\n\\n\\n\\n \\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n curr, prev = 0, 0\\n for n in nums:\\n curr, prev = max(curr, prev + n), curr\\n return curr\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n dp = [0 for _ in range(len(nums))]\\n for i in range(len(nums)):\\n if i == 0:\\n dp[i] = nums[0]\\n elif i==1:\\n dp[i] = max(nums[:2])\\n else:\\n dp[i] = max(dp[i-2]+nums[i], dp[i-1])\\n return dp[-1]\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n if n <= 2:\\n return max(nums)\\n dp = [0] * n\\n dp[0] = nums[0]\\n dp[1] = max(nums[0], nums[1])\\n for i in range(2, n):\\n dp[i] = max(dp[i-2] + nums[i], dp[i-1])\\n return dp[-1]\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n # If there are no houses, you can't rob anything\\n if not nums:\\n return 0\\n \\n # If there's only one house, rob it\\n if len(nums) == 1:\\n return nums[0]\\n \\n # Initialize the first two values\\n prev2 = 0 # This is dp[i-2], initially 0 because no houses have been robbed\\n prev1 = nums[0] # This is dp[i-1], initially the value of the first house\\n \\n # Iterate over the rest of the houses\\n for i in range(1, len(nums)):\\n # Compute the current value as the max of robbing or skipping the current house\\n current = max(prev1, prev2 + nums[i])\\n \\n # Move the window: prev2 becomes prev1, prev1 becomes the current value\\n prev2 = prev1\\n prev1 = current\\n \\n # The result is the last computed value, i.e., the max amount of money we can rob\\n return prev1\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums):\\n n = len(nums)\\n if n == 0:\\n return 0\\n\\n s0, s1 = [0, 0], [0, 0]\\n s1[0] = nums[0]\\n\\n for i in range(1, n):\\n s0[i % 2] = max(s0[(i - 1) % 2], s1[(i - 1) % 2])\\n s1[i % 2] = s0[(i - 1) % 2] + nums[i]\\n\\n return max(s0[(n - 1) % 2], s1[(n - 1) % 2])\\n\\n\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n if len(nums) == 0:\\n return 0\\n if len(nums)==1:\\n return nums[0]\\n dp = [0]*(len(nums)+1 )# dp[i] = maximum robbing considering i homes\\n dp[0] = 0\\n dp[1] = nums[0]\\n dp[2] = max(nums[0], nums[1])\\n for i in range(2, len(nums)):\\n dp[i+1] = max(dp[i-1]+nums[i], dp[i] + 0)\\n return dp[-1]\\n\\n\\n \\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n\\n # at each step we need to find the max amount of robbable money in the [0,i-1) subarray and add nums[i] to it. Now if that does not exist then the max robbable amount is just nums[i]. \\n\\n # nums[i-2], nums[i-3] nums[3] = nums[1] + nums[0]\\n\\n if len(nums) == 1:\\n return nums[0]\\n\\n result = [0] * (len(nums) + 1)\\n result[0] = 0\\n result[1] = nums[0]\\n result[2] = nums[1]\\n\\n for i in range(2, len(nums)):\\n result[i+1] = max(result[i-1] + nums[i], result[i-2] + nums[i])\\n \\n return max(result)\\n\\n \\n\\n \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n rob1, rob2 = 0, 0\\n\\n for n in nums:\\n temp = rob2\\n rob2 = max(n + rob1, rob2)\\n rob1 = temp\\n\\n return max(rob1, rob2)\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int], start = 0, memoize = None) -> int:\\n # [a, b, c, d]\\n # [x, x, c, d] if rob a\\n # [x, x, x, d] if rob b\\n # if rob c, no reason not to also rob a\\n l = len(nums) - start\\n\\n if l == 0:\\n return 0\\n\\n if not memoize and len(nums) > 10:\\n memoize = [-1] * len(nums)\\n elif memoize and memoize[start] >= 0:\\n return memoize[start]\\n\\n rob_a = nums[start]\\n if l > 2:\\n rob_a += self.rob(nums, start+2, memoize)\\n\\n if not (l > 1):\\n return rob_a\\n\\n rob_b = nums[start+1]\\n if l > 3:\\n rob_b += self.rob(nums, start+3, memoize)\\n\\n decision = max(rob_a, rob_b)\\n\\n if memoize:\\n memoize[start] = decision\\n\\n return decision\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n \\n if n == 1:\\n return nums[0]\\n \\n dp = [0] * n\\n \\n dp[0] = nums[0]\\n dp[1] = max(nums[0], nums[1])\\n \\n for i in range(2, n):\\n dp[i] = max(dp[i-1], nums[i] + dp[i-2])\\n \\n return dp[-1] \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n \\n if (len(nums) == 0):\\n return 0\\n elif (len(nums) == 1):\\n return nums[0]\\n elif (len(nums) == 2):\\n return max(nums)\\n \\n dp = [0]* len(nums)\\n dp[0] = nums[0]\\n dp[1] = max(nums[0:2])\\n \\n \\n for i in range(2, len(nums)):\\n dp[i] = max(dp[i-1], dp[i-2]+nums[i])\\n return dp[-1]\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n \\n def robb(nums, ind, dp):\\n if ind == 0:\\n return nums[0]\\n if ind < 0:\\n return 0\\n if dp[ind] != -1:\\n return dp[ind]\\n two = nums[ind] + robb(nums, ind-2, dp)\\n nextt = robb(nums, ind-1, dp)\\n\\n dp[ind] = max(two, nextt)\\n return dp[ind]\\n\\n dp = [-1] * len(nums)\\n return robb(nums, len(nums)-1, dp)\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n \\n if n == 1:\\n return nums[0]\\n \\n dp = [0] * n\\n \\n dp[0] = nums[0]\\n dp[1] = max(nums[0], nums[1])\\n \\n for i in range(2, n):\\n dp[i] = max(dp[i-1], nums[i] + dp[i-2])\\n \\n return dp[-1] \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n=len(nums)\\n if n==1:\\n return nums[0]\\n x=[0]*n\\n x[0],x[1]=nums[0],nums[1]\\n if n>=3:\\n x[2]=nums[2]+x[0]\\n if n>3:\\n for i in range(3,n):\\n x[i]=nums[i]+max(x[i-2],x[i-3])\\n return max(x[-1],x[-2])\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n=len(nums)\\n memo=defaultdict(lambda:-1)\\n def checker(index):\\n if index<0:\\n return 0\\n if index==0:\\n return nums[0]\\n if memo[index] !=-1:\\n return memo[index]\\n\\n result=max(nums[index]+checker(index-2),checker(index-1))\\n memo[index]=result\\n return result\\n\\n\\n\\n\\n\\n\\n\\n return checker(n-1)\\n \\n \\n\\n \\n\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n if len(nums) <= 2:\\n return max(nums)\\n \\n maxx = max(nums[0], nums[1])\\n for i in range(2, len(nums)):\\n curmax = 0\\n for j in range(i-1):\\n curmax = max(curmax, nums[i]+nums[j])\\n nums[i] = curmax\\n maxx = max(maxx, curmax)\\n return maxx\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List [int]) -> int:\\n maxes = {}\\n if len(nums) == 1:\\n return nums[0]\\n elif len(nums) == 2:\\n return max(nums[0], nums[1])\\n elif len(nums) == 3:\\n return max(nums[0] + nums[2], nums[1])\\n for i in range(3, len(nums),2):\\n if i < 4:\\n nums[i-1] = nums[i-3] + nums[i-1]\\n else:\\n nums[i-1] = max(nums[i-3] + nums[i-1], nums[i-1] + nums[i-4])\\n nums[i] = max(nums[i-3]+nums[i], nums[i-2]+ nums[i])\\n print(nums)\\n if len(nums) % 2 == 0:\\n return max(nums[-2],nums[-1])\\n else:\\n return max(nums[-1] + nums[-3], nums[-2], nums[-1]+nums[-4]) \\n \\n\\n \\n \\n\\n\\n\\n \\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n\\n\\\"\\\"\\\"\\nclass Solution:\\n def rob(self, nums: List[int]) -> int:\\n def dp(i):\\n if i <= 0:\\n return nums[0]\\n if i == 1:\\n return max(nums[0], nums[1])\\n \\n if i in memo:\\n return memo[i]\\n \\n memo[i] = max(dp(i-1), dp(i-2) + nums[i])\\n return memo[i]\\n\\n memo = {}\\n return dp(len(nums) - 1)\\n\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n # dp - O(N) time, O(1) space\\n minus_two = 0\\n minus_one = nums[0]\\n profit = minus_one\\n for i in range(1, len(nums)):\\n profit = max(minus_two + nums[i], minus_one)\\n minus_two = minus_one\\n minus_one = profit\\n \\n return profit\\n\\n # recursion w/ memoization - O(N) time, O(N) space\\n # memo = {}\\n # def _rob(idx):\\n # if idx >= len(nums):\\n # return 0\\n # elif idx not in memo:\\n # rob_current_house = nums[idx] + _rob(idx + 2)\\n # skip_current_house = _rob(idx + 1)\\n # memo[idx] = max(rob_current_house, skip_current_house)\\n # return memo[idx]\\n \\n # return _rob(0)\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"def robHouse(index, nums, dp):\\n if index == 0:\\n return nums[0]\\n \\n if index < 0:\\n return 0\\n\\n if dp[index] != -1:\\n return dp[index]\\n\\n pick = nums[index] + robHouse(index-2, nums, dp)\\n not_pick = robHouse(index-1, nums, dp)\\n\\n dp[index] = max(pick, not_pick)\\n return dp[index]\\n\\nclass Solution:\\n def rob(self, nums: List[int]) -> int:\\n if len(nums) == 1:\\n return nums[0]\\n dp = [-1] * len(nums)\\n \\n # robHouse(len(nums)-1, nums, dp)\\n dp[0] = nums[0]\\n for i in range(1, len(nums)):\\n if i > 1:\\n take = nums[i] + dp[i-2]\\n else:\\n take = nums[i]\\n\\n non_take = dp[i-1]\\n dp[i] = max(take, non_take)\\n\\n \\n return dp[-1]\\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n dp_table=[]\\n if len(nums)==1:\\n return nums[0]\\n dp_table.append(nums[0])\\n dp_table.append(max(nums[0],nums[1]))\\n if len(nums)>2:\\n for i in range(2,len(nums)):\\n dp_table.append(max(dp_table[i-1],dp_table[i-2]+nums[i]))\\n \\n return dp_table[-1]\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n\\n withPrev = 0\\n withoutPrev =0\\n for c in nums:\\n curSelect = c + withoutPrev\\n withoutPrev = max(withoutPrev,withPrev)\\n withPrev=curSelect\\n \\n return max(withPrev,withoutPrev)\\n\\n\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [0]*(n+2)\\n dp[0] = 0\\n dp[1] = 0\\n for i in range(len(nums)):\\n dp[i+2] = max(dp[i]+nums[i],dp[i+1])\\n return dp[n+1]\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n if len(nums) <= 2:\\n return max(nums)\\n \\n total_amount = [0] * len(nums)\\n total_amount[0] = nums[0]\\n total_amount[1] = max(nums[0], nums[1])\\n\\n for i in range(2, len(nums)):\\n total_amount[i] = max(total_amount[i-1], total_amount[i-2] + nums[i])\\n return total_amount[-1] \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n\\n\\n if len(nums) == 0:\\n return 0\\n elif len(nums) == 1:\\n return nums[0]\\n\\n money = [0, nums[0]]\\n\\n for house in range(2, len(nums) + 1):\\n\\n # Rob house\\n temp1 = money[house - 2] + nums[house - 1]\\n\\n # Don't rob house\\n temp2 = money[house - 1]\\n\\n money.append(max(temp1, temp2))\\n\\n return money[len(nums)]\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n \\n self.cache = {}\\n def dp(nums, until):\\n if until in self.cache:\\n return self.cache[until]\\n \\n if until == 0:\\n return nums[0]\\n if until == 1:\\n return max(nums[0], nums[1])\\n \\n max_rob = max(nums[until] + dp(nums, until-2), dp(nums, until-1))\\n self.cache[until] = max_rob\\n return max_rob\\n \\n return dp(nums, len(nums)-1)\\n \\n \",\n \"runtime\": \"43\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":52,"string":"52"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n if len(nums) <=2 :\n return max(nums)\n dp = [0] * len(nums)\n dp[0] = nums[0]\n dp[1] = max(nums[0], nums[1])\n \n\n for i in range(2, len(nums)):\n dp[i] = max(dp[i-1], nums[i] + dp[i-2])\n return dp[-1]\n","memory":"15900"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n if not nums:\n return 0\n if len(nums)==1:\n return nums[0]\n prev = curr = 0\n for num in nums:\n new_rob = max(curr,prev+num)\n prev = curr\n curr = new_rob\n return curr\n\n \n\n ","memory":"16000"},{"code":"class Solution:\n\n def max_robbery(self, idx, nums, length):\n if idx>=length:\n return 0\n\n if self.dp[idx] != -1:\n return self.dp[idx]\n\n pick = nums[idx] + self.max_robbery(idx+2, nums, length)\n not_pick = self.max_robbery(idx+1, nums, length)\n\n self.dp[idx] = max(pick, not_pick)\n\n return self.dp[idx]\n\n def rob(self, nums: List[int]) -> int:\n dp = [0 for _ in range(len(nums))]\n dp[len(nums)-1] = nums[len(nums)-1]\n\n for i in range(len(nums)-2, -1, -1):\n take = nums[i]\n if i < len(nums)-2:\n take += dp[i+2]\n notTake = dp[i+1]\n dp[i] = max(take, notTake)\n\n return dp[0]","memory":"16100"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n if len(nums) == 1:\n return nums[0]\n \n elif len(nums) == 2:\n return max(nums)\n \n n = len(nums)\n\n cur = max(nums[1], nums[0])\n prev = nums[0]\n\n for i in range(2, n):\n cur, prev = max(cur, prev+nums[i]), cur\n \n return cur","memory":"16100"},{"code":"class Solution:\n def __init__(self):\n self.memo={}\n def robfrom(self,nums,i):\n if i>=len(nums):\n return 0\n elif len(nums)==1:\n return nums[0]\n if i in self.memo:\n return self.memo[i]\n self.memo[i]= max(self.robfrom(nums,i+1),nums[i]+self.robfrom(nums,i+2))\n return self.memo[i]\n \n\n def rob(self, nums: List[int]) -> int:\n self.memo={} \n return self.robfrom(nums,0)","memory":"16200"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n \n if (len(nums) == 0):\n return 0\n elif (len(nums) == 1):\n return nums[0]\n elif (len(nums) == 2):\n return max(nums)\n \n dp = [0]* len(nums)\n dp[0] = nums[0]\n dp[1] = max(nums[0:2])\n \n \n for i in range(2, len(nums)):\n dp[i] = max(dp[i-1], dp[i-2]+nums[i])\n return dp[-1]","memory":"16300"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n length = len(nums)\n dp = [0] * length\n\n if length == 1:\n return nums[0]\n dp[0] = nums[0]\n dp[1] = max(nums[0], nums[1])\n for n in range(2,length):\n dp[n] = max(dp[n-1], dp[n-2] + nums[n])\n return dp[-1]\n ","memory":"16300"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n if n < 3:\n return max(nums)\n\n rob1, rob2 = 0, 0\n for i in range(n):\n tmp = max(rob2, rob1 + nums[i])\n rob1 = rob2\n rob2 = tmp\n \n return rob2","memory":"16400"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n dp = [nums[0]]\n\n for i in range(1, len(nums)):\n if i == 1:\n dp.append(max(nums[0], nums[1]))\n else:\n dp.append(max(dp[-1], dp[-2]+nums[i]))\n\n return max(dp[-1], dp[-2]) if len(dp) > 1 else dp[-1]","memory":"16400"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n dp = [0 for _ in range(len(nums)+2)]\n\n for i in range(len(nums)-1, -1, -1):\n cur_num = nums[i]\n\n max_res = dp[i+1]\n\n for j in range(i+2, len(nums)+2):\n max_res = max(max_res, cur_num + dp[j])\n \n dp[i] = max_res\n\n return dp[0]\n","memory":"16500"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n rob1, rob2 = 0, 0\n\n for n in nums:\n temp = max(n + rob1, rob2)\n rob1 = rob2\n rob2 = temp\n return rob2","memory":"16500"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n n = len(nums)\n if n==1: return nums[0]\n dp = [0]*n\n dp[0] =nums[0]\n dp[1] = max(nums[0], nums[1])\n for i in range(2, n):\n dp[i] = max(dp[i-1], dp[i-2]+nums[i])\n return dp[-1]","memory":"16600"},{"code":"class Solution:\n def rob(self, nums: List[int]) -> int:\n\n if not nums: \n return 0 \n\n n = len(nums)\n dp = [0] * (n+1) \n dp[n], dp[n-1] = 0, nums[n-1]\n for i in range(n-2, -1, -1):\n dp[i] = max(dp[i+1], dp[i+2]+nums[i])\n\n return dp[0]\n\n ","memory":"16600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n if len(nums) <=2 :\\n return max(nums)\\n dp = [0] * len(nums)\\n dp[0] = nums[0]\\n dp[1] = max(nums[0], nums[1])\\n \\n\\n for i in range(2, len(nums)):\\n dp[i] = max(dp[i-1], nums[i] + dp[i-2])\\n return dp[-1]\\n\",\n \"memory\": \"15900\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n if not nums:\\n return 0\\n if len(nums)==1:\\n return nums[0]\\n prev = curr = 0\\n for num in nums:\\n new_rob = max(curr,prev+num)\\n prev = curr\\n curr = new_rob\\n return curr\\n\\n \\n\\n \",\n \"memory\": \"16000\"\n },\n {\n \"code\": \"class Solution:\\n\\n def max_robbery(self, idx, nums, length):\\n if idx>=length:\\n return 0\\n\\n if self.dp[idx] != -1:\\n return self.dp[idx]\\n\\n pick = nums[idx] + self.max_robbery(idx+2, nums, length)\\n not_pick = self.max_robbery(idx+1, nums, length)\\n\\n self.dp[idx] = max(pick, not_pick)\\n\\n return self.dp[idx]\\n\\n def rob(self, nums: List[int]) -> int:\\n dp = [0 for _ in range(len(nums))]\\n dp[len(nums)-1] = nums[len(nums)-1]\\n\\n for i in range(len(nums)-2, -1, -1):\\n take = nums[i]\\n if i < len(nums)-2:\\n take += dp[i+2]\\n notTake = dp[i+1]\\n dp[i] = max(take, notTake)\\n\\n return dp[0]\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n if len(nums) == 1:\\n return nums[0]\\n \\n elif len(nums) == 2:\\n return max(nums)\\n \\n n = len(nums)\\n\\n cur = max(nums[1], nums[0])\\n prev = nums[0]\\n\\n for i in range(2, n):\\n cur, prev = max(cur, prev+nums[i]), cur\\n \\n return cur\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.memo={}\\n def robfrom(self,nums,i):\\n if i>=len(nums):\\n return 0\\n elif len(nums)==1:\\n return nums[0]\\n if i in self.memo:\\n return self.memo[i]\\n self.memo[i]= max(self.robfrom(nums,i+1),nums[i]+self.robfrom(nums,i+2))\\n return self.memo[i]\\n \\n\\n def rob(self, nums: List[int]) -> int:\\n self.memo={} \\n return self.robfrom(nums,0)\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n \\n if (len(nums) == 0):\\n return 0\\n elif (len(nums) == 1):\\n return nums[0]\\n elif (len(nums) == 2):\\n return max(nums)\\n \\n dp = [0]* len(nums)\\n dp[0] = nums[0]\\n dp[1] = max(nums[0:2])\\n \\n \\n for i in range(2, len(nums)):\\n dp[i] = max(dp[i-1], dp[i-2]+nums[i])\\n return dp[-1]\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n length = len(nums)\\n dp = [0] * length\\n\\n if length == 1:\\n return nums[0]\\n dp[0] = nums[0]\\n dp[1] = max(nums[0], nums[1])\\n for n in range(2,length):\\n dp[n] = max(dp[n-1], dp[n-2] + nums[n])\\n return dp[-1]\\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n if n < 3:\\n return max(nums)\\n\\n rob1, rob2 = 0, 0\\n for i in range(n):\\n tmp = max(rob2, rob1 + nums[i])\\n rob1 = rob2\\n rob2 = tmp\\n \\n return rob2\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n dp = [nums[0]]\\n\\n for i in range(1, len(nums)):\\n if i == 1:\\n dp.append(max(nums[0], nums[1]))\\n else:\\n dp.append(max(dp[-1], dp[-2]+nums[i]))\\n\\n return max(dp[-1], dp[-2]) if len(dp) > 1 else dp[-1]\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n dp = [0 for _ in range(len(nums)+2)]\\n\\n for i in range(len(nums)-1, -1, -1):\\n cur_num = nums[i]\\n\\n max_res = dp[i+1]\\n\\n for j in range(i+2, len(nums)+2):\\n max_res = max(max_res, cur_num + dp[j])\\n \\n dp[i] = max_res\\n\\n return dp[0]\\n\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n rob1, rob2 = 0, 0\\n\\n for n in nums:\\n temp = max(n + rob1, rob2)\\n rob1 = rob2\\n rob2 = temp\\n return rob2\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n n = len(nums)\\n if n==1: return nums[0]\\n dp = [0]*n\\n dp[0] =nums[0]\\n dp[1] = max(nums[0], nums[1])\\n for i in range(2, n):\\n dp[i] = max(dp[i-1], dp[i-2]+nums[i])\\n return dp[-1]\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def rob(self, nums: List[int]) -> int:\\n\\n if not nums: \\n return 0 \\n\\n n = len(nums)\\n dp = [0] * (n+1) \\n dp[n], dp[n-1] = 0, nums[n-1]\\n for i in range(n-2, -1, -1):\\n dp[i] = max(dp[i+1], dp[i+2]+nums[i])\\n\\n return dp[0]\\n\\n \",\n \"memory\": \"16600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":13,"string":"13"}}},{"rowIdx":79,"cells":{"question_id":{"kind":"number","value":199,"string":"199"},"name":{"kind":"string","value":"binary-tree-right-side-view"},"content":{"kind":"string","value":"<p>Given the <code>root</code> of a binary tree, imagine yourself standing on the <strong>right side</strong> of it, return <em>the values of the nodes you can see ordered from top to bottom</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/02/14/tree.jpg\" style=\"width: 401px; height: 301px;\" />\n<pre>\n<strong>Input:</strong> root = [1,2,3,null,5,null,4]\n<strong>Output:</strong> [1,3,4]\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> root = [1,null,3]\n<strong>Output:</strong> [1,3]\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> root = []\n<strong>Output:</strong> []\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>\n\t<li><code>-100 <= Node.val <= 100</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":63.84586668123503,"string":"63.845867"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["tree","depth-first-search","breadth-first-search","binary-tree"],"string":"[\n \"tree\",\n \"depth-first-search\",\n \"breadth-first-search\",\n \"binary-tree\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15\", 0.0148], [\"16\", 0.0037], [\"17\", 0.0111], [\"18\", 0.0296], [\"19\", 0.148], [\"20\", 0.0814], [\"21\", 0.1073], [\"22\", 0.1812], [\"23\", 0.7805], [\"24\", 0.4254], [\"25\", 0.4513], [\"26\", 0.8581], [\"27\", 2.7187], [\"28\", 1.5609], [\"29\", 1.6312], [\"30\", 2.6891], [\"31\", 6.732], [\"32\", 4.2463], [\"33\", 3.9282], [\"34\", 5.7222], [\"35\", 10.3126], [\"36\", 6.7394], [\"37\", 5.6112], [\"38\", 6.7024], [\"39\", 9.976], [\"40\", 6.2401], [\"41\", 4.7235], [\"42\", 4.2316], [\"43\", 4.631], [\"44\", 3.1552]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15900\", 0.0037], [\"16000\", 0.0148], [\"16100\", 0.0148], [\"16200\", 0.2293], [\"16300\", 4.287], [\"16400\", 24.1724], [\"16500\", 43.292]]}"},"rt_list":{"kind":"list like","value":[{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n d=defaultdict(int)\n def foo(x,depth):\n if x.left: foo(x.left,depth+1)\n d[depth]=x.val\n if x.right: foo(x.right,depth+1)\n if root: foo(root,0)\n return [d[i] for i in sorted(d.keys())]","runtime":"15"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n \n if not root:\n return []\n\n q = deque([root])\n\n right_view = []\n\n while q:\n level_len = len(q)\n\n for i in range(level_len):\n n = q.popleft()\n\n if i == level_len - 1:\n right_view.append(n.val)\n \n if n.left:\n q.append(n.left)\n if n.right:\n q.append(n.right)\n \n return right_view\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # if not root:\n # return []\n \n # q = deque([root, None])\n\n # right_view = []\n\n # curr = root\n # while q:\n\n # prev, curr = curr, q.popleft()\n\n # while curr:\n # if curr.left:\n # q.append(curr.left)\n # if curr.right:\n # q.append(curr.right)\n \n # prev, curr = curr, q.popleft()\n \n # right_view.append(prev.val)\n\n # if q:\n # q.append(None)\n \n \n # return right_view\n\n","runtime":"16"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nfrom collections import deque\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n queue = deque()\n if root is None:\n return []\n \n if root.left is None and root.right is None:\n return [root.val]\n \n result = []\n queue.append(root)\n while queue:\n child_queue = deque()\n prev = -1\n while queue:\n curr = queue.popleft()\n\n if curr.left is not None:\n child_queue.append(curr.left)\n\n if curr.right is not None:\n child_queue.append(curr.right)\n \n prev = curr\n \n result.append(prev.val)\n queue = child_queue\n \n return result \n\n \n ","runtime":"17"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n dq = collections.deque()\n if root is not None: dq.append(root)\n res = []\n\n while dq:\n currLen = len(dq)\n for i in range(currLen):\n node = dq.popleft()\n if i == currLen - 1:\n res.append(node.val)\n if node.left: dq.append(node.left)\n if node.right: dq.append(node.right)\n\n return res\n ","runtime":"18"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n if not root:\n return res\n queue = deque()\n queue.append(root)\n\n while queue:\n qlen = len(queue)\n res.append(queue[-1].val)\n for _ in range(qlen):\n node = queue.popleft()\n if node.left:\n queue.append(node.left)\n if node.right:\n queue.append(node.right)\n return res","runtime":"19"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n \n q = collections.deque([root])\n res = []\n\n while q:\n level = []\n for _ in range(len(q)):\n cur = q.popleft()\n level.append(cur.val)\n if cur.right:\n q.append(cur.right)\n if cur.left:\n q.append(cur.left)\n res.append(level[0])\n return res","runtime":"20"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root: return []\n res = []\n q = deque()\n q.append(root)\n while q:\n res.append(q[-1].val)\n for i in range(len(q)):\n node = q.popleft()\n if node.left: q.append(node.left)\n if node.right: q.append(node.right)\n return res","runtime":"21"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n\n def dfs(self, root, res, lvl):\n if root:\n if len(res) == lvl:\n res.append(root.val)\n self.dfs(root.right, res, lvl+1)\n self.dfs(root.left, res, lvl+1)\n return res\n\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n return self.dfs(root, [], 0)","runtime":"22"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n\n height = 0\n ans = {}\n hi = self.traverse(root, height, ans)\n\n result = []\n\n for i in range(hi+1):\n result.append(ans[i])\n\n return result\n \n def traverse(self, node, height, ans) -> int:\n if height not in ans:\n ans[height] = node.val\n \n hi = height\n\n if node.right:\n localHeight = self.traverse(node.right, height + 1, ans)\n hi = max(hi, localHeight)\n if node.left:\n localHeight = self.traverse(node.left, height + 1, ans)\n hi = max(hi, localHeight)\n\n return hi\n","runtime":"22"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n ans = []\n queue = deque([root])\n\n while len(queue) > 0:\n lev_len = len(queue)\n right = None\n\n for i in range(lev_len):\n temp = queue.popleft()\n if temp:\n right = temp\n queue.append(temp.left)\n queue.append(temp.right)\n if right:\n ans.append(right.val)\n return ans","runtime":"23"},{"code":"# Definition for a binary tree node.\nclass TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n\n # dfs level order traversal, add last node in each level to result\n\n # edge cases: empty node\n from collections import deque\n queue = deque()\n queue.append(root)\n res = []\n\n while queue:\n l = len(queue)\n for i in range(l):\n node = queue.popleft()\n if not node:\n break\n if node.left:\n queue.append(node.left)\n if node.right:\n queue.append(node.right)\n if i == (l - 1):\n res.append(node.val)\n\n return(res)","runtime":"24"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n\n q = deque()\n q.append(root)\n output = []\n while q:\n level = []\n for i in range(len(q)):\n node = q.popleft()\n level.append(node.val)\n if node.left:\n q.append(node.left)\n if node.right:\n q.append(node.right)\n output.append(level[-1])\n return output","runtime":"24"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n \n result = []\n queue = [root]\n \n while queue:\n level_length = len(queue)\n for i in range(level_length):\n node = queue.pop(0)\n # If it's the last node in the current level, add its value to the result\n if i == level_length - 1:\n result.append(node.val)\n # Add left and right children to the queue\n if node.left:\n queue.append(node.left)\n if node.right:\n queue.append(node.right)\n \n return result\n ","runtime":"25"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n maxheight = -1\n res = []\n def dfs(root,currheight):\n if not root:\n return\n nonlocal maxheight, res\n if currheight>maxheight:\n maxheight = currheight\n res.append(root.val)\n dfs(root.right,currheight+1)\n dfs(root.left,currheight+1)\n dfs(root,0)\n return res","runtime":"26"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n\n def rec(r, level):\n if r is None:\n return\n\n if len(res) <= level:\n res.append(r.val)\n else:\n res[level] = r.val\n \n rec(r.left, level+1)\n rec(r.right, level+1)\n \n rec(root, 0)\n return res","runtime":"28"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root: return []\n result = [root.val]\n def bfs(node_list):\n if not node_list or set(node_list) == {None}:\n return\n temp = []\n for node in node_list:\n if node:\n if node.left != None: temp+= [node.left]\n if node.right != None: temp+= [node.right]\n # temp += [node.left, node.right]\n # temp = [t for t in temp if t != None]\n if temp:\n result.append(temp[-1].val)\n return bfs(temp)\n bfs([root])\n return result\n \n \n ","runtime":"28"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n look_up = {}\n\n def dfs(node, depth):\n if not node:\n return\n look_up[depth] = node.val\n dfs(node.left, depth + 1)\n dfs(node.right, depth + 1)\n \n dfs(root, 0)\n return list(look_up.values())","runtime":"29"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n\n ans = []\n\n q = deque([root])\n\n while q:\n \n length = len(q)\n last_node = None\n for i in range(length):\n node = q.popleft()\n if node:\n last_node = node\n q.append(node.left)\n q.append(node.right)\n \n if last_node: \n ans.append(last_node.val)\n \n return ans\n\n ","runtime":"29"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n queue = deque([root])\n ans = []\n \n while queue:\n n = len(queue)\n for i in range(n):\n node = queue.popleft()\n \n if node.left:\n queue.append(node.left)\n if node.right:\n queue.append(node.right)\n \n if i == n - 1:\n ans.append(node.val)\n \n return ans","runtime":"30"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n queue = deque([root])\n ans = []\n \n while queue:\n n = len(queue)\n for i in range(n):\n node = queue.popleft()\n \n if node.left:\n queue.append(node.left)\n if node.right:\n queue.append(node.right)\n \n if i == n - 1:\n ans.append(node.val)\n \n return ans","runtime":"30"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution: #2\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]: \n if not root:\n return []\n q = [root]\n ans = []\n while q:\n node = q[-1]\n ans.append(node.val)\n next_level = []\n for node in q:\n if node.left:\n next_level.append(node.left)\n if node.right:\n next_level.append(node.right)\n q = next_level\n return ans ","runtime":"31"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n queue=[root]\n var=0\n final_ans=[]\n if not root:\n return None\n while(len(queue)!=0):\n lvl=len(queue)\n for i in range(lvl):\n var=queue.pop(0)\n if var.left is not None:\n queue.append(var.left)\n if var.right is not None:\n queue.append(var.right)\n final_ans.append(var.val)\n return final_ans","runtime":"31"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def __init__(self):\n self.res = []\n def helper(self, root, level):\n if level == len(self.res):\n self.res.append(root.val)\n if root.right:\n self.helper(root.right, level+1)\n if root.left:\n self.helper(root.left, level+1)\n\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n self.helper(root, 0)\n return self.res\n","runtime":"32"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n from collections import deque\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n if not root:\n return res\n q = deque([root])\n # Only insert the right side into res array, only until right is available, then only left (if available)\n while q:\n right = None\n for i in range(len(q)):\n node = q.popleft()\n right = node\n if node.left:\n q.append(node.left)\n if node.right:\n q.append(node.right) \n \n\n res.append(right.val) \n return res \n\n\n\n\n\n\n # q = deque([root])\n # res = []\n # while q and root is not None:\n # n = len(q)\n # right = None\n # for i in range(len(q)):\n # node = q.popleft()\n # right = node\n \n # if node.left:\n # q.append(node.left)\n # if node.right:\n # q.append(node.right) \n \n # res.append(right.val)\n # return res\n ","runtime":"32"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nfrom collections import deque\n\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n \n result = []\n q = deque([root])\n \n while q:\n # check rightmost value at this level\n result.append(q[-1].val)\n\n # iterate all nodes in this level and add children to next level\n for i in range(len(q)):\n node = q.popleft()\n if node.left:\n q.append(node.left)\n if node.right:\n q.append(node.right)\n\n return result\n","runtime":"33"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n # 2024-09-16, iterative\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n st = []\n right_view = []\n curr_node = root\n curr_depth = 0\n while curr_node or st:\n while curr_node:\n st.append([curr_node, curr_depth])\n if len(right_view) == curr_depth:\n right_view.append(curr_node.val)\n curr_node = curr_node.right\n curr_depth += 1\n if st:\n curr_node, curr_depth = st.pop()\n curr_node = curr_node.left\n curr_depth += 1\n else:\n curr_node = None\n \n return right_view\n\n # 2024-09-16, recursive, 38 ms, 16.40 MB\n # def preOrderRightSearch(self, node: Optional[TreeNode], right_view: List[int], node_depth: int):\n \n # if not node:\n # return\n # if len(right_view) == node_depth:\n # right_view.append(node.val)\n # self.preOrderRightSearch(node.right, right_view, node_depth + 1)\n # self.preOrderRightSearch(node.left, right_view, node_depth + 1)\n\n # def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n \n # right_view = []\n # self.preOrderRightSearch(root, right_view, 0)\n\n # return right_view","runtime":"33"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n res=[]\n q=deque()\n if(root):\n q.append(root)\n else:\n return []\n while(q):\n level=[]\n for i in range(len(q)):\n k=q.popleft()\n if k:\n level.append(k.val)\n q.append(k.left)\n q.append(k.right)\n if level:\n res.append(level[-1])\n return res\n\n ","runtime":"34"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n \n result = []\n\n def dfs(node, depth):\n \n if not node:\n return\n \n if depth == len(result):\n result.append(node.val)\n \n dfs(node.right, depth + 1)\n dfs(node.left, depth + 1)\n \n dfs(root, 0)\n return result","runtime":"34"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n stack = []\n cur = root\n prevlevel = -1\n stack.append((0,root))\n ans = []\n while stack:\n tempstack = []\n while stack:\n curlevel, node = stack.pop(0)\n if curlevel!=prevlevel:\n ans.append(node.val)\n prevlevel = curlevel\n if node.right:\n tempstack.append((curlevel+1, node.right))\n if node.left:\n tempstack.append((curlevel+1, node.left))\n stack = tempstack\n return ans\n\n","runtime":"35"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n \n rl = []\n queue = collections.deque([root])\n \n while queue:\n rl.append(queue[-1].val)\n\n for i in range(0, len(queue)):\n node = queue.popleft() \n if node.left:\n queue.append(node.left)\n if node.right:\n queue.append(node.right)\n \n return rl\n \n","runtime":"35"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n res = []\n q = deque([root]) # it's not empty when root is null\n while q:\n level_size = len(q)\n for i in range(level_size):\n cur = q.popleft()\n if i == 0: # then it's right most\n res.append(cur.val)\n if cur.right:\n q.append(cur.right)\n if cur.left:\n q.append(cur.left) \n return res","runtime":"36"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n q = collections.deque([root])\n while q:\n rightSide = None\n qLen = len(q)\n for _ in range(qLen):\n node = q.popleft()\n if node:\n rightSide = node\n q.append(node.left)\n q.append(node.right)\n if rightSide:\n res.append(rightSide.val)\n return res","runtime":"36"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n def dfs(root, level):\n if not root:\n return\n if len(res) == level:\n res.append(root.val)\n dfs(root.right, level + 1)\n dfs(root.left, level + 1)\n res = []\n dfs(root, 0)\n return res","runtime":"37"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n res = []\n queue = deque()\n if root:\n queue.append(root)\n while len(queue) > 0:\n last = len(queue) - 1\n for i in range(len(queue)):\n cur = queue.popleft()\n if i == last:\n res.append(cur.val)\n if cur.left:\n queue.append(cur.left)\n if cur.right:\n queue.append(cur.right)\n \n return res\n\n ","runtime":"37"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n ans = []\n if not root: return []\n q = collections.deque()\n q.append(root)\n while q:\n N = len(q)\n while N:\n N -= 1\n curr = q.popleft()\n if curr.left: q.append(curr.left)\n if curr.right: q.append(curr.right)\n if N == 0: ans.append(curr.val)\n \n return ans","runtime":"38"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n\n q = deque([root])\n result = []\n while q:\n for _ in range(len(q)):\n node = q.popleft()\n if node.left is not None:\n q.append(node.left)\n if node.right is not None:\n q.append(node.right)\n result.append(node.val)\n\n return result\n","runtime":"38"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n queue = collections.deque()\n res = []\n if root is None:\n return res\n queue.append(root)\n\n while queue:\n size = len(queue)\n for i in range(size):\n node = queue.popleft()\n if node.left:\n queue.append(node.left)\n if node.right:\n queue.append(node.right)\n if i == size-1:\n res.append(node.val)\n \n return res","runtime":"39"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nimport queue\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n l = []\n if not root: return l\n q = queue.Queue()\n q.put((0, root))\n current_level = 0\n while not q.empty():\n level, node = q.get()\n if current_level == level:\n l.append(node.val)\n current_level += 1\n if node.right:\n q.put((current_level, node.right))\n if node.left:\n q.put((current_level, node.left))\n\n return l","runtime":"39"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n \n ans = []\n if root is None:\n return []\n\n def dfs(root, level, ans):\n if root is None:\n return\n if len(ans) < level:\n ans.append(root.val)\n dfs(root.right, level + 1, ans)\n dfs(root.left, level + 1, ans)\n dfs(root, 1, ans)\n return ans\n","runtime":"40"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n res = []\n q = deque([root]) # it's not empty when root is null\n while q:\n level_size = len(q)\n for i in range(level_size):\n cur = q.popleft()\n if cur.left:\n q.append(cur.left)\n if cur.right:\n q.append(cur.right)\n if i == level_size - 1: # then it's right most\n res.append(cur.val)\n return res","runtime":"40"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n \n if not root:\n return []\n q = deque()\n q.append(root)\n l = []\n while q:\n s = len(q)\n a = []\n for i in range(s):\n p = q.popleft()\n a.append(p.val)\n if p.left:\n q.append(p.left)\n if p.right:\n q.append(p.right)\n \n l.append(a)\n ans = []\n for i in l:\n ans.append(i[-1])\n return ans\n\n \n ","runtime":"41"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n q=deque()\n if root is None:\n return []\n res=[]\n q.append(root)\n while q:\n qlen=len(q)\n flag=True\n for i in range(qlen):\n node=q.popleft()\n if node:\n if flag:\n res.append(node.val)\n flag=False\n q.append(node.right)\n q.append(node.left)\n return res","runtime":"41"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if root is None:\n return []\n \n queue = []\n res = []\n\n tempRoot = [root, 1]\n while tempRoot:\n if tempRoot[0].left:\n queue.append([tempRoot[0].left, tempRoot[1] + 1])\n if tempRoot[0].right:\n queue.append([tempRoot[0].right, tempRoot[1] + 1])\n \n while len(res) < tempRoot[1]:\n res.append([])\n\n if res[tempRoot[1] - 1]:\n res[tempRoot[1] - 1].append(tempRoot[0].val)\n else:\n res[tempRoot[1] - 1] = [tempRoot[0].val]\n \n if len(queue) > 0:\n tempRoot = queue.pop(0)\n else:\n tempRoot = None\n \n ans = []\n for level in res:\n ans.append(level[-1])\n \n return ans","runtime":"42"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n\n res = defaultdict(list)\n\n def traverse(node, level):\n if not node:\n return\n \n res[level].append(node.val)\n if node.left:\n traverse(node.left, level+1)\n if node.right:\n traverse(node.right, level+1)\n \n traverse(root, 0)\n return [i[-1] for i in res.values()]\n","runtime":"42"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n \n from collections import deque\n queue = deque([root])\n rightSide = []\n\n while queue:\n right = None\n for _ in range(len(queue)):\n node = queue.popleft()\n if node:\n queue.append(node.left)\n queue.append(node.right)\n right = node.val\n rightSide.append(right)\n \n rightSide.pop()\n return rightSide\n\n\n \n\n\n \n\n","runtime":"43"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n\n res = []\n queue = deque()\n queue.append(root)\n\n while queue:\n size = len(queue)\n node = None\n for i in range(size):\n node = queue.popleft()\n if node.left:\n queue.append(node.left)\n if node.right:\n queue.append(node.right)\n res.append(node.val)\n\n return res\n ","runtime":"43"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nfrom collections import deque\n\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n if not root:\n return []\n \n result = []\n\n current_level = deque([root])\n next_level = deque()\n\n while current_level or next_level:\n result.append(current_level[-1].val)\n while current_level:\n node = current_level.pop()\n if node.right:\n next_level.appendleft(node.right)\n if node.left:\n next_level.appendleft(node.left)\n current_level, next_level = next_level, current_level\n next_level.clear()\n\n return result\n","runtime":"44"},{"code":"# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n queue=[root]\n var=0\n final_ans=[]\n if not root:\n return None\n while(len(queue)!=0):\n lvl=len(queue)\n for i in range(lvl):\n var=queue.pop(0)\n if var.left is not None:\n queue.append(var.left)\n if var.right is not None:\n queue.append(var.right)\n final_ans.append(var.val)\n return final_ans","runtime":"44"}],"string":"[\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n d=defaultdict(int)\\n def foo(x,depth):\\n if x.left: foo(x.left,depth+1)\\n d[depth]=x.val\\n if x.right: foo(x.right,depth+1)\\n if root: foo(root,0)\\n return [d[i] for i in sorted(d.keys())]\",\n \"runtime\": \"15\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n \\n if not root:\\n return []\\n\\n q = deque([root])\\n\\n right_view = []\\n\\n while q:\\n level_len = len(q)\\n\\n for i in range(level_len):\\n n = q.popleft()\\n\\n if i == level_len - 1:\\n right_view.append(n.val)\\n \\n if n.left:\\n q.append(n.left)\\n if n.right:\\n q.append(n.right)\\n \\n return right_view\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # if not root:\\n # return []\\n \\n # q = deque([root, None])\\n\\n # right_view = []\\n\\n # curr = root\\n # while q:\\n\\n # prev, curr = curr, q.popleft()\\n\\n # while curr:\\n # if curr.left:\\n # q.append(curr.left)\\n # if curr.right:\\n # q.append(curr.right)\\n \\n # prev, curr = curr, q.popleft()\\n \\n # right_view.append(prev.val)\\n\\n # if q:\\n # q.append(None)\\n \\n \\n # return right_view\\n\\n\",\n \"runtime\": \"16\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nfrom collections import deque\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n queue = deque()\\n if root is None:\\n return []\\n \\n if root.left is None and root.right is None:\\n return [root.val]\\n \\n result = []\\n queue.append(root)\\n while queue:\\n child_queue = deque()\\n prev = -1\\n while queue:\\n curr = queue.popleft()\\n\\n if curr.left is not None:\\n child_queue.append(curr.left)\\n\\n if curr.right is not None:\\n child_queue.append(curr.right)\\n \\n prev = curr\\n \\n result.append(prev.val)\\n queue = child_queue\\n \\n return result \\n\\n \\n \",\n \"runtime\": \"17\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n dq = collections.deque()\\n if root is not None: dq.append(root)\\n res = []\\n\\n while dq:\\n currLen = len(dq)\\n for i in range(currLen):\\n node = dq.popleft()\\n if i == currLen - 1:\\n res.append(node.val)\\n if node.left: dq.append(node.left)\\n if node.right: dq.append(node.right)\\n\\n return res\\n \",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n if not root:\\n return res\\n queue = deque()\\n queue.append(root)\\n\\n while queue:\\n qlen = len(queue)\\n res.append(queue[-1].val)\\n for _ in range(qlen):\\n node = queue.popleft()\\n if node.left:\\n queue.append(node.left)\\n if node.right:\\n queue.append(node.right)\\n return res\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n \\n q = collections.deque([root])\\n res = []\\n\\n while q:\\n level = []\\n for _ in range(len(q)):\\n cur = q.popleft()\\n level.append(cur.val)\\n if cur.right:\\n q.append(cur.right)\\n if cur.left:\\n q.append(cur.left)\\n res.append(level[0])\\n return res\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n if not root: return []\\n res = []\\n q = deque()\\n q.append(root)\\n while q:\\n res.append(q[-1].val)\\n for i in range(len(q)):\\n node = q.popleft()\\n if node.left: q.append(node.left)\\n if node.right: q.append(node.right)\\n return res\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n\\n def dfs(self, root, res, lvl):\\n if root:\\n if len(res) == lvl:\\n res.append(root.val)\\n self.dfs(root.right, res, lvl+1)\\n self.dfs(root.left, res, lvl+1)\\n return res\\n\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n return self.dfs(root, [], 0)\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n\\n height = 0\\n ans = {}\\n hi = self.traverse(root, height, ans)\\n\\n result = []\\n\\n for i in range(hi+1):\\n result.append(ans[i])\\n\\n return result\\n \\n def traverse(self, node, height, ans) -> int:\\n if height not in ans:\\n ans[height] = node.val\\n \\n hi = height\\n\\n if node.right:\\n localHeight = self.traverse(node.right, height + 1, ans)\\n hi = max(hi, localHeight)\\n if node.left:\\n localHeight = self.traverse(node.left, height + 1, ans)\\n hi = max(hi, localHeight)\\n\\n return hi\\n\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n ans = []\\n queue = deque([root])\\n\\n while len(queue) > 0:\\n lev_len = len(queue)\\n right = None\\n\\n for i in range(lev_len):\\n temp = queue.popleft()\\n if temp:\\n right = temp\\n queue.append(temp.left)\\n queue.append(temp.right)\\n if right:\\n ans.append(right.val)\\n return ans\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\nclass TreeNode:\\n def __init__(self, val=0, left=None, right=None):\\n self.val = val\\n self.left = left\\n self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n\\n # dfs level order traversal, add last node in each level to result\\n\\n # edge cases: empty node\\n from collections import deque\\n queue = deque()\\n queue.append(root)\\n res = []\\n\\n while queue:\\n l = len(queue)\\n for i in range(l):\\n node = queue.popleft()\\n if not node:\\n break\\n if node.left:\\n queue.append(node.left)\\n if node.right:\\n queue.append(node.right)\\n if i == (l - 1):\\n res.append(node.val)\\n\\n return(res)\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n\\n q = deque()\\n q.append(root)\\n output = []\\n while q:\\n level = []\\n for i in range(len(q)):\\n node = q.popleft()\\n level.append(node.val)\\n if node.left:\\n q.append(node.left)\\n if node.right:\\n q.append(node.right)\\n output.append(level[-1])\\n return output\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n \\n result = []\\n queue = [root]\\n \\n while queue:\\n level_length = len(queue)\\n for i in range(level_length):\\n node = queue.pop(0)\\n # If it's the last node in the current level, add its value to the result\\n if i == level_length - 1:\\n result.append(node.val)\\n # Add left and right children to the queue\\n if node.left:\\n queue.append(node.left)\\n if node.right:\\n queue.append(node.right)\\n \\n return result\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n maxheight = -1\\n res = []\\n def dfs(root,currheight):\\n if not root:\\n return\\n nonlocal maxheight, res\\n if currheight>maxheight:\\n maxheight = currheight\\n res.append(root.val)\\n dfs(root.right,currheight+1)\\n dfs(root.left,currheight+1)\\n dfs(root,0)\\n return res\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n res = []\\n\\n def rec(r, level):\\n if r is None:\\n return\\n\\n if len(res) <= level:\\n res.append(r.val)\\n else:\\n res[level] = r.val\\n \\n rec(r.left, level+1)\\n rec(r.right, level+1)\\n \\n rec(root, 0)\\n return res\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n if not root: return []\\n result = [root.val]\\n def bfs(node_list):\\n if not node_list or set(node_list) == {None}:\\n return\\n temp = []\\n for node in node_list:\\n if node:\\n if node.left != None: temp+= [node.left]\\n if node.right != None: temp+= [node.right]\\n # temp += [node.left, node.right]\\n # temp = [t for t in temp if t != None]\\n if temp:\\n result.append(temp[-1].val)\\n return bfs(temp)\\n bfs([root])\\n return result\\n \\n \\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n look_up = {}\\n\\n def dfs(node, depth):\\n if not node:\\n return\\n look_up[depth] = node.val\\n dfs(node.left, depth + 1)\\n dfs(node.right, depth + 1)\\n \\n dfs(root, 0)\\n return list(look_up.values())\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n\\n ans = []\\n\\n q = deque([root])\\n\\n while q:\\n \\n length = len(q)\\n last_node = None\\n for i in range(length):\\n node = q.popleft()\\n if node:\\n last_node = node\\n q.append(node.left)\\n q.append(node.right)\\n \\n if last_node: \\n ans.append(last_node.val)\\n \\n return ans\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n queue = deque([root])\\n ans = []\\n \\n while queue:\\n n = len(queue)\\n for i in range(n):\\n node = queue.popleft()\\n \\n if node.left:\\n queue.append(node.left)\\n if node.right:\\n queue.append(node.right)\\n \\n if i == n - 1:\\n ans.append(node.val)\\n \\n return ans\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n queue = deque([root])\\n ans = []\\n \\n while queue:\\n n = len(queue)\\n for i in range(n):\\n node = queue.popleft()\\n \\n if node.left:\\n queue.append(node.left)\\n if node.right:\\n queue.append(node.right)\\n \\n if i == n - 1:\\n ans.append(node.val)\\n \\n return ans\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution: #2\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]: \\n if not root:\\n return []\\n q = [root]\\n ans = []\\n while q:\\n node = q[-1]\\n ans.append(node.val)\\n next_level = []\\n for node in q:\\n if node.left:\\n next_level.append(node.left)\\n if node.right:\\n next_level.append(node.right)\\n q = next_level\\n return ans \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n queue=[root]\\n var=0\\n final_ans=[]\\n if not root:\\n return None\\n while(len(queue)!=0):\\n lvl=len(queue)\\n for i in range(lvl):\\n var=queue.pop(0)\\n if var.left is not None:\\n queue.append(var.left)\\n if var.right is not None:\\n queue.append(var.right)\\n final_ans.append(var.val)\\n return final_ans\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"# Definition for a binary tree node.\\n# class TreeNode:\\n# def __init__(self, val=0, left=None, right=None):\\n# self.val = val\\n# self.left = left\\n# self.right = right\\nclass Solution:\\n def __init__(self):\\n self.res = []\\n def helper(self, root, level):\\n if level == len(self.res):\\n self.res.append(root.val)\\n if root.right:\\n self.helper(root.right, level+1)\\n if root.left:\\n self.helper(root.left, level+1)\\n\\n def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\\n if not root:\\n return []\\n self.helper(root, 0)\\n return self.res\\n\",\n \"runtime\": \"32\"\n },\n {\n \"