1

給定一個整數數組 nums 和一個整數目標值 target，請你在該數組中找出 和為目標值 target 的那 兩個 整數，并返回它們的數組下標。

你可以假設每種輸入只會對應一個答案。但是，數組中同一個元素在答案里不能重復出現。

你可以按任意順序返回答案。

示例 1：

輸入：nums = [2,7,11,15], target = 9
輸出：[0,1]
解釋：因為 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

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

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

package mainimport "fmt"func twoSum(nums []int, target int) []int {numMap := make(map[int]int) // 前一個是鍵，后一個int是值，map是映射// 遍歷數組 nums，i 是當前元素的索引，num 是當前元素的值for i, num := range nums {complement := target - num// j：這是從 numMap 中獲取的與 complement 對應的值if j, ok := numMap[complement]; ok {// []int{j, i} 是一個整數切片的初始化.返回一個包含兩個整數的切片，第一個整數是 j，第二個整數是 ireturn []int{j, i}}numMap[num] = i}return nil
}func main() {nums1 := []int{2, 7, 11, 15}target1 := 9result1 := twoSum(nums1, target1)fmt.Println(result1)nums2 := []int{3, 2, 4}target2 := 6result2 := twoSum(nums2, target2)fmt.Println(result2)
}

2

給你兩個 非空 的鏈表，表示兩個非負的整數。它們每位數字都是按照 逆序 的方式存儲的，并且每個節點只能存儲 一位 數字。
請你將兩個數相加，并以相同形式返回一個表示和的鏈表。
你可以假設除了數字 0 之外，這兩個數都不會以 0 開頭。

package mainimport "fmt"// 表示鏈表節點的數據結構
type ListNode struct {Val  intNext *ListNode
}// 接受兩個非空鏈表，表示兩個非負整數，返回它們的和的鏈表
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {// create 一個虛擬頭節點dummyHead := &ListNode{}// create 一個指針current := dummyHead// 進位標志carry := 0// 遍歷兩個鏈表，直到兩個鏈表都遍歷完并且沒有進位為止for l1 != nil || l2 != nil || carry > 0 {// 計算當前位的數字總和sum := carryif l1 != nil {sum += l1.Vall1 = l1.Next}if l2 != nil {sum += l2.Vall2 = l2.Next}// 更新進位  ,注意這里如果小于10carry就是0，否則為1carry = sum / 10// 創建新節點存儲當前位的數字current.Next = &ListNode{Val: sum % 10}// 將指針移動到下一個節點current = current.Next}// 返回結果鏈表的頭節點的下一個節點（跳過虛擬頭節點）return dummyHead.Next
}// 用于打印鏈表的值，方便查看結果
func printLinkedList(node *ListNode) {for node != nil {fmt.Print(node.Val)if node.Next != nil {fmt.Print("->")}node = node.Next}fmt.Println()
}func main() {// 實例1l1 := &ListNode{Val: 2, Next: &ListNode{Val: 4, Next: &ListNode{Val: 3}}}l2 := &ListNode{Val: 5, Next: &ListNode{Val: 6, Next: &ListNode{Val: 4}}}result := addTwoNumbers(l1, l2)printLinkedList(result)
}

3

給定一個字符串 s ，請你找出其中不含有重復字符的 最長子串 的長度。
示例 1:

輸入: s = “abcabcbb”
輸出: 3
解釋: 因為無重復字符的最長子串是 “abc”，所以其長度為 3。
示例 2:

輸入: s = “bbbbb”
輸出: 1
解釋: 因為無重復字符的最長子串是 “b”，所以其長度為 1。
示例 3:

輸入: s = “pwwkew”
輸出: 3
解釋: 因為無重復字符的最長子串是 “wke”，所以其長度為 3。
請注意，你的答案必須是 子串 的長度，“pwke” 是一個子序列，不是子串。

假設我們有一個字符串：s = "abcabcbb"。

我們開始遍歷這個字符串，使用一個“盒子”來存儲不重復的字符。

1. 我們從字符串的開頭開始，第一個字符是 ‘a’，我們放入盒子中，盒子內有：[a]，目前盒子的長度為1。
2. 接著是 ‘b’，我們放入盒子中，盒子內有：[a, b]，目前盒子的長度為2。
3. 然后是 ‘c’，我們放入盒子中，盒子內有：[a, b, c]，目前盒子的長度為3。
4. 然后又是 ‘a’，在這里我們發現盒子內已經有了 ‘a’，所以我們需要重新開始計算盒子。我們將 ‘a’ 上一次出現的位置后面的字符都去掉，得到新的盒子內容為 [b, c, a]，目前盒子的長度為3。
5. 然后是 ‘b’，我們放入盒子中，盒子內有：[b, c, a]，目前盒子的長度為3。
6. 接著是 ‘c’，我們發現 ‘c’ 已經在盒子中了，所以我們需要重新開始計算盒子。我們將 ‘c’ 上一次出現的位置后面的字符都去掉，得到新的盒子內容為 [a, b, c]，目前盒子的長度為3。
7. 最后是 ‘b’，我們放入盒子中，盒子內有：[a, b, c]，目前盒子的長度為3。

我們遍歷完整個字符串后，最長的不含重復字符的子串就是 “abc”，它的長度為 3。

package mainimport "fmt"
// start 和 i 分別表示當前不含重復字符的子串的起始位置和結束位置。lastI 表示字符上一次出現的位置。func lengthOfLongestSubstring(s string) int {// 使用 map 存儲字符最后出現的位置lastOccurred := make(map[byte]int)start, maxLength := 0, 0// 遍歷字符串for i, ch := range []byte(s) {// 如果字符已經出現過，并且出現位置在當前子串中if lastI, ok := lastOccurred[ch]; ok && lastI >= start {start = lastI + 1 // 更新子串起始位置}// 更新字符最后出現的位置lastOccurred[ch] = i// 更新最大子串長度if i-start+1 > maxLength {maxLength = i - start + 1}}return maxLength
}func main() {s1 := "abcabcbb"fmt.Println(lengthOfLongestSubstring(s1))
}

4

給定兩個大小分別為 m 和 n 的正序（從小到大）數組 nums1 和 nums2。請你找出并返回這兩個正序數組的 中位數 。

算法的時間復雜度應該為 O(log (m+n)) 。
示例 1：

輸入：nums1 = [1,3], nums2 = [2]
輸出：2.00000
解釋：合并數組 = [1,2,3] ，中位數 2
示例 2：

輸入：nums1 = [1,2], nums2 = [3,4]
輸出：2.50000
解釋：合并數組 = [1,2,3,4] ，中位數 (2 + 3) / 2 = 2.5

# 雙斜杠 // 表示整數除法，它會將結果向下取整為最接近的整數
class Solution(object):def findMedianSortedArrays(self, nums1, nums2):""":type nums1: List[int]  # 接受的第一個有序數組:type nums2: List[int]  # 接受的第二個有序數組:rtype: float           # 返回值為中位數的浮點數"""m = len(nums1)  # 第一個數組的長度n = len(nums2)  # 第二個數組的長度for num in nums2:nums1.append(num)  # 將 nums2 中的所有元素添加到 nums1 中nums1.sort()  # 將合并后的 nums1 數組進行排序i = len(nums1)  # 合并后數組的長度if i % 2 == 0:  # 如果數組長度為偶數a = nums1[i // 2]  # 取中間兩個數中的后一個數b = nums1[i // 2 - 1]  # 取中間兩個數中的前一個數k = (float(a) + b) / 2  # 計算中位數else:  # 如果數組長度為奇數k = nums1[(i) // 2]  # 取中間的那個數作為中位數return k  # 返回中位數

5

給你一個字符串 s，找到 s 中最長的回文子串。
如果字符串的反序與原始字符串相同，則該字符串稱為回文字符串。
示例 1：

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

輸入：s = “cbbd”
輸出：“bb”

class Solution:def longestPalindrome(self, s: str) -> str:n = len(s)  # 字符串長度if n < 2:  # 如果字符串長度小于2，直接返回字符串本身return s# 創建一個包含 n 行的列表，每行包含 n 個元素，每個元素都是 Falsedp = [[False] * n for _ in range(n)]  # 創建一個二維數組，用于存儲子串是否為回文串的狀態start, max_len = 0, 1  # 記錄最長回文子串的起始位置和長度，默認為第一個字符和長度為1# 初始化長度為1和2的回文子串for i in range(n):dp[i][i] = Trueif i < n - 1 and s[i] == s[i + 1]:dp[i][i + 1] = Truestart = imax_len = 2# 從長度為3開始遍歷，更新狀態數組dpfor length in range(3, n + 1):for i in range(n - length + 1):j = i + length - 1  # 子串的結束位置if s[i] == s[j] and dp[i + 1][j - 1]:  # 如果子串兩端字符相等且去掉兩端字符后仍為回文串dp[i][j] = Truestart = i  # 更新最長回文子串的起始位置max_len = length  # 更新最長回文子串的長度# start 是子串的起始索引。
# start + max_len 是子串的結束索引（不包括該索引對應的字符）。
# 因此，s[start:start + max_len] 表示從字符串 s 中提取子串，起始索引為 start，結束索引為 start + max_len - 1，
# 即提取了從 start 開始到 start + max_len - 1（包括起始索引，不包括結束索引）的子串。return s[start:start + max_len]  # 返回最長回文子串

6