Given an `m x n`

integer matrix `matrix`

, if an element is `0`

, set its entire row and column to `0`

's.

You must do it in place.

**Example 1:**

`Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]`

Output: [[1,0,1],[0,0,0],[1,0,1]]

**Example 2:**

Given an `m x n`

integer matrix `matrix`

, if an element is `0`

, set its entire row and column to `0`

's.

You must do it in place.

**Example 1:**

`Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]`

Output: [[1,0,1],[0,0,0],[1,0,1]]

**Example 2:**

You are given the head of a singly linked-list. The list can be represented as:

`L0 → L1 → … → Ln - 1 → Ln`

*Reorder the list to be on the following form:*

`L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2…`

Given the `head`

of a linked list, remove the `nth`

node from the end of the list and return its head.

**Example 1:**

`Input: head = [1,2,3,4,5], n = 2`

Output: [1,2,3,5]

**Example 2:**

`Input: head = [1], n = 1`

Output: []

**Example 3:**

`Input: head = [1,2], n…`

You are given an array of `k`

linked-lists `lists`

, each linked-list is sorted in ascending order.

*Merge all the linked-lists into one sorted linked-list and return it.*

**Example 1:**

`Input: lists = [[1,4,5],[1,3,4],[2,6]]`

Output: [1,1,2,3,4,4,5,6]

Explanation: The linked-lists are:

[

1->4->5,

1->3->4,

2->6

]

merging them into one sorted list:

1->1->2->3->4->4->5->6…

Given an array of intervals `intervals`

where `intervals[i] = [starti, endi]`

, return *the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping*.

**Example 1:**

`Input: intervals = [[1,2],[2,3],[3,4],[1,3]]`

Output: 1

Explanation: [1,3] can be removed and the rest of the intervals are non-overlapping.

**…**

Given an unsorted array of integers `nums`

, return *the length of the longest consecutive elements sequence.*

You must write an algorithm that runs in `O(n)`

time.

Example 1:

`Input: nums = [100,4,200,1,3,2]`

Output: 4

Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.

…

Given an `m x n`

2D binary grid `grid`

which represents a map of `'1'`

s (land) and `'0'`

s (water), return *the number of islands*.

An **island** is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are…