循环算法在 Javascript 中表现异常

function generateRoundRobinSchedule(roundData) {
  let teams = roundData.teams;
  let scheduleInfo = roundData.schedule;
  let allMatches = [];

  // Create all unique matches
  for (let i = 0; i < teams.length; i++) {
    for (let j = i + 1; j < teams.length; j++) {
      allMatches.push({
        team1: i,
        team2: j
      });
    }
  }

  // Helper function to add days to a date
  function addDays(dateStr, days) {
    const date = new Date(dateStr);
    date.setDate(date.getDate() + days);
    return date.toISOString().split('T')[0];
  }

  // Initialize variables for scheduling
  let matchSchedule = [];
  let currentDate = scheduleInfo.start_date;
  const timeslots = scheduleInfo.timeslots;
  const matchesPerWeek = timeslots.reduce((acc, slot) => acc + slot.courts.length, 0);

  // Schedule matches
  while (allMatches.length > 0) {
    let weeklyMatches = [];
    let teamsPlayedThisWeek = new Set();

    for (let match of allMatches) {
      if (!teamsPlayedThisWeek.has(match.team1) && !teamsPlayedThisWeek.has(match.team2)) {
        weeklyMatches.push(match);
        teamsPlayedThisWeek.add(match.team1);
        teamsPlayedThisWeek.add(match.team2);
      }

      if (weeklyMatches.length === matchesPerWeek) {
        break;
      }
    }

    // Remove scheduled matches from allMatches
    allMatches = allMatches.filter(match => !weeklyMatches.includes(match));

    // Assign timeslots and courts to weekly matches
    let timeslotIndex = 0;
    let courtIndex = 0;
    for (let match of weeklyMatches) {
      const timeslot = timeslots[timeslotIndex];
      const court = timeslot.courts[courtIndex];

      matchSchedule.push({
        team1: teams[match.team1],
        team2: teams[match.team2],
        date: currentDate,
        time: timeslot.time,
        court: court,
        duration: scheduleInfo.match_length
      });

      courtIndex++;
      if (courtIndex >= timeslot.courts.length) {
        courtIndex = 0;
        timeslotIndex++;
        if (timeslotIndex >= timeslots.length) {
          timeslotIndex = 0;
        }
      }
    }

    // Prepare for next week
    currentDate = addDays(currentDate, 7);
  }

  console.log(matchSchedule)
  return matchSchedule;
}

generateRoundRobinSchedule(roundData);

<script>
const roundData = {
  "teams": [
      { "player1_email": "1", "player2_email": "2" },
      { "player1_email": "3", "player2_email": "4" },
      { "player1_email": "5", "player2_email": "6" },
      { "player1_email": "7", "player2_email": "8" },
      { "player1_email": "9", "player2_email": "10" },
      { "player1_email": "11", "player2_email": "12" },
      { "player1_email": "13", "player2_email": "14" },
      { "player1_email": "15", "player2_email": "16" },
      { "player1_email": "17", "player2_email": "18" },
      { "player1_email": "19", "player2_email": "20" },
      { "player1_email": "21", "player2_email": "22" },
      { "player1_email": "23", "player2_email": "24" }
  ],
  "schedule": {
      "start_date": "2023-11-20",
      "days": ["Monday"],
      "timeslots": [
          { "time": "18:30", "courts": ["Court 1", "Court 2"] },
          { "time": "19:00", "courts": ["Court 4"] },
          { "time": "20:00", "courts": ["Court 1", "Court 2"] },
          { "time": "20:30", "courts": ["Court 4"] }
      ],
      "match_length": 90
  }
}
</script>

const rotate = (n, xs) => [
  ...xs.slice(xs.length - (n % xs.length)), 
  ...xs.slice(0, xs.length - (n % xs.length))
]

const BYE = Symbol()

const roundRobin = (ts, all = ts .concat (ts .length % 2 == 0 ? [] : [BYE]), rest = all.slice(0, -1)) => 
  rest
    .map ((_, i) => rotate (i + 1, fold([...rotate (i, rest), all.at(-1)])))
    .map(b => b.filter(([a, b]) => a !== BYE && b !== BYE))
    .map((b, i) => i % 2 == 0 ? b : b.map(([a, b]) => [b, a]))           

const fold = xs =>
  xs.slice(0, Math.ceil(xs.length / 2)) .map ((x, i) => [x, xs[xs.length - i - 1]])


//----------------------------------------------------------------------

// (Disposable) code to log results to console
const display = sched => `    \\         Venue/Time
     \\ ${sched[0].map((_, i) => String(i + 1).padStart(4, ' ')).join('')}
Round  +-----------------------
${sched.map((r, i) => String(i + 1).padStart(5, ' ') + '  | ' + r.map(([a, b]) => a + b).join('  ')).join('\n')}`


console.log(display(roundRobin([...'ABCDEFGHIJKL'])))

.as-console-wrapper {max-height: 100% !important; top: 0}