Given an array of non-negative integers `nums`

, 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.

You can assume that you…

Given two List of strings **a **and **b**, we need to find the minimum number of manipulations required to make each two strings anagram from the two lists.

`Input : `

a = "a", "jk", "abb", "mn", "abc"…

Given the `root`

of a binary tree, the value of a target node `target`

, and an integer `k`

, return *an array of the values of all nodes that have a distance *`k`

* from the target node.*

You can return the answer in **any order**.

**Example 1:**

A company has `n`

employees with a unique ID for each employee from `0`

to `n - 1`

. The head of the company is the one with `headID`

.

Each employee has one direct manager given in the `manager`

array where `manager[i]`

is the direct manager of the `i-th`

employee, `manager[headID]…`

Given strings `s1`

and `s2`

, return *the minimum contiguous substring part of *`s1`

*, so that *`s2`

* is a subsequence of the part*.

If there is no such window in `s1`

that covers all characters in `s2`

, return the empty string `""`

. …

We are given a set of documents. Each document is submitted by a different individual. However, we suspect that some individuals may have copied from others. Given a plagiarized submitted document, we want to identify the number of documents with which there is a potential match. We have converted each…

Given an array of positive integers `nums`

and a positive integer `target`

, return the minimal length of a **contiguous subarray** `[numsl, numsl+1, ..., numsr-1, numsr]`

of which the sum is greater than or equal to `target`

. If there is no such subarray, return `0`

instead.

**Example 1:**

**Input:** target =…

`Input: arr[] = {1, 3, 6, 10, 11, 15};`

Output: 2

Input: arr[] = {1, 1, 1, 1};

Output: 5

Input: arr[] = {1, 1, 3, 4};

Output: 10

Input: arr[] = {1, 2, 5, 10, 20, 40};

Output: 4

Input: arr[] = {1, 2, 3, 4, 5, 6};

Output…

Given an array of integers `arr`

, you are initially positioned at the first index of the array.

In one step you can jump from an index `i`

to index:

`i + 1`

where:`i + 1 < arr.length`

.`i - 1`

where:`i - 1 >= 0`

.`j`

where:`arr[i]…`