Leetcode: Arrays Flashcards

Question

max consecutive ones Given a binary array nums, return the maximum number of consecutive 1's in the array. Example 1: Input: nums = [1,1,0,1,1,1] Output: 3 Explanation: The first two digits or the last three digits are consecutive 1s. The maximum number of consecutive 1s is 3.

Answer 1

I only included this bc the for loop does not work, what if the last 3 items are the max? we never get to check bc of the for loop, so after the loop we have to check again 1 final time time: O(n) space: constant class Solution: - ---def findMaxConsecutiveOnes(self, nums): - -------response, current = 0, 0 - -------for x in nums: - -----------if x == 1: - ---------------current += 1 - -----------else: - ---------------response = max(response, current) - ---------------current = 0 - --------------- - -------return max(response, current)

Answer 2

brute force is double for loop, you can also use binary search? what? 1. - ---def minSubArrayLen(self, target, nums): - -------if not nums: - -----------return 0 - -------if len(nums) == 1: - -----------if nums[0] == target: - ---------------return 1 - -----------else: - ---------------return 0 - ------- - -------left, right = 0, 1 - -------response = float("inf") - -------current = nums[0] - -------while left < len(nums): - -----------if current >= target: - ---------------response = min(response, right - left) - ---------------current -= nums[left] - ---------------left += 1 - -----------elif current < target and right < len(nums): - ---------------current += nums[right] - ---------------right += 1 - -----------else: #it is less than, but right is at the end - ---------------left += 1 - -------return response if response != float("inf") else 0 - ---def other(self, target, nums): - -------_sum = sum(nums) - -------if _sum < target: - -----------return 0 - -------if _sum == target: - -----------return len(nums) - -------l, r = 0, -1 - --- - -------length = len(nums) - -------_sum = 0 - -------while l < len(nums): - -----------if _sum < target and r + 1 < len(nums): - ---------------r += 1 - ---------------_sum += nums[r] - -----------else: - ---------------_sum -= nums [l] - ---------------l += 1 - -----------if _sum >= target: - ---------------length = min(r - l + 1, length) - -------return length

Answer 3

``` from collections import deque class Solution: ``` time: O(N), 2N bc we reverse the nums, then we reverse it again in parts space: constant - ---def reverse_parts(self, nums, k): - -------k = k % len(nums) - -------if k != 0: - -----------self.reverse(0, len(nums) - 1, nums) - -----------self.reverse(0, k - 1, nums) - -----------self.reverse(k, len(nums) - 1, nums) - --- - ---def reverse(self, left, right, nums): - -------while left < right: - -----------nums[left], nums[right] = nums[right], nums[left] - -----------left += 1 - -----------right -= 1 time: O(N), 3n bc we create a new array, loop through the range, then copy it into the original array space: O(N), N for new array - ---def brute_with_optimization(self, nums, k): - -------true_rotations = k % len(nums) - -------final = [0] * len(nums) - -------for i in range(len(nums)): - -----------final[(i + true_rotations) % len(nums)] = nums[i] - -------nums[:] = final

Answer 4

time: linear space: constant class Solution: - ---def removeDuplicates(self, nums): - -------if not nums: - -----------return 0 - ------- - -------cur = nums[0] - -------count = 1 - ------- - -------for i in range(1, len(nums)): - -----------if nums[i] != cur: - ---------------cur = nums[i] - ---------------nums[count] = nums[i] - ---------------count += 1 - -------return count

Answer 5

time: linear space: constant class Solution: - ---def removeDuplicates(self, nums): - -------if not nums: - -----------return 0 - ------- - -------cur = nums[0] - -------count = 1 - ------- - -------for i in range(1, len(nums)): - -----------if nums[i] != cur: - ---------------cur = nums[i] - ---------------nums[count] = nums[i] - ---------------count += 1 - -------return count

Answer 6

brute is when you iterate, make a swap index array with all the indexes and where you would swap them, then iterate through the array and swap those indexes. linear time and space 1. think quick sort, we have a low index (start) and we can do a 1 pass iteration that swaps values in the array effectively time: linear, 1 pass space: constant class Solution(object): - ---def answer(self, nums): - -------start = 0 - -------for i, x in enumerate(nums): - -----------if x != 0: - ---------------nums[start], nums[i] = nums[i], nums[start] - ---------------start += 1 - -------return nums time: linear, 1.5 passes space: constant - ---def answer2(self, nums): - -------start=0 - -------for i, x in enumerate(nums): - -----------if x!=0: - ---------------nums[start] = nums[i] - ---------------start += 1 - --------------- - -------for j in range(start, len(nums)): - -----------nums[j]=0

Answer 7

reverse the list, then at each space call a reverse function on the slice of the list, reverse(start, i) where start begins at 0, then increments to i+1, then after the loop we have to remember to reverse the last section bc the for-loop doesn't catch the last word time: O(n), 2N technically bc we loop twice space: constant class Solution: - ---def answer(self, input): - -------self.remove_trailing_leading_spaces(input) - -------self.remove_inside_spaces(input) - -------return self.reverse_words(input) - ---def remove_inside_spaces(self, input): - -------first_white_space = False - -------for i in range(len(input) -1, -1, -1): - -----------if input[i] == " ": - ---------------if first_white_space: - -------------------del input[i] - ---------------else: - -------------------first_white_space = True - -----------else: - ---------------first_white_space = False - ---def remove_trailing_leading_spaces(self, input): - -------while input[-1] == " ": - -----------input.pop() - -------input.reverse() - -------while input[-1] == " ": - -----------input.pop() - -------input.reverse() - --- - ---def reverse_words(self, input): - -------input = input[::-1] - -------start = 0 - -------in_word = False - -------for i in range(len(input)): - -----------if input[i] != " ": - ---------------if not in_word: - -------------------start = i - -------------------in_word = True - --------------- - -----------elif in_word: - ---------------self.reverse(start, i, input) - ---------------in_word = False - ------- - -------if in_word: - -----------self.reverse(start, len(input), input) - -------return input - --- - ---def reverse(self, start, stop, input): - -------stop -= 1 - -------while stop > start: - -----------input[start], input[stop] = input[stop], input[start] - -----------start += 1 - -----------stop -= 1

Answer 8

1. trick is dealing with the extra white space 2. pop white spaces off end, reverse it, do it again, then reverse it back to normal 3. you can delete items in an array safely if you iterate backward. Deleting index 5 in an array of length 6 is okay bc the next index is 4, so you wont get an out of index error time: O(n), we reverse the list twice, iterate to delete trailing white spaces, then iterate over the list and reverse the words in the list. O(4N + M) where M is the time to reverse just the words in the list space: constant! The more time is a huge tradeoff, you could just do it in N + M time where M is the length of the words and single white spaces by adding a response array, then appending the reversed words to that array instead of doing it in place. You will need to keep track of adding white spaces after each word and such, that is tricky class Solution: - ---def answer(self, input): - -------self.remove_trailing_leading_spaces(input) - -------self.remove_inside_spaces(input) - -------return self.reverse_words(input) - ---def remove_inside_spaces(self, input): - -------first_white_space = False - -------for i in range(len(input) -1, -1, -1): - -----------if input[i] == " ": - ---------------if first_white_space: - -------------------del input[i] - ---------------else: - -------------------first_white_space = True - -----------else: - ---------------first_white_space = False - ---def remove_trailing_leading_spaces(self, input): - -------while input[-1] == " ": - -----------input.pop() - -------input.reverse() - -------while input[-1] == " ": - -----------input.pop() - -------input.reverse() - --- - ---def reverse_words(self, input): - -------input = input[::-1] - -------start = 0 - -------in_word = False - -------for i in range(len(input)): - -----------if input[i] != " ": - ---------------if not in_word: - -------------------start = i - -------------------in_word = True - --------------- - -----------elif in_word: - ---------------self.reverse(start, i, input) - ---------------in_word = False - ------- - -------if in_word: - -----------self.reverse(start, len(input), input) - -------return input - --- - ---def reverse(self, start, stop, input): - -------stop -= 1 - -------while stop > start: - -----------input[start], input[stop] = input[stop], input[start] - -----------start += 1 - -----------stop -= 1

Answer 9

1. my custom solution works, we basically check if the next one up or down is the opposite, bc then we have found the first bad version! 1. for the custom, it is simple binary search, much like quick sort, you need to increment the partition one way or the other so you don't redo an index! to see why you return low, do a test case where we have .... good, bad..... and we get the last good index as low, or the first bad index as high. when we go through the binary search the last bad index as good makes mid the last good index, which will eventually return the first bad index. The vise-versa is true if we do the reverse time: Log(n) space: constant class Solution: - ---def firstBadVersion(self, n): - -------def isBadVersion(n): - -----------pass - -------low = 0 - -------high = n - -------while high >= low: - -----------mid = (low + high) // 2 - -----------if isBadVersion(mid): - ---------------if mid != 0: - -------------------if not isBadVersion(mid - 1): - -----------------------return mid - ---------------else: - -------------------return mid - ---------------high = mid - -----------else: - ---------------if mid != n: - -------------------if isBadVersion(mid + 1): - -----------------------return mid + 1 - ---------------else: - -------------------if isBadVersion(mid): - -----------------------return mid - ---------------low = mid - ---def optimized_binary_search(self, n): - -------def isBadVersion(n): - -----------pass - -------low = 0 - -------high = n - -------while high >= low: - -----------mid = (low + high) // 2 - -----------if isBadVersion(mid): - ---------------high = mid - 1 - -----------else: - ---------------low = mid + 1 - -------return low

Answer 10

time: O(nums1 + nums2), we convert them to sets which takes N time for each, then we find the intersection which takes min(n, m) time space: O(nums1 + nums2), the space for sets and response class Solution: - ---# interesction means common elements between the 2 - ---def intersection(self, nums1, nums2): - -------set1 = set(nums1) - -------set2 = set(nums2) - -------if len(set1) < len(set2): - -----------return [x for x in set1 if x in set2] - -------else: - -----------return [x for x in set2 if x in set1] - --- - ---def intersection(self, nums1, nums2): - -------set1 = set(nums1) - -------set2 = set(nums2) - ------- - -------return set1.intersection(set2)

Answer 11

time: O(n * log(n)), we go through each element and count their digits, counting digits takes log time space: constant class Solution: - ---def findNumbers(self, nums): - -------response = 0 - -------for x in nums: - -----------count = 0 - -----------while x > 0: - ---------------x //= 10 - ---------------count += 1 - -----------if count % 2 == 0: - ---------------response += 1 - ----------- - -------return response

Answer 12

1. think merge sort! time: O(n + m), we go through all items in both lists space: O(m ) bc we need to make a copy of nums1 class Solution: - ---def merge(self, nums1, m, nums2, n): - -------nums1_copy = nums1[:m + 1] - ------- - -------i = j = k = 0 - -------while i < m and j < n: - -----------if nums1_copy[i] < nums2[j]: - ---------------nums1[k] = nums1_copy[i] - ---------------i += 1 - -----------else: - ---------------nums1[k] = nums2[j] - ---------------j += 1 - -----------k += 1 - ------- - -------while i < m: - -----------nums1[k] = nums1_copy[i] - -----------k += 1 - -----------i += 1 - ------- - -------while j < n: - -----------nums1[k] = nums2[j] - -----------j += 1 - -----------k += 1

Answer 13

1. do it in 1 loop if you realize you can check if the double or the half exists. if the half exists (NOT FLOOR DIVISION, 3 AND 7 DO NOT WORK) time: O(n) space: o(n) class Solution: - ---def checkIfExist(self, arr): - -------doubles_set = set() - -------for i in range(len(arr)): - -----------double_key = 2 * arr[i] - -----------half_key = arr[i] / 2 - -----------if (double_key in doubles_set) or (half_key in doubles_set): - ---------------return True - -----------doubles_set.add(arr[i]) --------return False

Answer 14

while loop solution is tricky, I think my custom one makes most intuitive sense to me 1. needs to have gone up, and gone down. if it has gone up and transitioned to down it cannot go down again. Use booleans to make this reality 2. return down bc if up = true then down = true, down will be the boolean we can return. If it only goes up down will be false! time: O(n) space: O(1) class Solution: - ---def validMountainArray(self, arr): - -------if len(arr) < 3: - -----------return False - -------up = False - -------down = False - -------prev = arr[0] - -------for x in arr[1:]: - -----------if x > prev and not down: - ---------------up = True - -----------elif x < prev and up: - ---------------down = True - -----------else: - ---------------return False - -----------prev = x - -------return down - --------------- - --------------- - ---def while_loop(self, arr): - -------if len(arr) < 3: - -----------return False - -------start = 0 - ------- - -------while start < end - 1 and arr[start] < arr[start + 1]: - -----------start += 1 - ------- - -------if start == 0 or start == end - 1: - -----------return False - ------- - -------while start < end -1 and arr[start] > arr[start + 1]: - -----------start += 1 - ----------- - -------return start == end - 1

Answer 15

1. go backward! use max, replace it in-place time: O(n) space: o(1) ``` class Solution: ----def replaceElements(self, arr): --------_max = -1 --------for i in range(len(arr) - 1, -1, -1): #Note that if the values are very small negatives, they would be replaced with -1, is that what we want? unsure ------------arr[i], _max = _max, max(_max, arr[i]) --------return arr ```

Answer 16

1. two-pointer 2. when even == odd, we are done! time: O(n) space: O(1) class Solution: - ---def sortArrayByParity(self, nums): - -------even, odd = 0, len(nums) - 1 - -------while even < odd: - -----------if nums[even] % 2 != 0: - ---------------nums[even], nums[odd] = nums[odd], nums[even] - ---------------odd -= 1 - -----------else: - ---------------even += 1 - -------return nums

Answer 17

1. must be done in-place 2. make a stream with rules, kind of state-functiony 3. need to understand all edge cases, [0,0,0], [1,1,1, [0], [1], [1,0], [0,1] 4. we need to return 1, 3, 1, 1, 2, 2, respectively 5. understand regular case first [0, 1, 1, 0, 1, 1, 0, 1, 1, 1] 6. get a current/prev count, on a zero, calc max + 1, prev = current, current = 0 7. since we do a for loop, the last index isn't always triggered how we want, so must check if we have "swapped" 8. the swap boolean indicates how we calculate the final response. for 3 1's, we never swap, so the answer is just 3, the cur ones, but if we have swapped, it is prev + cur ones + 1 since there is a 0 in there somewhere that wants to be swapped time: O(n) space: O(1) class Solution: ----def findMaxConsecutiveOnes(self, nums): --------if len(nums) == 1 and nums[0] == 1: ------------return 1 --------prev_ones = 0 --------cur_ones = 0 --------response = 0 --------swapped = False --------for x in nums: ------------if x == 0: ----------------response = max(cur_ones + prev_ones + 1, response) ----------------prev_ones, cur_ones = cur_ones, 0 ----------------swapped = True ------------else: ----------------cur_ones += 1 -------- --------if swapped: ------------response = max(response, cur_ones + prev_ones + 1) --------else: ------------response = max(response, cur_ones) --------return response

Answer 18

1. dynamically build the max_set 2. each time we have more than 3 values, remove the smallest value 3. check if the max_set has less than 3 values, if it does we return the max (as per the problem statement) 4. else, return the smallest in the set! time: O(n) space: O(4), bc we never have more than 4 elements in the set, so it is constant class Solution: - ---def thirdMax(self, nums): - -------max_set = set() - -------for x in nums: - -----------max_set.add(x) - -----------if len(max_set) > 3: - ---------------max_set.remove(min(max_set)) - ------- - -------if len(max_set) < 3: - -----------return max(max_set) - -------else: - -----------return min(max_set)

Answer 19

brute force is to use N space. Make a hashmap on range 1, N inclusive, then loop again and check if they're in the set, if they are remove it. All leftovers are the response 1. since we know all the nums are in the range [1,n] inclusive, we can actually use that to constant time index this array and search for duplicates 2. [1, 1, 1], we get the num 1, then go to the index abs(num) - 1 = 0 (which is technically the index related to 1 based on the params [1,N] values), if it isn't negative, make it negative. 3. ABSOLUTE VALUE bc if you make it negative then go back to it later, you get a negative index!!! 4. loop again through the range of the list, if the arr[i] > 0, add i + 1 to response (dont forget it is i + 1, not just i) time: O(n), we do 2 loops space: O(1), no space except output class Solution: - ---def findDisappearedNumbers(self, nums): - -------for i in range(len(nums)): - -----------index = abs(nums[i]) - 1 - ----------- - -----------if nums[index] > 0: - ---------------nums[index] *= -1 - ----------- - -------response = [] - -------for i in range(len(nums)): - -----------if nums[i] > 0: - ---------------response.append(i + 1) - -------return response

Answer 20

1. it is sorted, we know the square of a number is always positive, so compare absolute values of left/right index, then add those into a response array respectively in reverse order time: O(n) space: O(1) if we do not include response array class Solution: - ---def brute(self, nums): - -------return sorted([x * x for x in nums]) - ---def sortedSquares(self, nums): - -------response = [0] * len(nums) - -------left, right = 0, len(nums) - 1 - -------for i in range(len(nums) - 1, -1, -1): - -----------if abs(nums[right]) >= abs(nums[left]): - ---------------current = nums[right] - ---------------right -= 1 - -----------else: - ---------------current = nums[left] - ---------------left += 1 - -----------response[i] = current * current - -------return response

Answer 21

brute force is linear time, just do a linear search and you can find it 1. sorted, so we can probably do binary search, we just need to find the inflection point 2. check if it has done a full rotation, if so return index 0, this allows us to do the custom binary search method 4. inflection point is when all values on left < mid and mid > all on right. At this point the return is mid + 1 time: O(log(n)), binary search space: O(1) class Solution: - ---def findMin(self, nums): - -------if nums[0] <= nums[-1]: - -----------return nums[0] - -------end = nums[-1] - -------right = len(nums) - 1 - -------left = 0 - ------- - -------while right >= left: - -----------mid = (right + left) // 2 - -----------if mid + 1 < len(nums) and nums[mid + 1] < nums[mid]: - ---------------return nums[mid + 1] - -----------if mid - 1 >= 0 and nums[mid - 1] > nums[mid]: - ---------------return nums[mid] - ----------- - -----------# elif nums[mid] >= nums[0]: - -----------#---- left = mid + 1 - -----------# else: - -----------#---- right = mid - 1 - -----------elif nums[mid] <= end: - ---------------right = mid - 1 - -----------else: - ---------------left = mid + 1

Answer 22

1. think 2 sum with sorted list! 2. iterate over the range, check if the value > 0, if so we're done bc all the values left are positive and can never sum to 0 3. check if index == 0 or the previous number != current, this checks to make sure we do not run duplicate 2 sums if there was an array that had [-1, -1, -1 or something 4. we could use a set and check if the num[i] value has been seen before, but that adds N space 5. do a standard 2 sum on each index, make sure low = i + 1, and while low < high since they cannot be equal indexes 6. when you find a valid value, you add it to a response list. If you sort it then add it to the response list as a set, it still works. This prevents duplicate answers of equal value being added. if not you need to do the while loop time: O(n^2), we iterate through the range and we sort the initial list, so n^2 +n log(n) space: O(n) bc python uses N space for sorted/sort. If we implemented QS it would be logN class Solution: - ---def threeSum_twoSum(self, nums): - -------# response = [] - -------response = set() - -------nums.sort() - -------for i in range(len(nums)): - -----------if nums[i] > 0: - ---------------break - -----------if i == 0 or nums[i] != nums[i - 1]: - ---------------self.two_sum(nums, response, i) - ----------- - -------return response - --- - ---def two_sum(self, nums, response, i): - -------low, high = i + 1, len(nums) - 1 - -------while low < high: - -----------_sum = nums[i] + nums[low] + nums[high] - -----------if _sum < 0: - ---------------low += 1 - -----------elif _sum > 0: - ---------------high -= 1 - -----------else: - ---------------li = [nums[i], nums[low], nums[high]] - ---------------response.add(tuple(sorted(li))) - ---------------low += 1 - ---------------high -= 1 - ---------------# response.append(li) - ---------------# low += 1 - ---------------# high -= 1 - ---------------''' - ---------------If you add a list instead of a set to response - ---------------you need to do this bc if you choose to use a list, there is a chance to add duplicates if you have [-1, -1, -1, 0, 1, 2] - ---------------you need to check backwards bc if you check forwards you can get a mistake with [-2,0,1,1,2], you get -2,0,2, but you - ---------------miss -2, 1, 1 since low == 2, high = 3, but low == low + 1 - ---------------''' - ---------------# while low < high and nums[low] == nums[low - 1]: - ---------------#---- low += 1 1. this is if we cannot sort the initial list or change it, and we don't want to make a copy of nums time: O(n^2) space: O(n) for the seen map - ---def threeSum_no_sort(self, nums): - -------response = set() - -------seen = {} - -------for i, val1 in enumerate(nums): - -----------for j, val2 in enumerate(nums[i + 1:], start = i + 1): - ---------------triplet_val = val1 + val2 - ---------------zero_compliment = -triplet_val - ---------------''' - ---------------[-1,0,1,2,-1,-4] - ---------------we need the seen[zero_compliment] == i check bc 2 is added to the seen map on a previous iteration - ---------------when we get to 2, -4, we have "seen" the zeros compliment 2 before, but it was on a previous iteration - ---------------that check helps us check against the previous iteration, this protects us against counting 1 values twice - ---------------''' - ---------------if zero_compliment in seen and seen[zero_compliment] == i: - -------------------''' - -------------------sorted returns a list, so we need to use tuple() to cast it to a tuple - -------------------bc lists are not hashable (they are mutable, all mutable items not hashable) - -------------------''' - -------------------response.add(tuple(sorted([val1, val2, zero_compliment]))) - ---------------seen[val2] = i - -------return response

Answer 23

1. two pointer! walk through the proble, you will find the answer! you do not need "smart next step calculations" outside of the current left/right 19, 600, 0, 0, 31, 19 if at 19/19 they are equal, and you go to 31 instead of 600, you only go off the min value, 19, then you would move left up 1 and youd be at the same spot as before 19, 600, 0, 500, 0, 19 if you default and move right down 1, youll get 0, then move down to 500, which will lead to go from 19 to 600 the thing that may not be obvious is when you increment left/right, you might think there is an edge case that if you don't increment properly it will fail. The good thing is bc it checks each iteration whether to go right or left, you will eventually get to the best area even if you just check the current level time: O(n), we iterate through the list once space: O(1), no extra space class Solution: - ---def maxArea(self, height): - -------max_area = 0 - -------left, right = 0, len(height) - 1 - -------while left < right: - -----------h_left, h_right = height[left], height[right] - -----------_min = min(h_left, h_right) - -----------max_area = max(max_area, _min * (right - left)) - -----------if h_left < h_right: - ---------------left += 1 - -----------else: - ---------------right -= 1 - -------return max_area

Answer 24

You can sort it or use a hashmap too as brute. 1. similar to find all dissapeared nums in array 2. use array itself to keep track of seen with indexing and negatives. 3. loop, if arr[num - 1] (0th index) is positive, make it negative, if it is negative we have seen it before so add the actual number (absolute value number, not anum bc you probably made it abs(num) -1), add it to response time: O(n), we do 1 loop, could be 3 if i did it my custom way space: constant class Solution: - ---def optimal(self, nums): - -------response = [] - -------for i, num in enumerate(nums): - -----------anum = abs(num) - 1 - -----------if nums[anum] > 0: - ---------------nums[anum] *= -1 - -----------else: - ---------------response.append(abs(num)) - -------return response - --- - ---def got_first_try(self, nums): - -------for i, num in enumerate(nums): - -----------anum = abs(num) - 1 - -----------if nums[anum] > 0: - ---------------nums[anum] *= -1 - ----------- - -------for i, num in enumerate(nums): - -----------anum = abs(num) - 1 - -----------nums[anum] *= -1 - ------- - -------return [i for i in range(1, len(nums) + 1) if nums[i - 1] < 0]

Answer 25

1. DON'T FORGET TO CHECK BASECASE (what is the base case you ask?? if new color == flood color!!!) 2. standard BFS solution with a queue. Queue can get as large as min(length, width), visualize a 2x100 and see it time: O(n), the entire matrix could be 1 color space: O(min(row, col)) ``` from collections import deque class Solution: ----def floodFill(self, image, sr: int, sc: int, newColor: int): --------deltas = [(-1, 0), (1, 0), (0, -1), (0, 1)] --------flood_color = image[sr][sc] -------- --------if flood_color == newColor: ------------return image -------- --------queue = deque() --------queue.append((sr, sc)) --------image[sr][sc] = newColor ``` - -------while queue: - -----------row, col = queue.popleft()---- - -----------for dr, dc in deltas: - ---------------new_row = row + dr - ---------------new_col = col + dc - ---------------if 0 <= new_row < len(image) and 0 <= new_col < len(image[0]): - -------------------if image[new_row][new_col] == flood_color: - -----------------------queue.append((new_row, new_col)) - -----------------------image[new_row][new_col] = newColor - ------------------- - -------return image

Leetcode: Arrays Flashcards

(49 cards)