下标索引 VS for循环遍历

1. 序列类型与索引的概念
   • 在 Python 中，许多数据类型都属于序列类型，例如字符串（str）、列表（list）、元组（tuple）等。序列中的每个元素都有一个对应的位置编号，这个位置编号就是索引。
   • 索引从 0 开始，即序列中的第一个元素的索引为 0，第二个元素的索引为 1，以此类推。例如，对于字符串"hello"，字符'h'的索引是 0，字符'e'的索引是 1。
   • 除了正向索引，还可以使用负向索引。负向索引从 - 1 开始，表示序列中的最后一个元素， - 2 表示倒数第二个元素，依此类推。例如，对于字符串"hello"，'o'的负向索引是 - 1。
2. 使用索引访问元素
   • 对于列表my_list = [10, 20, 30, 40]，可以使用索引来访问其中的元素。例如，my_list[0]将返回 10，my_list[2]将返回 30。
   • 对于字符串也同样适用，例如，对于字符串my_string = "python"，my_string[1]将返回'y'。
   • 如果使用的索引超出了序列的范围，将会引发IndexError异常。例如，对于列表my_list = [1, 2, 3]，my_list[3]会导致错误，因为该列表最大索引为 2。
3. 索引切片
   • 除了单个元素的索引访问，还可以使用切片来获取序列的一部分。切片的语法是sequence[start:stop:step]。
   • start表示起始索引（包含），stop表示结束索引（不包含），step表示步长。例如，对于列表my_list = [1, 2, 3, 4, 5]，my_list[1:3]将返回[2, 3]，这里起始索引是 1，结束索引是 3，所以获取的是索引为 1 和 2 的元素。
   • 如果省略start，则从序列的开头开始切片，例如my_list[:3]等同于my_list[0:3]，将返回[1, 2, 3]。如果省略stop，则切片到序列的末尾，例如my_list[2:]将返回[3, 4, 5]。如果step不为 1，例如my_list[0:5:2]，将返回[1, 3, 5]，表示每隔一个元素取一个。

1. 基本语法和原理
   • Python 中的for循环用于遍历可迭代对象（如列表、元组、字符串、字典等）。其基本语法为：

   for variable in iterable:
       # 循环体语句

• 其中，variable是在每次循环中用来接收可迭代对象中的元素的变量，iterable是要遍历的可迭代对象。例如，对于列表my_list = [10, 20, 30]，可以使用for循环遍历：

   for num in my_list:
       print(num)

• 在每次循环中，num将依次被赋值为my_list中的元素 10、20、30，然后执行循环体中的print(num)语句。

1. 遍历不同类型的可迭代对象
   • 遍历列表：如上面的例子所示，通过for循环可以轻松遍历列表中的每个元素。
   • 遍历字符串：对于字符串my_string = "python"，可以这样遍历：

   for char in my_string:
       print(char)

• 这将依次打印出字符串中的每个字符'p'、'y'、't'、'h'、'o'、'n'。
• 遍历字典（键）：对于字典my_dict = {'a': 1, 'b': 2, 'c': 3}，如果直接使用for循环，默认是遍历字典的键：

   for key in my_dict:
       print(key)

• 这将打印出字典的键'a'、'b'、'c'。如果想要同时遍历键和值，可以使用items()方法，例如：

   for key, value in my_dict.items():
       print(key, value)

• 这将打印出'a' 1、'b' 2、'c' 3。

1. for循环中的else子句
   • Python 的for循环还可以有else子句。当for循环正常结束（即没有通过break语句提前跳出循环）时，else子句中的代码将被执行。例如：

   my_list = [1, 2, 3]
   for num in my_list:
       print(num)
   else:
       print("The loop has finished without break.")

• 在这个例子中，因为for循环正常结束，所以else子句中的print语句将被执行。如果在for循环中使用break语句提前跳出循环，else子句将不会被执行。

​下面直接看题：

题目：

给你一个下标从 0 开始、长度为 n 的整数数组 nums ，以及整数 indexDifference 和整数 valueDifference 。

你的任务是从范围 [0, n - 1] 内找出  2 个满足下述所有条件的下标 i 和 j ：

• abs(i - j) >= indexDifference 且
• abs(nums[i] - nums[j]) >= valueDifference

返回整数数组 answer。如果存在满足题目要求的两个下标，则 answer = [i, j] ；否则，answer = [-1, -1] 。如果存在多组可供选择的下标对，只需要返回其中任意一组即可。

注意：i 和 j 可能 相等 。

示例 1：

输入：nums = [5,1,4,1], indexDifference = 2, valueDifference = 4
输出：[0,3]
解释：在示例中，可以选择 i = 0 和 j = 3 。
abs(0 - 3) >= 2 且 abs(nums[0] - nums[3]) >= 4 。
因此，[0,3] 是一个符合题目要求的答案。
[3,0] 也是符合题目要求的答案。

示例 2：

输入：nums = [2,1], indexDifference = 0, valueDifference = 0
输出：[0,0]
解释：
在示例中，可以选择 i = 0 和 j = 0 。 
abs(0 - 0) >= 0 且 abs(nums[0] - nums[0]) >= 0 。 
因此，[0,0] 是一个符合题目要求的答案。 
[0,1]、[1,0] 和 [1,1] 也是符合题目要求的答案。 

示例 3：

输入：nums = [1,2,3], indexDifference = 2, valueDifference = 4
输出：[-1,-1]
解释：在示例中，可以证明无法找出 2 个满足所有条件的下标。
因此，返回 [-1,-1] 。

解题思路:

        两层for循环，第一层遍历下标为0到(n-indexDifference),第二层遍历(i+indexDifference)到n，这样就可以保证下标差一定是满足第一个条件的，我们只需要去判断第二个条件是否成立即可。

代码：

class Solution:
    def findIndices(self, nums: list[int], indexDifference: int, valueDifference: int) -> list[int]:
        n=len(nums)
        for i in range(n-indexDifference):
            for j in range(i+indexDifference,n):
                if abs(nums[i]-nums[j])>=valueDifference:
                    return [i,j]
        return [-1,-1]

        这段代码定义了一个名为Solution的类，其中包含一个名为findIndices的方法。该方法接受一个整数列表nums，一个整数indexDifference和一个整数valueDifference作为输入。它返回一个包含两个索引i和j的列表，这两个索引位置上的数字的绝对差至少为valueDifference，并且它们的索引距离大于等于indexDifference。

        如果存在这样的索引位置，则该方法返回这些索引[i, j]，否则返回[-1, -1]。

        这个实现循环遍历了指定范围内的索引i和j，并检查是否满足绝对差条件。如果满足条件，方法会返回这两个索引。这段代码存当找到满足条件的第一对索引时就返回，符合题意。

​