循环数组中索引相对偏移量的优化计算方法

function getOffset(currentIndex: number, index: number, length: number): number {
  const diff = index - currentIndex;

  if (diff === 0) {
    return 0;
  } else if (diff < 0) { // 处理负向差异
    if (diff < -3) { // 负向超出3个位置，考虑循环
      // Math.min(length - currentIndex + index, 3) 这里的逻辑可能不够直观且存在问题
      // 实际上需要将其映射到 -3
      // 对于 currentIndex=0, index=6, length=10: diff=-4. 期望是+3
      // 对于 currentIndex=0, index=7, length=10: diff=-3. 期望是-3
      // 对于 currentIndex=0, index=9, length=10: diff=-1. 期望是-1
      // 这里的原始代码逻辑复杂且与预期不完全匹配
      return Math.min(length + diff, 3); // 修正：这是为了获取正向的循环距离，但后续判断仍需优化
    } else { // 负向3个位置内
      return diff; // 原始代码这里返回 Math.min(diff, 3) 是错误的，因为diff本身是负数
    }
  } else { // 处理正向差异
    if (diff > 3) { // 正向超出3个位置，考虑循环
      // Math.max(diff - length, -3) 这里的逻辑也复杂
      // 对于 currentIndex=0, index=4, length=10: diff=4. 期望是+3
      // 对于 currentIndex=0, index=7, length=10: diff=7. 期望是+3
      return Math.max(diff - length, -3); // 修正：这是为了获取负向的循环距离，但后续判断仍需优化
    } else { // 正向3个位置内
      return diff; // 原始代码这里返回 Math.min(diff, 3) 冗余，因为diff已小于等于3
    }
  }
}

function getOffset(currentIndex: number, index: number, length: number): number {
  // 1. 计算从 currentIndex 到 index 的正向循环距离
  // (index - currentIndex + length) 确保结果为正，然后 % length 得到0到length-1的距离
  const diff = (index - currentIndex + length) % length;

  // 2. 根据正向循环距离判断实际偏移量
  if (diff <= 3) {
    // 如果正向距离在0到3之间，直接返回这个距离
    // 对应 0, +1, +2, +3
    return diff;
  } else if (diff >= length - 3) {
    // 如果正向距离接近数组末尾（例如 length-1, length-2, length-3）
    // 这意味着它实际上是负向的循环距离
    // 例如，length=10, diff=9 (index=9, currentIndex=0) -> 9 - 10 = -1
    // 例如, length=10, diff=7 (index=7, currentIndex=0) -> 7 - 10 = -3
    return diff - length;
  } else {
    // 剩下的情况是：正向距离大于3，且不是负向的循环距离（即不在 length-3 到 length-1 之间）
    // 这些索引被视为超出范围的“远端”正向偏移，统一映射为 +3
    // 例如，length=10, currentIndex=0, index=4,5,6: diff=4,5,6
    // 这些都映射为 +3
    return 3;
  }
}

// 期望输出: 0
console.log(`getOffset(0, 0, 10) -> ${getOffset(0, 0, 10)}`); // diff = (0 - 0 + 10) % 10 = 0. 0 <= 3, return 0. (正确)

// 期望输出: 1
console.log(`getOffset(0, 1, 10) -> ${getOffset(0, 1, 10)}`); // diff = (1 - 0 + 10) % 10 = 1. 1 <= 3, return 1. (正确)

// 期望输出: -1
console.log(`getOffset(0, 9, 10) -> ${getOffset(0, 9, 10)}`); // diff = (9 - 0 + 10) % 10 = 9. 9 >= 10 - 3 (7), return 9 - 10 = -1. (正确)

// 期望输出: 3
console.log(`getOffset(0, 6, 10) -> ${getOffset(0, 6, 10)}`); // diff = (6 - 0 + 10) % 10 = 6. 6 不满足 <=3 也不满足 >=7, return 3. (正确)

// 更多测试用例：
// 期望输出: 2
console.log(`getOffset(0, 2, 10) -> ${getOffset(0, 2, 10)}`); // diff = 2. return 2. (正确)

// 期望输出: 3
console.log(`getOffset(0, 3, 10) -> ${getOffset(0, 3, 10)}`); // diff = 3. return 3. (正确)

// 期望输出: -2
console.log(`getOffset(0, 8, 10) -> ${getOffset(0, 8, 10)}`); // diff = 8. return 8 - 10 = -2. (正确)

// 期望输出: -3
console.log(`getOffset(0, 7, 10) -> ${getOffset(0, 7, 10)}`); // diff = 7. return 7 - 10 = -3. (正确)

// 期望输出: 3 (远端正向)
console.log(`getOffset(0, 4, 10) -> ${getOffset(0, 4, 10)}`); // diff = 4. else 分支, return 3. (正确)

// 期望输出: 3 (远端正向)
console.log(`getOffset(0, 5, 10) -> ${getOffset(0, 5, 10)}`); // diff = 5. else 分支, return 3. (正确)

// 改变 currentIndex
// currentIndex = 5, index = 8, length = 10
// 期望输出: 3 (8在5的+3位置)
console.log(`getOffset(5, 8, 10) -> ${getOffset(5, 8, 10)}`); // diff = (8 - 5 + 10) % 10 = 3. return 3. (正确)

// currentIndex = 5, index = 2, length = 10
// 期望输出: -3 (2在5的-3位置)
console.log(`getOffset(5, 2, 10) -> ${getOffset(5, 2, 10)}`); // diff = (2 - 5 + 10) % 10 = 7. 7 >= 7, return 7 - 10 = -3. (正确)

// currentIndex = 5, index = 0, length = 10
// 期望输出: -3 (0在5的-5位置，应映射为-3)
console.log(`getOffset(5, 0, 10) -> ${getOffset(5, 0, 10)}`); // diff = (0 - 5 + 10) % 10 = 5. else 分支, return 3. (错误，期望-3)
// 修正：这里发现一个问题，当diff=5时，它应该被视为负向的远端。
// 问题在于 `diff >= length - 3` 只能捕获到 `length-1, length-2, length-3`。
// 对于 `length=10, currentIndex=5, index=0`，diff是5。
// 线性距离是 `0-5 = -5`。循环距离是 `5`。
// 如果 `diff > length / 2`，则更倾向于负向距离。
// 重新审视需求：`offset = 0, +1, +2, +3, -1, -2, -3`。
// `4,5,6` 映射到 `+3`。`7,8,9` 映射到 `-3, -2, -1`。
// 这里的 `getOffset(0, 6, 10) -> 3` 是正确的。
// `getOffset(0, 7, 10) -> -3` 是正确的。
// `getOffset(5, 0, 10)` 期望是 `-3`。
// `diff = (0 - 5 + 10) % 10 = 5`。
// `5 <= 3` (否)
// `5 >= 10 - 3 = 7` (否)
// `else { return 3; }`
// 看来这个优化后的函数没有完全满足 `currentIndex = 0, offset = -3` 对应 `index = 7`，而 `currentIndex = 5, offset = -3` 对应 `index = 2` 的需求。
// 并且 `currentIndex = 5, index = 0` 应该映射到 `-3`，但结果是 `3`。

// 仔细阅读原始问题描述：
// offset   0   +1   +2   +3   +3   +3   +3   -3   -2   -1
// indices  0    1    2    3    4    5    6    7    8    9
// 这段描述意味着：
// 0 -> 0
// 1 -> +1
// 2 -> +2
// 3 -> +3
// 4 -> +3 (远端正向)
// 5 -> +3 (远端正向)
// 6 -> +3 (远端正向)
// 7 -> -3 (远端负向)
// 8 -> -2 (近端负向)
// 9 -> -1 (近端负向)

// 根据这个映射，`getOffset(0, 6, 10)` 期望是 `3`，当前函数输出 `3`，正确。
// `getOffset(0, 7, 10)` 期望是 `-3`，当前函数输出 `-3`，正确。
// 那么 `getOffset(5, 0, 10)` 呢？
// `currentIndex = 5`, `index = 0`, `length = 10`
// `diff = (0 - 5 + 10) % 10 = 5`
// 此时 `index = 0` 相对于 `currentIndex = 5` 的线性距离是 `-5`。
// 循环距离（正向）是 `5`。
// 按照表格，`0` 相当于 `5 - 5`。
// 如果我们把 `currentIndex` 想象成 `0`，那么 `index = 0` 相当于 `index = 5`。
// 那么 `offset` 应该是 `+3`。
// 原始问题中的 `offset` 表格是针对 `currentIndex = 0` 的。
// 它的规则是：
// `index` 在 `[0, 3]` 之间，直接返回 `index`。
// `index` 在 `[4, 6]` 之间，返回 `3`。
// `index` 在 `[7, 7]` 之间，返回 `-3`。
// `index` 在 `[8, 9]` 之间，返回 `index - 10`。

// 这意味着 `offset` 的计算是基于 `index` 和 `currentIndex` 的相对位置，但最终的映射规则有点特殊。
// 优化后的函数 `getOffset(currentIndex, index, length)` 的逻辑是：
// 1. `diff = (index - currentIndex + length) % length;` (计算正向循环距离)
// 2. `if (diff <= 3) return diff;` (0, 1, 2, 3)
// 3. `else if (diff >= length - 3) return diff - length;` (-1, -2, -3)
// 4. `else return 3;` (所有其他情况，即 `4, 5, ..., length-4` 之间的 `diff` 都返回 `3`)

// 让我们重新检查 `getOffset(5, 0, 10)` 的结果。
// `currentIndex = 5, index = 0, length = 10`
// `diff = (0 - 5 + 10) % 10 = 5`
// `diff <= 3` (5 <= 3) -> false
// `diff >= length - 3` (5 >= 7) -> false
// `else { return 3; }` -> 返回 `3`。

// 根据原始问题中的示例 `offset` 表格，当 `currentIndex = 0` 时：
// `index = 0, offset = 0`
// `index = 1, offset = +1`
// `index = 2, offset = +2`
// `index = 3, offset = +3`
// `index = 4, offset = +3`
// `index = 5, offset = +3`
// `index = 6, offset = +3`
// `index = 7, offset = -3`
// `index = 8, offset = -2`
// `index = 9, offset = -1`

// 让我们用优化后的函数验证这些：
// `getOffset(0, 0, 10)` -> diff=0 -> 0 (正确)
// `getOffset(0, 1, 10)`