enumerate(iterable, start=0)

# 傳統(tǒng)寫法
nums = [1, 3, 5, 7]
i = 0
for val in nums:
    print(f"索引 {i}：值 {val}")
    i += 1
# enumerate 寫法
for idx, val in enumerate(nums):
    print(f"索引 {idx}：值 {val}")
# 自定義索引起始值（比如題目要求索引從 1 開始）
for idx, val in enumerate(nums, start=1):
    print(f"索引 {idx}：值 {val}")

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        n=len(nums)
        for i in range(n):
            for j in range(i+1,n):
                if target == nums[i]+nums[j]:
                    return[i,j]

from typing import List  # 導(dǎo)入List類型注解，用于指定參數(shù)和返回值類型
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        """
        給定一個整數(shù)數(shù)組 nums 和一個整數(shù)目標(biāo)值 target，
        請你在該數(shù)組中找出 和為目標(biāo)值 target 的那 兩個 整數(shù)，并返回它們的數(shù)組下標(biāo)。
        你可以假設(shè)每種輸入只會對應(yīng)一個答案，且同一個元素不能使用兩遍。
        你可以按任意順序返回答案。
        :param nums: 整數(shù)數(shù)組，存儲待查找的數(shù)字
        :param target: 目標(biāo)和，需要找到兩個數(shù)相加等于該值
        :return: 包含兩個數(shù)下標(biāo)List[int]，順序無要求
        """
        # 初始化一個空字典（哈希表），用于存儲「數(shù)字: 下標(biāo)」的映射
        # 作用：將遍歷過的數(shù)字和其下標(biāo)記錄下來，后續(xù)可以O(shè)(1)時間查詢是否存在目標(biāo)差值
        hashtable = dict()
        # 遍歷數(shù)組，enumerate同時返回下標(biāo)i和對應(yīng)數(shù)字num
        for i, num in enumerate(nums):
            # 計算目標(biāo)差值：target - 當(dāng)前數(shù)字 = 需要找的另一個數(shù)
            complement = target - num
            # 檢查哈希表中是否已經(jīng)存在這個差值
            # 如果存在，說明之前遍歷過的某個數(shù)字和當(dāng)前數(shù)字相加等于target
            if complement in hashtable:
                # 返回「差值對應(yīng)的下標(biāo)」和「當(dāng)前數(shù)字的下標(biāo)」，即為答案
                return [hashtable[complement], i]
            # 如果不存在，將當(dāng)前數(shù)字和其下標(biāo)存入哈希表，供后續(xù)遍歷查詢
            # 注意：先檢查再存入，避免同一個元素被重復(fù)使用（比如num=3, target=6時，不會匹配到自己）
            hashtable[nums[i]] = i
        # 題目保證有且僅有一個答案，理論上不會執(zhí)行到這里，返回空列表作為兜底
        return []

class Solution(object):
    def moveZeroes(self, nums):
        n=len(nums)
        left = right = 0
        while right<n:
            if nums[right]!=0:
                nums[left],nums[right]=nums[right],nums[left]
                left+=1
            right+=1

class Solution(object):
    def moveZeroes(self, nums):
        slow = 0  # 慢指針：記錄非零元素應(yīng)存放的位置，初始為0
    # enumerate的fast_idx作為快指針，遍歷數(shù)組篩選非零元素
        for fast_idx, val in enumerate(nums):
            if val != 0:  # 遇到非零元素，與慢指針位置交換并后移慢指針
                nums[slow], nums[fast_idx] = nums[fast_idx], nums[slow]
                slow += 1

class Solution(object):
    def findAnagrams(self, s, p):
        """
        :type s: str  # 原字符串
        :type p: str  # 目標(biāo)異位詞的基準(zhǔn)字符串
        :rtype: List[int]  # 返回所有異位詞在s中的起始索引
        """
        # 初始化結(jié)果列表
        result = []
        # 獲取p和s的長度
        len_p, len_s = len(p), len(s)
        # 邊界條件：如果p比s長，不可能有異位詞，直接返回空列表
        if len_p > len_s:
            return result
        # 初始化兩個數(shù)組，統(tǒng)計26個小寫字母的出現(xiàn)次數(shù)（ASCII碼映射）
        # ord('a') = 97，所以用 ord(c) - ord('a') 得到0-25的索引
        count_p = [0] * 26
        count_window = [0] * 26
        # 第一步：統(tǒng)計p的字符計數(shù)，同時初始化滑動窗口的初始狀態(tài)（前l(fā)en_p個字符）
        for i in range(len_p):
            # 統(tǒng)計p的字符
            count_p[ord(p[i]) - ord('a')] += 1
            # 統(tǒng)計s前l(fā)en_p個字符（初始窗口）
            count_window[ord(s[i]) - ord('a')] += 1
        # 檢查初始窗口是否匹配
        if count_p == count_window:
            result.append(0)
        # 第二步：滑動窗口遍歷s的剩余部分（從len_p到len_s-1）
        # 窗口起始索引從1開始，結(jié)束索引從len_p開始
        for right in range(len_p, len_s):
            # 移出窗口左側(cè)的字符（窗口起始索引是 right - len_p）
            left_char = s[right - len_p]
            count_window[ord(left_char) - ord('a')] -= 1
            # 移入窗口右側(cè)的新字符
            right_char = s[right]
            count_window[ord(right_char) - ord('a')] += 1
            # 檢查當(dāng)前窗口是否匹配p的字符計數(shù)
            if count_p == count_window:
                # 記錄當(dāng)前窗口的起始索引
                result.append(right - len_p + 1)
        return result

class Solution(object):
    def findAnagrams(self, s, p):
        """
        :type s: str
        :type p: str
        :rtype: List[int]
        """
        result = []
        len_p, len_s = len(p), len(s)
        # 邊界條件：p比s長直接返回空
        if len_p > len_s:
            return result
        # 初始化26字母計數(shù)數(shù)組
        count_p = [0] * 26
        count_window = [0] * 26
        # 第一步：統(tǒng)計p的字符，同時初始化窗口前l(fā)en_p個字符（用enumerate遍歷）
        # 遍歷p的字符，統(tǒng)計計數(shù)
        for idx, char in enumerate(p):
            count_p[ord(char) - ord('a')] += 1
        # 遍歷s前l(fā)en_p個字符，初始化窗口（用enumerate更清晰）
        for idx, char in enumerate(s[:len_p]):
            count_window[ord(char) - ord('a')] += 1
        # 檢查初始窗口是否匹配
        if count_p == count_window:
            result.append(0)
        # 第二步：滑動窗口（用enumerate遍歷s中從len_p開始的部分）
        # 遍歷的是s[len_p:]，enumerate的start參數(shù)指定索引從len_p開始（對應(yīng)原s的索引）
        for right_idx, right_char in enumerate(s[len_p:], start=len_p):
            # 計算要移出窗口的左側(cè)字符的索引
            left_idx = right_idx - len_p
            left_char = s[left_idx]
            # 移出左側(cè)字符：計數(shù)-1
            count_window[ord(left_char) - ord('a')] -= 1
            # 移入右側(cè)新字符：計數(shù)+1
            count_window[ord(right_char) - ord('a')] += 1
            # 檢查當(dāng)前窗口是否匹配，匹配則記錄起始索引（left_idx + 1）
            if count_p == count_window:
                result.append(left_idx + 1)
        return result

class Solution(object):
    def setZeroes(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
            # 初始化兩個集合，分別存儲需要置零的行和列
        rows = set()
        cols = set()
    # 第一步：遍歷矩陣，標(biāo)記需要置零的行和列
        m = len(matrix)       # 矩陣的行數(shù)
        if m == 0:
            return
        n = len(matrix[0])    # 矩陣的列數(shù)
        for i in range(m):
            for j in range(n):
                if matrix[i][j] == 0:
                    rows.add(i)
                    cols.add(j)
    # 第二步：根據(jù)標(biāo)記的行和列，將對應(yīng)位置置零
        for i in range(m):
            for j in range(n):
                if i in rows or j in cols:
                    matrix[i][j] = 0

class Solution(object):
    def setZeroes(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
        # 初始化兩個集合，分別存儲需要置零的行和列
        rows = set()
        cols = set()
        # 第一步：遍歷矩陣，用enumerate獲取行索引+行數(shù)據(jù)，標(biāo)記需要置零的行和列
        # 外層enumerate：i是行索引，row是當(dāng)前行的所有元素
        for i, row in enumerate(matrix):
            # 內(nèi)層enumerate：j是列索引，val是當(dāng)前位置的元素值
            for j, val in enumerate(row):
                if val == 0:
                    rows.add(i)   # 標(biāo)記需要置零的行
                    cols.add(j)   # 標(biāo)記需要置零的列
        # 第二步：再次遍歷矩陣，根據(jù)標(biāo)記置零（同樣用enumerate）
        for i, row in enumerate(matrix):
            for j, _ in enumerate(row):  # 只需要列索引j，元素值用_占位即可
                if i in rows or j in cols:
                    matrix[i][j] = 0

# 生成“元素值: 作為字典的“鍵”（適用于無重復(fù)元素的數(shù)組）
nums = [2, 7, 11, 15]
# 字典推導(dǎo)式 + enumerate：鍵是元素值，值是對應(yīng)索引
val2idx = {val: idx for idx, val in enumerate(nums)}
print(val2idx[7])  # 輸出：1（快速找到7的索引）

nums = [10, 20, 30]
# 將枚舉對象轉(zhuǎn)為列表，方便查看所有（索引，值）對
enum_list = list(enumerate(nums))
print(enum_list)  # 輸出：[(0, 10), (1, 20), (2, 30)]

nums = [5, 3, 8]
# start=1 讓索引從1開始，符合題目“第k個元素”的表述習(xí)慣
for idx, val in enumerate(nums, start=1):
    print(f"第 {idx} 個元素：{val}")  # 輸出：第1個元素：5，第2個元素：3...