【計題01組01號】LeetCode——數組與字符串

尋找數組的中心索引

給你一個整數數組 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()

實現 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"]

數組拆分I

給定長度為 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

兩數之和II-輸入有序數組

給定一個已按照 非遞減順序排列  的整數數組 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,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

楊輝三角II

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

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

 

 

示例 1:

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

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

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

提示:

0 <= rowIndex <= 33
 

進階：

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

反轉字符串中的單詞III

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

 

示例：

輸入："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]
說明:

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