From 0e3b3d2d1cb82e6dfcfe40c398b693d93163804e Mon Sep 17 00:00:00 2001 From: Himanshu Maurya Date: Mon, 11 Sep 2023 15:55:46 +0100 Subject: [PATCH] added more answeres --- content/posts/grind75.md | 274 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 257 insertions(+), 17 deletions(-) diff --git a/content/posts/grind75.md b/content/posts/grind75.md index 42d0d24..6d0edb6 100644 --- a/content/posts/grind75.md +++ b/content/posts/grind75.md @@ -1,19 +1,18 @@ --- title: "Grind 75 Questions" -date: 2023-09-11T23:29:21+08:00 +date: 2023-0911:29:21+08:00 draft: false ShowToc: true -category: [coding, interview prep] +category: [coding, interview] tags: ["coding", "grind75", "interview"] description: "Grind 75 Questions for Interview Prep" summary: "Grind 75 Questions for Interview Prep" --- - # Week1 -## 1. [Two Sum](https://leetcode.com/problems/two-sum) +## [Two Sum](https://leetcode.com/problems/two-sum) - Array @@ -120,7 +119,7 @@ class Solution(object): data[x] = i ``` -## 2. [Valid Parentheses](https://leetcode.com/problems/valid-parentheses) +## [Valid Parentheses](https://leetcode.com/problems/valid-parentheses) ### Problem @@ -193,7 +192,7 @@ class Solution(object): return True ``` -## 3. [Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists) +## [Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists) - Linked List @@ -281,7 +280,7 @@ class Solution(object): return start ``` -## 4. [Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock) +## [Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock) - Array @@ -349,7 +348,7 @@ class Solution(object): return max_profit ``` -## 5. [Valid Palindrome](https://leetcode.com/problems/valid-palindrome) +## [Valid Palindrome](https://leetcode.com/problems/valid-palindrome) ### Problem @@ -421,22 +420,263 @@ class Solution(object): return all (s[i] == s[-i-1] for i in range(len_s//2)) ``` -## 6. [Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree) +## [Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree) -## 7. [Valid Anagram](https://leetcode.com/problems/valid-anagram) +### Problem + +Given the `root` of a binary tree, invert the tree, and return *its root*. + +**Example 1:** + +![https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg](https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg) + +``` +Input: root = [4,2,7,1,3,6,9] +Output: [4,7,2,9,6,3,1] +``` + +**Example 2:** + +![https://assets.leetcode.com/uploads/2021/03/14/invert2-tree.jpg](https://assets.leetcode.com/uploads/2021/03/14/invert2-tree.jpg) + +``` +Input: root = [2,1,3] +Output: [2,3,1] + +``` + +**Example 3:** + +``` +Input: root = [] +Output: [] + +``` + +**Constraints:** + +- The number of nodes in the tree is in the range `[0, 100]`. +- `100 <= Node.val <= 100` + +### Solution + +```python +# 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 + +def build_binary_tree(root): + """ + create a binary tree from array + root: array + """ + tot_nodes = len(root) + tree_nodes = [] + for i in range(tot_nodes): + tree_nodes.append(TreeNode(val=root[i])) + + for i in range(tot_nodes//2): + tree_nodes[i].left = tree_nodes[i*2+1] + tree_nodes[i].right = tree_nodes[i*2+2] + + return tree_nodes[0] + +def traverse_binary_tree(root): + """ + Traverse a binary tree + root: TreeNode + """ + + bt_arr = [] + stack = [root] + while stack: + + node = stack.pop(0) + + bt_arr.append(node.val) + if node.left: + stack.append(node.left) + if node.right: + stack.append(node.right) + + return bt_arr + +class Solution(object): + + def invertTree(self, root): + """ + :type root: TreeNode + :rtype: TreeNode + """ + stack = [root] + while stack: + node = stack.pop(0) + if node: + if node.left: + stack.append(node.left) + if node.right: + stack.append(node.right) + + node.left, node.right = node.right, node.left + + return root +``` + +## [Valid Anagram](https://leetcode.com/problems/valid-anagram) + +### Problem + +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 vaoriginal 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 * 10^4` +- `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? + +### Solution + +```python +from collections import Counter +class Solution: + def isAnagram(self, s: str, t: str) -> bool: + count_s = Counter(s) + count_t = Counter(t) + + if len(count_s.keys()) != len(count_t.keys()): + return False + + for k, v in count_s.items(): + try: + if count_s[k] == count_t[k]: + continue + else: + return False + except KeyError as e: + return False + + return True +``` + +## [Binary Search](https://leetcode.com/problems/binary-search) + +### Problem + +Given an array of integers `nums` which is sorted in ascending order, and an integer `target`, write a function to search `target` in `nums`. If `target` exists, then return its index. Otherwise, return `-1`. + +You must write an algorithm with `O(log n)` runtime complexity. + +**Example 1:** + +``` +Input: nums = [-1,0,3,5,9,12], target = 9 +Output: 4 +Explanation: 9 exists in nums and its index is 4 +``` + +**Example 2:** + +``` +Input: nums = [-1,0,3,5,9,12], target = 2 +Output: -1 +Explanation: 2 does not exist in nums so return -1 +``` + +**Constraints:** + +- `1 <= nums.length <= 10^4` +- `-10^4 < nums[i], target < 10^4` +- All the integers in `nums` are **unique**. +- `nums` is sorted in ascending order. + +### Solution + +```python +from typing import List + +class Solution: + def search(self, nums: List[int], target: int) -> int: + # O(log(N)) solution + start, end = 0, len(nums)-1 + while start <= end: + # this prevents memory issues if numbers are too big + mid = start + (end-start)//2 + + if target == nums[mid]: + return mid + + elif target <= nums[mid]: + end = mid-1 + else: + start = mid+1 + return -1 +``` + +## [Flood Fill](https://leetcode.com/problems/flood-fill) + +An image is represented by an `m x n` integer grid `image` where `image[i][j]` represents the pixel value of the image. -## 8. [Binary Search](https://leetcode.com/problems/binary-search) +You are also given three integers `sr`, `sc`, and `color`. You should perform a **flood fill** on the image starting from the pixel `image[sr][sc]`. + +To perform a **flood fill**, consider the starting pixel, plus any pixels connected **4-directionally** to the starting pixel of the same color as the starting pixel, plus any pixels connected **4-directionally** to those pixels (also with the same color), and so on. Replace the color of all of the aforementioned pixels with `color`. + +Return *the modified image after performing the flood fill*. + +![https://assets.leetcode.com/uploads/2021/06/01/flood1-grid.jpg](https://assets.leetcode.com/uploads/2021/06/01/flood1-grid.jpg) + +``` +Input: image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, color = 2 +Output: [[2,2,2],[2,2,0],[2,0,1]] +Explanation: From the center of the image with position (sr, sc) = (1, 1) (i.e., the red pixel), all pixels connected by a path of the same color as the starting pixel (i.e., the blue pixels) are colored with the new color. +Note the bottom corner is not colored 2, because it is not 4-directionally connected to the starting pixel. + +``` + +**Example 2:** + +``` +Input: image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, color = 0 +Output: [[0,0,0],[0,0,0]] +Explanation: The starting pixel is already colored 0, so no changes are made to the image. +``` + +**Constraints:** -## 9. [Flood Fill](https://leetcode.com/problems/flood-fill) +- `m == image.length` +- `n == image[i].length` +- `1 <= m, n <= 50` +- `0 <= image[i][j], color < 2^16` +- `0 <= sr < m` +- `0 <= sc < n` -## 10. [Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree) +## [Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree) -## 11. [Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree) +## [Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree) -## 12. [Linked List Cycle](https://leetcode.com/problems/linked-list-cycle) +## [Linked List Cycle](https://leetcode.com/problems/linked-list-cycle) -## 13. [Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks) +## [Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks) # References -[Grind 75 - A better Blind 75 you can customize, by the author of Blind 75](https://www.techinterviewhandbook.org/grind75) \ No newline at end of file +1. [Grind 75 - A better Blind 75 you can customize, by the author of Blind 75](https://www.techinterviewhandbook.org/grind75) \ No newline at end of file