Given an array containing only 0s and 1s and an integer S, return the number of non-empty subarrays that sum up to S.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: A = [1,0,1,0,1], S = 2
Output: 4
Explanation: 
These are the 4 subarrays:
[1,0,1,0,1]
[1,0,1,0,1]
[1,0,1,0,1]
[1,0,1,0,1]
</pre>
&nbsp;

Binary Subarray Sums

Given a non-negative integer, n, return the count of prime numbers less than n.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 9
Output: 4
Explanation: The prime numbers less than 9 are: 2, 3, 5, 7.
</pre>

Number Of Primes

Given a list of temperatures return the list of temperatures such that each day tells you how many days you need to wait until a day with warmer temperature. If there is no future date with warmer temperature then return 0.
For example, given the list of temperatures <code>T = [73, 74, 75, 71, 69, 72, 76, 73]</code>,&nbsp; output&nbsp;<code>[1, 1, 4, 2, 1, 1, 0, 0]</code>.

Warm Temperatures

Given two arrays A and B where B is an anagram of A meaning that B consists of the same elements of A just not necessarily in the same order.
Return an index mapping from A to B called P such that P[i] = j and the i'th element in A is the same as the j'th element in B.
For example, given
<pre style="white-space: pre-wrap; word-break: keep-all;">A = [12, 28, 46, 32, 50]
B = [50, 12, 32, 46, 28]
</pre>
Return this mapping:
<pre style="white-space: pre-wrap; word-break: keep-all;">[1, 4, 3, 2, 0]
</pre>
<code>P[0] = 1</code> because the <code>0</code>th element of <code>A</code> is the same as&nbsp;<code>B[1]</code>, and <code>P[1] = 4</code> because the <code>1st</code>&nbsp;element of <code>A</code> appears at <code>B[4]</code>.
&nbsp;

Map Anagrams

Return the index of the first non-repeating character in a given string. If there are no non-repeating characters then return -1.
Examples:
<pre style="white-space: pre-wrap; word-break: keep-all;">s = "swecareers"
return 1.

s = "loveswecareers",
return 0.
</pre>
Note: Assume the string only contains lowercase letters.

First Non Repeating Character

Given two integer arrays, return the intersection of the two arrays.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: nums1 = [1,2,2,1], nums2 = [2,2]
Output: [2]
</pre>
<div>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
Output: [9,4]</pre>
</div>
&nbsp;

Intersection Of Two Arrays

Given a string that consists only of lower and upper case letters, return the length of the longest possible palindrome that can be constructed with the given letters.
Note: You can assume the length of the string is less than 1000. Also, note that this is case sensitive so "Bb" is not considered a palindrome.
Example: 
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
"qweeeegg"

Output:
7

Explanation:
The longest possible palindrome that can be constructed is: "geeqeeg". The length is 7 so return that value.
</pre>

Largest Palindrome

Given a string s and an integer k, return the length of the longest substring that contains k distinct characters.
Example 1:
<div>
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: s = "eceba", k = 2
Output: 3
Explanation: "ece" which its length is 3.</pre>
<div>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: s = "aa", k = 1
Output: 2
Explanation: "aa" which its length is 2.
</pre>
</div>
</div>

K Distinct Characters

Given a string, return the size of the longest substring such that it contains at most 2 distinct characters.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "eceba"
Output: 3
Explanation: t is "ece" which its size is 3.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "ccaabbb"
Output: 5
Explanation: t is "aabbb" which its size is 5.
</pre>

Two Distinct Character Substring

You are given a string, s. Find the length of the longest substring without repeating characters.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "abcabc"
Output: 3 
Explanation: Longest substring is <code>"abc"</code>, with the length of 3.</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "ffewef"
Output: 3
Explanation: Longest substring is <code>"few"</code>, with the length of 3.</pre>
&nbsp;

Maximum Substring With Non Repeating Characters

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 called nums and an integer that is a target value called k, return the maximum length of a subarray that sums up to the target value k. If it doesn't exist then return 0.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: nums = <code>[1, -1, 5, -2, 3]</code>, k = <code>3</code> Output: 4 Explanation: The subarray <code>[1, -1, 5, -2]</code> sums up to 3 which is also the longest subarray.</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: nums = <code>[-2, -1, 2, 1]</code>, k = <code>1</code> Output: 2 Explanation: The subarray <code>[-1, 2]</code> sums up to 1 which is also the longest subarray.</pre>
Challenge: Try to solve it in O(n) time.

Target Max Subarray Sum

Given 2 strings called: S and T, return the minimum substring in S that contains all characters of T. Do it in O(n) complexity. If no substring exists then return the empty string. If the substring exists then you are guaranteed to only have one unique solution.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"
</pre>
&nbsp;

Minimum Full Window

Given a chemical formula in the form of a string, return the count of each atom in the form of a string that follows this format: the name of the first atom (this must be in sorted ascending order), followed by the count, the name of the second atom, followed by its count and so on.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
formula = "H2O"
Output: "H2O"
Explanation: 
The count of the atoms are {'H': 2, 'O': 1}.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
formula = "Mg(OH)2"
Output: "H2MgO2"
Explanation: 
The count of the atoms are {'H': 2, 'Mg': 1, 'O': 2}.
</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
formula = "K4(ON(SO3)2)2"
Output: "K4N2O14S4"
Explanation: 
The count of the atoms are {'K': 4, 'N': 2, 'O': 14, 'S': 4}.
</pre>
&nbsp; 
&nbsp;

Count Atoms

Given a 2D array that represents a grid consisting of only 1's and 0's, an island is defined by a group of 1's connected horizontally or vertically (representing an island surrounded by 0's representing water).
Return the number of unique islands. An island is unique if it has the same shape as another island and can be translated (not reflected or rotated).
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">11000
11000
00011
00011
</pre>
Return <code>1</code>.
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">11011
10000
00001
11011</pre>
Return <code>3</code>. We see that:
<pre style="white-space: pre-wrap; word-break: keep-all;">11
1
</pre>
and
<pre style="white-space: pre-wrap; word-break: keep-all;"> 1
11
</pre>
are both counted because although they have the same shape, one island is a rotation of another, not a translation.
Note: The size of the edges of the&nbsp;<code>grid</code>&nbsp;is always less than 50.

Count Unique Islands

Given a string, return true if any permutation of the string can be a palindrome.
Remember that a palindrome is the same when reversed.&nbsp;
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>"code"</code> Output: false</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>"aab" </code>Output: true</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>"carerac"</code> Output: true</pre>

Is Permutation Palindrome

You are given an array of size 8 representing prison cells where 1 represents occupied and 0 represents vacant.&nbsp;
Every day the state of a cell changes depending on these rules:
1. If a cell has two adjacent neighbors that are both occupied or vacant then the cell must become occupied.
2. Otherwise, it must become vacant.
(Since the prison is in a row, the first and last cells cannot have 2 adjacent cells.)
Given a state of the prison and&nbsp;<code>N</code>, return the new state after <code>N</code>&nbsp;days.
&nbsp;
<div>
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: cells = [0,1,0,1,1,0,0,1], N = 7
Output: [0,0,1,1,0,0,0,0]
Explanation: 
This is how the prison changes over 7 days:
Day 0: [0, 1, 0, 1, 1, 0, 0, 1] (Initial State)
Day 1: [0, 1, 1, 0, 0, 0, 0, 0]
Day 2: [0, 0, 0, 0, 1, 1, 1, 0]
Day 3: [0, 1, 1, 0, 0, 1, 0, 0]
Day 4: [0, 0, 0, 0, 0, 1, 0, 0]
Day 5: [0, 1, 1, 1, 0, 1, 0, 0]
Day 6: [0, 0, 1, 0, 1, 1, 0, 0]
Day 7: [0, 0, 1, 1, 0, 0, 0, 0]

</pre>
<div>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: cells = [1,0,0,1,0,0,1,0], N = 1000000000
Output: [0,0,1,1,1,1,1,0]
</pre>
&nbsp;
Assume:
<ol>
<li><code>cells.length == 8</code></li>
<li><code>cells[i]</code> is in <code>{0, 1}</code></li>
<li><code>1 &lt;= N &lt;= 10^9</code></li>
</ol>
</div>
</div>

Prison State Changes

There are a group of <code>N</code> rabbits. <code>S</code> rabbits are chosen where <code>S</code> is between 0 and <code>N</code> inclusive. Each one of the <code>S</code> rabbits tells you how many other rabbits have the same color. The <code>answers</code> are stored in an array.

Return the minimum possible of rabbits that satisfy the given array of <code>answers.</code>

<pre style="white-space: pre-wrap; word-break: keep-all;">
Examples:
Input: answers = [1, 2, 2]
Output: 5
Explanation:
Suppose the one rabbit that answered &quot;1&quot; is colored yellow.
That means that there is an additional yellow rabbit that didn't get chosen to be questioned and recorded in the answers array.
The two rabbits that answered &quot;2&quot; can&#39;t be yellow or the answers wouldn't make sense.
Suppose both the rabbits that answered &quot;2&quot; are green.
Then there should be 1 other green rabbit that wasn&#39;t chosen to be questioned and recorded in the answers array.
Therefore the minimum number of rabbits in the group is 5: 3 that answered plus 2 that didn&#39;t.

Input: answers = [20, 20, 20]
Output: 21

Input: answers = [1, 0, 1, 0, 0]
Output: 5

Input: answers = []
Output: 0
</pre>

Minimum Number Of Rabbits

Given an array of integers that is not empty every element appears twice except for one. Return the one that doesn't appear twice.&nbsp;
Challenge:
Implement it in O(n) time complexity and O(1) time complexity.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [2,2,1]
Output: 1
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [4,1,2,1,2]
Output: 4
</pre>

One Number

Given two matrices A and B return the result of AB.
Constraint: both A and B are <a href="https://en.wikipedia.org/wiki/Sparse_matrix" target="_blank" rel="noopener">sparse matrices</a>
Assume that A's column number is equal to B's row number.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:

A = [
 [ 1, 0, 0],
 [-1, 0, 3]
]

B = [
 [ 7, 0, 0 ],
 [ 0, 0, 0 ],
 [ 0, 0, 1 ]
]

Output:

 | 1 0 0 | | 7 0 0 | | 7 0 0 |
AB = | -1 0 3 | x | 0 0 0 | = | -7 0 3 |
 | 0 0 1 |
</pre>

Multiply Sparse Matrices

A strobogrammatic number is any number that is the same when it is rotated 180 degrees.
Given a number in the form of a string, return true if it's a strobogrammatic number otherwise return false.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "69"
Output: true
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "88"
Output: true</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "962"
Output: false</pre>

Flipped Number

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 a non-empty array of words and an integer k, return the k most frequent elements. The result should be sorted by frequency in descending order. If two words have the same frequency then the word that is lexicographically lower should come first.
You can assume valid input.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: ["i", "love", "swecareers", "i", "love", "coding"], k = 2
Output: ["i", "love"]
Explanation: "i" and "love" are the most frequent words with both occuring twice so "i" comes before "love" because it's lexicographically lower.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4
Output: ["the", "is", "sunny", "day"]
Explanation: "the", "is", "sunny" and "day" are the k = 4 most frequent words, with the number of occurrences for each word being 4, 3, 2 and 1 respectively.
</pre>
Challenge:
<ol>
<li>Can you solve it in&nbsp;O(n log k) time and O(n) extra space?</li>
</ol>

Most Frequent Words

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

In an ancient civilization their language used English lowercase letters, but in a different&nbsp;<code>order.</code>&nbsp;The&nbsp;<code>order</code>&nbsp;of the ancient alphabet is a permutation of all the lowercase letters in the English language.
Given an array of strings that represent&nbsp;<code>words</code>&nbsp;written in an ancient language and the&nbsp;<code>order</code>&nbsp;of the ancient language alphabet, return true if and only if the given array is lexicographically sorted.
&nbsp;
<div>
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: words = ["hello","swecareers"], order = "hlabcdefgijkmnopqrstuvwxyz"
Output: true
Explanation: As 'h' comes before 's' in this language, then the sequence is sorted.
</pre>
<div>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
Output: false
Explanation: Since 'd' comes after 'l' in the order, which means that words[0] &gt; words[1] and the given words are unsorted.
</pre>
<div>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
Output: false
Explanation: The first three characters "app" match, and the second string is shorter (in size.) According to lexicographical rules the shorter word comes first in all cases.
</pre>
&nbsp;
Assume:
<ol>
<li><code>1 &lt;= words.size &lt;= 100</code></li>
<li><code>1 &lt;= words[i].size &lt;= 20</code></li>
<li><code>The size of the given alphabet is always size 26</code></li>
<li>All characters in <code>words[i]</code> and <code>order</code> are lowercase characters.</li>
</ol>
</div>
</div>
</div>

Problem Title	Difficulty	Frequency in Interviews
2sum	Easy
Maximum Substring With Non Repeating Characters	Medium
Minimum Full Window	Hard
Total Subarray Sums	Medium
Most Frequent Words	Medium
First Non Repeating Character	Easy
K Distinct Characters	Hard
Intersection Of Two Arrays	Easy
Number Of Primes	Easy
Verify Ancient Language	Easy
Warm Temperatures	Medium
Prison State Changes	Medium
Count Unique Islands	Medium
One Number	Easy
Multiply Sparse Matrices	Medium
Two Distinct Character Substring	Hard
Count Atoms	Hard
Target Max Subarray Sum	Medium
Flipped Number	Easy
Is Permutation Palindrome	Easy
Largest Palindrome	Easy
Binary Subarray Sums	Medium
Map Anagrams	Easy
Minimum Number Of Rabbits	Medium
Maximum Absolute Difference In Arrays	Easy

Most Frequently Asked Hash Table Interview Questions

Sort By: Company Questions

Sort By: Problem Type