0036_valid-sudoku/README.md

@@ -1,49 +0,0 @@
-Determine if a `9 x 9` Sudoku board is valid. Only the filled cells need to be validated **according to the following rules**:
-
-1.  Each row must contain the digits `1-9` without repetition.
-2.  Each column must contain the digits `1-9` without repetition.
-3.  Each of the nine `3 x 3` sub-boxes of the grid must contain the digits `1-9` without repetition.
-
-**Note:**
-
-*   A Sudoku board (partially filled) could be valid but is not necessarily solvable.
-*   Only the filled cells need to be validated according to the mentioned rules.
-
-**Example 1:**
-
-![](https://upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Sudoku-by-L2G-20050714.svg/250px-Sudoku-by-L2G-20050714.svg.png)
-
-    Input: 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"]]
-    Output: true
-    
-
-**Example 2:**
-
-    Input: board = 
-    [["8","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"]]
-    Output: false
-    Explanation: Same as Example 1, except with the 5 in the top left corner being modified to 8. Since there are two 8's in the top left 3x3 sub-box, it is invalid.
-    
-
-**Constraints:**
-
-*   `board.length == 9`
-*   `board[i].length == 9`
-*   `board[i][j]` is a digit `1-9` or `'.'`.

0036_valid-sudoku/python3/solution.py

@@ -1,54 +0,0 @@
-class Solution:
-    def isValidSudoku(self, board: List[List[str]]) -> bool:
-        #
-        # NOTE: **READ THE PROBLEM DESCRIPTION ALWAYS!!**
-        #
-        # Even though it mentions Sudoku, it doesn't mean the
-        # rules are the same as the real world. Which is the case
-        # here — we need to only look at the filled cell and the rules
-        # provided.
-        
-        size = len(board)
-        
-        # 1. Check if rows and cols are valid
-        #
-        # We can iterate both rows and cols at the same time since
-        # the sudoku board has 9 rows and 9 cols
-        for i in range(size):
-            row = set()
-            col = set()
-            
-            for j in range(size):
-                # ith row check
-                if board[i][j] != '.':
-                    if board[i][j] in row:
-                        return False
-                    
-                    row.add(board[i][j])
-                
-                # ith col check
-                if board[j][i] != '.':
-                    if board[j][i] in col:
-                        return False
-                    
-                    col.add(board[j][i])
-        
-        # 2. Check if squares are valid
-        # 
-        # We can do normal row * col iteration and use `// 3` to figure
-        # out which square a cell belongs to
-        
-        squares = [[set(), set(), set()] for _ in range(3)]
-        for i in range(size):
-            for j in range(size):
-                cell = board[i][j]
-                if cell == '.':
-                    continue
-                
-                square = squares[i // 3][j // 3]
-                if cell in square:
-                    return False
-                
-                square.add(cell)
-        
-        return True

0049_group-anagrams/README.md

@@ -1,27 +0,0 @@
-Given an array of strings `strs`, group **the anagrams** together. You can return the answer in **any order**.
-
-An **Anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
-
-**Example 1:**
-
-    Input: strs = ["eat","tea","tan","ate","nat","bat"]
-    Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
-    
-
-**Example 2:**
-
-    Input: strs = [""]
-    Output: [[""]]
-    
-
-**Example 3:**
-
-    Input: strs = ["a"]
-    Output: [["a"]]
-    
-
-**Constraints:**
-
-*   `1 <= strs.length <= 104`
-*   `0 <= strs[i].length <= 100`
-*   `strs[i]` consists of lowercase English letters.

0049_group-anagrams/python3/naive.py

@@ -1,13 +0,0 @@
-# Time: O(N * MlogM) where N is len(strs) and M is num of chars in a string
-# Space: O(N)
-
-class Solution:
-    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
-        groups = {}
-        
-        for s in strs:
-            s_sorted = ''.join(sorted(s))
-            
-            groups[s_sorted] = groups.get(s_sorted, []) + [s]
-        
-        return list(groups.values())

0049_group-anagrams/python3/solution.py

@@ -1,24 +0,0 @@
-# Time: O(N · M)
-# Space: O(N)
-
-from collections import Counter, defaultdict
-
-class Solution:
-    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
-        # If key doesn't exist, creates empty list using `list`
-        # factory/ctor function
-        groups = defaultdict(list)
-        
-        for s in strs:
-            # Keep counter for num of times each letter appeared
-            counts = [0] * 26
-            
-            for c in s:
-                i = ord(c) - ord('a')
-                counts[i] += 1
-            
-            # Lists aren't hashable, so we need to convert the counts
-            # to tuple so that we can key them
-            groups[tuple(counts)].append(s)
-        
-        return list(groups.values())

0217_contains-duplicate/README.md

@@ -1,24 +0,0 @@
-Given an integer array `nums`, return `true` if any value appears **at least twice** in the array, and return `false` if every element is distinct.
-
-**Example 1:**
-
-    Input: nums = [1,2,3,1]
-    Output: true
-    
-
-**Example 2:**
-
-    Input: nums = [1,2,3,4]
-    Output: false
-    
-
-**Example 3:**
-
-    Input: nums = [1,1,1,3,3,4,3,2,4,2]
-    Output: true
-    
-
-**Constraints:**
-
-*   `1 <= nums.length <= 105`
-*   `-109 <= nums[i] <= 109`

0217_contains-duplicate/python3/solution.py

@@ -1,11 +0,0 @@
-class Solution:
-    def containsDuplicate(self, nums: List[int]) -> bool:
-        counts = {}
-        
-        for num in nums:
-            counts[num] = counts.get(num, 0) + 1
-            
-            if counts[num] > 1:
-                return True
-        
-        return False

0238_product-of-array-except-self/NOTES.md

@@ -1,8 +0,0 @@
-## What if we were allowed to use division?
-
-Well, one might think that you can then find product(nums) and divide by nums[i] in the loop. But the problem with this approach is when there are 0s in the array. That causes the entire product to become zero.
-
-So, we probably need to keep track of zero count and the first zero index.
-
-1. If there are >1 zeroes, then the result would be all zeroes so.
-2. If there's only 1 zero, then we need to keep product excluding the zero to be kept. Then fill the result with all zeroes except for the 0 element's index which would equal the product.

0238_product-of-array-except-self/README.md

@@ -1,25 +0,0 @@
-Given an integer array `nums`, return _an array_ `answer` _such that_ `answer[i]` _is equal to the product of all the elements of_ `nums` _except_ `nums[i]`.
-
-The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
-
-You must write an algorithm that runs in `O(n)` time and without using the division operation.
-
-**Example 1:**
-
-    Input: nums = [1,2,3,4]
-    Output: [24,12,8,6]
-    
-
-**Example 2:**
-
-    Input: nums = [-1,1,0,-3,3]
-    Output: [0,0,9,0,0]
-    
-
-**Constraints:**
-
-*   `2 <= nums.length <= 105`
-*   `-30 <= nums[i] <= 30`
-*   The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
-
-**Follow up:** Can you solve the problem in `O(1)` extra space complexity? (The output array **does not** count as extra space for space complexity analysis.)

0238_product-of-array-except-self/python3/solution.py

@@ -1,25 +0,0 @@
-from functools import reduce
-
-class Solution:
-    def productExceptSelf(self, nums: List[int]) -> List[int]:
-        # We can divide this problem by finding the prefix and
-        # postfix products of a given element and then multiplying
-        # them together
-        result = [0] * len(nums)
-        
-        # Find prefix products, i.e, for ith element, store
-        # product of 0 to a[i - 1]
-        prefix = 1
-        for i, num in enumerate(nums):
-            result[i] = prefix
-            prefix *= num
-        
-        # Find suffix products by iterating from the last, and
-        # combine them with prefix in the same step to reduce cost
-        suffix = 1
-        for i in range(len(nums) - 1, -1, -1):
-            result[i] *= suffix
-            suffix *= nums[i]
-        
-        return result
-            

0242_valid-anagram/README.md

@@ -1,22 +0,0 @@
-Given two strings `s` and `t`, return `true` _if_ `t` _is an anagram of_ `s`_, and_ `false` _otherwise_.
-
-An **Anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
-
-**Example 1:**
-
-    Input: s = "anagram", t = "nagaram"
-    Output: true
-    
-
-**Example 2:**
-
-    Input: s = "rat", t = "car"
-    Output: false
-    
-
-**Constraints:**
-
-*   `1 <= s.length, t.length <= 5 * 104`
-*   `s` and `t` consist of lowercase English letters.
-
-**Follow up:** What if the inputs contain Unicode characters? How would you adapt your solution to such a case?

0242_valid-anagram/python3/nlogn.py

@@ -1,13 +0,0 @@
-# Time: O(NlogN)
-# Space: O(1)
-
-from collections import Counter
-
-class Solution:
-    def isAnagram(self, s: str, t: str) -> bool:
-        slen, tlen = len(s), len(t)
-        
-        if slen != tlen:
-            return False
-        
-        return sorted(s) == sorted(t)

0242_valid-anagram/python3/oneliner.py

@@ -1,8 +0,0 @@
-# Time: O(N)
-# Space: O(N)
-
-from collections import Counter
-
-class Solution:
-    def isAnagram(self, s: str, t: str) -> bool:
-        return Counter(s) == Counter(t)

0242_valid-anagram/python3/solution.py

@@ -1,21 +0,0 @@
-# Time: O(N) where N is num of chars in string
-# Space: O(N) where N is num of chars in string
-
-from collections import Counter
-
-class Solution:
-    def isAnagram(self, s: str, t: str) -> bool:
-        slen, tlen = len(s), len(t)
-        
-        if slen != tlen:
-            return False
-        
-        scounts, tcounts = {}, {}
-        
-        for i in range(slen):
-            sc, tc = s[i], t[i]
-            
-            scounts[sc] = scounts.get(sc, 0) + 1
-            tcounts[tc] = tcounts.get(tc, 0) + 1
-            
-        return scounts == tcounts

0347_top-k-frequent-elements/python3/bucketsort.py

@@ -1,41 +0,0 @@
-class Solution:
-    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
-        '''
-        Approach using bucket sort
-        '''
-        
-        c = Counter(nums)
-        
-        # Idea here is that the list indices will represent
-        # the actual counts and we store elements matching thise
-        # counts under the index. If size n list is provided, max
-        # count possible is n but lists are 0-indexed so we set
-        # num_bucket to have n+1 size.
-        num_bucket = [[] for _ in range(len(nums) + 1)]
-        
-        # Later down, we will iterate in reverse through `num_bucket` and
-        # instead of iterating through the entire list, we can take note
-        # of the max count we observe and start from there instead.
-        max_count_seen = -1
-        
-        for num, count in c.items():
-            num_bucket[count].append(num)
-                
-            max_count_seen = max(max_count_seen, count)
-        
-        result = []
-        j = max_count_seen
-        
-        # Iterate reverse through num_bucket (note the max_count_seen
-        # optimization) and fill the result array until k elements are
-        # added
-        while j >= 0:
-            for num in num_bucket[j]:
-                result.append(num)
-                
-                # Possible that we filled k elements already in this inner
-                # loop, so get out
-                if len(result) == k:
-                    return result
-            
-            j -= 1

0347_top-k-frequent-elements/python3/solution.py

@@ -1,4 +1,3 @@
-from collections import Counter
 from heapq import heapify, heappop
 
 class Solution: