給你一個整數陣列 nums ，請計算陣列的 中心下標 ，

陣列 中心下標 是陣列的一個下標，其左側所有元素相加的和等于右側所有元素相加的和，

如果中心下標位于陣列最左端，那么左側數之和視為 0 ，因為在下標的左側不存在元素，這一點對于中心下標位于陣列最右端同樣適用，

如果陣列有多個中心下標，應該回傳 最靠近左邊 的那一個，如果陣列不存在中心下標，回傳 -1 ，

示例 1：

輸入：nums = [1, 7, 3, 6, 5, 6]
輸出：3
解釋：
中心下標是 3 ，
左側數之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，
右側數之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等，
示例 2：

輸入：nums = [1, 2, 3]
輸出：-1
解釋：
陣列中不存在滿足此條件的中心下標，
示例 3：

輸入：nums = [2, 1, -1]
輸出：0
解釋：
中心下標是 0 ，
左側數之和 sum = 0 ，（下標 0 左側不存在元素），
右側數之和 sum = nums[1] + nums[2] = 1 + -1 = 0 ，

提示：

1 <= nums.length <= 104

-1000 <= nums[i] <= 1000

給定一個排序陣列和一個目標值，在陣列中找到目標值，并回傳其索引，如果目標值不存在于陣列中，回傳它將會被按順序插入的位置，

請必須使用時間復雜度為 O(log n) 的演算法，

示例 1:

輸入: nums = [1,3,5,6], target = 5
輸出: 2
示例 2:

輸入: nums = [1,3,5,6], target = 2
輸出: 1
示例 3:

輸入: nums = [1,3,5,6], target = 7
輸出: 4
示例 4:

輸入: nums = [1,3,5,6], target = 0
輸出: 0
示例 5:

輸入: nums = [1], target = 0
輸出: 0
 

提示:

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 為無重復元素的升序排列陣列
-104 <= target <= 104

以陣列 intervals 表示若干個區間的集合，其中單個區間為 intervals[i] = [starti, endi] ，請你合并所有重疊的區間，并回傳一個不重疊的區間陣列，該陣列需恰好覆寫輸入中的所有區間，

示例 1：

輸入：intervals = [[1,3],[2,6],[8,10],[15,18]]
輸出：[[1,6],[8,10],[15,18]]
解釋：區間 [1,3] 和 [2,6] 重疊, 將它們合并為 [1,6].
示例 2：

輸入：intervals = [[1,4],[4,5]]
輸出：[[1,5]]
解釋：區間 [1,4] 和 [4,5] 可被視為重疊區間，
 

提示：

1 <= intervals.length <= 104
intervals[i].length == 2
0 <= starti <= endi <= 104

給你一幅由 N × N 矩陣表示的影像，其中每個像素的大小為 4 位元組，請你設計一種演算法，將影像旋轉 90 度，

不占用額外記憶體空間能否做到？

示例 1:

給定 matrix = 
[
  [1,2,3],
  [4,5,6],
  [7,8,9]
],

原地旋轉輸入矩陣，使其變為:
[
  [7,4,1],
  [8,5,2],
  [9,6,3]
]
示例 2:

給定 matrix =
[
  [ 5, 1, 9,11],
  [ 2, 4, 8,10],
  [13, 3, 6, 7],
  [15,14,12,16]
], 

原地旋轉輸入矩陣，使其變為:
[
  [15,13, 2, 5],
  [14, 3, 4, 1],
  [12, 6, 8, 9],
  [16, 7,10,11]
]

撰寫一種演算法，若M × N矩陣中某個元素為0，則將其所在的行與列清零，

示例 1：

輸入：
[
  [1,1,1],
  [1,0,1],
  [1,1,1]
]
輸出：
[
  [1,0,1],
  [0,0,0],
  [1,0,1]
]
示例 2：

輸入：
[
  [0,1,2,0],
  [3,4,5,2],
  [1,3,1,5]
]
輸出：
[
  [0,0,0,0],
  [0,4,5,0],
  [0,3,1,0]
]

給你一個大小為 m x n 的矩陣 mat ，請以對角線遍歷的順序，用一個陣列回傳這個矩陣中的所有元素，

示例 1：

輸入：mat = [[1,2,3],[4,5,6],[7,8,9]]
輸出：[1,2,4,7,5,3,6,8,9]
示例 2：

輸入：mat = [[1,2],[3,4]]
輸出：[1,2,3,4]
 

提示：

m == mat.length
n == mat[i].length
1 <= m, n <= 104
1 <= m * n <= 104
-105 <= mat[i][j] <= 105

撰寫一個函式來查找字串陣列中的最長公共前綴，

如果不存在公共前綴，回傳空字串 ""，

示例 1：

輸入：strs = ["flower","flow","flight"]
輸出："fl"
示例 2：

輸入：strs = ["dog","racecar","car"]
輸出：""
解釋：輸入不存在公共前綴，
 

提示：

1 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 僅由小寫英文字母組成

給你一個字串 s，找到 s 中最長的回文子串，

示例 1：

輸入：s = "babad"
輸出："bab"
解釋："aba" 同樣是符合題意的答案，
示例 2：

輸入：s = "cbbd"
輸出："bb"
示例 3：

輸入：s = "a"
輸出："a"
示例 4：

輸入：s = "ac"
輸出："a"
 

提示：

1 <= s.length <= 1000
s 僅由數字和英文字母（大寫和/或小寫）組成

給你一個字串 s ，逐個翻轉字串中的所有 單詞 ，

單詞 是由非空格字符組成的字串，s 中使用至少一個空格將字串中的 單詞 分隔開，

請你回傳一個翻轉 s 中單詞順序并用單個空格相連的字串，

說明：

輸入字串 s 可以在前面、后面或者單詞間包含多余的空格，
翻轉后單詞間應當僅用一個空格分隔，
翻轉后的字串中不應包含額外的空格，
 

示例 1：

輸入：s = "the sky is blue"
輸出："blue is sky the"
示例 2：

輸入：s = "  hello world  "
輸出："world hello"
解釋：輸入字串可以在前面或者后面包含多余的空格，但是翻轉后的字符不能包括，
示例 3：

輸入：s = "a good   example"
輸出："example good a"
解釋：如果兩個單詞間有多余的空格，將翻轉后單詞間的空格減少到只含一個，
示例 4：

輸入：s = "  Bob    Loves  Alice   "
輸出："Alice Loves Bob"
示例 5：

輸入：s = "Alice does not even like bob"
輸出："bob like even not does Alice"
 

提示：

1 <= s.length <= 104
s 包含英文大小寫字母、數字和空格 ' '
s 中 至少存在一個 單詞
 

進階：

請嘗試使用 O(1) 額外空間復雜度的原地解法，

實作 strStr() 函式，

給你兩個字串 haystack 和 needle ，請你在 haystack 字串中找出 needle 字串出現的第一個位置（下標從 0 開始），如果不存在，則回傳  -1 ，

說明：

當 needle 是空字串時，我們應當回傳什么值呢？這是一個在面試中很好的問題，

對于本題而言，當 needle 是空字串時我們應當回傳 0 ，這與 C 語言的 strstr() 以及 Java 的 indexOf() 定義相符，

示例 1：

輸入：haystack = "hello", needle = "ll"
輸出：2
示例 2：

輸入：haystack = "aaaaa", needle = "bba"
輸出：-1
示例 3：

輸入：haystack = "", needle = ""
輸出：0
 

提示：

0 <= haystack.length, needle.length <= 5 * 104
haystack 和 needle 僅由小寫英文字符組成

撰寫一個函式，其作用是將輸入的字串反轉過來，輸入字串以字符陣列 s 的形式給出，

不要給另外的陣列分配額外的空間，你必須原地修改輸入陣列、使用 O(1) 的額外空間解決這一問題，

示例 1：

輸入：s = ["h","e","l","l","o"]
輸出：["o","l","l","e","h"]
示例 2：

輸入：s = ["H","a","n","n","a","h"]
輸出：["h","a","n","n","a","H"]

給定長度為 2n 的整數陣列 nums ，你的任務是將這些數分成 n 對, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得從 1 到 n 的 min(ai, bi) 總和最大，

回傳該 最大總和 ，

示例 1：

輸入：nums = [1,4,3,2]
輸出：4
解釋：所有可能的分法（忽略元素順序）為：
1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
所以最大總和為 4
示例 2：

輸入：nums = [6,2,6,5,1,2]
輸出：9
解釋：最優的分法為 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9

給定一個已按照 非遞減順序排列  的整數陣列 numbers ，請你從陣列中找出兩個數滿足相加之和等于目標數 target ，

函式應該以長度為 2 的整數陣列的形式回傳這兩個數的下標值，numbers 的下標 從 1 開始計數 ，所以答案陣列應當滿足 1 <= answer[0] < answer[1] <= numbers.length ，

你可以假設每個輸入 只對應唯一的答案 ，而且你 不可以 重復使用相同的元素，

 
示例 1：

輸入：numbers = [2,7,11,15], target = 9
輸出：[1,2]
解釋：2 與 7 之和等于目標數 9 ，因此 index1 = 1, index2 = 2 ，
示例 2：

輸入：numbers = [2,3,4], target = 6
輸出：[1,3]
示例 3：

輸入：numbers = [-1,0], target = -1
輸出：[1,2]
 

提示：

2 <= numbers.length <= 3 * 104
-1000 <= numbers[i] <= 1000
numbers 按 非遞減順序 排列
-1000 <= target <= 1000
僅存在一個有效答案

給你一個陣列 nums 和一個值 val，你需要 原地 移除所有數值等于 val 的元素，并回傳移除后陣列的新長度，

不要使用額外的陣列空間，你必須僅使用 O(1) 額外空間并 原地 修改輸入陣列，

元素的順序可以改變，你不需要考慮陣列中超出新長度后面的元素，

說明:

為什么回傳數值是整數，但輸出的答案是陣列呢?

請注意，輸入陣列是以「參考」方式傳遞的，這意味著在函式里修改輸入陣列對于呼叫者是可見的，

你可以想象內部操作如下:

// nums 是以“參考”方式傳遞的，也就是說，不對實參作任何拷貝
int len = removeElement(nums, val);

// 在函式里修改輸入陣列對于呼叫者是可見的，
// 根據你的函式回傳的長度, 它會列印出陣列中 該長度范圍內 的所有元素，
for (int i = 0; i < len; i++) {
    print(nums[i]);
}
 

示例 1：

輸入：nums = [3,2,2,3], val = 3
輸出：2, nums = [2,2]
解釋：函式應該回傳新的長度 2, 并且 nums 中的前兩個元素均為 2，你不需要考慮陣列中超出新長度后面的元素，例如，函式回傳的新長度為 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也會被視作正確答案，
示例 2：

輸入：nums = [0,1,2,2,3,0,4,2], val = 2
輸出：5, nums = [0,1,4,0,3]
解釋：函式應該回傳新的長度 5, 并且 nums 中的前五個元素為 0, 1, 3, 0, 4，注意這五個元素可為任意順序，你不需要考慮陣列中超出新長度后面的元素，

給定一個二進制陣列， 計算其中最大連續 1 的個數，

示例：

輸入：[1,1,0,1,1,1]
輸出：3
解釋：開頭的兩位和最后的三位都是連續 1 ，所以最大連續 1 的個數是 3.
 

提示：

輸入的陣列只包含 0 和 1 ，
輸入陣列的長度是正整數，且不超過 10,000，

給定一個含有 n 個正整數的陣列和一個正整數 target ，

找出該陣列中滿足其和 ≥ target 的長度最小的 連續子陣列 [numsl, numsl+1, ..., numsr-1, numsr] ，并回傳其長度，如果不存在符合條件的子陣列，回傳 0 ，

示例 1：

輸入：target = 7, nums = [2,3,1,2,4,3]
輸出：2
解釋：子陣列 [4,3] 是該條件下的長度最小的子陣列，
示例 2：

輸入：target = 4, nums = [1,4,4]
輸出：1
示例 3：

輸入：target = 11, nums = [1,1,1,1,1,1,1,1]
輸出：0
 

提示：

1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

給定一個非負整數 numRows，生成「楊輝三角」的前 numRows 行，

在「楊輝三角」中，每個數是它左上方和右上方的數的和，

示例 1:

輸入: numRows = 5
輸出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
示例 2:

輸入: numRows = 1
輸出: [[1]]

提示:

• 1 <= numRows <= 30

給定一個非負索引 rowIndex，回傳「楊輝三角」的第 rowIndex 行，

在「楊輝三角」中，每個數是它左上方和右上方的數的和，

示例 1:

輸入: rowIndex = 3
輸出: [1,3,3,1]
示例 2:

輸入: rowIndex = 0
輸出: [1]
示例 3:

輸入: rowIndex = 1
輸出: [1,1]
 

提示:

0 <= rowIndex <= 33
 

進階：

你可以優化你的演算法到 O(rowIndex) 空間復雜度嗎？

給定一個字串，你需要反轉字串中每個單詞的字符順序，同時仍保留空格和單詞的初始順序，

示例：

輸入："Let's take LeetCode contest"
輸出："s'teL ekat edoCteeL tsetnoc"
 

提示：

在字串中，每個單詞由單個空格分隔，并且字串中不會有任何額外的空格，

已知一個長度為 n 的陣列，預先按照升序排列，經由 1 到 n 次 旋轉 后，得到輸入陣列，例如，原陣列 nums = [0,1,2,4,5,6,7] 在變化后可能得到：
若旋轉 4 次，則可以得到 [4,5,6,7,0,1,2]
若旋轉 7 次，則可以得到 [0,1,2,4,5,6,7]
注意，陣列 [a[0], a[1], a[2], ..., a[n-1]] 旋轉一次 的結果為陣列 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] ，

給你一個元素值 互不相同 的陣列 nums ，它原來是一個升序排列的陣列，并按上述情形進行了多次旋轉，請你找出并回傳陣列中的 最小元素 ，

示例 1：

輸入：nums = [3,4,5,1,2]
輸出：1
解釋：原陣列為 [1,2,3,4,5] ，旋轉 3 次得到輸入陣列，
示例 2：

輸入：nums = [4,5,6,7,0,1,2]
輸出：0
解釋：原陣列為 [0,1,2,4,5,6,7] ，旋轉 4 次得到輸入陣列，
示例 3：

輸入：nums = [11,13,15,17]
輸出：11
解釋：原陣列為 [11,13,15,17] ，旋轉 4 次得到輸入陣列，
 

提示：

n == nums.length
1 <= n <= 5000
-5000 <= nums[i] <= 5000
nums 中的所有整數 互不相同
nums 原來是一個升序排序的陣列，并進行了 1 至 n 次旋轉

給你一個有序陣列 nums ，請你 原地 洗掉重復出現的元素，使每個元素 只出現一次 ，回傳洗掉后陣列的新長度，

不要使用額外的陣列空間，你必須在 原地 修改輸入陣列 并在使用 O(1) 額外空間的條件下完成，

說明:

為什么回傳數值是整數，但輸出的答案是陣列呢?

請注意，輸入陣列是以「參考」方式傳遞的，這意味著在函式里修改輸入陣列對于呼叫者是可見的，

你可以想象內部操作如下:

// nums 是以“參考”方式傳遞的，也就是說，不對實參做任何拷貝
int len = removeDuplicates(nums);

// 在函式里修改輸入陣列對于呼叫者是可見的，
// 根據你的函式回傳的長度, 它會列印出陣列中 該長度范圍內 的所有元素，
for (int i = 0; i < len; i++) {
    print(nums[i]);
}
 
示例 1：

輸入：nums = [1,1,2]
輸出：2, nums = [1,2]
解釋：函式應該回傳新的長度 2 ，并且原陣列 nums 的前兩個元素被修改為 1, 2 ，不需要考慮陣列中超出新長度后面的元素，
示例 2：

輸入：nums = [0,0,1,1,1,2,2,3,3,4]
輸出：5, nums = [0,1,2,3,4]
解釋：函式應該回傳新的長度 5 ， 并且原陣列 nums 的前五個元素被修改為 0, 1, 2, 3, 4 ，不需要考慮陣列中超出新長度后面的元素，
 

提示：

0 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按升序排列

給定一個陣列 nums，撰寫一個函式將所有 0 移動到陣列的末尾，同時保持非零元素的相對順序，

示例:

輸入: [0,1,0,3,12]
輸出: [1,3,12,0,0]
說明:

必須在原陣列上操作，不能拷貝額外的陣列，
盡量減少操作次數，