Initial commit

Author: Cenkay

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Cenkay Arapisaoglu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,9 @@
+class Solution(object):
+    def getIntersectionNode(self, headA, headB):
+        r1, r2, l1, l2 = headA, headB, 0, 0
+        while headA: headA, l1 = headA.next, l1 + 1
+        while headB: headB, l2 = headB.next, l2 + 1
+        while l1 > l2: r1, l1 = r1.next, l1 - 1
+        while l2 > l1: r2, l2 = r2.next, l2 - 1
+        while r1 != r2: r1, r2 = r1.next, r2.next
+        return r1

solutions/python/160.py

@@ -0,0 +1,5 @@
+class Solution:
+    # @param n, an integer
+    # @return an integer
+    def reverseBits(self, n):
+        return int(bin(n)[2:].zfill(32)[::-1],2)

solutions/python/190.py

@@ -0,0 +1,14 @@
+class Codec:
+
+    def encode(self, strs):
+        return "".join(str(len(s)) + ":" + s for s in strs)
+
+    def decode(self, s):
+        strs = []
+        while s:
+            i = s.find(":")
+            length = int(s[:i])
+            s = s[i+1:]
+            strs.append(s[:length])
+            s = s[length:]
+        return strs

solutions/python/271.py

@@ -0,0 +1,18 @@
+# The knows API is already defined for you.
+# @param a, person a
+# @param b, person b
+# @return a boolean, whether a knows b
+# def knows(a, b):
+
+class Solution(object):
+    def findCelebrity(self, n):
+        i = 0
+        while i < n:
+            person = i
+            i += 1
+            while i < n and not knows(person, i) and knows(i, person):
+                i += 1
+        j = person - 1
+        while j >= 0 and not knows(person, j) and knows(j, person):
+            j -= 1
+        return person if j < 0 else -1

solutions/python/277.py

@@ -0,0 +1,22 @@
+class ZigzagIterator(object):
+
+    def __init__(self, v1, v2):
+        self.arr1, self.arr2, self.l1, self.l2 = v1, v2, len(v1), len(v2)
+        self.i = self.j = 0
+        self.n, self.turn = max(self.l1, self.l2), v1 and 1 or 0
+
+    def next(self):
+        if self.turn:
+            num = self.arr1[self.i]
+            self.i += 1
+            if self.j < self.l2:
+                self.turn = 0
+        else:
+            num = self.arr2[self.j]
+            self.j += 1
+            if self.i < self.l1:
+                self.turn = 1
+        return num
+
+    def hasNext(self):
+        return self.turn and self.i < self.l1 or self.j < self.l2

solutions/python/281.py

@@ -0,0 +1,11 @@
+class Solution(object):
+    def guessNumber(self, n):
+        l, r, g = 1, n, 1
+        while g and l <= r:
+            m = (l + r) // 2
+            g = guess(m)
+            if g == 1:
+                l = m + 1
+            else:
+                r = m
+        return m

solutions/python/374.py

@@ -0,0 +1,6 @@
+class Solution(object):
+    def findNthDigit(self, n):
+        start, size, step = 1, 1, 9
+        while n > size * step:
+            n, size, step, start = n - (size * step), size + 1, step * 10, start * 10
+        return int(str(start + (n - 1) // size)[(n - 1) % size])

solutions/python/400.py

@@ -0,0 +1,14 @@
+class Solution(object):
+    def originalDigits(self, s):
+        res = ""
+        res += "0"*s.count('z')
+        res += "1"*(s.count('o')-s.count('z')-s.count('w')-s.count('u'))
+        res += "2"*s.count('w')
+        res += "3"*(s.count('h') - s.count('g'))
+        res += "4"*s.count('u')
+        res += "5"*(s.count('f') - s.count('u'))
+        res += "6"*s.count('x')
+        res += "7"*(s.count('s')-s.count('x'))
+        res += "8"*s.count("g")
+        res += "9"*(s.count('i') - s.count('x') - s.count("g") - s.count('f') + s.count('u'))
+        return res

solutions/python/423.py

@@ -0,0 +1,27 @@
+class Codec:
+
+    def serialize(self, root):
+        arr = []
+        def dfs(node):
+            if not node: return
+            arr.append(str(node.val))
+            for child in node.children:
+                dfs(child)
+            arr.append("#")
+        dfs(root)
+        return " ".join(arr)
+
+    def deserialize(self, data):
+        if not data: return None
+        data = collections.deque(data.split(" "))
+        root = Node(int(data.popleft()), [])
+        q = [root]
+        while data:
+            val = data.popleft()
+            if val == "#":
+                q.pop()
+            else:
+                new = Node(int(val), [])
+                q[-1].children.append(new)
+                q.append(new)
+        return root

solutions/python/428.py

@@ -0,0 +1,7 @@
+class Solution(object):
+    def levelOrder(self, root):
+        q, ret = [root], []
+        while any(q):
+            ret.append([node.val for node in q])
+            q = [child for node in q for child in node.children if child]
+        return ret

solutions/python/429.py

@@ -0,0 +1,18 @@
+class Solution(object):
+    def flatten(self, head):
+        stack, cur, root = [], head, head
+        while stack or cur:
+            if cur.child:
+                if cur.next:
+                    stack.append(cur.next)
+                new = cur.child
+                new.prev = cur
+                cur.child = None
+                cur.next = cur = new
+            elif not cur.next and stack:
+                cur.next = stack.pop()
+                cur.next.prev = cur
+                cur = cur.next
+            else:
+                cur = cur.next
+        return root

solutions/python/430.py

@@ -0,0 +1,58 @@
+"""
+# Definition for a Node.
+class Node(object):
+    def __init__(self, val, children):
+        self.val = val
+        self.children = children
+"""
+"""
+# Definition for a binary tree node.
+class TreeNode(object):
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+"""
+class Codec:
+
+    def encode(self, root):
+        """Encodes an n-ary tree to a binary tree.
+        
+        :type root: Node
+        :rtype: TreeNode
+        """
+        if not root:
+            return None
+
+        binary = TreeNode(root.val)                 # create a binary root
+        if not root.children:
+            return binary
+
+        binary.left = self.encode(root.children[0]) # left child of binary is the encoding of all n-ary children,
+        node = binary.left                          #     starting with the first child.
+        for child in root.children[1:]:             # other children of n-ary root are right child of previous child
+            node.right = self.encode(child)
+            node = node.right
+
+        return binary
+
+    def decode(self, data):
+        """Decodes your binary tree to an n-ary tree.
+        
+        :type data: TreeNode
+        :rtype: Node
+        """
+        if not data:
+            return None
+
+        nary = Node(data.val, [])                   # create n-ary root
+        node = data.left                            # move to first child of n-ary root
+        while node:                                 # while more children of n-ary root
+            nary.children.append(self.decode(node)) # append to list
+            node = node.right                       # and move to next child
+            
+        return nary
+
+# Your Codec object will be instantiated and called as such:
+# codec = Codec()
+# codec.decode(codec.encode(root))

solutions/python/431.py

@@ -0,0 +1,20 @@
+class Solution:
+    def findKthNumber(self, n, k):
+        def calSteps(n1, n2):
+            steps = 0
+            while n1 <= n:
+                steps += min(n + 1, n2) - n1
+                n1 *= 10
+                n2 *= 10
+            return steps
+        cur = 1
+        k -= 1
+        while k:
+            steps = calSteps(cur, cur + 1)
+            if steps <= k:
+                cur += 1
+                k -= steps
+            else:
+                cur *= 10
+                k -= 1
+        return cur

solutions/python/440.py

@@ -0,0 +1,10 @@
+class Solution(object):
+    def numberOfBoomerangs(self, points):
+        res = 0
+        for p in points:
+            dic = collections.defaultdict(int)
+            for q in points:
+                d = (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2
+                dic[d] += 1
+            for k in dic: res += dic[k] * (dic[k] - 1)
+        return res

solutions/python/447.py

@@ -0,0 +1,30 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Codec:
+
+    def serialize(self, root):
+        """Encodes a tree to a single string.
+        
+        :type root: TreeNode
+        :rtype: str
+        """
+        return root
+        
+
+    def deserialize(self, data):
+        """Decodes your encoded data to tree.
+        
+        :type data: str
+        :rtype: TreeNode
+        """
+        return data
+        
+
+# Your Codec object will be instantiated and called as such:
+# codec = Codec()
+# codec.deserialize(codec.serialize(root))

solutions/python/449.py

@@ -0,0 +1,9 @@
+class Solution(object):
+    def circularArrayLoop(self, nums):
+        loops, n = [[set(), set()] for _ in range(len(nums))], len(nums)
+        for loop in range(3):
+            for i, num in enumerate(nums):
+                mode = 0 if num > 0 else 1
+                if loop == 2 and i in loops[i][mode] and i != (i + num) % n: return True
+                loops[(i + num) % n][mode] |= loops[i][mode] or {i}
+        return False

solutions/python/457.py

@@ -0,0 +1,11 @@
+class Solution(object):
+    def poorPigs(self, buckets, minutesToDie, minutesToTest):
+        """
+        :type buckets: int
+        :type minutesToDie: int
+        :type minutesToTest: int
+        :rtype: int
+        """
+        pigs = 0
+        while (minutesToTest / minutesToDie + 1) ** pigs < buckets: pigs += 1
+        return pigs

solutions/python/458.py

@@ -0,0 +1,7 @@
+class Solution(object):
+    def change(self, amount, coins):
+        dp = [1] + [0] * amount
+        for coin in coins:
+            for i in range(coin, amount + 1):
+                dp[i] += dp[i - coin]
+        return dp[-1]

solutions/python/518.py

@@ -0,0 +1,7 @@
+class Codec:
+
+    def encode(self, longUrl): return longUrl
+    def decode(self, shortUrl): return shortUrl
+# Your Codec object will be instantiated and called as such:
+# codec = Codec()
+# codec.decode(codec.encode(url))

solutions/python/535.py

@@ -0,0 +1,8 @@
+class Solution:
+    def splitArray(self, nums):
+        n = len(nums)
+        s = [0] * (n + 1)
+        for i in range(n): s[i + 1] = s[i] + nums[i]
+        def check(l, r):
+            return set(s[m] - s[l] for m in range(l + 1, r + 1) if s[m] - s[l] == s[r + 1] - s[m + 1])
+        return any(check(0, j - 1) & check(j + 1, n - 1) for j in range(n))

solutions/python/548.py

@@ -0,0 +1,6 @@
+class Solution:
+    def checkRecord(self, n):
+        dp, mod = [1, 0, 0, 1, 1, 0], 10 ** 9 + 7
+        for i in range(1, n):
+            dp[0], dp[1], dp[2], dp[3], dp[4], dp[5] = sum(dp) % mod, dp[0], dp[1], sum(dp[3:]) % mod, dp[3], dp[4]
+        return sum(dp) % mod

solutions/python/552.py

@@ -0,0 +1,3 @@
+class Solution(object):
+    def maxDepth(self, root, level = 1):
+        return max(root and [self.maxDepth(child, level + 1) for child in root.children] + [level] or [0])

solutions/python/559.py

@@ -0,0 +1,9 @@
+class Solution(object):
+    def preorder(self, root):
+        ret, q = [], collections.deque([root])
+        while any(q):
+            node = q.popleft()
+            ret.append(node.val)
+            for child in node.children[::-1]:
+                if child: q.appendleft(child)
+        return ret