An account is a list of strings such that the first element is a name, the remaining strings are emails associated with the account.
Given a list of accounts, combine the accounts if accounts share the same email.&nbsp;
Return the accounts such that the first element in each array is the name and the remaining elements are emails in sorted order. The accounts should be returned in sorted order as well.
Example 1:
<pre style="white-space: pre-wrap;">Input: 
accounts = [["John", "johnsmith@mail.com", "john00@mail.com"], ["John", "johnnybravo@mail.com"], ["John", "johnsmith@mail.com", "john_newyork@mail.com"], ["Mary", "mary@mail.com"]]
Output: [["John", 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com'], ["John", "johnnybravo@mail.com"], ["Mary", "mary@mail.com"]]
Explanation: 
The first and third John have the same email "johnsmith@mail.com" so merge those accounts.
</pre>
&nbsp;
&nbsp;

Combine Accounts

Given a binary tree that is not empty, return the sum of the maximum path. A path of a tree is defined as a sequence of nodes connecting one node to any other node in the tree that flows along the parent-child connections and there must be at the least, one node that doesn't go through the root.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [1,2,3]

 1
 / \
 2 3

Output: 6
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [-10,9,20,null,null,15,7]</pre>

<pre style="white-space: pre-wrap; word-break: keep-all;">
 -10
 / \
 9 20
 / \
 15 7
</pre>
Output: 42

Binary Tree Max Path

You have an integer n representing the number of courses you need to take and the courses are labeled from 0 to n-1.
Some courses have prerequisite courses. In order to take course 0, you need to have completed course 1. This is represented as a pair: [0, 1].
Given n and a list of pairs representing prerequisite courses, return the ordering of courses to complete all the courses from 0 to n-1.
Return an empty array if no such ordering exists. If there are multiple orderings, return the order that is lexicographically smallest.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 2, [[1,0]] 
Output: <code>[0,1]</code> Explanation:&nbsp;In order to take course 1 you need to complete course 0. So the output would be <code>[0,1] .</code></pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 4, [[1,0],[2,0],[3,1],[3,2]]
Output: <code>[0,1,2,3]</code> Explanation:&nbsp;There are a total of 4 courses to take. In order to take course 3 you should have completed courses 1 and 2. Both courses 1 and 2 should be taken after you complete course 0. One correct course order is <code>[0,1,2,3]</code> it's the lexicographically smallest. Another correct ordering is <code>[0,2,1,3]</code>&nbsp;but&nbsp;it's&nbsp;not&nbsp;the&nbsp;lexicographically&nbsp;smallest.</pre>

Schedule Classes

Given the root of a binary tree, return the leftmost value in the last row of the tree.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
</pre>
<pre style="white-space: pre-wrap; word-break: keep-all;">
 2
 / \
 1 3
</pre>
<pre style="white-space: pre-wrap; word-break: keep-all;">
Output:
1
</pre>
 Example 2: 
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:

 1
 / \
 2 3
 / / \
 4 5 6
 /
 7

Output:
7
</pre>
You can assume valid input and the root node is not NULL.

Binary Tree Left Most Value

You are given a 2D array of integers representing an image where each integer represents a pixel value ranging from 0 to 65535.
You are also given a coordinate sr, sc which represents a starting pixel in the image grid. You must perform a flood fill from this starting pixel with a new color.&nbsp;
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 as the starting pixel), and so on. Replace the color of all of the aforementioned pixels with the new color.
A flood fill is defined by changing all pixels that are surrounded (top, left, bottom, right) by the starting pixel to the new color and repeatedly doing this for all connected pixels with the same color as the starting pixel.
Return the new image.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
image = [ [1,1,1], [1,1,0], [1,0,1] ]
sr = 1, sc = 1, newColor = 2
Output: [ [2,2,2], [2,2,0], [2,0,1] ]
Explanation: 
From the center position, all pixels connected with the first pixel and has the same color are changed to the new color. The bottom right corner's pixel color isn't changed because it's not connected via top, left, bottom, right with the center pixel.</pre>
Constraints:
<ul>
<li>The length of <code>image</code> and <code>image[0]</code> be in the range&nbsp;<code>[1, 50]</code>.</li>
<li>The starting pixel will always be within the valid grid.</li>
<li>The color values within the grid and the <code>newColor</code> will always be within 0 and&nbsp;65535.</li>
</ul>
&nbsp;

Flood Fill

Given n nodes which are labeled from 0 to n-1 and a 2D list representing undirected edges (each edge is represented as a pair of nodes), return true if the edges make a tree.
Assume valid input and no repeated edges in the list of given edges. [0,1] and [1,0] are the same so they won't occur more than once in the list of given edges.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>n = 5</code>, and <code>edges = [[0,1], [0,2], [0,3], [1,4]]</code> Output: true</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>n = 5, </code>and <code>edges = [[0,1], [1,2], [2,3], [1,3], [1,4]]</code> Output: false</pre>
&nbsp;

Valid Tree

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 a binary tree, return the max depth.
The max depth is the number of nodes from the root node to the deepest leaf node. A leaf node is a node without any children.
Example:
Given binary tree <code>[3,9,20,null,null,15,7]</code>,
<pre style="white-space: pre-wrap; word-break: keep-all;"> 3
 / \
 9 20
 / \
 15 7</pre>
return 3.

Binary Tree Max Depth

Given a binary tree, return the minimum depth.
The minimum depth is the shortest path from the root node to a leaf node. A leaf node has no children.
Example:
Given the tree <code>[3,9,20,null,null,15,7]</code>,
<pre style="white-space: pre-wrap; word-break: keep-all;"> 3
 / \
 9 20
 / \
 15 7</pre>
return 2.

Binary Tree Min Depth

Given an integer n which represents n nodes labeled from 0 to n-1 and a list of edges (each edge is a pair of nodes), return the number of connected components in the undirected graph.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>n = 5</code> and <code>edges = [[0, 1], [1, 2], [3, 4]]</code></pre>
<pre> 0 3
 | |
 1 --- 2 4 Output: 2</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>n = 5</code> and <code>edges = [[0, 1], [1, 2], [2, 3], [3, 4]]</code> </pre>
<pre> 0 4
 | |
 1 --- 2 --- 3</pre>
<pre style="white-space: pre-wrap; word-break: keep-all;"> Output:&nbsp;&nbsp;1</pre>
Note: Assume there are no duplicate edges that appear. [1, 0] is the same as [0, 1] and they wont appear twice.

Count Connected Components In Graph

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, remove the minimum number of invalid parentheses&nbsp;such that the input string is valid. Return a list of all possible results in sorted order.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "()())()"
Output: ["()()()", "(())()"]
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "(a)())()"
Output: ["(a)()()", "(a())()"]
</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: ")("
Output: [""]
</pre>

Delete Incorrect Brackets

Given two arrays of strings which represent two sentences, and a list of string pairs which represent words that are similar to each other, return true if the two sentences are similar to each other based on the word pairs.
For example:
Given the sentences, "great acting skills", "fine drama talent" and&nbsp;<code>pairs = [["great", "fine"], ["acting","drama"], ["skills","talent"]]</code> return true because they are similar.
Also keep in mind that similarity relationships are transitive meaning if words such as "fine" and "great" are similar, and "fine" and "good" are also similar, "great" and "good" are similar as well. Also, keep in mind the same words are always similar even if it doesn't specify in the similar word pairs. For example: "great" is always similar to "great" even if&nbsp;<code>pairs = []</code>.
Sentences can only be similar if they are of the same length.
Note:
<ul>
<li>The size of <code>words1</code> and <code>words2</code> is less than&nbsp;<code>1000</code>.</li>
<li>The size of <code>pairs</code> is less than&nbsp;<code>2000</code>.</li>
<li>The size of each <code>pairs[i]</code> will be exactly&nbsp;<code>2</code>.</li>
<li>The size of each <code>words[i]</code> and <code>pairs[i][j]</code> are in the range&nbsp;<code>[1, 20]</code>.</li>
</ul>
&nbsp;

Similar Sentences II

Given a binary tree, each node only has a value from 0 to 25 that represent the lowercase letters 'a' to 'z'. 0 represents 'a', 1 represents 'b' and so on until 25 represents 'z'.
Return the lexicographically smallest string that can be formed from a leaf to the root of the binary tree.
Note: A short prefix of a string is lexicographically smaller than the whole string. For example "ab" is lexicographically smaller than "aba". Also, a leaf of a node is a node without any children.
<div>
<div>
&nbsp;
</div>
</div>
<div>
Example 1:
<img style="width: 100px; height: auto;" src="https://swecareers-images.s3.us-east-2.amazonaws.com/images/smallest-string-in-tree/example-1.png" alt="" />
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [0,1,2,3,4,3,4]
Output: "dba"
</pre>
<div>
Example 2:
<img style="width: 100px; height: auto;" src="https://swecareers-images.s3.us-east-2.amazonaws.com/images/smallest-string-in-tree/example-2.png" alt="" />
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [25,1,3,1,3,0,2]
Output: "adz"
</pre>
<div>
Example 3:
<img style="height: 100px; width: auto;" src="https://swecareers-images.s3.us-east-2.amazonaws.com/images/smallest-string-in-tree/example-3.png" alt="" />
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [2,2,1,null,1,0,null,0]
Output: "abc"
</pre>
&nbsp;
</div>
</div>
</div>

Smallest String In Tree

There is a weird printer that follows two rules:
<ol>
<li>The printer can only print sequences of the same character at a time.</li>
<li>For every turn, the printer prints characters starting from and ending at any place that will cover the original existing characters.</li>
</ol>
Given a string that contains only lowercase English letters, return the minimum number of turns the printer is needed to print the string.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "aaabbb"
Output: 2
Explanation: Print "aaa" first and then print "bbb".
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "aba"
Output: 2
Explanation: Print "aaa" first and then print "b" from the second place of the string, which will cover the existing character 'a'.
</pre>

Weird Printer

Given a list of non-negative integers and a target integer, S. Return the total number of ways to add the integers to S such that you are only allowed to place + or - between the integers.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: nums is [1, 1, 1, 1, 1], S is 3. 
Output: 5
Explanation: 

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

There are 5 ways to add symbols to add up the nums to be target 3.
</pre>
Note:
<ol>
<li>The given array only contains positive integers and never exceed length 20.</li>
<li>The total sum of elements in the array never exceeds 1000.</li>
<li>Your output is guaranteed to be a 32-bit integer.</li>
</ol>

Number Of Ways To Sum

Given a string representing arbitrarily nested ternary expressions, calculate the result of the expression. You can always assume that the given expression is valid and only consists of digits <code>0-9</code>, <code>?</code>, <code>:</code>, <code>T</code> and <code>F</code> (<code>T</code> and <code>F</code> represent True and False respectively).
Given a string that represents an arbitrary number of nested ternary expressions, return the result of the expression.
Constraints:
<ol>
<li>The size of the given string is less than 10000.</li>
<li>Each number contains only one digit.</li>
<li>Assume that the expression is always valid and only contains characters 0 to 9, ?, :, T and F (T and F represent True and False respectively).</li>
<li>The conditional expressions group right-to-left.</li>
<li>The condition will always be&nbsp;<code>T</code> or <code>F</code>. That is, the condition will never be a digit.</li>
<li>The result of the expression will always result in a digit <code>0 to 9</code>, <code>T</code> or <code>F</code>.</li>
</ol>
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "T?2:3"

Output: "2"

Explanation: If true, then result is 2; otherwise result is 3.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "F?1:T?4:5"

Output: "4"

Explanation: The conditional expressions group right-to-left. Using parenthesis, it is read/evaluated as:

 "(F ? 1 : (T ? 4 : 5))" "(F ? 1 : (T ? 4 : 5))"
 -> "(F ? 1 : 4)" or -> "(T ? 4 : 5)"
 -> "4" -> "4"
</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "T?T?F:5:3"

Output: "F"

Explanation: The conditional expressions group right-to-left. Using parenthesis, it is read/evaluated as:

 "(T ? (T ? F : 5) : 3)" "(T ? (T ? F : 5) : 3)"
 -> "(T ? F : 3)" or -> "(T ? F : 5)"
 -> "F" -> "F"
</pre>

Problem Title	Difficulty	Frequency in Interviews
Delete Incorrect Brackets	Hard
Binary Tree Max Path	Hard
Schedule Classes	Medium
Flood Fill	Easy
Count Unique Islands	Medium
Binary Tree Max Depth	Easy
Combine Accounts	Medium
Count Connected Components In Graph	Medium
Valid Tree	Medium
Number Of Ways To Sum	Medium
Binary Tree Left Most Value	Medium
Binary Tree Min Depth	Easy
Single Pixel II	Medium
Single Pixel I	Medium
Similar Sentences II	Medium
Parse Ternary Expression	Medium
Smallest String In Tree	Medium
Weird Printer	Hard

Most Frequently Asked Depth First Search Interview Questions

Sort By: Company Questions

Sort By: Problem Type