Trees- 104. Maximum Depth of Binary Tree

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        else:
            leftDepth = self.maxDepth(root.left)
            rightDepth = self.maxDepth(root.right)
            
            if leftDepth > rightDepth:
                return leftDepth + 1
            else:
                return rightDepth + 1

Sorting and Searching - 278. First Bad Version

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

# The isBadVersion API is already defined for you.
# def isBadVersion(version: int) -> bool:

class Solution:
    def firstBadVersion(self, n: int) -> int:
        low = 1
        high = n
        
        while low < high:
            mid = int((low+high)/2) 
            
            if isBadVersion(mid):
                high = mid
            else: 
                low = mid + 1
        return low
            
 
        

Others - 191. Number of 1 Bits

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================
class Solution:
    def hammingWeight(self, n: int) -> int:
        return bin(n).count('1')

Linked List - 237. Delete Node in a Linked List

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        node.val = node.next.val
        node.next = node.next.next

Sorting and Searching - 88. Merge Sorted Array

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        
        for i in range(n):
            nums1[i + m] = nums2[i]
        nums1.sort()

String - 14. Longest Common Prefix

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        min_elem = strs[0]

        for i in range(len(strs)):
            if len(min_elem) > len(strs[i]):
                min_elem = strs[i]

        #print(min_elem)

        for i in range(len(min_elem)):
            for j in range(len(strs)):
                if strs[j][i] != min_elem[i]:
                    return min_elem[:i]
            
        return min_elem

String - 28. Implement strStr()

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        h = len(haystack)
        n = len(needle)

        for i in range(h):
            if haystack[i:i+n]==needle:
                return i
        
        return -1

String - 8. String to Integer (atoi)

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

class Solution:
    def myAtoi(self, s: str) -> int:
        s = s.strip()
        if len(s) == 0: return 0
        res = 0
        sign = 1
        flag = 0

        if s[0] == '-':
            sign = -1
       
        for i in range(len(s)):
            if s[i].isnumeric():
                res = res*10+(ord(s[i])-ord('0'))
                flag = 1
            elif (s[i] == "+" or s[i] == "-") and (flag == 0):
                flag = 1
                pass
            else:
                break
        
        res = res*sign
        if res in range((-2**31), (2**31)-1):
            return res
        elif res<0: 
            return -2**31
        else: 
            return 2**31-1

String - 125. Valid Palindrome

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================
class Solution:
    def isPalindrome(self, s: str) -> bool:
        mod_string = ""
        for elem in s:
            if elem.isalnum():
                mod_string += elem

        if mod_string.lower() == mod_string.lower()[::-1]:
            return 1
        else:
            return 0

String - 242. Valid Anagram

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================
class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if len(s) != len(t):
            return 0
        else: 
            dict_ana = {}
            for val in s:
                if val in dict_ana:
                    dict_ana[val] += 1
                else:
                    dict_ana[val] = 1

        
            for val in t:
                if val in dict_ana:
                    dict_ana[val] -= 1

         
            if not any(dict_ana.values()):
                return 1
            else:
                return 0

String - 387. First Unique Character in a String

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================
class Solution:
    def firstUniqChar(self, s: str) -> int:
        
        save_idx = {}
        for val in s:
            if val in save_idx:
                save_idx[val] += 1
            else:
                save_idx[val] = 1

        for idx, val in enumerate(s):
            if save_idx[val] == 1:
                return idx
        return -1

String - 7. Reverse Integer

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================
class Solution:
    def reverse(self, x: int) -> int:
        x_str = str(x)

        if x_str[0] == '-':
            a = x_str[::-1]
            rev = int(x_str[0]+a[:-1])
        else:
            rev = int(x_str[::-1])
        
        if rev not in range((-1 << 31), (1 << 31) - 1):
            return 0
        else:
            return rev

String - 344. Reverse String

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================
class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        for i in range(len(s)):
            s.insert(i, s.pop())

Array - 48. Rotate Image

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================
class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        n = len(matrix)
        for row in range(n):
            for col in range(row+1, n):
                matrix[row][col], matrix[col][row] = matrix[col][row], matrix[row][col]
        
        for row in range(n):
            matrix[row].reverse()
            

        

Array - 36. Valid Sudoku

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:
        # 1. Each row must contain the digits 1-9 without repetition.

        # row
        for row in range(9):
            dig_arr = [0] * 10
            for col in range(9):
                if board[row][col].isdigit():
                    num = int(board[row][col])
                    if dig_arr[num] == 0:
                        dig_arr[num] = 1
                    else:
                        return 0

        # 2. Each column must contain the digits 1-9 without repetition.

        # column
        for col in range(9):
            dig_arr = [0] * 10
            for row in range(9):
                if board[row][col].isdigit():
                    num = int(board[row][col])
                    if dig_arr[num] == 0:
                        dig_arr[num] = 1
                    else:
                        return 0

        # 3. Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition. 

        # sub-boxes
        for row in range(0, 9, 3):
            for col in range(0, 9, 3):
                dig_arr = [0] * 10
                for i in range(row, row+3):
                    for j in range(col, col+3):
                        if board[i][j].isdigit():
                            num = int(board[i][j])
                            if dig_arr[num] == 0:
                                dig_arr[num] = 1
                            else:
                                return 0
        
        return 1

Array - 1. Two Sum

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

# Method - 1

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        dicts = {}
        for idx, n in enumerate(nums):
            x = target - n
            if x not in dicts:
                dicts[n] = idx
            else:
                return ([dicts[x], idx])

# Method - 2

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        original = nums.copy()
        nums.sort()
        i = 0
        j = len(nums)-1
        nums_i = 0
        nums_j = 0
        idx_i = 0
        idx_j = 0
        while i < j:
            if nums[i] + nums[j] == target:
                #return ([i, j])
                nums_i = nums[i]
                nums_j = nums[j]
                break
            elif nums[i] + nums[j] > target:
                j -= 1
            else: 
                i +=1
        
        for idx, n in enumerate(original):
            if n == nums_i:
                idx_i = idx
                break
        
        for idx, n in enumerate(original):
            if n == nums_j and idx != idx_i:
                idx_j = idx
                break
                
        return [idx_i, idx_j] 

            

Array - 350. Intersection of Two Arrays II

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

# Method - 1
class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        intersec = []

        i = 0
        j = 0

        nums1.sort()
        nums2.sort()

        while(i<len(nums1) and j<len(nums2)):
            if nums1[i] == nums2[j]:
                intersec.append(nums1[i])
                i += 1
                j += 1
            elif nums1[i] < nums2[j]:
                i += 1
            else:
                j += 1
        return intersec


# Method - 2
class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        intersec = []

        dict = {}
        for n in nums1:
            if n in dict:
                dict[n] += 1
            else: 
                dict[n] = 1
        # print(dict)
        for n in nums2:
            if n in dict and dict[n]>0:
                dict[n] -= 1
                intersec.append(n)

        return intersec

Array - 283. Move Zeroes

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        count = 0
        for i in range(len(nums)):
            if nums[i] != 0:
                nums[count] = nums[i]
                count +=1
        while count < len(nums):
            nums[count] = 0
            count+=1

Array - 66. Plus One

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================
class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        map_arr = int(''.join(map(str, digits)))+1
        string = ','.join(str(map_arr))
        res = [int(item) for item in string.split(',')]
        return res

Array - 136. Single Number

#===================================
# Tanzila Islam
# Email: tanzilamohita@gmail.com
# Language: Python 3
#===================================

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        if len(nums) == 1:
            return (nums[0])
        elif len(nums) != 0:
            res = 0
            for i in range(len(nums)):
                res ^= nums[i] 
        return res