JavaScript实现象棋锦标赛可行队伍数求解功能测试失败，请求问题排查帮助

看起来你的代码思路方向是对的，但存在几个关键问题导致无法通过测试，我帮你逐一排查并修正：

1. 全局变量引发的循环逻辑混乱 #

你的所有for循环里的i都没有用let/const声明，导致i成为全局变量。后续循环会直接覆盖之前的i值，比如arrayToUse的循环结束后，i的数值会干扰getTeams里的循环起始位置，引发完全不符合预期的逻辑错误。

2. 二次方程函数返回值类型不一致 #

quadraticEquation函数在判别式D=0时返回对象，D<0时返回字符串'false'，但后续代码需要调用.map()和.filter()方法——这些类型根本没有这些方法，会直接触发运行时错误。必须统一返回数组类型。

3. 偶数队伍判断的低效循环 #

你处理纯偶数队伍（队伍数为2的幂）时，用了一个从0到input的大循环，当input达到1e6时，这个循环会执行百万次，效率极低。实际上纯偶数队伍的总场数满足2^m -1 = N，也就是N+1必须是2的幂，直接用位运算判断即可，完全不需要循环。

4. 队伍数计算的冗余且易出错逻辑 #

在getTeams里计算经过loop轮翻倍后的队伍数时，你用了循环累加的方式，不仅冗余还容易因为变量修改出错。其实可以直接用幂运算x * (2 ** loop)，简洁又准确。

5. 结果字符串的多余换行 #

你用forEach拼接结果时，最后会多一个不必要的换行符，不符合常规输出要求，改用join('\n')可以完美解决这个问题。

修正后的完整代码 #

function solve(input) { 
  // 修正二次方程求解函数，统一返回正根数组
  let quadraticEquation = (number) => { 
    const a = 1; 
    const b = -1; 
    const c = -number * 2; 
    if (a === 0) return []; 
    const D = b * b - 4 * a * c; 
    const roots = []; 
    if (D < 0) return roots; 
    if (D === 0) {
      roots.push((-b + Math.sqrt(D)) / (2 * a));
    } else if (D > 0) {
      roots.push((-b + Math.sqrt(D)) / (2 * a)); 
      roots.push((-b - Math.sqrt(D)) / (2 * a)); 
    } 
    // 只保留正根
    return roots.filter(root => root > 0);
  } 

  const target = input; 
  const roots = quadraticEquation(target); 
  // 筛选出符合条件的正整数奇数根
  const validOddRoots = roots
    .map(Math.abs)
    .filter(root => Number.isInteger(root) && root % 2 !== 0); 

  const candidates = []; 
  // 遍历所有可能的奇数x（x >=3，因为x=1总场数为0，无意义）
  const maxX = validOddRoots.length > 0 ? Math.max(...validOddRoots) : 0; 
  for (let i = 3; i <= maxX; i += 2) { 
    candidates.push(i); 
  } 

  const validPairs = []; 
  candidates.forEach(x => { 
    let totalMatches = x * (x - 1) / 2; 
    let currentTeams = x; 
    let loopCount = 0; 
    if (totalMatches === target) { 
      validPairs.push([x, loopCount]); 
    } else { 
      do { 
        loopCount++; 
        currentTeams *= 2; 
        totalMatches += currentTeams / 2; // 每轮比赛场数为当前队伍数的一半
        if (totalMatches === target) { 
          validPairs.push([x, loopCount]); 
        } 
      } while (totalMatches < target); 
    } 
  }); 

  function getFinalTeams(pairs) { 
    const result = []; 
    // 处理奇数起始的队伍情况
    pairs.forEach(([x, loop]) => { 
      const teamCount = x * (2 ** loop); 
      result.push(teamCount); 
    }); 
    // 处理纯偶数队伍情况（队伍数为2的幂）
    const powerOfTwoCheck = target + 1; 
    if (powerOfTwoCheck > 0 && (powerOfTwoCheck & (powerOfTwoCheck - 1)) === 0) { 
      result.push(powerOfTwoCheck); 
    } 
    // 去重并排序，确保结果有序且无重复
    return [...new Set(result)].sort((a, b) => a - b); 
  } 

  const finalTeams = getFinalTeams(validPairs); 
  return finalTeams.length === 0 ? "-1" : finalTeams.join('\n'); 
} 

// 测试用例验证
console.log(solve(325)); 
console.log(solve(3));    // 输出：3\n4
console.log(solve(15));   
console.log(solve(21));   // 输出：7
console.log(solve(10));   // 输出：5
console.log(solve(1));    // 输出：2
console.log(solve(5));    // 输出：-1
console.log(solve(9));    // 输出：-1

修正后的关键优化点说明 #

1. 统一返回值类型：quadraticEquation始终返回数组，避免后续方法调用报错。
2. 局部变量隔离：所有循环变量用let声明，彻底解决全局变量冲突问题。
3. 高效幂判断：用位运算(num & (num-1)) === 0快速判断是否为2的幂，大幅提升大数值场景下的效率。
4. 简化队伍数计算：用幂运算直接计算翻倍后的队伍数，减少逻辑复杂度和出错概率。
5. 结果去重排序：确保输出结果有序且无重复，符合题目要求。

内容的提问来源于stack exchange，提问作者Rurohi53