halves & quarters

Author: inker

src/engine/predicates/wc/index.ts

@@ -1,6 +1,6 @@
-import { countBy, identity, mapValues, sumBy } from 'lodash';
+import { chunk, countBy, identity, mapValues, stubTrue, sumBy } from 'lodash';
 
-import { type Confederation } from '#model/types';
+import { type Confederation, type Country } from '#model/types';
 import type NationalTeam from '#model/team/NationalTeam';
 import type UnknownNationalTeam from '#model/team/UnknownNationalTeam';
 import { type Predicate } from '#engine/dfs/gs';
@@ -46,6 +46,56 @@ export default (year: number, teams: readonly Team[]): Predicate<Team> => {
     return r === 0 ? numGroups : r;
   });
 
+  const isPossibleByRankingConstraint = ((): Predicate<Team> => {
+    if (year === 2026) {
+      const quarters = [
+        [4, 8, 5],
+        [7, 3, 6],
+        [2, 0, 11],
+        [9, 1, 10],
+      ] satisfies number[][];
+
+      const halves = chunk(quarters, 2).map(c => c.flat());
+
+      const quarterByGroup = new Map(
+        quarters.values().flatMap((arr, qi) => arr.values().map(i => [i, qi])),
+      );
+
+      const firstFourTeams = (
+        ['Spain', 'Argentina', 'France', 'England'] satisfies Country[]
+      ).map(name => teams.find(t => t.name === name)!);
+
+      const rankByTeam = new Map(
+        firstFourTeams.values().map((t, i) => [t.id, i]),
+      );
+
+      return (picked, groups, groupIndex) => {
+        const rank = rankByTeam.get(picked.id);
+        if (rank !== undefined) {
+          const quarter = quarterByGroup.get(groupIndex)!;
+          const isAnotherTeamInSameQuarter = quarters[quarter].some(gi =>
+            groups[gi].some(t => rankByTeam.has(t.id)),
+          );
+          if (isAnotherTeamInSameQuarter) {
+            return false;
+          }
+          const half = quarter >> 1;
+          const otherRank = rank ^ 1;
+          const otherRankTeam = firstFourTeams[otherRank];
+          const isOtherTeamInSameHalf = halves[half].some(gi =>
+            groups[gi].some(t => t.id === otherRankTeam.id),
+          );
+          if (isOtherTeamInSameHalf) {
+            return false;
+          }
+        }
+        return true;
+      };
+    }
+
+    return stubTrue;
+  })();
+
   return (picked, groups, groupIndex) => {
     const group = groups[groupIndex];
     const currentPotIndex = getSmallestArrayLength(groups);
@@ -54,6 +104,10 @@ export default (year: number, teams: readonly Team[]): Predicate<Team> => {
       return false;
     }
 
+    if (!isPossibleByRankingConstraint(picked, groups, groupIndex)) {
+      return false;
+    }
+
     const virtualGroup = [...group, picked] as const;
     const numRemainingTeams = groupSize - virtualGroup.length;
     const isGroupPossible = confMinMaxEntries.every(([conf, [min, max]]) => {