@xcpcio/core 0.2.1

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@xcpcio/core",
+  "description": "XCPCIO Core",
+  "version": "0.2.1",
+  "license": "MIT",
+  "author": "Dup4 <lyuzhi.pan@gmail.com>",
+  "keywords": [
+    "ICPC",
+    "CCPC"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xcpcio/xcpcio.git"
+  },
+  "homepage": "https://github.com/xcpcio/xcpcio",
+  "bugs": {
+    "url": "https://github.com/xcpcio/xcpcio/issues"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "sideEffects": false,
+  "devDependencies": {
+    "@babel/types": "^7.22.4",
+    "@types/lodash": "^4.14.195",
+    "@types/node": "^17.0.45",
+    "@typescript-eslint/eslint-plugin": "^5.59.9",
+    "@typescript-eslint/parser": "^5.59.9",
+    "bumpp": "^7.2.0",
+    "eslint": "^8.42.0",
+    "esmo": "^0.14.1",
+    "npm-run-all": "^4.1.5",
+    "pnpm": "^7.33.0",
+    "prettier": "^2.8.8",
+    "taze": "^0.10.2",
+    "typescript": "^4.9.5",
+    "unbuild": "^0.7.6",
+    "vite": "^4.3.9",
+    "vitest": "^0.32.0"
+  },
+  "dependencies": {
+    "dayjs": "^1.11.8",
+    "lodash": "^4.17.21",
+    "@xcpcio/types": "0.2.1"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub",
+    "start": "esmo src/index.ts",
+    "test": "vitest",
+    "lint": "run-p lint:*",
+    "lint:build": "# tsc --noEmit"
+  }
+}

package/src/contest.ts

@@ -0,0 +1,191 @@
+import { Contest as IContest, ContestState, Image, VERSION, StatusTimeDisplay } from "@xcpcio/types";
+
+import { Problem, Problems, createProblems, createProblemsByProblemIds } from "./problem";
+import { dayjs, createDayJS, getTimeDiff } from "./utils";
+
+export class Contest {
+  name = "";
+
+  startTime: dayjs.Dayjs;
+  endTime: dayjs.Dayjs;
+  freezeTime: dayjs.Dayjs;
+
+  totalDurationTimestamp: number;
+  freezeDurationTimestamp: number;
+  unFreezeDurationTimestamp: number;
+
+  penalty: number;
+
+  problems: Problems;
+  problemsMap: Map<string, Problem>;
+
+  statusTimeDisplay: StatusTimeDisplay;
+
+  badge?: string;
+  medal?: Record<string, Record<string, number>>;
+  organization?: string;
+
+  group?: Record<string, string>;
+  tag?: Record<string, string>;
+
+  logo?: Image;
+  banner?: Image;
+  boardLink?: string;
+
+  version = VERSION;
+
+  constructor() {
+    this.startTime = createDayJS();
+    this.endTime = createDayJS();
+    this.freezeTime = createDayJS();
+
+    this.totalDurationTimestamp = 0;
+    this.freezeDurationTimestamp = 0;
+    this.unFreezeDurationTimestamp = 0;
+
+    // 20 mins
+    this.penalty = 20 * 60;
+
+    this.problems = [];
+    this.problemsMap = new Map<string, Problem>();
+
+    this.statusTimeDisplay = {
+      correct: true,
+      incorrect: true,
+      pending: true,
+    };
+  }
+
+  getContestDuration(timeFormat = "HH:mm:ss"): string {
+    return dayjs.duration(this.endTime.diff(this.startTime)).format(timeFormat);
+  }
+
+  getContestState(): ContestState {
+    const now = createDayJS();
+
+    if (now.isBefore(this.startTime)) {
+      return ContestState.PENDING;
+    }
+
+    if (now.isSameOrAfter(this.endTime)) {
+      return ContestState.FINISHED;
+    }
+
+    if (now.isSameOrAfter(this.freezeTime)) {
+      return ContestState.FROZEN;
+    }
+
+    return ContestState.RUNNING;
+  }
+
+  getContestPendingTime(): string {
+    let baseTime = createDayJS();
+    if (baseTime.isAfter(this.startTime)) {
+      baseTime = this.startTime;
+    }
+
+    return getTimeDiff(Math.floor(dayjs.duration(this.startTime.diff(baseTime)).asSeconds()));
+  }
+
+  getContestRemainingTime(endTime: dayjs.Dayjs): string {
+    let baseTime = dayjs();
+    if (baseTime.isAfter(endTime)) {
+      baseTime = endTime;
+    }
+
+    return getTimeDiff(Math.floor(dayjs.duration(endTime.diff(baseTime)).asSeconds()));
+  }
+
+  getContestElapsedTime(): string {
+    let baseTime = dayjs();
+    if (baseTime.isAfter(this.endTime)) {
+      baseTime = this.endTime;
+    }
+
+    return getTimeDiff(Math.floor(dayjs.duration(baseTime.diff(this.startTime)).asSeconds()));
+  }
+
+  getContestProgressRatio(): number {
+    const baseTime = dayjs();
+
+    if (this.startTime.isSameOrAfter(baseTime)) {
+      return 0;
+    }
+
+    if (this.endTime.isSameOrBefore(baseTime)) {
+      return 100;
+    }
+
+    const total = this.endTime.diff(this.startTime, "s");
+    const pass = baseTime.diff(this.startTime, "s");
+
+    return Math.round((pass * 100) / total);
+  }
+}
+
+export function createContest(contestJSON: IContest): Contest {
+  const c = new Contest();
+
+  c.name = contestJSON.contest_name;
+
+  c.startTime = createDayJS(contestJSON.start_time);
+  c.endTime = createDayJS(contestJSON.end_time);
+
+  c.totalDurationTimestamp = c.endTime.unix() - c.startTime.unix();
+
+  {
+    // default value
+    c.freezeTime = c.endTime;
+    c.freezeDurationTimestamp = 0;
+
+    if (contestJSON.frozen_time !== undefined && contestJSON.frozen_time != null) {
+      const frozenTime = Number(contestJSON.frozen_time);
+
+      c.freezeTime = createDayJS(c.endTime.unix() - frozenTime);
+      c.freezeDurationTimestamp = frozenTime;
+    }
+
+    if (contestJSON.freeze_time !== undefined && contestJSON.freeze_time !== null) {
+      c.freezeTime = createDayJS(contestJSON.freeze_time);
+      c.freezeDurationTimestamp = c.endTime.unix() - c.freezeTime.unix();
+    }
+
+    c.unFreezeDurationTimestamp = c.totalDurationTimestamp - c.freezeDurationTimestamp;
+  }
+
+  c.penalty = contestJSON.penalty;
+
+  {
+    if (contestJSON.problem_id !== undefined && contestJSON.problem_id !== null) {
+      c.problems = createProblemsByProblemIds(contestJSON.problem_id, contestJSON.balloon_color);
+    }
+
+    if (contestJSON.problems !== undefined && contestJSON.problems !== null) {
+      c.problems = createProblems(contestJSON.problems);
+    }
+
+    c.problemsMap = new Map(c.problems.map((p) => [p.id, p]));
+  }
+
+  if (contestJSON.status_time_display !== undefined && contestJSON.status_time_display !== null) {
+    c.statusTimeDisplay = {
+      correct: Boolean(contestJSON.status_time_display.correct ?? false),
+      incorrect: Boolean(contestJSON.status_time_display.incorrect ?? false),
+      pending: Boolean(contestJSON.status_time_display.pending ?? false),
+    };
+  }
+
+  c.badge = contestJSON.badge;
+  c.medal = contestJSON.medal;
+  c.organization = contestJSON.organization;
+
+  c.group = contestJSON.group;
+  c.tag = contestJSON.tag;
+
+  c.banner = contestJSON.banner;
+
+  c.logo = contestJSON.logo;
+  c.boardLink = contestJSON.board_link;
+
+  return c;
+}

package/src/image.ts

@@ -0,0 +1,13 @@
+import { Image } from "@xcpcio/types";
+
+export function getImageSource(image: Image): string {
+  if (image?.url) {
+    return image.url;
+  }
+
+  if (image?.base64) {
+    return `data:image/${image.type};base64,${image.base64}`;
+  }
+
+  return "";
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./utils";
+export * from "./contest";
+export * from "./image";
+export * from "./problem";
+export * from "./rank";
+export * from "./resolver";
+export * from "./submission-status";
+export * from "./submission";
+export * from "./team";

package/src/problem.ts

@@ -0,0 +1,157 @@
+import { Problem as IProblem, Problems as IProblems, BalloonColor } from "@xcpcio/types";
+
+import { Submissions } from "./submission";
+
+export interface ProblemStatistics {
+  acceptedNum: number;
+  rejectedNum: number;
+  pendingNum: number;
+
+  submittedNum: number;
+}
+
+export class Problem {
+  id: string;
+  label: string;
+
+  name: string;
+
+  timeLimit?: string;
+  memoryLimit?: string;
+
+  balloonColor?: BalloonColor;
+
+  statistics: ProblemStatistics;
+
+  constructor() {
+    this.id = "";
+    this.label = "";
+
+    this.name = "";
+
+    this.statistics = {
+      acceptedNum: 0,
+      rejectedNum: 0,
+      pendingNum: 0,
+      submittedNum: 0,
+    };
+  }
+}
+
+export type Problems = Array<Problem>;
+
+export function createProblem(problemJSON: IProblem): Problem {
+  const p = new Problem();
+
+  p.id = String(problemJSON.id);
+  p.label = problemJSON.label;
+
+  p.name = problemJSON.name ?? "";
+
+  p.timeLimit = problemJSON.time_limit;
+  p.memoryLimit = problemJSON.memory_limit;
+
+  p.balloonColor = problemJSON.balloon_color;
+
+  return p;
+}
+
+export function createProblems(problemsJSON: IProblems): Problems {
+  return problemsJSON.map((pJSON) => {
+    const p = new Problem();
+
+    p.id = pJSON.id;
+    p.label = pJSON.label;
+
+    p.name = pJSON.name ?? "";
+
+    p.timeLimit = pJSON.time_limit;
+    p.memoryLimit = pJSON.memory_limit;
+
+    p.balloonColor = pJSON.balloon_color;
+
+    return p;
+  });
+}
+
+export function createProblemsByProblemIds(problemIds: string[], balloonColors?: BalloonColor[]): Problems {
+  const problems = problemIds.map((label: string, index: number) => {
+    const p = new Problem();
+    p.id = String(index);
+    p.label = label;
+
+    return p;
+  });
+
+  if (balloonColors !== undefined && balloonColors !== null) {
+    for (const index in balloonColors) {
+      problems[index].balloonColor = balloonColors[index];
+    }
+  }
+
+  return problems;
+}
+
+export class TeamProblemStatistics {
+  isFirstSolved: boolean;
+
+  isSolved: boolean;
+  solvedTimestamp: number;
+
+  isSubmitted: boolean;
+  lastSubmitTimestamp: number;
+
+  failedCount: number;
+  pendingCount: number;
+  ignoreCount: number;
+  totalCount: number;
+
+  submissions: Submissions;
+  problem: Problem;
+
+  contestPenalty: number;
+
+  constructor(options?: { teamProblemStatistics?: TeamProblemStatistics }) {
+    this.isFirstSolved = options?.teamProblemStatistics?.isFirstSolved ?? false;
+
+    this.isSolved = options?.teamProblemStatistics?.isSolved ?? false;
+    this.solvedTimestamp = options?.teamProblemStatistics?.solvedTimestamp ?? 0;
+
+    this.isSubmitted = options?.teamProblemStatistics?.isSubmitted ?? false;
+    this.lastSubmitTimestamp = options?.teamProblemStatistics?.lastSubmitTimestamp ?? 0;
+
+    this.failedCount = options?.teamProblemStatistics?.failedCount ?? 0;
+    this.pendingCount = options?.teamProblemStatistics?.pendingCount ?? 0;
+    this.ignoreCount = options?.teamProblemStatistics?.ignoreCount ?? 0;
+    this.totalCount = options?.teamProblemStatistics?.totalCount ?? 0;
+
+    this.submissions = options?.teamProblemStatistics?.submissions ?? [];
+    this.problem = options?.teamProblemStatistics?.problem ?? new Problem();
+
+    this.contestPenalty = options?.teamProblemStatistics?.contestPenalty ?? 20 * 60;
+  }
+
+  get isAccepted() {
+    return this.isSolved;
+  }
+
+  get isWrongAnswer() {
+    return !this.isSolved && this.pendingCount === 0 && this.failedCount > 0;
+  }
+
+  get isPending() {
+    return !this.isSolved && this.pendingCount > 0;
+  }
+
+  get isUnSubmitted() {
+    return this.totalCount === 0;
+  }
+
+  get penalty() {
+    if (this.isSolved === false) {
+      return 0;
+    }
+
+    return Math.floor(this.solvedTimestamp / 60) * 60 + this.failedCount * this.contestPenalty;
+  }
+}

package/src/rank.ts

@@ -0,0 +1,122 @@
+import _ from "lodash";
+
+import { Contest } from "./contest";
+import { Team, Teams } from "./team";
+import { Submission, Submissions } from "./submission";
+import { TeamProblemStatistics } from "./problem";
+
+export class Rank {
+  readonly contest: Contest;
+
+  teams: Teams;
+  teamsMap: Map<string, Team>;
+
+  submissions: Submissions;
+  submissionsMap: Map<string, Submission>;
+
+  firstSolvedSubmissions: Map<string, Submissions>;
+
+  constructor(contest: Contest, teams: Teams, submissions: Submissions) {
+    this.contest = contest;
+
+    this.teams = _.cloneDeep(teams);
+    this.teamsMap = new Map(this.teams.map((t) => [t.id, t]));
+
+    this.submissions = _.cloneDeep(submissions).sort(Submission.compare);
+    this.submissionsMap = new Map(this.submissions.map((s) => [s.id, s]));
+
+    this.firstSolvedSubmissions = new Map(this.contest.problems.map((p) => [p.id, []]));
+  }
+
+  buildRank(options?: { timestamp?: number }) {
+    (() => {
+      for (const t of this.teams) {
+        t.problemStatistics = this.contest.problems.map((p) => {
+          const ps = new TeamProblemStatistics();
+          ps.problem = p;
+          ps.contestPenalty = this.contest.penalty;
+
+          return ps;
+        });
+
+        t.problemStatisticsMap = new Map(t.problemStatistics.map((ps) => [ps.problem.id, ps]));
+      }
+
+      this.firstSolvedSubmissions = new Map(this.contest.problems.map((p) => [p.id, []]));
+
+      for (const s of this.submissions) {
+        const teamId = s.teamId;
+        const problemId = s.problemId;
+        const team = this.teamsMap.get(teamId);
+        const problem = this.contest.problemsMap.get(problemId);
+
+        if (team === undefined || problem === undefined) {
+          continue;
+        }
+
+        if (options?.timestamp !== undefined && options?.timestamp !== null) {
+          if (s.timestamp > options.timestamp) {
+            break;
+          }
+        }
+
+        const problemStatistics = team.problemStatisticsMap.get(problemId) as TeamProblemStatistics;
+        const submissions = problemStatistics.submissions;
+        const firstSolvedSubmissions = this.firstSolvedSubmissions.get(problemId) as Array<Submission>;
+
+        submissions.push(s);
+        problem.statistics.submittedNum++;
+
+        if (problemStatistics.isSolved) {
+          continue;
+        }
+
+        if (s.isIgnore || s.isNotCalculatedPenaltyStatus()) {
+          problemStatistics.ignoreCount++;
+          continue;
+        }
+
+        problemStatistics.isSubmitted = true;
+        problemStatistics.lastSubmitTimestamp = s.timestamp;
+        problemStatistics.totalCount++;
+
+        if (s.isAccepted()) {
+          problemStatistics.isSolved = true;
+          problemStatistics.solvedTimestamp = s.timestamp;
+
+          problem.statistics.acceptedNum++;
+
+          if (
+            firstSolvedSubmissions.length === 0 ||
+            firstSolvedSubmissions[firstSolvedSubmissions.length - 1].timestamp === s.timestamp
+          ) {
+            problemStatistics.isFirstSolved = true;
+            firstSolvedSubmissions.push(s);
+          }
+        }
+
+        if (s.isRejected()) {
+          problemStatistics.failedCount++;
+          problem.statistics.rejectedNum++;
+        }
+
+        if (s.isPending()) {
+          problemStatistics.pendingCount++;
+          problem.statistics.pendingNum++;
+        }
+      }
+
+      this.teams.forEach((t) => t.calcSolvedData());
+      this.teams.sort(Team.compare);
+
+      {
+        let rank = 1;
+        for (const t of this.teams) {
+          t.rank = rank++;
+        }
+      }
+    })();
+
+    return this;
+  }
+}

package/src/resolver-operation.ts

@@ -0,0 +1,22 @@
+import { TeamProblemStatistics } from "./problem";
+import { Team } from "./team";
+
+export class ResolverOperation {
+  id: number;
+
+  team: Team;
+  problemIx: number;
+
+  beforeTeamProblemStatistics: TeamProblemStatistics;
+  afterTeamProblemStatistics: TeamProblemStatistics;
+
+  constructor() {
+    this.id = 0;
+
+    this.team = new Team();
+    this.problemIx = 0;
+
+    this.beforeTeamProblemStatistics = new TeamProblemStatistics();
+    this.afterTeamProblemStatistics = new TeamProblemStatistics();
+  }
+}

package/src/resolver.ts

@@ -0,0 +1,120 @@
+import _ from "lodash";
+
+import { Rank } from "./rank";
+import { Contest } from "./contest";
+import { Team, Teams } from "./team";
+import { Submission, Submissions } from "./submission";
+import { TeamProblemStatistics } from "./problem";
+import { ResolverOperation } from "./resolver-operation";
+
+export class Resolver extends Rank {
+  finalRank: Rank;
+  operations: Array<ResolverOperation>;
+
+  beforeFreezeSubmissions: Submissions;
+  afterFreezeSubmissions: Submissions;
+
+  constructor(contest: Contest, teams: Teams, submissions: Submissions) {
+    submissions.sort(Submission.compare);
+
+    let beforeFreezeSubmissions = submissions;
+    let afterFreezeSubmissions = submissions;
+
+    {
+      const ix = _.sortedIndex(
+        submissions.map((s) => s.timestamp),
+        contest.unFreezeDurationTimestamp,
+      );
+
+      beforeFreezeSubmissions = submissions.slice(0, ix + 1);
+      afterFreezeSubmissions = submissions.slice(ix, -1);
+    }
+
+    super(contest, teams, beforeFreezeSubmissions);
+
+    this.finalRank = new Rank(contest, teams, submissions);
+    this.operations = [];
+
+    this.beforeFreezeSubmissions = beforeFreezeSubmissions;
+    this.afterFreezeSubmissions = afterFreezeSubmissions;
+  }
+
+  buildResolver() {
+    this.buildRank();
+    this.finalRank.buildRank();
+
+    for (const s of this.afterFreezeSubmissions) {
+      const teamId = s.teamId;
+      const problemId = s.problemId;
+      const team = this.teamsMap.get(teamId);
+      const problem = this.contest.problemsMap.get(problemId);
+
+      if (team === undefined || problem === undefined) {
+        continue;
+      }
+
+      const problemStatistics = team.problemStatisticsMap.get(problemId) as TeamProblemStatistics;
+
+      problemStatistics.pendingCount++;
+      problemStatistics.totalCount++;
+      if (!problemStatistics.isAccepted) {
+        problemStatistics.lastSubmitTimestamp = s.timestamp;
+      }
+    }
+
+    {
+      const teams_ = _.cloneDeep(this.teams);
+
+      for (let i = this.teams.length - 1; i >= 0; ) {
+        const team = teams_[i];
+        const teamId = team.id;
+
+        let handleCnt = 0;
+        let problemIx = -1;
+        for (const p of team.problemStatistics) {
+          problemIx++;
+
+          if (!p.isPending) {
+            continue;
+          }
+
+          handleCnt++;
+
+          const beforeTeamProblemStatistics = this.teamsMap.get(teamId)?.problemStatistics[
+            problemIx
+          ] as TeamProblemStatistics;
+          const afterTeamProblemStatistics = this.finalRank.teamsMap.get(teamId)?.problemStatistics[
+            problemIx
+          ] as TeamProblemStatistics;
+
+          const op = new ResolverOperation();
+          op.id = this.operations.length;
+          op.team = this.teamsMap.get(teamId) as Team;
+          op.problemIx = problemIx;
+
+          op.beforeTeamProblemStatistics = beforeTeamProblemStatistics;
+          op.afterTeamProblemStatistics = afterTeamProblemStatistics;
+
+          this.operations.push(op);
+
+          team.problemStatistics[problemIx] = afterTeamProblemStatistics;
+          team.calcSolvedData();
+
+          break;
+        }
+
+        {
+          let j = i;
+          while (j > 0 && Team.compare(teams_[j], teams_[j - 1]) < 0) {
+            [teams_[j], teams_[j - 1]] = [teams_[j - 1], teams_[j]];
+            j--;
+          }
+        }
+
+        if (handleCnt === 0) {
+          i--;
+        }
+      }
+    }
+  }
+}