bowang0911/leetcode huggingface dataset:
Max Difference You Can Get From Changing an Integer

You are given an integer `num`. You will apply the following steps exactly **two** times:

*   Pick a digit `x (0 <= x <= 9)`.
*   Pick another digit `y (0 <= y <= 9)`. The digit `y` can be equal to `x`.
*   Replace all the occurrences of `x` in the decimal representation of `num` by `y`.
*   The new integer **cannot** have any leading zeros, also the new integer **cannot** be 0.

Let `a` and `b` be the results of applying the operations to `num` the first and second times, respectively.

Return _the max difference_ between `a` and `b`.

**Example 1:**

**Input:** num = 555
**Output:** 888
**Explanation:** The first time pick x = 5 and y = 9 and store the new integer in a.
The second time pick x = 5 and y = 1 and store the new integer in b.
We have now a = 999 and b = 111 and max difference = 888

**Example 2:**

**Input:** num = 9
**Output:** 8
**Explanation:** The first time pick x = 9 and y = 9 and store the new integer in a.
The second time pick x = 9 and y = 1 and store the new integer in b.
We have now a = 9 and b = 1 and max difference = 8

**Constraints:**

*   `1 <= num <= 10`8
Check If a String Can Break Another String

Given two strings: `s1` and `s2` with the same size, check if some permutation of string `s1` can break some permutation of string `s2` or vice-versa. In other words `s2` can break `s1` or vice-versa.

A string `x` can break string `y` (both of size `n`) if `x[i] >= y[i]` (in alphabetical order) for all `i` between `0` and `n-1`.

**Example 1:**

**Input:** s1 =  "abc ", s2 =  "xya "
**Output:** true
**Explanation:**  "ayx " is a permutation of s2= "xya " which can break to string  "abc " which is a permutation of s1= "abc ".

**Example 2:**

**Input:** s1 =  "abe ", s2 =  "acd "
**Output:** false 
**Explanation:** All permutations for s1= "abe " are:  "abe ",  "aeb ",  "bae ",  "bea ",  "eab " and  "eba " and all permutation for s2= "acd " are:  "acd ",  "adc ",  "cad ",  "cda ",  "dac " and  "dca ". However, there is not any permutation from s1 which can break some permutation from s2 and vice-versa.

**Example 3:**

**Input:** s1 =  "leetcodee ", s2 =  "interview "
**Output:** true

**Constraints:**

*   `s1.length == n`
*   `s2.length == n`
*   `1 <= n <= 10^5`
*   All strings consist of lowercase English letters.
Number of Ways to Wear Different Hats to Each Other

There are `n` people and `40` types of hats labeled from `1` to `40`.

Given a 2D integer array `hats`, where `hats[i]` is a list of all hats preferred by the `ith` person.

Return _the number of ways that the `n` people wear different hats to each other_.

Since the answer may be too large, return it modulo `109 + 7`.

**Example 1:**

**Input:** hats = \[\[3,4\],\[4,5\],\[5\]\]
**Output:** 1
**Explanation:** There is only one way to choose hats given the conditions. 
First person choose hat 3, Second person choose hat 4 and last one hat 5.

**Example 2:**

**Input:** hats = \[\[3,5,1\],\[3,5\]\]
**Output:** 4
**Explanation:** There are 4 ways to choose hats:
(3,5), (5,3), (1,3) and (1,5)

**Example 3:**

**Input:** hats = \[\[1,2,3,4\],\[1,2,3,4\],\[1,2,3,4\],\[1,2,3,4\]\]
**Output:** 24
**Explanation:** Each person can choose hats labeled from 1 to 4.
Number of Permutations of (1,2,3,4) = 24.

**Constraints:**

*   `n == hats.length`
*   `1 <= n <= 10`
*   `1 <= hats[i].length <= 40`
*   `1 <= hats[i][j] <= 40`
*   `hats[i]` contains a list of **unique** integers.
Destination City

You are given the array `paths`, where `paths[i] = [cityAi, cityBi]` means there exists a direct path going from `cityAi` to `cityBi`. _Return the destination city, that is, the city without any path outgoing to another city._

It is guaranteed that the graph of paths forms a line without any loop, therefore, there will be exactly one destination city.

**Example 1:**

**Input:** paths = \[\[ "London ", "New York "\],\[ "New York ", "Lima "\],\[ "Lima ", "Sao Paulo "\]\]
**Output:**  "Sao Paulo " 
**Explanation:** Starting at  "London " city you will reach  "Sao Paulo " city which is the destination city. Your trip consist of:  "London " ->  "New York " ->  "Lima " ->  "Sao Paulo ".

**Example 2:**

**Input:** paths = \[\[ "B ", "C "\],\[ "D ", "B "\],\[ "C ", "A "\]\]
**Output:**  "A "
**Explanation:** All possible trips are: 
 "D " ->  "B " ->  "C " ->  "A ". 
 "B " ->  "C " ->  "A ". 
 "C " ->  "A ". 
 "A ". 
Clearly the destination city is  "A ".

**Example 3:**

**Input:** paths = \[\[ "A ", "Z "\]\]
**Output:**  "Z "

**Constraints:**

*   `1 <= paths.length <= 100`
*   `paths[i].length == 2`
*   `1 <= cityAi.length, cityBi.length <= 10`
*   `cityAi != cityBi`
*   All strings consist of lowercase and uppercase English letters and the space character.
Check If All 1's Are at Least Length K Places Away

Given an binary array `nums` and an integer `k`, return `true` _if all_ `1`_'s are at least_ `k` _places away from each other, otherwise return_ `false`.

**Example 1:**

**Input:** nums = \[1,0,0,0,1,0,0,1\], k = 2
**Output:** true
**Explanation:** Each of the 1s are at least 2 places away from each other.

**Example 2:**

**Input:** nums = \[1,0,0,1,0,1\], k = 2
**Output:** false
**Explanation:** The second 1 and third 1 are only one apart from each other.

**Constraints:**

*   `1 <= nums.length <= 105`
*   `0 <= k <= nums.length`
*   `nums[i]` is `0` or `1`
Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit

Given an array of integers `nums` and an integer `limit`, return the size of the longest **non-empty** subarray such that the absolute difference between any two elements of this subarray is less than or equal to `limit`_._

**Example 1:**

**Input:** nums = \[8,2,4,7\], limit = 4
**Output:** 2 
**Explanation:** All subarrays are: 
\[8\] with maximum absolute diff |8-8| = 0 <= 4.
\[8,2\] with maximum absolute diff |8-2| = 6 > 4. 
\[8,2,4\] with maximum absolute diff |8-2| = 6 > 4.
\[8,2,4,7\] with maximum absolute diff |8-2| = 6 > 4.
\[2\] with maximum absolute diff |2-2| = 0 <= 4.
\[2,4\] with maximum absolute diff |2-4| = 2 <= 4.
\[2,4,7\] with maximum absolute diff |2-7| = 5 > 4.
\[4\] with maximum absolute diff |4-4| = 0 <= 4.
\[4,7\] with maximum absolute diff |4-7| = 3 <= 4.
\[7\] with maximum absolute diff |7-7| = 0 <= 4. 
Therefore, the size of the longest subarray is 2.

**Example 2:**

**Input:** nums = \[10,1,2,4,7,2\], limit = 5
**Output:** 4 
**Explanation:** The subarray \[2,4,7,2\] is the longest since the maximum absolute diff is |2-7| = 5 <= 5.

**Example 3:**

**Input:** nums = \[4,2,2,2,4,4,2,2\], limit = 0
**Output:** 3

**Constraints:**

*   `1 <= nums.length <= 105`
*   `1 <= nums[i] <= 109`
*   `0 <= limit <= 109`
Find the Kth Smallest Sum of a Matrix With Sorted Rows

You are given an `m x n` matrix `mat` that has its rows sorted in non-decreasing order and an integer `k`.

You are allowed to choose **exactly one element** from each row to form an array.

Return _the_ `kth` _smallest array sum among all possible arrays_.

**Example 1:**

**Input:** mat = \[\[1,3,11\],\[2,4,6\]\], k = 5
**Output:** 7
**Explanation:** Choosing one element from each row, the first k smallest sum are:
\[1,2\], \[1,4\], \[3,2\], \[3,4\], \[1,6\]. Where the 5th sum is 7.

**Example 2:**

**Input:** mat = \[\[1,3,11\],\[2,4,6\]\], k = 9
**Output:** 17

**Example 3:**

**Input:** mat = \[\[1,10,10\],\[1,4,5\],\[2,3,6\]\], k = 7
**Output:** 9
**Explanation:** Choosing one element from each row, the first k smallest sum are:
\[1,1,2\], \[1,1,3\], \[1,4,2\], \[1,4,3\], \[1,1,6\], \[1,5,2\], \[1,5,3\]. Where the 7th sum is 9.  

**Constraints:**

*   `m == mat.length`
*   `n == mat.length[i]`
*   `1 <= m, n <= 40`
*   `1 <= mat[i][j] <= 5000`
*   `1 <= k <= min(200, nm)`
*   `mat[i]` is a non-decreasing array.
Build an Array With Stack Operations

You are given an integer array `target` and an integer `n`.

You have an empty stack with the two following operations:

*   **`"Push "`**: pushes an integer to the top of the stack.
*   **`"Pop "`**: removes the integer on the top of the stack.

You also have a stream of the integers in the range `[1, n]`.

Use the two stack operations to make the numbers in the stack (from the bottom to the top) equal to `target`. You should follow the following rules:

*   If the stream of the integers is not empty, pick the next integer from the stream and push it to the top of the stack.
*   If the stack is not empty, pop the integer at the top of the stack.
*   If, at any moment, the elements in the stack (from the bottom to the top) are equal to `target`, do not read new integers from the stream and do not do more operations on the stack.

Return _the stack operations needed to build_ `target` following the mentioned rules. If there are multiple valid answers, return **any of them**.

**Example 1:**

**Input:** target = \[1,3\], n = 3
**Output:** \[ "Push ", "Push ", "Pop ", "Push "\]
**Explanation:** Initially the stack s is empty. The last element is the top of the stack.
Read 1 from the stream and push it to the stack. s = \[1\].
Read 2 from the stream and push it to the stack. s = \[1,2\].
Pop the integer on the top of the stack. s = \[1\].
Read 3 from the stream and push it to the stack. s = \[1,3\].

**Example 2:**

**Input:** target = \[1,2,3\], n = 3
**Output:** \[ "Push ", "Push ", "Push "\]
**Explanation:** Initially the stack s is empty. The last element is the top of the stack.
Read 1 from the stream and push it to the stack. s = \[1\].
Read 2 from the stream and push it to the stack. s = \[1,2\].
Read 3 from the stream and push it to the stack. s = \[1,2,3\].

**Example 3:**

**Input:** target = \[1,2\], n = 4
**Output:** \[ "Push ", "Push "\]
**Explanation:** Initially the stack s is empty. The last element is the top of the stack.
Read 1 from the stream and push it to the stack. s = \[1\].
Read 2 from the stream and push it to the stack. s = \[1,2\].
Since the stack (from the bottom to the top) is equal to target, we stop the stack operations.
The answers that read integer 3 from the stream are not accepted.

**Constraints:**

*   `1 <= target.length <= 100`
*   `1 <= n <= 100`
*   `1 <= target[i] <= n`
*   `target` is strictly increasing.
Count Triplets That Can Form Two Arrays of Equal XOR

Given an array of integers `arr`.

We want to select three indices `i`, `j` and `k` where `(0 <= i < j <= k < arr.length)`.

Let's define `a` and `b` as follows:

*   `a = arr[i] ^ arr[i + 1] ^ ... ^ arr[j - 1]`
*   `b = arr[j] ^ arr[j + 1] ^ ... ^ arr[k]`

Note that **^** denotes the **bitwise-xor** operation.

Return _the number of triplets_ (`i`, `j` and `k`) Where `a == b`.

**Example 1:**

**Input:** arr = \[2,3,1,6,7\]
**Output:** 4
**Explanation:** The triplets are (0,1,2), (0,2,2), (2,3,4) and (2,4,4)

**Example 2:**

**Input:** arr = \[1,1,1,1,1\]
**Output:** 10

**Constraints:**

*   `1 <= arr.length <= 300`
*   `1 <= arr[i] <= 108`
Minimum Time to Collect All Apples in a Tree

Given an undirected tree consisting of `n` vertices numbered from `0` to `n-1`, which has some apples in their vertices. You spend 1 second to walk over one edge of the tree. _Return the minimum time in seconds you have to spend to collect all apples in the tree, starting at **vertex 0** and coming back to this vertex._

The edges of the undirected tree are given in the array `edges`, where `edges[i] = [ai, bi]` means that exists an edge connecting the vertices `ai` and `bi`. Additionally, there is a boolean array `hasApple`, where `hasApple[i] = true` means that vertex `i` has an apple; otherwise, it does not have any apple.

**Example 1:**

**Input:** n = 7, edges = \[\[0,1\],\[0,2\],\[1,4\],\[1,5\],\[2,3\],\[2,6\]\], hasApple = \[false,false,true,false,true,true,false\]
**Output:** 8 
**Explanation:** The figure above represents the given tree where red vertices have an apple. One optimal path to collect all apples is shown by the green arrows.  

**Example 2:**

**Input:** n = 7, edges = \[\[0,1\],\[0,2\],\[1,4\],\[1,5\],\[2,3\],\[2,6\]\], hasApple = \[false,false,true,false,false,true,false\]
**Output:** 6
**Explanation:** The figure above represents the given tree where red vertices have an apple. One optimal path to collect all apples is shown by the green arrows.  

**Example 3:**

**Input:** n = 7, edges = \[\[0,1\],\[0,2\],\[1,4\],\[1,5\],\[2,3\],\[2,6\]\], hasApple = \[false,false,false,false,false,false,false\]
**Output:** 0

**Constraints:**

*   `1 <= n <= 105`
*   `edges.length == n - 1`
*   `edges[i].length == 2`
*   `0 <= ai < bi <= n - 1`
*   `hasApple.length == n`
Number of Ways of Cutting a Pizza

Given a rectangular pizza represented as a `rows x cols` matrix containing the following characters: `'A'` (an apple) and `'.'` (empty cell) and given the integer `k`. You have to cut the pizza into `k` pieces using `k-1` cuts.

For each cut you choose the direction: vertical or horizontal, then you choose a cut position at the cell boundary and cut the pizza into two pieces. If you cut the pizza vertically, give the left part of the pizza to a person. If you cut the pizza horizontally, give the upper part of the pizza to a person. Give the last piece of pizza to the last person.

_Return the number of ways of cutting the pizza such that each piece contains **at least** one apple._ Since the answer can be a huge number, return this modulo 10^9 + 7.

**Example 1:**

**Input:** pizza = \[ "A.. ", "AAA ", "... "\], k = 3
**Output:** 3 
**Explanation:** The figure above shows the three ways to cut the pizza. Note that pieces must contain at least one apple.

**Example 2:**

**Input:** pizza = \[ "A.. ", "AA. ", "... "\], k = 3
**Output:** 1

**Example 3:**

**Input:** pizza = \[ "A.. ", "A.. ", "... "\], k = 1
**Output:** 1

**Constraints:**

*   `1 <= rows, cols <= 50`
*   `rows == pizza.length`
*   `cols == pizza[i].length`
*   `1 <= k <= 10`
*   `pizza` consists of characters `'A'` and `'.'` only.
Consecutive Characters

The **power** of the string is the maximum length of a non-empty substring that contains only one unique character.

Given a string `s`, return _the **power** of_ `s`.

**Example 1:**

**Input:** s =  "leetcode "
**Output:** 2
**Explanation:** The substring  "ee " is of length 2 with the character 'e' only.

**Example 2:**

**Input:** s =  "abbcccddddeeeeedcba "
**Output:** 5
**Explanation:** The substring  "eeeee " is of length 5 with the character 'e' only.

**Constraints:**

*   `1 <= s.length <= 500`
*   `s` consists of only lowercase English letters.
Simplified Fractions

Given an integer `n`, return _a list of all **simplified** fractions between_ `0` _and_ `1` _(exclusive) such that the denominator is less-than-or-equal-to_ `n`. You can return the answer in **any order**.

**Example 1:**

**Input:** n = 2
**Output:** \[ "1/2 "\]
**Explanation:**  "1/2 " is the only unique fraction with a denominator less-than-or-equal-to 2.

**Example 2:**

**Input:** n = 3
**Output:** \[ "1/2 ", "1/3 ", "2/3 "\]

**Example 3:**

**Input:** n = 4
**Output:** \[ "1/2 ", "1/3 ", "1/4 ", "2/3 ", "3/4 "\]
**Explanation:**  "2/4 " is not a simplified fraction because it can be simplified to  "1/2 ".

**Constraints:**

*   `1 <= n <= 100`
Count Good Nodes in Binary Tree

Given a binary tree `root`, a node _X_ in the tree is named **good** if in the path from root to _X_ there are no nodes with a value _greater than_ X.

Return the number of **good** nodes in the binary tree.

**Example 1:**

**Input:** root = \[3,1,4,3,null,1,5\]
**Output:** 4
**Explanation:** Nodes in blue are **good**.
Root Node (3) is always a good node.
Node 4 -> (3,4) is the maximum value in the path starting from the root.
Node 5 -> (3,4,5) is the maximum value in the path
Node 3 -> (3,1,3) is the maximum value in the path.

**Example 2:**

**Input:** root = \[3,3,null,4,2\]
**Output:** 3
**Explanation:** Node 2 -> (3, 3, 2) is not good, because  "3 " is higher than it.

**Example 3:**

**Input:** root = \[1\]
**Output:** 1
**Explanation:** Root is considered as **good**.

**Constraints:**

*   The number of nodes in the binary tree is in the range `[1, 10^5]`.
*   Each node's value is between `[-10^4, 10^4]`.
Form Largest Integer With Digits That Add up to Target

Given an array of integers `cost` and an integer `target`, return _the **maximum** integer you can paint under the following rules_:

*   The cost of painting a digit `(i + 1)` is given by `cost[i]` (**0-indexed**).
*   The total cost used must be equal to `target`.
*   The integer does not have `0` digits.

Since the answer may be very large, return it as a string. If there is no way to paint any integer given the condition, return `"0 "`.

**Example 1:**

**Input:** cost = \[4,3,2,5,6,7,2,5,5\], target = 9
**Output:**  "7772 "
**Explanation:** The cost to paint the digit '7' is 2, and the digit '2' is 3. Then cost( "7772 ") = 2\*3+ 3\*1 = 9. You could also paint  "977 ", but  "7772 " is the largest number.
**Digit    cost**
  1  ->   4
  2  ->   3
  3  ->   2
  4  ->   5
  5  ->   6
  6  ->   7
  7  ->   2
  8  ->   5
  9  ->   5

**Example 2:**

**Input:** cost = \[7,6,5,5,5,6,8,7,8\], target = 12
**Output:**  "85 "
**Explanation:** The cost to paint the digit '8' is 7, and the digit '5' is 5. Then cost( "85 ") = 7 + 5 = 12.

**Example 3:**

**Input:** cost = \[2,4,6,2,4,6,4,4,4\], target = 5
**Output:**  "0 "
**Explanation:** It is impossible to paint any integer with total cost equal to target.

**Constraints:**

*   `cost.length == 9`
*   `1 <= cost[i], target <= 5000`
Number of Students Doing Homework at a Given Time

Given two integer arrays `startTime` and `endTime` and given an integer `queryTime`.

The `ith` student started doing their homework at the time `startTime[i]` and finished it at time `endTime[i]`.

Return _the number of students_ doing their homework at time `queryTime`. More formally, return the number of students where `queryTime` lays in the interval `[startTime[i], endTime[i]]` inclusive.

**Example 1:**

**Input:** startTime = \[1,2,3\], endTime = \[3,2,7\], queryTime = 4
**Output:** 1
**Explanation:** We have 3 students where:
The first student started doing homework at time 1 and finished at time 3 and wasn't doing anything at time 4.
The second student started doing homework at time 2 and finished at time 2 and also wasn't doing anything at time 4.
The third student started doing homework at time 3 and finished at time 7 and was the only student doing homework at time 4.

**Example 2:**

**Input:** startTime = \[4\], endTime = \[4\], queryTime = 4
**Output:** 1
**Explanation:** The only student was doing their homework at the queryTime.

**Constraints:**

*   `startTime.length == endTime.length`
*   `1 <= startTime.length <= 100`
*   `1 <= startTime[i] <= endTime[i] <= 1000`
*   `1 <= queryTime <= 1000`
Rearrange Words in a Sentence

Given a sentence `text` (A _sentence_ is a string of space-separated words) in the following format:

*   First letter is in upper case.
*   Each word in `text` are separated by a single space.

Your task is to rearrange the words in text such that all words are rearranged in an increasing order of their lengths. If two words have the same length, arrange them in their original order.

Return the new text following the format shown above.

**Example 1:**

**Input:** text =  "Leetcode is cool "
**Output:**  "Is cool leetcode "
**Explanation:** There are 3 words,  "Leetcode " of length 8,  "is " of length 2 and  "cool " of length 4.
Output is ordered by length and the new first word starts with capital letter.

**Example 2:**

**Input:** text =  "Keep calm and code on "
**Output:**  "On and keep calm code "
**Explanation:** Output is ordered as follows:
 "On " 2 letters.
 "and " 3 letters.
 "keep " 4 letters in case of tie order by position in original text.
 "calm " 4 letters.
 "code " 4 letters.

**Example 3:**

**Input:** text =  "To be or not to be "
**Output:**  "To be or to be not "

**Constraints:**

*   `text` begins with a capital letter and then contains lowercase letters and single space between words.
*   `1 <= text.length <= 10^5`
People Whose List of Favorite Companies Is Not a Subset of Another List

Given the array `favoriteCompanies` where `favoriteCompanies[i]` is the list of favorites companies for the `ith` person (**indexed from 0**).

_Return the indices of people whose list of favorite companies is not a **subset** of any other list of favorites companies_. You must return the indices in increasing order.

**Example 1:**

**Input:** favoriteCompanies = \[\[ "leetcode ", "google ", "facebook "\],\[ "google ", "microsoft "\],\[ "google ", "facebook "\],\[ "google "\],\[ "amazon "\]\]
**Output:** \[0,1,4\] 
**Explanation:** 
Person with index=2 has favoriteCompanies\[2\]=\[ "google ", "facebook "\] which is a subset of favoriteCompanies\[0\]=\[ "leetcode ", "google ", "facebook "\] corresponding to the person with index 0. 
Person with index=3 has favoriteCompanies\[3\]=\[ "google "\] which is a subset of favoriteCompanies\[0\]=\[ "leetcode ", "google ", "facebook "\] and favoriteCompanies\[1\]=\[ "google ", "microsoft "\]. 
Other lists of favorite companies are not a subset of another list, therefore, the answer is \[0,1,4\].

**Example 2:**

**Input:** favoriteCompanies = \[\[ "leetcode ", "google ", "facebook "\],\[ "leetcode ", "amazon "\],\[ "facebook ", "google "\]\]
**Output:** \[0,1\] 
**Explanation:** In this case favoriteCompanies\[2\]=\[ "facebook ", "google "\] is a subset of favoriteCompanies\[0\]=\[ "leetcode ", "google ", "facebook "\], therefore, the answer is \[0,1\].

**Example 3:**

**Input:** favoriteCompanies = \[\[ "leetcode "\],\[ "google "\],\[ "facebook "\],\[ "amazon "\]\]
**Output:** \[0,1,2,3\]

**Constraints:**

*   `1 <= favoriteCompanies.length <= 100`
*   `1 <= favoriteCompanies[i].length <= 500`
*   `1 <= favoriteCompanies[i][j].length <= 20`
*   All strings in `favoriteCompanies[i]` are **distinct**.
*   All lists of favorite companies are **distinct**, that is, If we sort alphabetically each list then `favoriteCompanies[i] != favoriteCompanies[j].`
*   All strings consist of lowercase English letters only.
Maximum Number of Darts Inside of a Circular Dartboard

Alice is throwing `n` darts on a very large wall. You are given an array `darts` where `darts[i] = [xi, yi]` is the position of the `ith` dart that Alice threw on the wall.

Bob knows the positions of the `n` darts on the wall. He wants to place a dartboard of radius `r` on the wall so that the maximum number of darts that Alice throws lies on the dartboard.

Given the integer `r`, return _the maximum number of darts that can lie on the dartboard_.

**Example 1:**

**Input:** darts = \[\[-2,0\],\[2,0\],\[0,2\],\[0,-2\]\], r = 2
**Output:** 4
**Explanation:** Circle dartboard with center in (0,0) and radius = 2 contain all points.

**Example 2:**

**Input:** darts = \[\[-3,0\],\[3,0\],\[2,6\],\[5,4\],\[0,9\],\[7,8\]\], r = 5
**Output:** 5
**Explanation:** Circle dartboard with center in (0,4) and radius = 5 contain all points except the point (7,8).

**Constraints:**

*   `1 <= darts.length <= 100`
*   `darts[i].length == 2`
*   `-104 <= xi, yi <= 104`
*   All the `darts` are unique
*   `1 <= r <= 5000`