Given an integer array called nums and an integer called target, return the number of triplets that exist in the array such that nums[i] + nums[j] + nums[k] &lt; target where 0 &lt;= i &lt; j &lt; k &lt; len(nums).
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: nums = <code>[-2,0,1,3]</code>, target = 2 Output: 2 Explanation:&nbsp;These are the two triplets that are less than 2: &nbsp; [-2,0,1] [-2,0,3]</pre>
&nbsp;

Triplet Sum

Given an array <code>nums</code> of n integers, are there elements a, b, c in <code>nums</code> such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
Given an array of integers, return the index of all 3 distinct elements: x, y, z such that x + y + z = 0. Don't return duplicates.
&nbsp;
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Given nums = [-1, 0, 1, 2, -1, -4],
</pre>

<pre style="white-space: pre-wrap; word-break: keep-all;">
A solution set is:
[
 [-1, 0, 1],
 [-1, -1, 2]
]
</pre>

3sum

An array that is zero-indexed has length N and it contains integers from 0 to N-1. Return the longest length of a set S such that S[i] =&nbsp;{A[i], A[A[i]], A[A[A[i]]], ... } and the first element of S starts with a selection of element A[i] of index i, then the following element in S is A[A[i]] then&nbsp;A[A[A[i]]]&hellip; We stop adding to the set as soon as we get a duplicate value.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: A = [5,4,0,3,1,6,2]
Output: 4
Explanation: 
A[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A[4] = 1, A[5] = 6, A[6] = 2.

One of the longest S[K]:
S[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}
</pre>
&nbsp;

Nested Arrays

Given a list of integers where the number of integers is 2n, group&nbsp;the integers in pairs such that the sum of each pair is as large as possible. Return the largest sum.
Your grouping would look like this:&nbsp;(a1, b1), (a2, b2), ..., (an, bn) which results in the sum of each min(ai, bi) to be the largest possible integer.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,4,3,2]

Output: 4
 Explanation: We are given 2n integers so n is 2. The maximum sum of pairs is 4 = min(1, 2) + min(3, 4).
</pre>

Split Array I

You have an array, <code>prices</code>, in which the ith element represents the price of stock on day i. 

Find the maximum profit with instructions below: 

<ul>
	<li> You can complete as many transactions as needed. </li>
	<li> You must always sell the stock before you can buy again. You cannot engage in multiple transactions at the same time.
</ul>

Example 1:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: [5,2,4,3,10,2]
Output: 9
Explanation: Buy on day 1 (price 2), and sell on day 2 (price 4).
&nbsp; Then buy on day 3 (price 3), and sell on day 4 (price 10). 
&nbsp; maximum profit = (4 - 2) + (10 - 3) = 9.
</pre>

 

Example 2:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: [10,9, 8, 7]
Output: 0
Explanation: No transaction is done. maximum profit = 0.</pre>

Maximize Profits In The Stock Market II

You have an array, <code>prices</code>, in which the ith element represents the price of stock on day i. 

Find the maximum profit with instructions below: 

<ul>
	<li> You can complete at most two transactions . </li>
	<li> You must always sell the stock before you can buy again. You cannot engage in multiple transactions at the same time.
</ul>

Example 1:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: [1,4,2,1,4,6,10]
Output: 12
Explanation: Buy on day 0 (price 1), and sell on day 1 (price 4).
&nbsp; Then buy on day 3 (price 1), and sell on day 6 (price 10). 
&nbsp; maximum profit = (4 - 1) + (10 - 1) = 12.
</pre>

 

Example 2:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: [0,1,1,1,10]
Output: 10
Explanation: Buy on day 1 (price 0), and sell on day 4 (price 10).
&nbsp; Note that you cannot engage in multiple transactions at the same time.
&nbsp; maximum profit = 10 - 0 = 10.
</pre>

 

Example 3:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: [10,9, 8, 7]
Output: 0
Explanation: No transaction is done. maximum profit = 0.
</pre>

Maximize Profits In The Stock Market III

You have an array, <code>prices</code>, in which the ith element represents the price of stock on day i. 

Find the maximum profit if you can perform at most one transaction and you must buy the stock before selling.


Example 1:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: [8,1,4,2,8,9]
Output: 8
Explanation: Buy on day 1 (price 1), and sell on day 5 (price 9). maximum profit = 9 - 1 = 8.
</pre>

 

Example 2:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: [10,9, 8, 7]
Output: 0
Explanation: No transaction is done. maximum profit = 0.
</pre>

Maximize Profits In The Stock Market

&nbsp;
You are given an array of non-negative integers and each integer represents the height of vertical lines on the x-axis, at the corresponding index number. Find the maximum area of water that any given two vertical lines can hold.&nbsp;
&nbsp;
Note: There are at least two vertical lines&nbsp;
&nbsp;
<img style="width: 600px; height: 287px;" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/07/17/question_11.jpg" alt="" />
The above graph represents the array&nbsp;[1,8,6,2,5,4,8,3,7]. In this case, the blue area represents the maximum area of water, which is 49.&nbsp;
&nbsp;
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,8,6,2,5,4,8,3,7]
Output: 49 Input: [3,5,3,2,1,9,3,8] Output: 30</pre>

Largest Container With Water

The Fibonacci numbers are commonly represented as F(N) and they form a sequence such that each number is the sum of the two preceding ones, starting with&nbsp;<code>0</code> and <code>1</code>.
For example:
<pre style="white-space: pre-wrap; word-break: keep-all;">F(0) = 0,&nbsp; &nbsp;F(1)&nbsp;= 1
F(N) = F(N - 1) + F(N - 2), for N &gt; 1.
</pre>
&nbsp;
Given <code>N</code>, return&nbsp;<code>F(N)</code>.
&nbsp;
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 2
Output: 1
Explanation: F(2) = F(1) + F(0) = 1 + 0 = 1.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 3
Output: 2
Explanation: F(3) = F(2) + F(1) = 1 + 1 = 2.
</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 4
Output: 3
Explanation: F(4) = F(3) + F(2) = 2 + 1 = 3.
</pre>
&nbsp;

Fibonacci

You have an array sorted in ascending order but it is rotated at a certain pivot point that is unknown to you. Return the minimum element in the array. No duplicates exist in the array.
(i.e., &nbsp;<code>[0,1,2,4,5,6,7]</code>&nbsp;becomes&nbsp;&nbsp;<code>[4,5,6,7,0,1,2]</code>).
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [3,4,5,1,2] 
Output: 1
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [4,5,6,7,0,1,2]
Output: 0
</pre>

Identify Smallest In Modified Sorted Array

Given an array of integers, return the index such that the sum of the integers on the left is equal to the sum of the integers on the right. If no index exists, return -1. If there are multiple indexes that exist, return the left-most one.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
nums = [1, 7, 3, 6, 5, 6]
Output: 3
Explanation: 
The sum of the integers on the left of index 3 is equal to the sum of integers on the right of index 3.
</pre>
&nbsp;
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
nums = [1, 2, 3]
Output: -1
Explanation: 
No index exists that can satisfy the problem statement.</pre>
&nbsp;
Note:
<ul>
<li>The size of the given array is in the&nbsp;range <code>[0, 10000]</code>.</li>
<li>Each integer element in the array is in the range&nbsp;<code>[-1000, 1000]</code>.</li>
</ul>
&nbsp;

Find Pivot Index

You are given an array of integers and are asked to find and return the duplicate number in the array. Only one number is repeated in the array.
Note:
Your solution must have a complexity that's less than O(n2). Your solution's space complexity should be constant O(1). You are not allowed to modify the input array. Only one value is repeated in the input array but it can be repeated multiple times.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>[1,3,4,2,2]</code> Output: 2</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [3,1,3,4,2]
Output: 3</pre>
&nbsp;

Identify Repeated Number

Given an unsorted array of integers, return the lowest missing positive integer.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,2,0]
Output: 3
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [3,4,-1,1]
Output: 2
</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [7,8,9,11,12]
Output: 1
</pre>
Constraint:
Your solution should run in O(n) time and only use O(1) space.

Lowest Missing Positive Integer

Given a string of '0's and '1's we can flip '0' to a '1' or flip '1' to a '0', return the minimum number of flips to make the string monotone increasing.&nbsp;
A string is monotone increasing if it consists of zero or more number of '0's followed by zero or more number of '1's.
<div>
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "00110"
Output: 1
Explanation: We flip the last 0 to get 00111.
</pre>
<div>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "010110"
Output: 2
Explanation: We flip the right two most 0's 011111, or alternatively flip the first 1 to 0 and flip the last 0 to a 1 to get 000111.
</pre>
<div>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "00011000"
Output: 2
Explanation: We flip the 2 1's to get 00000000.
</pre>
</div>
</div>
</div>

Monotone Increasing String

Given an array of integers and an integer k, return the number of unique pairs such that their absolute difference is k.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [3, 1, 4, 1, 5], k = 2
Output: 2
Explanation: The 2 k difference pairs are: (1, 3) and (3, 5). The pair (1, 3) is used twice but we don't count it twice since we are only counting unique pairs.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:[1, 2, 3, 4, 5], k = 1
Output: 4
Explanation: There are 4 k-difference pairs in the array, (1, 2), (2, 3), (3, 4) and (4, 5).
</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1, 3, 1, 5, 4], k = 0
Output: 1
Explanation: There is only 1 k-difference pair in the array, (1, 1).
</pre>
Assume:
<ol>
<li>The pairs (i, j) and (j, i) are counted as one pair.</li>
<li>The length of the array is less than 10,000.</li>
</ol>

K Difference Pairs

Given an image that consists of black and white pixels, return the number of black single pixels.
An image is represented as a 2D char array that consists of 'B' and 'W' representing black and white pixels respectively. A black single pixel is a character 'B' where the same row and column doesn't contain any black pixels.
&nbsp;
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
[['W', 'W', 'B'],
 ['W', 'B', 'W'],
 ['B', 'W', 'W']]

Output: 3
Explanation: All the 'B's are black single pixels.
</pre>
&nbsp;

Single Pixel I

Given an image consisting of black and white pixels, and a positive integer N, return the total number of black pixels at a specific row R and column C that follow these rules:
<ol>
<li>Row R and column C should both have exactly N black pixels.</li>
<li>For every row that has a black pixel at column C, they should be exactly the same as row R</li>
</ol>
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
[['W', 'B', 'W', 'B', 'B', 'W'], 
 ['W', 'B', 'W', 'B', 'B', 'W'], 
 ['W', 'B', 'W', 'B', 'B', 'W'], 
 ['W', 'W', 'B', 'W', 'B', 'W']] 

N = 3
Output: 6
Explanation: All the bolded black pixels follow the rules.
 0 1 2 3 4 5 column index 
0 [['W', 'B', 'W', 'B', 'B', 'W'], 
1 ['W', 'B', 'W', 'B', 'B', 'W'], 
2 ['W', 'B', 'W', 'B', 'B', 'W'], 
3 ['W', 'W', 'B', 'W', 'B', 'W']] 
row index


Take 'B' at row R = 0 and column C = 1 as an example:
Rule 1, row R = 0 and column C = 1 both have exactly N = 3 black pixels. 
Rule 2, the rows that have black pixels at column C = 1 are rows 0, 1 and 2. They are exactly the same as row R = 0.

</pre>
&nbsp;

Single Pixel II

Given an array of integers that isn't sorted, return the length of the maximum consecutive sequence of elements.
Your solution should run in O(n) time complexity.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:&nbsp;[100, 4, 200, 1, 3, 2]
Output: 4
Explanation: The longest consecutive sequence of elements is <code>[1, 2, 3, 4]</code>. Therefore its output is 4.</pre>

Maximum Sequence Of Consecutive Numbers

Given an integer array that is unsorted, return the length of the longest increasing subarray.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,3,5,4,7]
Output: 3
Explanation: The longest increasing subarray is [1,3,5], its length is 3. 
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [2,2,2,2,2]
Output: 1
Explanation: The longest increasing subarray is [2], its length is 1. 
</pre>
Constrains: The length of the array won't exceed 10,000.

Largest Increasing Subsequence

Given a matrix M consisting of only 0's and 1s, return the longest line of consecutive ones in the matrix. The line can be horizontal, vertical, diagonal or anti-diagonal.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
[[0,1,1,0],
 [0,1,1,0],
 [0,0,0,1]]
Output: 3
</pre>
&nbsp;

Longest Line In Matrix

Given an array that contains n number of elements, return the element that occurs the majority of the time. A majority means the element needs to appear strictly more than n/2 number of times.
Assume the majority element always exists in the given array.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [3,2,3]
Output: 3</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [2,2,1,1,1,2,2]
Output: 2
</pre>

Majority In Array

Given an array of size n such that the array is a permutation of [0, 1, ..., n - 1], split up the array into partitions, then individually sort each partition. After concatenating all the partitions the result should be the sorted array. Return the maximum number of partitions that we can make.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: arr = [4,3,2,1,0]
Output: 1
Explanation:
We can never split the array into 2 or more partitions because there is no possibility of concatenating them to create a sorted array.
For example, partitioning the array into [4, 3], [2, 1, 0] will result in [3, 4, 0, 1, 2], which isn't sorted.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: arr = [1,0,2,3,4]
Output: 4
Explanation:
One possiblity of splitting the array is to split it into two partitions, such as [1, 0], [2, 3, 4].
However, splitting into [1, 0], [2], [3], [4] will result in the most number of partitions.
</pre>
&nbsp;

Chunk Up Sorted

Given m number of arrays with each array sorted in ascending order, choose up to 2 integers from 2 different arrays and calculate the absolute difference. Return the maximum difference between the 2 integers from the 2 different arrays.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
[[1,2,3],
 [4,5],
 [1,2,3]]
Output: 4
Explanation: 
The maximum distance is 4. Choose 1 in the first or third array and choose 5 in the second array.
</pre>
Note:
<ol>
<li>Assume each array will have at least 1 number. There will always be at least two non-empty arrays.</li>
<li>The number of integers in all the <code>m</code> arrays will be in range[2, 10000].</li>
<li>The integers in the <code>m</code> arrays will be in range[-10000, 10000].</li>
</ol>

Maximum Absolute Difference In Arrays

Given an integer array, find three numbers whose product is maximum and output the maximum product.
Given an array of integers, return the maximum product between any 3 numbers in the array.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,2,3]
Output: 6
</pre>
&nbsp;
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,2,3,4]
Output: 24
</pre>
&nbsp;
Constraints:
<ol>
<li>The size of the given array is in range [3,104] and each element is in the range [-1000, 1000].</li>
<li>Multiplying any three numbers in the given array will not exceed the range of a 32-bit signed integer.</li>
</ol>
&nbsp;

Max Product Of Three

Given an array of integers <code>nums</code>, find the largest sum of contiguous subarray that has at least one integer. 

Example 1:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: [-3,3,-1,7,-10,5]
Output: 9
Explanation:&nbsp;[3,-1,7] has the largest sum = 9.
</pre>

 

Example 2:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: [4,3,2,0,10]
Output: 19
Explanation:&nbsp;[4,3,2,0,10] has the largest sum = 19.
</pre>

 

Next Step:

Can you solve it in O(n)?

Largest Sum Of Subarray

Given a positive integer, you can swap any two digits at most once to make a maximum valued number. Return the maximum number you can create.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 2736
Output: 7236
Explanation: Swap digits 2 and 7.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 9973
Output: 9973
Explanation: No swap.
 </pre>

Largest Swap Number

Given an array of intervals, combine all intervals that are overlapping.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Merge the intervals: [1,3] and [2,6] into [1,6].
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [[1,4],[4,5]]
Output: [[1,5]]
Explanation: Intervals [1,4] and [4,5] overlap so merge them into [1,5].</pre>

Combine Intervals

You are given an array of integers and the <code>i</code>-th number represents the cost required to climb one or two steps. Return the minimum cost required to travel to the top.&nbsp;
You may start at index 0 or 1.&nbsp;
&nbsp;
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: cost = [2, 3, 4]
Output: 3
Explanation: Cheapest is start on cost[1] and go to the top
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: cost = [2,10,3,5,2,55,2]
Output: 9
Explanation: Cheapest is start on cost[0], and go to cost[2], cost[4], and cost[6]
</pre>
Note:
<ol>
<li>All the integers are in the&nbsp;range <code>[0, 999]</code>.</li>
</ol>

Lowest Cost To Climb Stairs

Given an array that consists of n distinct integers taken from [0, 1, ..., n] with one value missing, return the missing integer from the array.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [3,0,1]
Output: 2
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [9,6,4,2,3,5,7,0,1]
Output: 8
</pre>
Challenge: Implement your solution in O(n) time complexity and O(1) space complexity.

Absent Integer

Given an integer array that is sorted, a lower bound integer and an upper bound integer, return all the missing ranges in the array between the lower and upper bounds.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: nums = <code>[0, 1, 3, 50, 75]</code>, lower = 0 and upper = 99, Output: <code>["2", "4-&gt;49", "51-&gt;74", "76-&gt;99"]</code></pre>

Absent Ranges

Given an array, split it up into 2 contiguous subarrays called left and right such that:
1. All elements in left are less than or equal to all elements in right.
2. left and right cannot be empty
3. The overall number of elements in left is at a minimum.
Return the length of left after splitting up the array. You are guaranteed to have a solution every time.&nbsp;
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [5,0,3,8,6]
Output: 3
Explanation: left = [5,0,3], right = [8,6]
</pre>
<div>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,1,1,0,6,12]
Output: 4
Explanation: left = [1,1,1,0], right = [6,12]
</pre>
</div>
<div>
<div>&nbsp;</div>
</div>

Disjoint Interval Partitioning

You are given an elevation map, <code>heights[i]</code>, which represents the height of the terrain at index <code>i</code>. After <code>V</code> units of water droplets fall at index <code>K</code>, determine the accumulated height at each index.



Water always drops at index <code>K</code> and can either rest on the terrain or water at that index. Then, water droplets flow according to the following rules:
<li>If the droplet eventually falls by moving left, then move left.</li>
<li>If the droplet eventually falls by moving right, then move right.</li>
<li>Otherwise, rest at its current position.</li>
"Eventually fall" means that the droplet will eventually be at a lower level if it moves in that direction.
Also, "level" means the height of the terrain plus any water in that column.



Assume that water cannot move beyond the bounds of the array. Each unit of water has to be in exactly one block. 


Example 1: 
<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: heights = [2,1,1,2,1,2,2], V = 4, K = 3
Output: [2,2,2,3,2,2,2]
Explanation:
# #
# #
## # ###
#########
 0123456 <- index

</pre>

<pre style="white-space: pre-wrap; word-break: keep-all;">
The first drop of water lands at index K = 3:

# #
# w #
## # ###
#########
 0123456 

</pre>

When moving left or right, the water can only move to the same level or a lower level.
(By level, we mean the total height of the terrain plus any water in that column.)
Since moving left will eventually make it fall, it moves left.
(A droplet "made to fall" means go to a lower height than it was at previously.)

<pre style="white-space: pre-wrap; word-break: keep-all;">
# #
# #
## w# ###
#########
 0123456 
</pre>

Since moving left will not make it fall, it stays in place. The next droplet falls:

<pre style="white-space: pre-wrap; word-break: keep-all;">
# #
# w #
## w# ###
#########
 0123456 
</pre>

Since the new droplet moving left will eventually make it fall, it moves left.
Notice that the droplet still preferred to move left,
even though it could move right (and moving right makes it fall quicker.)

<pre style="white-space: pre-wrap; word-break: keep-all;">
# #
# w #
## w# ###
#########
 0123456 
</pre>

<pre style="white-space: pre-wrap; word-break: keep-all;">
# #
# #
##ww# ###
#########
 0123456 
</pre>

After those steps, the third droplet falls.
Since moving left would not eventually make it fall, it tries to move right.
Since moving right would eventually make it fall, it moves right.

<pre style="white-space: pre-wrap; word-break: keep-all;">
# #
# w #
##ww# ###
#########
 0123456 
</pre>

<pre style="white-space: pre-wrap; word-break: keep-all;">
# #
# #
##ww#w###
#########
 0123456 
</pre>

Finally, the fourth droplet falls.
Since moving left would not eventually make it fall, it tries to move right.
Since moving right would not eventually make it fall, it stays in place:

<pre style="white-space: pre-wrap; word-break: keep-all;">
# #
# w #
##ww#w###
#########
 0123456 

The final answer is [2,2,2,3,2,2,2]:
</pre>

<pre style="white-space: pre-wrap; word-break: keep-all;">
 # 
 ####### 
 ####### 
 0123456 
</pre>


Example 2: 
<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: heights = [1,2,3,4], V = 2, K = 2
Output: [2,3,3,4]
Explanation:
The last droplet settles at index 1, since moving further left would not cause it to eventually fall to a lower height.
</pre>


Example 3: 
<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: heights = [3,1,3], V = 5, K = 1
Output: [4,4,4]
</pre>


Note: <ol>
<li><code>heights</code> will have length in <code>[1, 100]</code> and contain integers in <code>[0, 99]</code>.</li>
<li><code>V</code> will be in range <code>[0, 2000]</code>.</li>
<li><code>K</code> will be in range <code>[0, heights.length - 1]</code>.</li>
</ol>

Pour Water

You are given an array <code>nums</code> with length greater than 1. Return an array <code>output</code> with the same length as <code>nums</code> where <code>output[i]</code> is equal to the product of all the elements of <code>nums</code> except <code>nums[i]</code>.

Example:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: <code>[1,2,3,4]</code>
Output: <code>[24,12,8,6]</code>
</pre>

Note: Solve it without division and in O(n).

Challenge: 
Try solving it with constant space complexity. (The output array does not count as extra space for the purpose of space complexity analysis.)

Array Product

Imagine you have an array of length n, initialized with all 0&#39;s and are given a list of operations to perform.

Each operation is represented with three numbers: [startIndex, endIndex, inc]. Elements between [startIndex ... endIndex] (startIndex and endIndex inclusive) are incremented with inc.

Return the end-result of the array after all the operations in the list are executed.

Example:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: length = 5, updates = [[1,3,2],[2,4,3],[0,2,-2]]
Output: [-2,0,3,5,3]
</pre>

Explanation:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Initial state:
[0,0,0,0,0]

After applying operation [1,3,2]:
[0,2,2,2,0]

After applying operation [2,4,3]:
[0,2,5,5,3]

After applying operation [0,2,-2]:
[-2,0,3,5,3]
</pre>

Sum Of Range

Suppose a sorted array of integers in ascending order is rotated at a pivot index and now you're given this array and a target value. Return the index where the target value is at if it doesn't exist return -1.
(i.e., <code>[0,1,2,4,5,6,7]</code> rotates and becomes&nbsp;<code>[4,5,6,7,0,1,2]</code>).
Assume no duplicates exist.
The solution must run in&nbsp;O(log&nbsp;n).
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: nums = [<code>4,5,6,7,0,1,2]</code>, target = 0 Output: 4</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: nums = [<code>4,5,6,7,0,1,2]</code>, target = 3 Output: -1</pre>

Search Rotated Array

Given a sorted array of integers in ascending order and a target value, return the index of the target. If the target doesn't exist, return the index where the target can be inserted such that the array is still in sorted order.
Assume no duplicates in the given array.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,3,5,6], 5
Output: 2
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,3,5,6], 2
Output: 1
</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,3,5,6], 7
Output: 4
</pre>
Example 4:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,3,5,6], 0
Output: 0
</pre>

Find Insert Index

Given an array of integers, return the shortest continuous subarray such that if you sort this subarray in ascending order, the whole array will be sorted in ascending order.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [2, 6, 4, 8, 10, 9, 15]
Output: 5
Explanation: Sort the subarray: [6, 4, 8, 10, 9] in ascending order so the whole array is sorted in ascending order.
</pre>
Note:
<ul>
<li>Then the length of the input array is within the range[1, 10,000].</li>
<li>The input array may contain duplicates, so ascending order here means &lt;=.</li>
</ul>
&nbsp;

Shortest Sorted Subarray

Given a list of words and two words word1 and word2, return the shortest distance between these two words in the list.

Example: 
Assume that words = <code>[&quot;practice&quot;, &quot;makes&quot;, &quot;perfect&quot;, &quot;coding&quot;, &quot;makes&quot;]</code>.

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: word1 = <code>&ldquo;coding&rdquo;</code>, word2 = <code>&ldquo;practice&rdquo;</code>
Output: 3
</pre>

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: word1 = <code>&quot;makes&quot;</code>, word2 = <code>&quot;coding&quot;</code>
Output: 1
</pre>

Note: 
You may assume that word1 does not equal to word2, and word1 and word2 are both in the list.

Closest Distance To Word III

Given a 2D array of size m x n where m is the number of rows and n is the number of columns, return the elements in an array such that it represents the 2D array in spiral order.
Note: The spiral order always starts at the top-left element.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
Output: [1,2,3,6,9,8,7,4,5]
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
[
 [1, 2, 3, 4],
 [5, 6, 7, 8],
 [9,10,11,12]
]
Output: [1,2,3,4,8,12,11,10,9,5,6,7]
</pre>

Swirling Grid

Given a list of positive integers:&nbsp;<code>nums</code> and integer <code>k</code>, return the number of contiguous subarrays such that the product is strictly less than <code>k</code>.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: nums = [6, 2, 5, 10], k = 100
Output: 8
Explanation: The 8 subarrays that have product less than 100 are: [6], [2], [5], [10], [6, 2], [2, 5], [5, 10], [6, 2, 5]. 
</pre>

Product Subarrays Less Than K

Given an array of integers and an integer k, you need to find the total number of continuous subarrays whose sum equals to k.
Given a list of integers&nbsp;and integer&nbsp;<code>k</code>, return the number of contiguous subarrays such that the sum equals&nbsp;<code>k</code>.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:nums = [1,1,1], k = 2
Output: 2
</pre>
Note:
<ol>
<li>The length of nums is in the range of [1, 20,000].</li>
<li>Each element in nums is in the range of [-1000, 1000] and integer&nbsp;k is in range of [-1e7, 1e7].</li>
</ol>

Total Subarray Sums

Given an array of integers, return the third-largest number in the given array. If the size of the array is less than 3, return the largest number.&nbsp;
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [3, 2, 1]

Output: 1
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1, 2]

Output: 2

</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [2, 2, 3, 1]

Output: 1

</pre>

Third Largest Number

Given an array of non-negative integers that represent elevations in a mountain, return the total amount of water the mountains store after raining.
<img style="width: auto; height: 100px;" src="https://swecareers-images.s3.us-east-2.amazonaws.com/images/water-in-mountains/example-1.png" /> The above mountain is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of water (blue section) are contained.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6</pre>

Water In Mountains

Given an array of numbers and a target value, return the indices of two numbers that add up to the target value. You can assume there is always only one correct answer in the given array.
&nbsp;
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].
</pre>
&nbsp;

2sum

A monkey starts at the top left corner of a m by n grid and the monkey can only move down or to the right. The finish goal is at the bottom right corner. Return the number of distinct paths that the monkey can take from the top right corner to the bottom right corner.

Note: m and n will be at most 100.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: m = 3, n = 2
Output: 3
Explanation:
There are 3 ways to move from the top left to the bottom right.
1. Right -&gt; Right -&gt; Down
2. Right -&gt; Down -&gt; Right
3. Down -&gt; Right -&gt; Right
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: m = 7, n = 3
Output: 28</pre>

Distinct Paths

Given an array that only contains non-negative integers, return the count of triplets from the array such that a triangle can be formed using each element in a triplet as the side length of a triangle.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [2,2,3,4]
Output: 3
Explanation:
These are all the triangles that can be formed: 
2,3,4 (using the first 2)
2,3,4 (using the second 2)
2,2,3
</pre>

Problem Title	Difficulty	Frequency in Interviews
2sum	Easy
Water In Mountains	Hard
3sum	Medium
Largest Sum Of Subarray	Easy
Combine Intervals	Medium
Maximize Profits In The Stock Market	Easy
Array Product	Medium
Search Rotated Array	Medium
Largest Container With Water	Medium
Total Subarray Sums	Medium
Swirling Grid	Medium
Lowest Missing Positive Integer	Hard
Pour Water	Medium
Fibonacci	Easy
Maximum Sequence Of Consecutive Numbers	Hard
Absent Integer	Easy
Identify Repeated Number	Medium
Distinct Paths	Medium
Identify Smallest In Modified Sorted Array	Medium
Product Subarrays Less Than K	Medium
Maximize Profits In The Stock Market II	Easy
K Difference Pairs	Easy
Closest Distance To Word III	Easy
Find Insert Index	Easy
Is Triangle Integer	Medium
Maximize Profits In The Stock Market III	Hard
Max Product Of Three	Easy
Majority In Array	Easy
Split Array I	Easy
Find Pivot Index	Easy
Largest Swap Number	Medium
Absent Ranges	Medium
Largest Increasing Subsequence	Easy
Chunk Up Sorted	Medium
Lowest Cost To Climb Stairs	Easy
Shortest Sorted Subarray	Easy
Third Largest Number	Easy
Disjoint Interval Partitioning	Medium
Longest Line In Matrix	Medium
Triplet Sum	Medium
Single Pixel II	Medium
Single Pixel I	Medium
Nested Arrays	Medium
Monotone Increasing String	Medium
Maximum Absolute Difference In Arrays	Easy
Sum Of Range	Medium

Most Frequently Asked Array Interview Questions

Sort By: Company Questions

Sort By: Problem Type