diff --git a/ArrayString/array_string_s1.py b/ArrayString/array_string_s1.py new file mode 100644 index 0000000..81dc5a6 --- /dev/null +++ b/ArrayString/array_string_s1.py @@ -0,0 +1,104 @@ +""" +Leetcode top interview 150 +https://leetcode.com/studyplan/top-interview-150/ + +Problem links: +1. https://leetcode.com/problems/merge-sorted-array/description/?envType=study-plan-v2&envId=top-interview-150 +2. https://leetcode.com/problems/remove-element/?envType=study-plan-v2&envId=top-interview-150 +3. https://leetcode.com/problems/remove-duplicates-from-sorted-array/description/?envType=study-plan-v2&envId=top-interview-150 +4. https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/description/?envType=study-plan-v2&envId=top-interview-150 +5. https://leetcode.com/problems/majority-element/description/?envType=study-plan-v2&envId=top-interview-150 +""" + + +class Solution(object): + def merge(self, nums1, m, nums2, n): + """ + :type nums1: List[int] + :type m: int + :type nums2: List[int] + :type n: int + :rtype: None Do not return anything, modify nums1 in-place instead. + """ + # TODO: this is not the right solution work on it later + del nums1[-(m - n):] + nums1.extend(nums2) + nums1.sort() + print(nums1) + + def removeElement(self, nums, val): + """ + :type nums: List[int] + :type val: int + :rtype: int + """ + st = 0 + ed = len(nums) - 1 + while st <= ed: + if nums[st] == val: + # nums.append(nums.pop(st)) + nums.pop(st) + ed -= 1 + else: + st += 1 + return len(nums) + + def removeDuplicates(self, nums): + """ + :type nums: List[int] + :rtype: int + """ + st = 0 + ed = st + 1 + while ed < len(nums): + if nums[st] == nums[ed]: + nums.pop(ed) + else: + st = ed + ed += 1 + return len(nums) + + def removeDuplicates2(self, nums): + """ + :type nums: List[int] + :rtype: int + #TODO complete this solution ans is not correct + """ + st = 0 + ed = st + 1 + count = 1 + while ed < len(nums): + print(count) + if nums[st] != nums[ed]: + count = 1 + if nums[st] == nums[ed]: + count += 1 + if count > 2: + nums.pop(ed) + ed += 1 + else: + st = ed + ed += 1 + print(nums) + + def majorityElement(self, nums): + """ + :type nums: List[int] + :rtype: int + """ + d = dict() + for num in nums: + if num in d: + d[num] += 1 + else: + d[num] = 0 + + return max(d, key=d.get) + + +s = Solution() +# s.merge([1, 2, 3, 0, 0, 0], 6, [2, 5, 6], 3) +# s.removeElement([0, 1, 2, 2, 3, 0, 4, 2], 2) +# s.removeDuplicates([0, 0, 1, 1, 1, 2, 2, 3, 3, 4]) +# s.removeDuplicates2([0, 0, 1, 1, 1, 1, 2, 3, 3]) +s.majorityElement([1, 2, 2, 1, 1, 1, 1, 2, 2]) diff --git a/ArrayString/array_string_s2.py b/ArrayString/array_string_s2.py new file mode 100644 index 0000000..cd22553 --- /dev/null +++ b/ArrayString/array_string_s2.py @@ -0,0 +1,80 @@ +""" +Leetcode top interview 150 +https://leetcode.com/studyplan/top-interview-150/ + +Problem links: +6. https://leetcode.com/problems/rotate-array/description/?envType=study-plan-v2&envId=top-interview-150 +7. https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/?envType=study-plan-v2&envId=top-interview-150 +""" + + +class Solution(object): + def rotate(self, nums, k): + k %= len(nums) # this is to avoid + return nums[-k:] + nums[:-k] + + def buy_the_stock(self, bought, bought_day, buy, day): + if buy < bought: + bought = buy + bought_day = day + return bought, bought_day + + def sell_the_stock(self, sold, sell): + if sell > sold: + sold = sell + return sold + + def maxProfit(self, prices): + """ + :type prices: List[int] + :rtype: int + """ + # TODO: this is not the right solution work on it later + day = 1 + sold = prices[-1] + bought = prices[0] + bought_day = 0 + while day < len(prices): + bought, bought_day = self.buy_the_stock(bought, bought_day, + prices[day], day) + day += 1 + while bought_day < len(prices): + sold = self.sell_the_stock(sold, prices[bought_day]) + bought_day += 1 + return sold - bought + + def jumped_to(self, now_at, nums): + print(f"returning {nums[now_at]}") + return nums[now_at] + + def canJump(self, nums): + """ + :type nums: List[int] + :rtype: bool + """ + # TODO: this is not the right solution work on it later + # i = 0 + # if len(nums) == 1 and nums[0] == 0: + # return True + # + # while i <= len(nums): + # if i == nums[-1]: + # return True + # print(i) + # i += self.jumped_to(i, nums) + # else: + # return False + + start = 0 + end = start + nums[start] + + while True: + end = self.jumped_to(start, end) + start = end + + +s = Solution() +# print(s.rotate([1, 2], 3)) +# print(s.maxProfit([2, 4, 1])) +print(s.canJump([3, 2, 1, 0, 4])) +# [2,3,1,1,4] diff --git a/HashMap/hashmap_s1.py b/HashMap/hashmap_s1.py new file mode 100644 index 0000000..4b79c99 --- /dev/null +++ b/HashMap/hashmap_s1.py @@ -0,0 +1,135 @@ +""" +Leetcode top interview 150 +https://leetcode.com/studyplan/top-interview-150/ + +Problem links: +1. https://leetcode.com/problems/ransom-note/description/?envType=study-plan-v2&envId=top-interview-150 +2. https://leetcode.com/problems/isomorphic-strings/description/?envType=study-plan-v2&envId=top-interview-150 +3. https://leetcode.com/problems/word-pattern/description/?envType=study-plan-v2&envId=top-interview-150 +4. https://leetcode.com/problems/valid-anagram/description/?envType=study +-plan-v2&envId=top-interview-150 + +""" + + +class Solution(object): + def canConstruct(self, ransomNote, magazine): + """ + :type ransomNote: str + :type magazine: str + :rtype: bool + + this solution on leetcode took: + 14 ms Beats 99.75% of users with Python + """ + ran_lett = set(ransomNote) + for letter in ran_lett: + if ransomNote.count(letter) > magazine.count(letter): + return False + return True + + def get_count_and_all_index(self, string, ch): + str_count = string.count(ch) + indx = [idx for idx, ltr in enumerate(string) if ltr == ch] + return str_count, indx + + def isIsomorphic(self, r, t): + """ + :type s: str + :type t: str + :rtype: bool + # TODO: Solution is having worst time complexity + """ + str_len = len(t) + while str_len > 0: + # for a, b in zip(r, t): + # r_count_indx = s.get_count_and_all_index(r, a) + # t_count_indx = s.get_count_and_all_index(t, b) + # if r_count_indx == t_count_indx: + # r = r.replace(a, "") + # t = t.replace(b, "") + # str_len -= r_count_indx[0] + # else: + # return False + for a, b in zip(r, t): + r_idx = [idx for idx, ltr in enumerate(r) if ltr == a] + t_idx = [idx for idx, ltr in enumerate(t) if ltr == b] + if r_idx == t_idx: + r = r.replace(a, "") + t = t.replace(b, "") + str_len -= len(r_idx) + else: + return False + return True + + def wordPattern(self, pattern, s): + """ + :type pattern: str + :type s: str + :rtype: bool + TODO: Sol failing for test case discuss with Abhi + test case: "aaa", "aa aa aa aa" + """ + dt = {} + for pt, ch in zip(pattern, s.split(" ")): + if pt not in dt and ch not in dt.values(): + dt[pt] = ch + elif (pt in dt and dt[pt] != ch) or ( + ch in dt.values() and pt not in dt): + return False + return True + + def isAnagram(self, s, t): + """ + :type s: str + :type t: str + :rtype: bool + """ + if len(s) != len(t): + return False + + # s = [*s] + # t = [*t] + # s.sort() + # t.sort() + # if s == t: + # return True + # else: + # return False + sd = {} + td = {} + for l, c in zip(s, t): + if l not in sd: + sd[l] = s.count(l) + if c not in td: + td[c] = t.count(c) + if sd == td: + return True + else: + return False + + def groupAnagrams(self, strs): + """ + :type strs: List[str] + :rtype: List[List[str]] + """ + groups = {} + if len(strs) == 1 or len(set(strs)) == 1: + return [strs] + + for ch in strs: + sw = ''.join(sorted(ch)) + if sw in groups: + groups[sw].append(ch) + else: + groups[sw] = ([ch]) + return groups.values() + + +so = Solution() +# print(so.canConstruct('aa', +# 'aab')) +# print(so.isIsomorphic("foo", "bar")) +# print(so.wordPattern("aaaa", "aa aa aa aa")) +# print(so.isAnagram("a", "ab")) +print(so.groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"])) diff --git a/HashMap/hashmap_s2.py b/HashMap/hashmap_s2.py new file mode 100644 index 0000000..20f12bf --- /dev/null +++ b/HashMap/hashmap_s2.py @@ -0,0 +1,80 @@ +""" +Leetcode top interview 150 +https://leetcode.com/studyplan/top-interview-150/ + +Problem links: +1. https://leetcode.com/problems/two-sum/description/?envType=study-plan-v2&envId=top-interview-150 +2. https://leetcode.com/problems/happy-number/description/?envType=study +-plan-v2&envId=top-interview-150 +3. https://leetcode.com/problems/contains-duplicate-ii/description/?envType=study-plan-v2&envId=top-interview-150 +4. https://leetcode.com/problems/longest-consecutive-sequence/description/?envType=study-plan-v2&envId=top-interview-150 +""" + + +class Solution(object): + def twoSum(self, nums, target): + """ + :type nums: List[int] + :type target: int + :rtype: List[int] + # TODO: Work on this + """ + pass + + def isHappy(self, n): + """ + :type n: int + :rtype: bool + # TODO: work on this + """ + pass + + def containsNearbyDuplicate(self, nums, k): + """ + :type nums: List[int] + :type k: int + :rtype: bool + #TODO: Solution exhausted time limit Work on it + """ + slow = 0 + fast = 1 + if len(nums) <= 1: + return False + + for i in range(len(nums) - 1): + nxt = i + 1 + while nxt < len(nums): + if nums[i] == nums[nxt] and abs(i - nxt) <= k: + return True + nxt += 1 + return False + + def longestConsecutive(self, nums): + """ + :type nums: List[int] + :rtype: int + # TODO: Invalid solution work on it + """ + cons = {} + if len(nums) == 0: + return 0 + elif len(nums) == 1: + return 1 + for i in range(len(nums) - 1): + for j in range(i + 1, len(nums)): + print(nums[i], nums[j]) + diff = abs(nums[i] - nums[j]) + if diff not in cons: + cons[diff] = {nums[i], nums[j]} + else: + cons[diff].update({nums[i], nums[j]}) + print(cons) + return len(max(cons.values(), key=len)) + + +so = Solution() +# print(so.twoSum([3, 2, 4], 6)) +# print(so.isHappy(19)) +# print(so.containsNearbyDuplicate([1, 0, 1, 1], 2)) +# print(so.longestConsecutive([100, 4, 200, 1, 3, 2])) +print(so.longestConsecutive([9, 1, 4, 7, 3, -1, 0, 5, 8, -1, 6])) diff --git a/TwoPointers/two_pointers_s1.py b/TwoPointers/two_pointers_s1.py new file mode 100644 index 0000000..f40227c --- /dev/null +++ b/TwoPointers/two_pointers_s1.py @@ -0,0 +1,93 @@ +""" +Leetcode top interview 150 +https://leetcode.com/studyplan/top-interview-150/ + +Problem links: +1. https://leetcode.com/problems/valid-palindrome/description/?envType=study-plan-v2&envId=top-interview-150 +2. https://leetcode.com/problems/is-subsequence/description/?envType=study-plan-v2&envId=top-interview-150 +""" + + +class Solution(object): + def isPalindrome(self, s): + """ + :type s: str + :rtype: bool + """ + letters = list(s.replace(" ", "")) + start = 0 + end = len(letters) - 1 + + while start < end: + if not letters[start].isalnum(): + letters.pop(start) + end = len(letters) - 1 + elif not letters[end].isalnum(): + letters.pop(end) + end -= 1 + elif (letters[start]).lower() != (letters[end]).lower(): + return False + else: + letters.pop(end) + letters.pop(start) + end = len(letters) - 1 + if len(letters) <= 1: + return True + + def isSubsequence(self, s, t): + """ + :type s: str + :type t: str + :rtype: bool + """ + # final = "".join(c for c in t if c in s) + # print(final) + # return s in final + # TODO not my solution + i, j = 0, 0 + + while i < len(s) and j < len(t): + print(i, j) + if s[i] == t[j]: + print(s[i], t[j]) + i += 1 + j += 1 + + return i == len(s) + + def threeSum(self, nums): + """ + :type nums: List[int] + :rtype: List[List[int]] + """ + # TODO: solution exceeds time limit work on it + result = [] + nums.sort() + slow = 0 + fast = 1 + if len(set(nums)) == 1 or len(nums) == 3: + if sum(nums[:3]) == 0: + return [nums[:3]] + else: + return result + + while slow < fast: + fast = slow + 1 + while fast < len(nums): + for i in range(fast + 1, len(nums)): + print(slow, fast, i) + tup = [nums[slow], nums[fast], nums[i]] + print(tup) + if sum(tup) == 0 and tup not in result: + result.append(tup) + fast += 1 + slow += 1 + return result + + +s = Solution() +# print(s.isPalindrome("a.")) +# print(s.isSubsequence(s="leeeeetcode", +# +# t="yyyyylyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyeyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyeyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyeyyyyyyeyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyeyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyeyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyytyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyycyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyoyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyydyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyeyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy")) +print(s.threeSum([1, -1, -1, 0]))