@xcpcio/core 0.2.1

package/dist/index.mjs

@@ -0,0 +1,676 @@
+import dayjs from 'dayjs';
+export { default as dayjs } from 'dayjs';
+import duration from 'dayjs/plugin/duration';
+import utc from 'dayjs/plugin/utc';
+import timezone from 'dayjs/plugin/timezone';
+import advancedFormat from 'dayjs/plugin/advancedFormat';
+import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
+import isSameOrAfter from 'dayjs/plugin/isSameOrAfter';
+import minMax from 'dayjs/plugin/minMax';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import { VERSION, ContestState, SubmissionStatus } from '@xcpcio/types';
+import _ from 'lodash';
+
+dayjs.extend(duration);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(advancedFormat);
+dayjs.extend(isSameOrBefore);
+dayjs.extend(isSameOrAfter);
+dayjs.extend(minMax);
+dayjs.extend(relativeTime);
+function createDayJS(time = void 0) {
+  if (time === void 0) {
+    return dayjs();
+  }
+  if (typeof time == "number" && String(time).length === 10) {
+    return dayjs.unix(time);
+  }
+  return dayjs(time);
+}
+function getTimestamp(time) {
+  if (typeof time === "number") {
+    return time;
+  }
+  return time.unix();
+}
+function getTimeDiff(seconds) {
+  const two = (a) => {
+    if (a < 10)
+      return "0" + a;
+    return String(a);
+  };
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = seconds % 60;
+  return [two(h), two(m), two(s)].join(":");
+}
+
+class Problem {
+  constructor() {
+    this.id = "";
+    this.label = "";
+    this.name = "";
+    this.statistics = {
+      acceptedNum: 0,
+      rejectedNum: 0,
+      pendingNum: 0,
+      submittedNum: 0
+    };
+  }
+}
+function createProblem(problemJSON) {
+  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;
+}
+function createProblems(problemsJSON) {
+  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;
+  });
+}
+function createProblemsByProblemIds(problemIds, balloonColors) {
+  const problems = problemIds.map((label, index) => {
+    const p = new Problem();
+    p.id = String(index);
+    p.label = label;
+    return p;
+  });
+  if (balloonColors !== void 0 && balloonColors !== null) {
+    for (const index in balloonColors) {
+      problems[index].balloonColor = balloonColors[index];
+    }
+  }
+  return problems;
+}
+class TeamProblemStatistics {
+  constructor(options) {
+    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;
+  }
+}
+
+class Contest {
+  constructor() {
+    this.name = "";
+    this.version = VERSION;
+    this.startTime = createDayJS();
+    this.endTime = createDayJS();
+    this.freezeTime = createDayJS();
+    this.totalDurationTimestamp = 0;
+    this.freezeDurationTimestamp = 0;
+    this.unFreezeDurationTimestamp = 0;
+    this.penalty = 20 * 60;
+    this.problems = [];
+    this.problemsMap = /* @__PURE__ */ new Map();
+    this.statusTimeDisplay = {
+      correct: true,
+      incorrect: true,
+      pending: true
+    };
+  }
+  getContestDuration(timeFormat = "HH:mm:ss") {
+    return dayjs.duration(this.endTime.diff(this.startTime)).format(timeFormat);
+  }
+  getContestState() {
+    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() {
+    let baseTime = createDayJS();
+    if (baseTime.isAfter(this.startTime)) {
+      baseTime = this.startTime;
+    }
+    return getTimeDiff(Math.floor(dayjs.duration(this.startTime.diff(baseTime)).asSeconds()));
+  }
+  getContestRemainingTime(endTime) {
+    let baseTime = dayjs();
+    if (baseTime.isAfter(endTime)) {
+      baseTime = endTime;
+    }
+    return getTimeDiff(Math.floor(dayjs.duration(endTime.diff(baseTime)).asSeconds()));
+  }
+  getContestElapsedTime() {
+    let baseTime = dayjs();
+    if (baseTime.isAfter(this.endTime)) {
+      baseTime = this.endTime;
+    }
+    return getTimeDiff(Math.floor(dayjs.duration(baseTime.diff(this.startTime)).asSeconds()));
+  }
+  getContestProgressRatio() {
+    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);
+  }
+}
+function createContest(contestJSON) {
+  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();
+  {
+    c.freezeTime = c.endTime;
+    c.freezeDurationTimestamp = 0;
+    if (contestJSON.frozen_time !== void 0 && contestJSON.frozen_time != null) {
+      const frozenTime = Number(contestJSON.frozen_time);
+      c.freezeTime = createDayJS(c.endTime.unix() - frozenTime);
+      c.freezeDurationTimestamp = frozenTime;
+    }
+    if (contestJSON.freeze_time !== void 0 && 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 !== void 0 && contestJSON.problem_id !== null) {
+      c.problems = createProblemsByProblemIds(contestJSON.problem_id, contestJSON.balloon_color);
+    }
+    if (contestJSON.problems !== void 0 && contestJSON.problems !== null) {
+      c.problems = createProblems(contestJSON.problems);
+    }
+    c.problemsMap = new Map(c.problems.map((p) => [p.id, p]));
+  }
+  if (contestJSON.status_time_display !== void 0 && 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;
+}
+
+function getImageSource(image) {
+  if (image?.url) {
+    return image.url;
+  }
+  if (image?.base64) {
+    return `data:image/${image.type};base64,${image.base64}`;
+  }
+  return "";
+}
+
+class Team {
+  constructor() {
+    this.id = "";
+    this.name = "";
+    this.organization = "";
+    this.group = [];
+    this.tag = [];
+    this.rank = 0;
+    this.solvedProblemNum = 0;
+    this.penalty = 0;
+    this.problemStatistics = [];
+    this.problemStatisticsMap = /* @__PURE__ */ new Map();
+  }
+  penaltyToMinute() {
+    return Math.floor(this.penalty / 60);
+  }
+  calcSolvedData() {
+    this.solvedProblemNum = 0;
+    this.penalty = 0;
+    for (const p of this.problemStatistics) {
+      if (p.isAccepted) {
+        this.solvedProblemNum++;
+        this.penalty += p.penalty;
+      }
+    }
+  }
+  static compare(lhs, rhs) {
+    if (lhs.solvedProblemNum !== rhs.solvedProblemNum) {
+      return rhs.solvedProblemNum - lhs.solvedProblemNum;
+    }
+    if (lhs.penalty !== rhs.penalty) {
+      return lhs.penalty - rhs.penalty;
+    }
+    if (lhs.name < rhs.name) {
+      return -1;
+    } else if (lhs.name > rhs.name) {
+      return 1;
+    }
+    return 0;
+  }
+}
+function createTeam(teamJSON) {
+  const t = new Team();
+  t.id = teamJSON.id ?? teamJSON.team_id ?? "";
+  t.name = teamJSON.name ?? teamJSON.team_name ?? "";
+  t.organization = teamJSON.organization ?? "";
+  t.group = teamJSON.group ?? [];
+  t.tag = teamJSON.group ?? [];
+  t.coach = teamJSON.coach;
+  t.members = teamJSON.members;
+  if (teamJSON.official === true) {
+    t.group.push("official");
+  }
+  if (teamJSON.unofficial === true) {
+    t.group.push("unofficial");
+  }
+  if (teamJSON.girl === true) {
+    t.group.push("girl");
+  }
+  t.group = [...new Set(t.group)];
+  t.group.sort();
+  return t;
+}
+function createTeams(teamsJSON) {
+  if (Array.isArray(teamsJSON)) {
+    return teamsJSON.map((t) => createTeam(t));
+  } else {
+    const teams = Object.entries(teamsJSON).map(
+      ([teamId, team]) => createTeam({ ...team, team_id: team.team_id ?? teamId })
+    );
+    return teams;
+  }
+}
+
+function stringToSubmissionStatus(status) {
+  status = status.toUpperCase().replace(" ", "_");
+  if (["OK", "AC", SubmissionStatus.ACCEPTED.toString()].includes(status)) {
+    return SubmissionStatus.ACCEPTED;
+  }
+  if ([SubmissionStatus.CORRECT.toString()].includes(status)) {
+    return SubmissionStatus.CORRECT;
+  }
+  if ([SubmissionStatus.PARTIALLY_CORRECT.toString()].includes(status)) {
+    return SubmissionStatus.PARTIALLY_CORRECT;
+  }
+  if (["WA", SubmissionStatus.WRONG_ANSWER.toString()].includes(status)) {
+    return SubmissionStatus.WRONG_ANSWER;
+  }
+  if (["RJ", "INCORRECT", SubmissionStatus.REJECTED.toString()].includes(status)) {
+    return SubmissionStatus.REJECTED;
+  }
+  if (["PD", SubmissionStatus.PENDING.toString()].includes(status)) {
+    return SubmissionStatus.PENDING;
+  }
+  if ([SubmissionStatus.WAITING.toString()].includes(status)) {
+    return SubmissionStatus.WAITING;
+  }
+  if ([SubmissionStatus.JUDGING.toString()].includes(status)) {
+    return SubmissionStatus.JUDGING;
+  }
+  if ([SubmissionStatus.FROZEN.toString()].includes(status)) {
+    return SubmissionStatus.FROZEN;
+  }
+  if (["CE", SubmissionStatus.COMPILE_ERROR.toString()].includes(status)) {
+    return SubmissionStatus.COMPILE_ERROR;
+  }
+  if (["PE", SubmissionStatus.PRESENTATION_ERROR.toString()].includes(status)) {
+    return SubmissionStatus.PRESENTATION_ERROR;
+  }
+  if (["TL", "TLE", SubmissionStatus.TIME_LIMIT_EXCEEDED.toString()].includes(status)) {
+    return SubmissionStatus.TIME_LIMIT_EXCEEDED;
+  }
+  if (["ML", "MLE", SubmissionStatus.MEMORY_LIMIT_EXCEEDED.toString()].includes(status)) {
+    return SubmissionStatus.MEMORY_LIMIT_EXCEEDED;
+  }
+  if (["OL", "OLE", SubmissionStatus.OUTPUT_LIMIT_EXCEEDED.toString()].includes(status)) {
+    return SubmissionStatus.OUTPUT_LIMIT_EXCEEDED;
+  }
+  if (["IL", "ILE", SubmissionStatus.IDLENESS_LIMIT_EXCEEDED.toString()].includes(status)) {
+    return SubmissionStatus.IDLENESS_LIMIT_EXCEEDED;
+  }
+  if (["RT", "RE", "RTE", SubmissionStatus.RUNTIME_ERROR.toString()].includes(status)) {
+    return SubmissionStatus.RUNTIME_ERROR;
+  }
+  if (["JE", SubmissionStatus.JUDGEMENT_FAILED.toString()].includes(status)) {
+    return SubmissionStatus.JUDGEMENT_FAILED;
+  }
+  if (["SE", SubmissionStatus.SYSTEM_ERROR.toString()].includes(status)) {
+    return SubmissionStatus.SYSTEM_ERROR;
+  }
+  if ([SubmissionStatus.HACKED.toString()].includes(status)) {
+    return SubmissionStatus.HACKED;
+  }
+  if ([SubmissionStatus.CONFIGURATION_ERROR.toString()].includes(status)) {
+    return SubmissionStatus.CONFIGURATION_ERROR;
+  }
+  if ([SubmissionStatus.CANCELED.toString()].includes(status)) {
+    return SubmissionStatus.CANCELED;
+  }
+  if ([SubmissionStatus.SKIPPED.toString()].includes(status)) {
+    return SubmissionStatus.SKIPPED;
+  }
+  if ([SubmissionStatus.SECURITY_VIOLATED.toString()].includes(status)) {
+    return SubmissionStatus.SECURITY_VIOLATED;
+  }
+  if ([SubmissionStatus.DENIAL_OF_JUDGEMENT.toString()].includes(status)) {
+    return SubmissionStatus.DENIAL_OF_JUDGEMENT;
+  }
+  return SubmissionStatus.UNKNOWN;
+}
+function isAccepted(status) {
+  const acceptedArray = [SubmissionStatus.ACCEPTED, SubmissionStatus.CORRECT];
+  return acceptedArray.includes(status);
+}
+function isRejected(status) {
+  const rejectArray = [
+    SubmissionStatus.RUNTIME_ERROR,
+    SubmissionStatus.TIME_LIMIT_EXCEEDED,
+    SubmissionStatus.MEMORY_LIMIT_EXCEEDED,
+    SubmissionStatus.OUTPUT_LIMIT_EXCEEDED,
+    SubmissionStatus.IDLENESS_LIMIT_EXCEEDED,
+    SubmissionStatus.WRONG_ANSWER,
+    SubmissionStatus.REJECTED,
+    SubmissionStatus.JUDGEMENT_FAILED,
+    SubmissionStatus.HACKED
+  ];
+  return rejectArray.includes(status);
+}
+function isPending(status) {
+  const pendingArray = [
+    SubmissionStatus.PENDING,
+    SubmissionStatus.WAITING,
+    SubmissionStatus.JUDGING,
+    SubmissionStatus.FROZEN
+  ];
+  return pendingArray.includes(status);
+}
+function isNotCalculatedPenaltyStatus(status) {
+  const isNotCalculatedPenaltyArray = [
+    SubmissionStatus.COMPILE_ERROR,
+    SubmissionStatus.PRESENTATION_ERROR,
+    SubmissionStatus.CONFIGURATION_ERROR,
+    SubmissionStatus.SYSTEM_ERROR,
+    SubmissionStatus.CANCELED,
+    SubmissionStatus.SKIPPED,
+    SubmissionStatus.UNKNOWN,
+    SubmissionStatus.UNDEFINED
+  ];
+  return isNotCalculatedPenaltyArray.includes(status);
+}
+
+class Submission {
+  constructor() {
+    this.status = SubmissionStatus.UNKNOWN;
+    this.isIgnore = false;
+    this.id = "";
+    this.teamId = "";
+    this.problemId = "";
+    this.timestamp = 0;
+  }
+  isAccepted() {
+    return isAccepted(this.status);
+  }
+  isRejected() {
+    return isRejected(this.status);
+  }
+  isPending() {
+    return isPending(this.status);
+  }
+  isNotCalculatedPenaltyStatus() {
+    return isNotCalculatedPenaltyStatus(this.status);
+  }
+  static compare(lhs, rhs) {
+    if (lhs.timestamp !== rhs.timestamp) {
+      return lhs.timestamp - rhs.timestamp;
+    }
+    if (lhs.teamId === rhs.teamId) {
+      if (lhs.isAccepted() && !rhs.isAccepted()) {
+        return -1;
+      }
+      if (!lhs.isAccepted() && rhs.isAccepted()) {
+        return 1;
+      }
+    }
+    return 0;
+  }
+}
+function createSubmission(submissionJSON) {
+  const s = new Submission();
+  s.id = String(submissionJSON.id ?? submissionJSON.submission_id ?? "");
+  s.teamId = String(submissionJSON.team_id);
+  s.problemId = String(submissionJSON.problem_id);
+  s.timestamp = submissionJSON.timestamp;
+  s.status = stringToSubmissionStatus(submissionJSON.status);
+  s.isIgnore = submissionJSON.is_ignore ?? false;
+  return s;
+}
+function createSubmissions(submissionsJSON) {
+  if (Array.isArray(submissionsJSON)) {
+    return submissionsJSON.map((s, index) => createSubmission({ ...s, id: s.submission_id ?? String(index) }));
+  } else {
+    const submissions = Object.entries(submissionsJSON).map(
+      ([submissionId, s]) => createSubmission({ ...s, id: s.submission_id ?? submissionId })
+    );
+    return submissions;
+  }
+}
+
+class Rank {
+  constructor(contest, teams, 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) {
+    (() => {
+      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 === void 0 || problem === void 0) {
+          continue;
+        }
+        if (options?.timestamp !== void 0 && options?.timestamp !== null) {
+          if (s.timestamp > options.timestamp) {
+            break;
+          }
+        }
+        const problemStatistics = team.problemStatisticsMap.get(problemId);
+        const submissions = problemStatistics.submissions;
+        const firstSolvedSubmissions = this.firstSolvedSubmissions.get(problemId);
+        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;
+  }
+}
+
+class ResolverOperation {
+  constructor() {
+    this.id = 0;
+    this.team = new Team();
+    this.problemIx = 0;
+    this.beforeTeamProblemStatistics = new TeamProblemStatistics();
+    this.afterTeamProblemStatistics = new TeamProblemStatistics();
+  }
+}
+
+class Resolver extends Rank {
+  constructor(contest, teams, 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 === void 0 || problem === void 0) {
+        continue;
+      }
+      const problemStatistics = team.problemStatisticsMap.get(problemId);
+      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];
+          const afterTeamProblemStatistics = this.finalRank.teamsMap.get(teamId)?.problemStatistics[problemIx];
+          const op = new ResolverOperation();
+          op.id = this.operations.length;
+          op.team = this.teamsMap.get(teamId);
+          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--;
+        }
+      }
+    }
+  }
+}
+
+export { Contest, Problem, Rank, Resolver, Submission, Team, TeamProblemStatistics, createContest, createDayJS, createProblem, createProblems, createProblemsByProblemIds, createSubmission, createSubmissions, createTeam, createTeams, getImageSource, getTimeDiff, getTimestamp, isAccepted, isNotCalculatedPenaltyStatus, isPending, isRejected, stringToSubmissionStatus };