From fbe5378b0671fe40d04e6f70fc62bf2f651720e4 Mon Sep 17 00:00:00 2001 From: Megha Krishna <97619961+megkrish@users.noreply.github.com> Date: Thu, 14 Dec 2023 14:28:46 +0530 Subject: [PATCH 1/7] Array string questions 1, 2 --- array_string_s1.py | 104 +++++++++++++++++++++++++++++++++++++++++++++ array_string_s2.py | 80 ++++++++++++++++++++++++++++++++++ 2 files changed, 184 insertions(+) create mode 100644 array_string_s1.py create mode 100644 array_string_s2.py diff --git a/array_string_s1.py b/array_string_s1.py new file mode 100644 index 0000000..81dc5a6 --- /dev/null +++ b/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/array_string_s2.py b/array_string_s2.py new file mode 100644 index 0000000..cd22553 --- /dev/null +++ b/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] From 0ac735096351d8b84ee64ba2d76ac3c968cf2d5b Mon Sep 17 00:00:00 2001 From: Megha Krishna <97619961+megkrish@users.noreply.github.com> Date: Thu, 14 Dec 2023 14:41:56 +0530 Subject: [PATCH 2/7] Delete array_string_s1.py --- array_string_s1.py | 104 --------------------------------------------- 1 file changed, 104 deletions(-) delete mode 100644 array_string_s1.py diff --git a/array_string_s1.py b/array_string_s1.py deleted file mode 100644 index 81dc5a6..0000000 --- a/array_string_s1.py +++ /dev/null @@ -1,104 +0,0 @@ -""" -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]) From f86d7aae2198528bd509fb494d6fa36886bf5313 Mon Sep 17 00:00:00 2001 From: Megha Krishna <97619961+megkrish@users.noreply.github.com> Date: Thu, 14 Dec 2023 14:42:14 +0530 Subject: [PATCH 3/7] Delete array_string_s2.py --- array_string_s2.py | 80 ---------------------------------------------- 1 file changed, 80 deletions(-) delete mode 100644 array_string_s2.py diff --git a/array_string_s2.py b/array_string_s2.py deleted file mode 100644 index cd22553..0000000 --- a/array_string_s2.py +++ /dev/null @@ -1,80 +0,0 @@ -""" -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] From a9bf95e0a34cc12d66fd74615df94917538f975f Mon Sep 17 00:00:00 2001 From: Megha Krishna <97619961+megkrish@users.noreply.github.com> Date: Thu, 14 Dec 2023 14:43:30 +0530 Subject: [PATCH 4/7] Array String solution array string solution 1 and 2 --- ArrayString/array_string_s1.py | 104 +++++++++++++++++++++++++++++++++ ArrayString/array_string_s2.py | 80 +++++++++++++++++++++++++ 2 files changed, 184 insertions(+) create mode 100644 ArrayString/array_string_s1.py create mode 100644 ArrayString/array_string_s2.py 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] From 6489d58b8c39b0e45bc4d7a829fd892e94c8b986 Mon Sep 17 00:00:00 2001 From: Megha Krishna <97619961+megkrish@users.noreply.github.com> Date: Sun, 24 Dec 2023 21:34:29 +0530 Subject: [PATCH 5/7] Two pointers solution Two pointer solutions 1 --- TwoPointers/two_pointers_s1.py | 93 ++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 TwoPointers/two_pointers_s1.py 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])) From ed7eacb1998bf78c1f3b201743dceb0bdebb7b3a Mon Sep 17 00:00:00 2001 From: Megha Krishna <97619961+megkrish@users.noreply.github.com> Date: Sat, 30 Dec 2023 20:42:44 +0530 Subject: [PATCH 6/7] Hashmap solutions hashmap solution for s1 --- HashMap/hashmap_s1.py | 135 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 135 insertions(+) create mode 100644 HashMap/hashmap_s1.py 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"])) From 6c614c06c418b072bc9192aba30cd12ed1ac49d0 Mon Sep 17 00:00:00 2001 From: Megha Krishna <97619961+megkrish@users.noreply.github.com> Date: Wed, 3 Jan 2024 11:58:08 +0530 Subject: [PATCH 7/7] HashMap Solution HashMap solution for s2 --- HashMap/hashmap_s2.py | 80 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 HashMap/hashmap_s2.py 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]))