Given a string *s*, partition *s* such that every substring of the partition is a palindrome.

Return the minimum cuts needed for a palindrome partitioning of *s*.

For example, given *s* = `"aab"`

,

Return `1`

since the palindrome partitioning `["aa","b"]`

could be produced using 1 cut.

Given a string *s*, partition *s* such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of *s*.

For example, given *s* = `"aab"`

,

Return

[ ["aa","b"], ["a","a","b"] ]Â» Solve this problem(link to this question)

Given a 2D board containing `'X'`

and `'O'`

, capture all regions surrounded by `'X'`

.

A region is captured by flipping all `'O'`

s into `'X'`

s in that surrounded region .

For example,

X X X X X O O X X X O X X O X X

After running your function, the board should be:

X X X X X X X X X X X X X O X XÂ» View Solution(link to this question)

Given a binary tree containing digits from `0-9`

only, each root-to-leaf path could represent a number.

An example is the root-to-leaf path `1->2->3`

which represents the number `123`

.

Find the total sum of all root-to-leaf numbers.

For example,

1 / \ 2 3

The root-to-leaf path `1->2`

represents the number `12`

.

The root-to-leaf path `1->3`

represents the number `13`

.

Return the sum = 12 + 13 = `25`

.

Given an unsorted array of integers, find the length of the longest consecutive elements sequence.

For example,

Given `[100, 4, 200, 1, 3, 2]`

,

The longest consecutive elements sequence is `[1, 2, 3, 4]`

. Return its length: `4`

.

Your algorithm should run in O(*n*) complexity.

Given two words (*start* and *end*), and a dictionary, find all shortest transformation sequence(s) from *start* to *end*, such that:

- Only one letter can be changed at a time
- Each intermediate word must exist in the dictionary

For example,

Given:

*start* = `"hit"`

*end* = `"cog"`

*dict* = `["hot","dot","dog","lot","log"]`

Return

[ ["hit","hot","dot","dog","cog"], ["hit","hot","lot","log","cog"] ]

**Note:**

- All words have the same length.
- All words contain only lowercase alphabetic characters.

Given two words (*start* and *end*), and a dictionary, find the length of shortest transformation sequence from *start* to *end*, such that:

- Only one letter can be changed at a time
- Each intermediate word must exist in the dictionary

For example,

Given:

*start* = `"hit"`

*end* = `"cog"`

*dict* = `["hot","dot","dog","lot","log"]`

As one shortest transformation is `"hit" -> "hot" -> "dot" -> "dog" -> "cog"`

,

return its length `5`

.

**Note:**

- Return 0 if there is no such transformation sequence.
- All words have the same length.
- All words contain only lowercase alphabetic characters.

Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.

For example,

`"A man, a plan, a canal: Panama"`

is a palindrome.

`"race a car"`

is *not* a palindrome.

**Note:**

Have you consider that the string might be empty? This is a good question to ask during an interview.

For the purpose of this problem, we define empty string as valid palindrome.

Â» View Solution(link to this question)Given a binary tree, find the maximum path sum.

The path may start and end at any node in the tree.

For example:

Given the below binary tree,

1 / \ 2 3

Return `6`

.

Say you have an array for which the *i*^{th} element is the price of a given stock on day *i*.

Design an algorithm to find the maximum profit. You may complete at most *two* transactions.

**Note:**

You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

Say you have an array for which the *i*^{th} element is the price of a given stock on day *i*.

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

Â» View Solution(link to this question)Say you have an array for which the *i*^{th} element is the price of a given stock on day *i*.

If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.

Â» View Solution(link to this question)Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.

For example, given the following triangle

[ [2], [3,4], [6,5,7], [4,1,8,3] ]

The minimum path sum from top to bottom is `11`

(i.e., 2 + 3 + 5 + 1 = 11).

**Note:**

Bonus point if you are able to do this using only *O*(*n*) extra space, where *n* is the total number of rows in the triangle.

Given an index *k*, return the *k*^{th} row of the Pascal's triangle.

For example, given *k* = 3,

Return `[1,3,3,1]`

.

**Note:**

Could you optimize your algorithm to use only *O*(*k*) extra space?

Given *numRows*, generate the first *numRows* of Pascal's triangle.

For example, given *numRows* = 5,

Return

[ [1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1] ]Â» View Solution(link to this question)

Follow up for problem "*Populating Next Right Pointers in Each Node*".

What if the given tree could be any binary tree? Would your previous solution still work?

**Note:**

- You may only use constant extra space.

For example,

Given the following binary tree,

1 / \ 2 3 / \ \ 4 5 7

After calling your function, the tree should look like:

1 -> NULL / \ 2 -> 3 -> NULL / \ \ 4-> 5 -> 7 -> NULLÂ» View Solution(link to this question)

Given a binary tree

struct TreeLinkNode { TreeLinkNode *left; TreeLinkNode *right; TreeLinkNode *next; }

Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to `NULL`

.

Initially, all next pointers are set to `NULL`

.

**Note:**

- You may only use constant extra space.
- You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two children).

For example,

Given the following perfect binary tree,

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

After calling your function, the tree should look like:

1 -> NULL / \ 2 -> 3 -> NULL / \ / \ 4->5->6->7 -> NULLÂ» View Solution(link to this question)

Given a string **S** and a string **T**, count the number of distinct subsequences of **T** in **S**.

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, `"ACE"`

is a subsequence of `"ABCDE"`

while `"AEC"`

is not).

Here is an example:

**S** = `"rabbbit"`

, **T** = `"rabbit"`

Return `3`

.

Given a binary tree, flatten it to a linked list in-place.

For example,

Given

1 / \ 2 5 / \ \ 3 4 6The flattened tree should look like:

1 \ 2 \ 3 \ 4 \ 5 \ 6

If you notice carefully in the flattened tree, each node's right child points to the next node of a pre-order traversal.

Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.

For example:Given the below binary tree and

`sum = 22`

,5 / \ 4 8 / / \ 11 13 4 / \ / \ 7 2 5 1

return

[ [5,4,11,2], [5,8,4,5] ]Â» View Solution(link to this question)

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

For example:Given the below binary tree and

`sum = 22`

,5 / \ 4 8 / / \ 11 13 4 / \ \ 7 2 1

return true, as there exist a root-to-leaf path `5->4->11->2`

which sum is 22.

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

Â» View Solution(link to this question)Given a binary tree, determine if it is height-balanced.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of *every* node never differ by more than 1.

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

Â» View Solution(link to this question)Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

Â» View Solution(link to this question)Given a binary tree, return the *bottom-up level order* traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).

For example:

Given binary tree `{3,9,20,#,#,15,7}`

,

3 / \ 9 20 / \ 15 7

return its bottom-up level order traversal as:

[ [15,7] [9,20], [3], ]

confused what `"{1,#,2,3}"`

means? > read more on how binary tree is serialized on OJ.

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

1 / \ 2 3 / 4 \ 5The above binary tree is serialized as

`"{1,2,3,#,#,4,#,#,5}"`

.Given inorder and postorder traversal of a tree, construct the binary tree.

**Note:**

You may assume that duplicates do not exist in the tree.

Given preorder and inorder traversal of a tree, construct the binary tree.

**Note:**

You may assume that duplicates do not exist in the tree.

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Â» View Solution(link to this question)Given a binary tree, return the *zigzag level order* traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:

Given binary tree `{3,9,20,#,#,15,7}`

,

3 / \ 9 20 / \ 15 7

return its zigzag level order traversal as:

[ [3], [20,9], [15,7] ]

confused what `"{1,#,2,3}"`

means? > read more on how binary tree is serialized on OJ.

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

1 / \ 2 3 / 4 \ 5The above binary tree is serialized as

`"{1,2,3,#,#,4,#,#,5}"`

.Given a binary tree, return the *level order* traversal of its nodes' values. (ie, from left to right, level by level).

For example:

Given binary tree `{3,9,20,#,#,15,7}`

,

3 / \ 9 20 / \ 15 7

return its level order traversal as:

[ [3], [9,20], [15,7] ]

confused what `"{1,#,2,3}"`

means? > read more on how binary tree is serialized on OJ.

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

1 / \ 2 3 / 4 \ 5The above binary tree is serialized as

`"{1,2,3,#,#,4,#,#,5}"`

.Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree is symmetric:

1 / \ 2 2 / \ / \ 3 4 4 3

But the following is not:

1 / \ 2 2 \ \ 3 3

**Note:**

Bonus points if you could solve it both recursively and iteratively.

confused what `"{1,#,2,3}"`

means? > read more on how binary tree is serialized on OJ.

Here's an example:

1 / \ 2 3 / 4 \ 5The above binary tree is serialized as

`"{1,2,3,#,#,4,#,#,5}"`

.Given two binary trees, write a function to check if they are equal or not.

Two binary trees are considered equal if they are structurally identical and the nodes have the same value.

Â» View Solution(link to this question)Two elements of a binary search tree (BST) are swapped by mistake.

Recover the tree without changing its structure.

A solution using O(

confused what `"{1,#,2,3}"`

means? > read more on how binary tree is serialized on OJ.

Here's an example:

1 / \ 2 3 / 4 \ 5The above binary tree is serialized as

`"{1,2,3,#,#,4,#,#,5}"`

.Given a binary tree, determine if it is a valid binary search tree (BST).

Assume a BST is defined as follows:

- The left subtree of a node contains only nodes with keys
**less than**the node's key. - The right subtree of a node contains only nodes with keys
**greater than**the node's key. - Both the left and right subtrees must also be binary search trees.

confused what `"{1,#,2,3}"`

means? > read more on how binary tree is serialized on OJ.

Here's an example:

1 / \ 2 3 / 4 \ 5The above binary tree is serialized as

`"{1,2,3,#,#,4,#,#,5}"`

. Given *s1*, *s2*, *s3*, find whether *s3* is formed by the interleaving of *s1* and *s2*.

For example,

Given:

*s1* = `"aabcc"`

,

*s2* = `"dbbca"`

,

When *s3* = `"aadbbcbcac"`

, return true.

When *s3* = `"aadbbbaccc"`

, return false.

Given *n*, generate all structurally unique **BST's** (binary search trees) that store values 1...*n*.

For example,

Given *n* = 3, your program should return all 5 unique BST's shown below.

1 3 3 2 1 \ / / / \ \ 3 2 1 1 3 2 / / \ \ 2 1 2 3

confused what `"{1,#,2,3}"`

means? > read more on how binary tree is serialized on OJ.

Here's an example:

1 / \ 2 3 / 4 \ 5The above binary tree is serialized as

`"{1,2,3,#,#,4,#,#,5}"`

.Given *n*, how many structurally unique **BST's** (binary search trees) that store values 1...*n*?

For example,

Given *n* = 3, there are a total of 5 unique BST's.

1 3 3 2 1 \ / / / \ \ 3 2 1 1 3 2 / / \ \ 2 1 2 3Â» View Solution(link to this question)

Given a binary tree, return the *inorder* traversal of its nodes' values.

For example:

Given binary tree `{1,#,2,3}`

,

1 \ 2 / 3

return `[1,3,2]`

.

**Note:** Recursive solution is trivial, could you do it iteratively?

confused what `"{1,#,2,3}"`

means? > read more on how binary tree is serialized on OJ.

Here's an example:

1 / \ 2 3 / 4 \ 5The above binary tree is serialized as

`"{1,2,3,#,#,4,#,#,5}"`

.Given a string containing only digits, restore it by returning all possible valid IP address combinations.

For example:

Given `"25525511135"`

,

return `["255.255.11.135", "255.255.111.35"]`

. (Order does not matter)

Reverse a linked list from position *m* to *n*. Do it in-place and in one-pass.

For example:

Given `1->2->3->4->5->NULL`

, *m* = 2 and *n* = 4,

return `1->4->3->2->5->NULL`

.

**Note:**

Given *m*, *n* satisfy the following condition:

1 ? *m* ? *n* ? length of list.

Given a collection of integers that might contain duplicates, *S*, return all possible subsets.

**Note:**

- Elements in a subset must be in non-descending order.
- The solution set must not contain duplicate subsets.

For example,

If ** S** =

`[1,2,2]`

, a solution is:[ [2], [1], [1,2,2], [2,2], [1,2], [] ]Â» View Solution(link to this question)

A message containing letters from `A-Z`

is being encoded to numbers using the following mapping:

'A' -> 1 'B' -> 2 ... 'Z' -> 26

Given an encoded message containing digits, determine the total number of ways to decode it.

For example,

Given encoded message `"12"`

, it could be decoded as `"AB"`

(1 2) or `"L"`

(12).

The number of ways decoding `"12"`

is 2.

The gray code is a binary numeral system where two successive values differ in only one bit.

Given a non-negative integer *n* representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.

For example, given *n* = 2, return `[0,1,3,2]`

. Its gray code sequence is:

00 - 0 01 - 1 11 - 3 10 - 2

**Note:**

For a given *n*, a gray code sequence is not uniquely defined.

For example, `[0,2,3,1]`

is also a valid gray code sequence according to the above definition.

For now, the judge is able to judge based on one instance of gray code sequence. Sorry about that.

Â» View Solution(link to this question)Given two sorted integer arrays A and B, merge B into A as one sorted array.

**Note:**

You may assume that A has enough space to hold additional elements from B. The number of elements initialized in A and B are *m* and *n* respectively.

Given a string *s1*, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of *s1* = `"great"`

:

great / \ gr eat / \ / \ g r e at / \ a t

To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node `"gr"`

and swap its two children, it produces a scrambled string `"rgeat"`

.

rgeat / \ rg eat / \ / \ r g e at / \ a t

We say that `"rgeat"`

is a scrambled string of `"great"`

.

Similarly, if we continue to swap the children of nodes `"eat"`

and `"at"`

, it produces a scrambled string `"rgtae"`

.

rgtae / \ rg tae / \ / \ r g ta e / \ t a

We say that `"rgtae"`

is a scrambled string of `"great"`

.

Given two strings *s1* and *s2* of the same length, determine if *s2* is a scrambled string of *s1*.

Given a linked list and a value *x*, partition it such that all nodes less than *x* come before nodes greater than or equal to *x*.

You should preserve the original relative order of the nodes in each of the two partitions.

For example,

Given `1->4->3->2->5->2`

and *x* = 3,

return `1->2->2->4->3->5`

.

Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area.

Â» View Solution(link to this question) Given *n* non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = `[2,1,5,6,2,3]`

.

The largest rectangle is shown in the shaded area, which has area = `10`

unit.

For example,

Given height = `[2,1,5,6,2,3]`

,

return `10`

.

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only *distinct* numbers from the original list.

For example,

Given `1->2->3->3->4->4->5`

, return `1->2->5`

.

Given `1->1->1->2->3`

, return `2->3`

.

Given a sorted linked list, delete all duplicates such that each element appear only *once*.

For example,

Given `1->1->2`

, return `1->2`

.

Given `1->1->2->3->3`

, return `1->2->3`

.

Follow up for "Search in Rotated Sorted Array":

What if *duplicates* are allowed?

Would this affect the run-time complexity? How and why?

Write a function to determine if a given target is in the array.

Â» Solve this problem(link to this question) Follow up for "Remove Duplicates":

What if duplicates are allowed at most *twice*?

For example,

Given sorted array A = `[1,1,1,2,2,3]`

,

Your function should return length = `5`

, and A is now `[1,1,2,2,3]`

.

Given a 2D board and a word, find if the word exists in the grid.

The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.

For example,

Given **board** =

[ ["ABCE"], ["SFCS"], ["ADEE"] ]

`"ABCCED"`

, -> returns `true`

,`"SEE"`

, -> returns `true`

,`"ABCB"`

, -> returns `false`

.Â» View Solution(link to this question)

Given a set of distinct integers, *S*, return all possible subsets.

**Note:**

- Elements in a subset must be in non-descending order.
- The solution set must not contain duplicate subsets.

For example,

If ** S** =

`[1,2,3]`

, a solution is:[ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]Â» View Solution(link to this question)

Given two integers *n* and *k*, return all possible combinations of *k* numbers out of 1 ... *n*.

For example,

If *n* = 4 and *k* = 2, a solution is:

[ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]Â» View Solution(link to this question)

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

For example,

**S** = `"ADOBECODEBANC"`

**T** = `"ABC"`

Minimum window is `"BANC"`

.

**Note:**

If there is no such window in S that covers all characters in T, return the emtpy string `""`

.

If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

Â» Solve this problem(link to this question) Given an array with *n* objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

**Note:**

You are not suppose to use the library's sort function for this problem.

**Follow up:**

A rather straight forward solution is a two-pass algorithm using counting sort.

First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array with total number of 0's, then 1's and followed by 2's.

Could you come up with an one-pass algorithm using only constant space?

Write an efficient algorithm that searches for a value in an *m* x *n* matrix. This matrix has the following properties:

- Integers in each row are sorted from left to right.
- The first integer of each row is greater than the last integer of the previous row.

For example,

Consider the following matrix:

[ [1, 3, 5, 7], [10, 11, 16, 20], [23, 30, 34, 50] ]

Given **target** = `3`

, return `true`

.

Given a *m* x *n* matrix, if an element is 0, set its entire row and column to 0. Do it in place.

Did you use extra space?

A straight forward solution using O(*m**n*) space is probably a bad idea.

A simple improvement uses O(*m* + *n*) space, but still not the best solution.

Could you devise a constant space solution?

Given two words *word1* and *word2*, find the minimum number of steps required to convert *word1* to *word2*. (each operation is counted as 1 step.)

You have the following 3 operations permitted on a word:

a) Insert a character

b) Delete a character

c) Replace a character

Given an absolute path for a file (Unix-style), simplify it.

For example,

**path** = `"/home/"`

, => `"/home"`

**path** = `"/a/./b/../../c/"`

, => `"/c"`

- Did you consider the case where
**path**=`"/../"`

?

In this case, you should return`"/"`

. - Another corner case is the path might contain multiple slashes
`'/'`

together, such as`"/home//foo/"`

.

In this case, you should ignore redundant slashes and return`"/home/foo"`

.

You are climbing a stair case. It takes *n* steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Â» View Solution(link to this question)Implement `int sqrt(int x)`

.

Compute and return the square root of *x*.

Given an array of words and a length *L*, format the text such that each line has exactly *L* characters and is fully (left and right) justified.

You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces `' '`

when necessary so that each line has exactly *L* characters.

Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.

For the last line of text, it should be left justified and no extra space is inserted between words.

For example,

**words**: `["This", "is", "an", "example", "of", "text", "justification."]`

**L**: `16`

.

Return the formatted lines as:

[ "This is an", "example of text", "justification. " ]

**Note:** Each word is guaranteed not to exceed *L* in length.

- A line other than the last line might contain only one word. What should you do in this case?

In this case, that line should be left-justified.

Given a number represented as an array of digits, plus one to the number.

Â» View Solution(link to this question)Validate if a given string is numeric.

Some examples:

`"0"`

=> `true`

`" 0.1 "`

=> `true`

`"abc"`

=> `false`

`"1 a"`

=> `false`

`"2e10"`

=> `true`

**Note:** It is intended for the problem statement to be ambiguous. You should gather all requirements up front before implementing one.

Given two binary strings, return their sum (also a binary string).

For example,

a = `"11"`

b = `"1"`

Return `"100"`

.

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

Â» View Solution(link to this question)Given a *m* x *n* grid filled with non-negative numbers, find a path from top left to bottom right which *minimizes* the sum of all numbers along its path.

**Note:** You can only move either down or right at any point in time.

Follow up for "Unique Paths":

Now consider if some obstacles are added to the grids. How many unique paths would there be?

An obstacle and empty space is marked as `1`

and `0`

respectively in the grid.

For example,

There is one obstacle in the middle of a 3x3 grid as illustrated below.

[ [0,0,0], [0,1,0], [0,0,0] ]

The total number of unique paths is `2`

.

**Note:** *m* and *n* will be at most 100.

A robot is located at the top-left corner of a *m* x *n* grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

How many possible unique paths are there?

Above is a 3 x 7 grid. How many possible unique paths are there?

**Note:** *m* and *n* will be at most 100.

Given a list, rotate the list to the right by *k* places, where *k* is non-negative.

For example:

Given `1->2->3->4->5->NULL`

and *k* = `2`

,

return `4->5->1->2->3->NULL`

.

The set `[1,2,3,…,`

contains a total of *n*]*n*! unique permutations.

By listing and labeling all of the permutations in order,

We get the following sequence (ie, for *n* = 3):

`"123"`

`"132"`

`"213"`

`"231"`

`"312"`

`"321"`

Given *n* and *k*, return the *k*^{th} permutation sequence.

**Note:** Given *n* will be between 1 and 9 inclusive.

Given an integer *n*, generate a square matrix filled with elements from 1 to *n*^{2} in spiral order.

For example,

Given *n* = `3`

,

[ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]Â» View Solution(link to this question)

Given a string *s* consists of upper/lower-case alphabets and empty space characters `' '`

, return the length of last word in the string.

If the last word does not exist, return 0.

**Note:** A word is defined as a character sequence consists of non-space characters only.

For example,

Given *s* = `"Hello World"`

,

return `5`

.

Given a set of *non-overlapping* intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

**Example 1:**

Given intervals `[1,3],[6,9]`

, insert and merge `[2,5]`

in as `[1,5],[6,9]`

.

**Example 2:**

Given `[1,2],[3,5],[6,7],[8,10],[12,16]`

, insert and merge `[4,9]`

in as `[1,2],[3,10],[12,16]`

.

This is because the new interval `[4,9]`

overlaps with `[3,5],[6,7],[8,10]`

.

Given a collection of intervals, merge all overlapping intervals.

For example,

Given `[1,3],[2,6],[8,10],[15,18]`

,

return `[1,6],[8,10],[15,18]`

.

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Determine if you are able to reach the last index.

For example:

A = `[2,3,1,1,4]`

, return `true`

.

A = `[3,2,1,0,4]`

, return `false`

.

Given a matrix of *m* x *n* elements (*m* rows, *n* columns), return all elements of the matrix in spiral order.

For example,

Given the following matrix:

[ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ]

You should return `[1,2,3,6,9,8,7,4,5]`

.

Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array `[−2,1,−3,4,−1,2,1,−5,4]`

,

the contiguous subarray `[4,−1,2,1]`

has the largest sum = `6`

.

If you have figured out the O(*n*) solution, try coding another solution using the divide and conquer approach, which is more subtle.

Follow up for N-Queens problem.

Now, instead outputting board configurations, return the total number of distinct solutions.

Â» View Solution(link to this question)The *n*-queens puzzle is the problem of placing *n* queens on an *n*×*n* chessboard such that no two queens attack each other.

Given an integer *n*, return all distinct solutions to the *n*-queens puzzle.

Each solution contains a distinct board configuration of the *n*-queens' placement, where `'Q'`

and `'.'`

both indicate a queen and an empty space respectively.

For example,

There exist two distinct solutions to the 4-queens puzzle:

[ [".Q..", // Solution 1 "...Q", "Q...", "..Q."], ["..Q.", // Solution 2 "Q...", "...Q", ".Q.."] ]Â» View Solution(link to this question)

Given an array of strings, return all groups of strings that are anagrams.

Note: All inputs will be in lower-case.

Â» View Solution(link to this question)You are given an *n* x *n* 2D matrix representing an image.

Rotate the image by 90 degrees (clockwise).

Follow up:

Could you do this in-place?

Given a collection of numbers that might contain duplicates, return all possible unique permutations.

For example,

`[1,1,2]`

have the following unique permutations:

`[1,1,2]`

, `[1,2,1]`

, and `[2,1,1]`

.

Given a collection of numbers, return all possible permutations.

For example,

`[1,2,3]`

have the following permutations:

`[1,2,3]`

, `[1,3,2]`

, `[2,1,3]`

, `[2,3,1]`

, `[3,1,2]`

, and `[3,2,1]`

.

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Your goal is to reach the last index in the minimum number of jumps.

For example:

Given array A = `[2,3,1,1,4]`

The minimum number of jumps to reach the last index is `2`

. (Jump `1`

step from index 0 to 1, then `3`

steps to the last index.)

Implement wildcard pattern matching with support for `'?'`

and `'*'`

.

'?' Matches any single character. '*' Matches any sequence of characters (including the empty sequence). The matching should cover theÂ» View Solution(link to this question)entireinput string (not partial). The function prototype should be: bool isMatch(const char *s, const char *p) Some examples: isMatch("aa","a") ? false isMatch("aa","aa") ? true isMatch("aaa","aa") ? false isMatch("aa", "*") ? true isMatch("aa", "a*") ? true isMatch("ab", "?*") ? true isMatch("aab", "c*a*b") ? false

Given two numbers represented as strings, return multiplication of the numbers as a string.

Note: The numbers can be arbitrarily large and are non-negative.

Â» View Solution(link to this question) Given *n* non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

For example,

Given `[0,1,0,2,1,0,1,3,2,1,2,1]`

, return `6`

.

The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. **Thanks Marcos** for contributing this image!

Given an unsorted integer array, find the first missing positive integer.

For example,

Given `[1,2,0]`

return `3`

,

and `[3,4,-1,1]`

return `2`

.

Your algorithm should run in *O*(*n*) time and uses constant space.

Given a collection of candidate numbers (** C**) and a target number (

Each number in ** C** may only be used

**Note:**

- All numbers (including target) will be positive integers.
- Elements in a combination (
*a*_{1},*a*_{2}, … ,*a*_{k}) must be in non-descending order. (ie,*a*_{1}?*a*_{2}? … ?*a*_{k}). - The solution set must not contain duplicate combinations.

For example, given candidate set `10,1,2,7,6,1,5`

and target `8`

,

A solution set is:

`[1, 7]`

`[1, 2, 5]`

`[2, 6]`

`[1, 1, 6]`

Given a set of candidate numbers (** C**) and a target number (

The **same** repeated number may be chosen from ** C** unlimited number of times.

**Note:**

- All numbers (including target) will be positive integers.
- Elements in a combination (
*a*_{1},*a*_{2}, … ,*a*_{k}) must be in non-descending order. (ie,*a*_{1}?*a*_{2}? … ?*a*_{k}). - The solution set must not contain duplicate combinations.

For example, given candidate set `2,3,6,7`

and target `7`

,

A solution set is:

`[7]`

`[2, 2, 3]`

The count-and-say sequence is the sequence of integers beginning as follows:

`1, 11, 21, 1211, 111221, ...`

`1`

is read off as `"one 1"`

or `11`

.

`11`

is read off as `"two 1s"`

or `21`

.

`21`

is read off as `"one 2`

, then `one 1"`

or `1211`

.

Given an integer *n*, generate the *n*^{th} sequence.

Note: The sequence of integers will be represented as a string.

Â» View Solution(link to this question)Write a program to solve a Sudoku puzzle by filling the empty cells.

Empty cells are indicated by the character `'.'`

.

You may assume that there will be only one unique solution.

A sudoku puzzle...

...and its solution numbers marked in red.

Â» Solve this problem(link to this question)Determine if a Sudoku is valid, according to: Sudoku Puzzles - The Rules.

The Sudoku board could be partially filled, where empty cells are filled with the character `'.'`

.

A partially filled sudoku which is valid.

Â» View Solution(link to this question)Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

You may assume no duplicates in the array.

Here are few examples.

`[1,3,5,6]`

, 5 → 2

`[1,3,5,6]`

, 2 → 1

`[1,3,5,6]`

, 7 → 4

`[1,3,5,6]`

, 0 → 0

Given a sorted array of integers, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of *O*(log *n*).

If the target is not found in the array, return `[-1, -1]`

.

For example,

Given `[5, 7, 7, 8, 8, 10]`

and target value 8,

return `[3, 4]`

.

Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., `0 1 2 4 5 6 7`

might become `4 5 6 7 0 1 2`

).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

Â» View Solution(link to this question)Given a string containing just the characters `'('`

and `')'`

, find the length of the longest valid (well-formed) parentheses substring.

For `"(()"`

, the longest valid parentheses substring is `"()"`

, which has length = 2.

Another example is `")()())"`

, where the longest valid parentheses substring is `"()()"`

, which has length = 4.

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place, do not allocate extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.

`1,2,3`

→ `1,3,2`

`3,2,1`

→ `1,2,3`

`1,1,5`

→ `1,5,1`

You are given a string, **S**, and a list of words, **L**, that are all of the same length. Find all starting indices of substring(s) in S that is a concatenation of each word in L exactly once and without any intervening characters.

For example, given:

**S**: `"barfoothefoobarman"`

**L**: `["foo", "bar"]`

You should return the indices: `[0,9]`

.

(order does not matter).

Divide two integers without using multiplication, division and mod operator.

Â» View Solution(link to this question)Implement strStr().

Returns a pointer to the first occurrence of needle in haystack, or **null** if needle is not part of haystack.

Given an array and a value, remove all instances of that value in place and return the new length.

The order of elements can be changed. It doesn't matter what you leave beyond the new length.

Â» View Solution(link to this question) Given a sorted array, remove the duplicates in place such that each element appear only *once* and return the new length.

Do not allocate extra space for another array, you must do this in place with constant memory.

For example,

Given input array A = `[1,1,2]`

,

Your function should return length = `2`

, and A is now `[1,2]`

.

Given a linked list, reverse the nodes of a linked list *k* at a time and return its modified list.

If the number of nodes is not a multiple of *k* then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,

Given this linked list: `1->2->3->4->5`

For *k* = 2, you should return: `2->1->4->3->5`

For *k* = 3, you should return: `3->2->1->4->5`

Given a linked list, swap every two adjacent nodes and return its head.

For example,

Given `1->2->3->4`

, you should return the list as `2->1->4->3`

.

Your algorithm should use only constant space. You may **not** modify the values in the list, only nodes itself can be changed.

Merge *k* sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Given *n* pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given *n* = 3, a solution set is:

`"((()))", "(()())", "(())()", "()(())", "()()()"`

Given a string containing just the characters `'('`

, `')'`

, `'{'`

, `'}'`

, `'['`

and `']'`

, determine if the input string is valid.

The brackets must close in the correct order, `"()"`

and `"()[]{}"`

are all valid but `"(]"`

and `"([)]"`

are not.

Given a linked list, remove the *n*^{th} node from the end of list and return its head.

For example,

Given linked list:1->2->3->4->5, and. After removing the second node from the end, the linked list becomesn= 21->2->3->5.

**Note:**

Given *n* will always be valid.

Try to do this in one pass.

Given a digit string, return all possible letter combinations that the number could represent.

A mapping of digit to letters (just like on the telephone buttons) is given below.

Input:Digit string "23"Output:["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

**Note:**

Although the above answer is in lexicographical order, your answer could be in any order you want.

Given an array *S* of *n* integers, are there elements *a*, *b*, *c*, and *d* in *S* such that *a* + *b* + *c* + *d* = target? Find all unique quadruplets in the array which gives the sum of target.

**Note:**

- Elements in a quadruplet (
*a*,*b*,*c*,*d*) must be in non-descending order. (ie,*a*?*b*?*c*?*d*) - The solution set must not contain duplicate quadruplets.

For example, given array S = {1 0 -1 0 -2 2}, and target = 0. A solution set is: (-1, 0, 0, 1) (-2, -1, 1, 2) (-2, 0, 0, 2)Â» Solve this problem(link to this question)

Given an array *S* of *n* integers, find three integers in *S* such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

For example, given array S = {-1 2 1 -4}, and target = 1. The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).Â» View Solution(link to this question)

Given an array *S* of *n* integers, are there elements *a*, *b*, *c* in *S* such that *a* + *b* + *c* = 0? Find all unique triplets in the array which gives the sum of zero.

**Note:**

- Elements in a triplet (
*a*,*b*,*c*) must be in non-descending order. (ie,*a*?*b*?*c*) - The solution set must not contain duplicate triplets.

For example, given array S = {-1 0 1 2 -1 -4}, A solution set is: (-1, 0, 1) (-1, -1, 2)Â» View Solution(link to this question)

Write a function to find the longest common prefix string amongst an array of strings.

Â» View Solution(link to this question)Given a roman numeral, convert it to an integer.

Input is guaranteed to be within the range from 1 to 3999.

Â» View Solution(link to this question)Given an integer, convert it to a roman numeral.

Input is guaranteed to be within the range from 1 to 3999.

Â» View Solution(link to this question)Given *n* non-negative integers *a _{1}*,

Note: You may not slant the container.

Â» View Solution(link to this question)Implement regular expression matching with support for `'.'`

and `'*'`

.

'.' Matches any single character. '*' Matches zero or more of the preceding element. The matching should cover theÂ» Solve this problem(link to this question)entireinput string (not partial). The function prototype should be: bool isMatch(const char *s, const char *p) Some examples: isMatch("aa","a") ? false isMatch("aa","aa") ? true isMatch("aaa","aa") ? false isMatch("aa", "a*") ? true isMatch("aa", ".*") ? true isMatch("ab", ".*") ? true isMatch("aab", "c*a*b") ? true

Determine whether an integer is a palindrome. Do this without extra space.

Could negative integers be palindromes? (ie, -1)

If you are thinking of converting the integer to string, note the restriction of using extra space.

You could also try reversing an integer. However, if you have solved the problem "Reverse Integer", you know that the reversed integer might overflow. How would you handle such case?

There is a more generic way of solving this problem.

Implement atoi to convert a string to an integer.

**Hint:** Carefully consider all possible input cases. If you want a challenge, please do not see below and ask yourself what are the possible input cases.

**Notes:** It is intended for this problem to be specified vaguely (ie, no given input specs). You are responsible to gather all the input requirements up front.

spoilers alert... click to show requirements for atoi.

The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.

The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.

If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.

If no valid conversion could be performed, a zero value is returned. If the correct value is out of the range of representable values, INT_MAX (2147483647) or INT_MIN (-2147483648) is returned.

Reverse digits of an integer.

**Example1:** x = 123, return 321

**Example2:** x = -123, return -321

Here are some good questions to ask before coding. Bonus points for you if you have already thought through this!

If the integer's last digit is 0, what should the output be? ie, cases such as 10, 100.

Did you notice that the reversed integer might overflow? Assume the input is a 32-bit integer, then the reverse of 1000000003 overflows. How should you handle such cases?

Throw an exception? Good, but what if throwing an exception is not an option? You would then have to re-design the function (ie, add an extra parameter).

The string `"PAYPALISHIRING"`

is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)

P A H N A P L S I I G Y I RAnd then read line by line:

`"PAHNAPLSIIGYIR"`

Write the code that will take a string and make this conversion given a number of rows:

string convert(string text, int nRows);

`convert("PAYPALISHIRING", 3)`

should return `"PAHNAPLSIIGYIR"`

.Â» View Solution(link to this question)Given a string *S*, find the longest palindromic substring in *S*. You may assume that the maximum length of *S* is 1000, and there exists one unique longest palindromic substring.

You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

**Input:** (2 -> 4 -> 3) + (5 -> 6 -> 4)

**Output:** 7 -> 0 -> 8

Given a string, find the length of the longest substring without repeating characters. For example, the longest substring without repeating letters for "abcabcbb" is "abc", which the length is 3. For "bbbbb" the longest substring is "b", with the length of 1.

Â» View Solution(link to this question)There are two sorted arrays A and B of size m and n respectively. Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

Â» Solve this problem(link to this question)Given an array of integers, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution.

**Input:** numbers={2, 7, 11, 15}, target=9

**Output:** index1=1, index2=2