@xcpcio/core 0.4.3 → 0.5.0

package/dist/index.cjs

@@ -379,6 +379,13 @@ class RankStatistics {
   }
 }
 
+class PlaceChartPointData {
+  constructor() {
+    this.timePoint = 0;
+    this.rank = 0;
+    this.lastSolvedProblem = null;
+  }
+}
 class Team {
   constructor() {
     this.id = "";
@@ -390,20 +397,26 @@ class Team {
     this.organizationRank = -1;
     this.solvedProblemNum = 0;
     this.attemptedProblemNum = 0;
+    this.lastSolvedProblem = null;
     this.lastSolvedProblemTimestamp = 0;
     this.penalty = 0;
     this.problemStatistics = [];
     this.problemStatisticsMap = /* @__PURE__ */ new Map();
+    this.submissions = [];
+    this.placeChartPoints = [];
   }
   reset() {
     this.rank = 0;
     this.organizationRank = -1;
     this.solvedProblemNum = 0;
     this.attemptedProblemNum = 0;
+    this.lastSolvedProblem = null;
     this.lastSolvedProblemTimestamp = 0;
     this.penalty = 0;
     this.problemStatistics = [];
     this.problemStatisticsMap = /* @__PURE__ */ new Map();
+    this.submissions = [];
+    this.placeChartPoints = [];
   }
   get penaltyToMinute() {
     return Math.floor(this.penalty / 60);
@@ -415,8 +428,8 @@ class Team {
   }
   calcSolvedData() {
     this.solvedProblemNum = 0;
-    this.penalty = 0;
     this.attemptedProblemNum = 0;
+    this.penalty = 0;
     for (const p of this.problemStatistics) {
       if (p.isAccepted) {
         this.solvedProblemNum++;
@@ -428,6 +441,24 @@ class Team {
   isEqualRank(otherTeam) {
     return this.solvedProblemNum === otherTeam.solvedProblemNum && this.penalty === otherTeam.penalty;
   }
+  postProcessPlaceChartPoints() {
+    if (this.placeChartPoints.length === 0) {
+      return;
+    }
+    const res = [];
+    res.push(this.placeChartPoints[0]);
+    for (let i = 1; i < this.placeChartPoints.length - 1; i++) {
+      const p = this.placeChartPoints[i];
+      const preP = res[res.length - 1];
+      if (p.rank !== preP.rank || p.lastSolvedProblem !== preP.lastSolvedProblem) {
+        res.push(p);
+      }
+    }
+    if (this.placeChartPoints.length > 1) {
+      res.push(this.placeChartPoints[this.placeChartPoints.length - 1]);
+    }
+    this.placeChartPoints = res;
+  }
   static compare(lhs, rhs) {
     if (lhs.solvedProblemNum !== rhs.solvedProblemNum) {
       return rhs.solvedProblemNum - lhs.solvedProblemNum;
@@ -618,6 +649,9 @@ class Submission {
   isNotCalculatedPenaltyStatus() {
     return isNotCalculatedPenaltyStatus(this.status);
   }
+  get timestampToMinute() {
+    return Math.floor(this.timestamp / 60);
+  }
   static compare(lhs, rhs) {
     if (lhs.timestamp !== rhs.timestamp) {
       return lhs.timestamp - rhs.timestamp;
@@ -694,87 +728,84 @@ class Rank {
       this.contest.problems.forEach((p) => {
         p.statistics.reset();
       });
-      for (const s of this.getSubmissions()) {
+      let preSubmissionTimestampToMinute = 0;
+      const allSubmissions = this.getSubmissions();
+      this.teams.forEach(
+        (t) => t.placeChartPoints.push({
+          timePoint: 0,
+          rank: 1,
+          lastSolvedProblem: null
+        })
+      );
+      for (let ix = 0; ix < allSubmissions.length; ix++) {
+        const s = allSubmissions[ix];
         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);
-        const submissions = problemStatistics.submissions;
-        submissions.push(s);
-        problem.statistics.submittedNum++;
-        if (problemStatistics.isSolved) {
-          continue;
-        }
-        if (s.isIgnore || s.isNotCalculatedPenaltyStatus()) {
-          problem.statistics.ignoreNum++;
-          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++;
-          problem.statistics.attemptedNum += problemStatistics.failedCount + 1;
-          if (problem.statistics.firstSolveSubmissions.length === 0 || problem.statistics.firstSolveSubmissions[problem.statistics.firstSolveSubmissions.length - 1].timestamp === s.timestamp) {
-            problemStatistics.isFirstSolved = true;
-            problem.statistics.firstSolveSubmissions.push(s);
+        (() => {
+          if (team === void 0 || problem === void 0) {
+            return;
           }
-          while (problem.statistics.lastSolveSubmissions.length > 0) {
-            problem.statistics.lastSolveSubmissions.pop();
+          const problemStatistics = team.problemStatisticsMap.get(problemId);
+          const submissions = problemStatistics.submissions;
+          submissions.push(s);
+          team.submissions.push(s);
+          problem.statistics.submittedNum++;
+          if (problemStatistics.isSolved) {
+            return;
           }
-          problem.statistics.lastSolveSubmissions.push(s);
-          team.lastSolvedProblemTimestamp = s.timestamp;
-        }
-        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;
-        let preTeam = null;
-        for (const t of this.teams) {
-          t.rank = rank++;
-          if (preTeam !== null) {
-            if (t.isEqualRank(preTeam)) {
-              t.rank = preTeam.rank;
+          if (s.isIgnore || s.isNotCalculatedPenaltyStatus()) {
+            problem.statistics.ignoreNum++;
+            problemStatistics.ignoreCount++;
+            return;
+          }
+          problemStatistics.isSubmitted = true;
+          problemStatistics.lastSubmitTimestamp = s.timestamp;
+          problemStatistics.totalCount++;
+          if (s.isAccepted()) {
+            problemStatistics.isSolved = true;
+            problemStatistics.solvedTimestamp = s.timestamp;
+            problem.statistics.acceptedNum++;
+            problem.statistics.attemptedNum += problemStatistics.failedCount + 1;
+            if (problem.statistics.firstSolveSubmissions.length === 0 || problem.statistics.firstSolveSubmissions[problem.statistics.firstSolveSubmissions.length - 1].timestamp === s.timestamp) {
+              problemStatistics.isFirstSolved = true;
+              problem.statistics.firstSolveSubmissions.push(s);
+            }
+            while (problem.statistics.lastSolveSubmissions.length > 0) {
+              problem.statistics.lastSolveSubmissions.pop();
             }
+            problem.statistics.lastSolveSubmissions.push(s);
+            team.lastSolvedProblem = problem;
+            team.lastSolvedProblemTimestamp = s.timestamp;
           }
-          preTeam = t;
-        }
-      }
-      if (this.contest.organization) {
-        let rank = 1;
-        let preTeam = null;
-        const se = /* @__PURE__ */ new Set();
-        for (const t of this.teams) {
-          const org = t.organization;
-          if (se.has(org)) {
-            continue;
+          if (s.isRejected()) {
+            problemStatistics.failedCount++;
+            problem.statistics.rejectedNum++;
           }
-          se.add(org);
-          t.organizationRank = rank++;
-          if (preTeam !== null) {
-            if (t.isEqualRank(preTeam)) {
-              t.organizationRank = preTeam.organizationRank;
-            }
+          if (s.isPending()) {
+            problemStatistics.pendingCount++;
+            problem.statistics.pendingNum++;
           }
-          preTeam = t;
+        })();
+        if (s.timestampToMinute > preSubmissionTimestampToMinute || ix === allSubmissions.length - 1) {
+          this.teams.forEach((t) => t.calcSolvedData());
+          this.teams.sort(Team.compare);
+          this.buildTeamRank();
+          this.teams.forEach(
+            (t) => t.placeChartPoints.push(
+              {
+                timePoint: s.timestampToMinute,
+                rank: t.rank,
+                lastSolvedProblem: t.lastSolvedProblem
+              }
+            )
+          );
         }
+        preSubmissionTimestampToMinute = s.timestampToMinute;
       }
+      this.teams.forEach((t) => t.postProcessPlaceChartPoints());
+      this.buildOrgRank();
     })();
     (() => {
       this.rankStatistics.reset();
@@ -785,6 +816,41 @@ class Rank {
     })();
     return this;
   }
+  buildTeamRank() {
+    let rank = 1;
+    let preTeam = null;
+    for (const t of this.teams) {
+      t.rank = rank++;
+      if (preTeam !== null) {
+        if (t.isEqualRank(preTeam)) {
+          t.rank = preTeam.rank;
+        }
+      }
+      preTeam = t;
+    }
+  }
+  buildOrgRank() {
+    if (!this.contest.organization) {
+      return;
+    }
+    let rank = 1;
+    let preTeam = null;
+    const se = /* @__PURE__ */ new Set();
+    for (const t of this.teams) {
+      const org = t.organization;
+      if (se.has(org)) {
+        continue;
+      }
+      se.add(org);
+      t.organizationRank = rank++;
+      if (preTeam !== null) {
+        if (t.isEqualRank(preTeam)) {
+          t.organizationRank = preTeam.organizationRank;
+        }
+      }
+      preTeam = t;
+    }
+  }
   getSubmissions() {
     if (this.options.enableFilterSubmissionsByTimestamp === false) {
       return this.submissions;
@@ -885,6 +951,7 @@ exports.dayjs = dayjs__default;
 exports.Contest = Contest;
 exports.ContestIndex = ContestIndex;
 exports.ContestIndexConfig = ContestIndexConfig;
+exports.PlaceChartPointData = PlaceChartPointData;
 exports.Problem = Problem;
 exports.ProblemStatistics = ProblemStatistics;
 exports.Rank = Rank;

package/dist/index.d.ts

@@ -14,6 +14,7 @@ declare class Submission {
     isRejected(): boolean;
     isPending(): boolean;
     isNotCalculatedPenaltyStatus(): boolean;
+    get timestampToMinute(): number;
     static compare(lhs: Submission, rhs: Submission): number;
 }
 type Submissions = Array<Submission>;
@@ -135,6 +136,12 @@ declare class RankStatistics {
     reset(): void;
 }
 
+declare class PlaceChartPointData {
+    timePoint: number;
+    rank: number;
+    lastSolvedProblem: Problem | null;
+    constructor();
+}
 declare class Team {
     id: string;
     name: string;
@@ -148,16 +155,20 @@ declare class Team {
     organizationRank: number;
     solvedProblemNum: number;
     attemptedProblemNum: number;
+    lastSolvedProblem: Problem | null;
     lastSolvedProblemTimestamp: number;
     penalty: number;
     problemStatistics: Array<TeamProblemStatistics>;
     problemStatisticsMap: Map<string, TeamProblemStatistics>;
+    submissions: Submissions;
+    placeChartPoints: Array<PlaceChartPointData>;
     constructor();
     reset(): void;
     get penaltyToMinute(): number;
     get dict(): number;
     calcSolvedData(): void;
     isEqualRank(otherTeam: Team): boolean;
+    postProcessPlaceChartPoints(): void;
     static compare(lhs: Team, rhs: Team): number;
 }
 type Teams = Array<Team>;
@@ -182,6 +193,8 @@ declare class Rank {
     options: RankOptions;
     constructor(contest: Contest, teams: Teams, submissions: Submissions);
     buildRank(): this;
+    buildTeamRank(): void;
+    buildOrgRank(): void;
     getSubmissions(): Submissions;
 }
 
@@ -209,4 +222,4 @@ declare function isRejected(status: SubmissionStatus): boolean;
 declare function isPending(status: SubmissionStatus): boolean;
 declare function isNotCalculatedPenaltyStatus(status: SubmissionStatus): boolean;
 
-export { Contest, ContestIndex, ContestIndexConfig, ContestIndexList, Problem, ProblemStatistics, Problems, Rank, RankOptions, RankStatistics, Resolver, Submission, Submissions, Team, TeamProblemStatistics, Teams, calcDict, createContest, createContestIndex, createContestIndexList, createDayJS, createProblem, createProblems, createProblemsByProblemIds, createSubmission, createSubmissions, createTeam, createTeams, getImageSource, getTimeDiff, getTimestamp, isAccepted, isNotCalculatedPenaltyStatus, isPending, isRejected, stringToSubmissionStatus };
+export { Contest, ContestIndex, ContestIndexConfig, ContestIndexList, PlaceChartPointData, Problem, ProblemStatistics, Problems, Rank, RankOptions, RankStatistics, Resolver, Submission, Submissions, Team, TeamProblemStatistics, Teams, calcDict, createContest, createContestIndex, createContestIndexList, createDayJS, createProblem, createProblems, createProblemsByProblemIds, createSubmission, createSubmissions, createTeam, createTeams, getImageSource, getTimeDiff, getTimestamp, isAccepted, isNotCalculatedPenaltyStatus, isPending, isRejected, stringToSubmissionStatus };

package/dist/index.mjs

@@ -363,6 +363,13 @@ class RankStatistics {
   }
 }
 
+class PlaceChartPointData {
+  constructor() {
+    this.timePoint = 0;
+    this.rank = 0;
+    this.lastSolvedProblem = null;
+  }
+}
 class Team {
   constructor() {
     this.id = "";
@@ -374,20 +381,26 @@ class Team {
     this.organizationRank = -1;
     this.solvedProblemNum = 0;
     this.attemptedProblemNum = 0;
+    this.lastSolvedProblem = null;
     this.lastSolvedProblemTimestamp = 0;
     this.penalty = 0;
     this.problemStatistics = [];
     this.problemStatisticsMap = /* @__PURE__ */ new Map();
+    this.submissions = [];
+    this.placeChartPoints = [];
   }
   reset() {
     this.rank = 0;
     this.organizationRank = -1;
     this.solvedProblemNum = 0;
     this.attemptedProblemNum = 0;
+    this.lastSolvedProblem = null;
     this.lastSolvedProblemTimestamp = 0;
     this.penalty = 0;
     this.problemStatistics = [];
     this.problemStatisticsMap = /* @__PURE__ */ new Map();
+    this.submissions = [];
+    this.placeChartPoints = [];
   }
   get penaltyToMinute() {
     return Math.floor(this.penalty / 60);
@@ -399,8 +412,8 @@ class Team {
   }
   calcSolvedData() {
     this.solvedProblemNum = 0;
-    this.penalty = 0;
     this.attemptedProblemNum = 0;
+    this.penalty = 0;
     for (const p of this.problemStatistics) {
       if (p.isAccepted) {
         this.solvedProblemNum++;
@@ -412,6 +425,24 @@ class Team {
   isEqualRank(otherTeam) {
     return this.solvedProblemNum === otherTeam.solvedProblemNum && this.penalty === otherTeam.penalty;
   }
+  postProcessPlaceChartPoints() {
+    if (this.placeChartPoints.length === 0) {
+      return;
+    }
+    const res = [];
+    res.push(this.placeChartPoints[0]);
+    for (let i = 1; i < this.placeChartPoints.length - 1; i++) {
+      const p = this.placeChartPoints[i];
+      const preP = res[res.length - 1];
+      if (p.rank !== preP.rank || p.lastSolvedProblem !== preP.lastSolvedProblem) {
+        res.push(p);
+      }
+    }
+    if (this.placeChartPoints.length > 1) {
+      res.push(this.placeChartPoints[this.placeChartPoints.length - 1]);
+    }
+    this.placeChartPoints = res;
+  }
   static compare(lhs, rhs) {
     if (lhs.solvedProblemNum !== rhs.solvedProblemNum) {
       return rhs.solvedProblemNum - lhs.solvedProblemNum;
@@ -602,6 +633,9 @@ class Submission {
   isNotCalculatedPenaltyStatus() {
     return isNotCalculatedPenaltyStatus(this.status);
   }
+  get timestampToMinute() {
+    return Math.floor(this.timestamp / 60);
+  }
   static compare(lhs, rhs) {
     if (lhs.timestamp !== rhs.timestamp) {
       return lhs.timestamp - rhs.timestamp;
@@ -678,87 +712,84 @@ class Rank {
       this.contest.problems.forEach((p) => {
         p.statistics.reset();
       });
-      for (const s of this.getSubmissions()) {
+      let preSubmissionTimestampToMinute = 0;
+      const allSubmissions = this.getSubmissions();
+      this.teams.forEach(
+        (t) => t.placeChartPoints.push({
+          timePoint: 0,
+          rank: 1,
+          lastSolvedProblem: null
+        })
+      );
+      for (let ix = 0; ix < allSubmissions.length; ix++) {
+        const s = allSubmissions[ix];
         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);
-        const submissions = problemStatistics.submissions;
-        submissions.push(s);
-        problem.statistics.submittedNum++;
-        if (problemStatistics.isSolved) {
-          continue;
-        }
-        if (s.isIgnore || s.isNotCalculatedPenaltyStatus()) {
-          problem.statistics.ignoreNum++;
-          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++;
-          problem.statistics.attemptedNum += problemStatistics.failedCount + 1;
-          if (problem.statistics.firstSolveSubmissions.length === 0 || problem.statistics.firstSolveSubmissions[problem.statistics.firstSolveSubmissions.length - 1].timestamp === s.timestamp) {
-            problemStatistics.isFirstSolved = true;
-            problem.statistics.firstSolveSubmissions.push(s);
+        (() => {
+          if (team === void 0 || problem === void 0) {
+            return;
           }
-          while (problem.statistics.lastSolveSubmissions.length > 0) {
-            problem.statistics.lastSolveSubmissions.pop();
+          const problemStatistics = team.problemStatisticsMap.get(problemId);
+          const submissions = problemStatistics.submissions;
+          submissions.push(s);
+          team.submissions.push(s);
+          problem.statistics.submittedNum++;
+          if (problemStatistics.isSolved) {
+            return;
           }
-          problem.statistics.lastSolveSubmissions.push(s);
-          team.lastSolvedProblemTimestamp = s.timestamp;
-        }
-        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;
-        let preTeam = null;
-        for (const t of this.teams) {
-          t.rank = rank++;
-          if (preTeam !== null) {
-            if (t.isEqualRank(preTeam)) {
-              t.rank = preTeam.rank;
+          if (s.isIgnore || s.isNotCalculatedPenaltyStatus()) {
+            problem.statistics.ignoreNum++;
+            problemStatistics.ignoreCount++;
+            return;
+          }
+          problemStatistics.isSubmitted = true;
+          problemStatistics.lastSubmitTimestamp = s.timestamp;
+          problemStatistics.totalCount++;
+          if (s.isAccepted()) {
+            problemStatistics.isSolved = true;
+            problemStatistics.solvedTimestamp = s.timestamp;
+            problem.statistics.acceptedNum++;
+            problem.statistics.attemptedNum += problemStatistics.failedCount + 1;
+            if (problem.statistics.firstSolveSubmissions.length === 0 || problem.statistics.firstSolveSubmissions[problem.statistics.firstSolveSubmissions.length - 1].timestamp === s.timestamp) {
+              problemStatistics.isFirstSolved = true;
+              problem.statistics.firstSolveSubmissions.push(s);
+            }
+            while (problem.statistics.lastSolveSubmissions.length > 0) {
+              problem.statistics.lastSolveSubmissions.pop();
             }
+            problem.statistics.lastSolveSubmissions.push(s);
+            team.lastSolvedProblem = problem;
+            team.lastSolvedProblemTimestamp = s.timestamp;
           }
-          preTeam = t;
-        }
-      }
-      if (this.contest.organization) {
-        let rank = 1;
-        let preTeam = null;
-        const se = /* @__PURE__ */ new Set();
-        for (const t of this.teams) {
-          const org = t.organization;
-          if (se.has(org)) {
-            continue;
+          if (s.isRejected()) {
+            problemStatistics.failedCount++;
+            problem.statistics.rejectedNum++;
           }
-          se.add(org);
-          t.organizationRank = rank++;
-          if (preTeam !== null) {
-            if (t.isEqualRank(preTeam)) {
-              t.organizationRank = preTeam.organizationRank;
-            }
+          if (s.isPending()) {
+            problemStatistics.pendingCount++;
+            problem.statistics.pendingNum++;
           }
-          preTeam = t;
+        })();
+        if (s.timestampToMinute > preSubmissionTimestampToMinute || ix === allSubmissions.length - 1) {
+          this.teams.forEach((t) => t.calcSolvedData());
+          this.teams.sort(Team.compare);
+          this.buildTeamRank();
+          this.teams.forEach(
+            (t) => t.placeChartPoints.push(
+              {
+                timePoint: s.timestampToMinute,
+                rank: t.rank,
+                lastSolvedProblem: t.lastSolvedProblem
+              }
+            )
+          );
         }
+        preSubmissionTimestampToMinute = s.timestampToMinute;
       }
+      this.teams.forEach((t) => t.postProcessPlaceChartPoints());
+      this.buildOrgRank();
     })();
     (() => {
       this.rankStatistics.reset();
@@ -769,6 +800,41 @@ class Rank {
     })();
     return this;
   }
+  buildTeamRank() {
+    let rank = 1;
+    let preTeam = null;
+    for (const t of this.teams) {
+      t.rank = rank++;
+      if (preTeam !== null) {
+        if (t.isEqualRank(preTeam)) {
+          t.rank = preTeam.rank;
+        }
+      }
+      preTeam = t;
+    }
+  }
+  buildOrgRank() {
+    if (!this.contest.organization) {
+      return;
+    }
+    let rank = 1;
+    let preTeam = null;
+    const se = /* @__PURE__ */ new Set();
+    for (const t of this.teams) {
+      const org = t.organization;
+      if (se.has(org)) {
+        continue;
+      }
+      se.add(org);
+      t.organizationRank = rank++;
+      if (preTeam !== null) {
+        if (t.isEqualRank(preTeam)) {
+          t.organizationRank = preTeam.organizationRank;
+        }
+      }
+      preTeam = t;
+    }
+  }
   getSubmissions() {
     if (this.options.enableFilterSubmissionsByTimestamp === false) {
       return this.submissions;
@@ -865,4 +931,4 @@ class Resolver extends Rank {
   }
 }
 
-export { Contest, ContestIndex, ContestIndexConfig, Problem, ProblemStatistics, Rank, RankOptions, RankStatistics, Resolver, Submission, Team, TeamProblemStatistics, calcDict, createContest, createContestIndex, createContestIndexList, createDayJS, createProblem, createProblems, createProblemsByProblemIds, createSubmission, createSubmissions, createTeam, createTeams, getImageSource, getTimeDiff, getTimestamp, isAccepted, isNotCalculatedPenaltyStatus, isPending, isRejected, stringToSubmissionStatus };
+export { Contest, ContestIndex, ContestIndexConfig, PlaceChartPointData, Problem, ProblemStatistics, Rank, RankOptions, RankStatistics, Resolver, Submission, Team, TeamProblemStatistics, calcDict, createContest, createContestIndex, createContestIndexList, createDayJS, createProblem, createProblems, createProblemsByProblemIds, createSubmission, createSubmissions, createTeam, createTeams, getImageSource, getTimeDiff, getTimestamp, isAccepted, isNotCalculatedPenaltyStatus, isPending, isRejected, stringToSubmissionStatus };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xcpcio/core",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "XCPCIO Core",
   "author": "Dup4 <lyuzhi.pan@gmail.com>",
   "license": "MIT",
@@ -42,7 +42,7 @@
   "dependencies": {
     "dayjs": "^1.11.8",
     "lodash": "^4.17.21",
-    "@xcpcio/types": "0.4.3"
+    "@xcpcio/types": "0.5.0"
   },
   "devDependencies": {
     "@babel/types": "^7.22.4",

package/src/rank.ts

@@ -77,113 +77,108 @@ export class Rank {
         p.statistics.reset();
       });
 
-      for (const s of this.getSubmissions()) {
+      let preSubmissionTimestampToMinute = 0;
+      const allSubmissions = this.getSubmissions();
+
+      this.teams.forEach(t =>
+        t.placeChartPoints.push({
+          timePoint: 0,
+          rank: 1,
+          lastSolvedProblem: null,
+        }),
+      );
+
+      for (let ix = 0; ix < allSubmissions.length; ix++) {
+        const s = allSubmissions[ix];
+
         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;
-        const submissions = problemStatistics.submissions;
-
-        submissions.push(s);
-        problem.statistics.submittedNum++;
-
-        if (problemStatistics.isSolved) {
-          continue;
-        }
-
-        if (s.isIgnore || s.isNotCalculatedPenaltyStatus()) {
-          problem.statistics.ignoreNum++;
-          problemStatistics.ignoreCount++;
-          continue;
-        }
-
-        problemStatistics.isSubmitted = true;
-        problemStatistics.lastSubmitTimestamp = s.timestamp;
-        problemStatistics.totalCount++;
+        (() => {
+          if (team === undefined || problem === undefined) {
+            return;
+          }
 
-        if (s.isAccepted()) {
-          problemStatistics.isSolved = true;
-          problemStatistics.solvedTimestamp = s.timestamp;
+          const problemStatistics = team.problemStatisticsMap.get(problemId) as TeamProblemStatistics;
+          const submissions = problemStatistics.submissions;
 
-          problem.statistics.acceptedNum++;
-          problem.statistics.attemptedNum += problemStatistics.failedCount + 1;
+          submissions.push(s);
+          team.submissions.push(s);
+          problem.statistics.submittedNum++;
 
-          if (
-            problem.statistics.firstSolveSubmissions.length === 0
-            || problem.statistics.firstSolveSubmissions[problem.statistics.firstSolveSubmissions.length - 1].timestamp === s.timestamp
-          ) {
-            problemStatistics.isFirstSolved = true;
-            problem.statistics.firstSolveSubmissions.push(s);
+          if (problemStatistics.isSolved) {
+            return;
           }
 
-          while (problem.statistics.lastSolveSubmissions.length > 0) {
-            problem.statistics.lastSolveSubmissions.pop();
+          if (s.isIgnore || s.isNotCalculatedPenaltyStatus()) {
+            problem.statistics.ignoreNum++;
+            problemStatistics.ignoreCount++;
+            return;
           }
 
-          problem.statistics.lastSolveSubmissions.push(s);
-          team.lastSolvedProblemTimestamp = s.timestamp;
-        }
-
-        if (s.isRejected()) {
-          problemStatistics.failedCount++;
-          problem.statistics.rejectedNum++;
-        }
-
-        if (s.isPending()) {
-          problemStatistics.pendingCount++;
-          problem.statistics.pendingNum++;
-        }
-      }
+          problemStatistics.isSubmitted = true;
+          problemStatistics.lastSubmitTimestamp = s.timestamp;
+          problemStatistics.totalCount++;
 
-      this.teams.forEach(t => t.calcSolvedData());
-      this.teams.sort(Team.compare);
+          if (s.isAccepted()) {
+            problemStatistics.isSolved = true;
+            problemStatistics.solvedTimestamp = s.timestamp;
 
-      {
-        let rank = 1;
-        let preTeam = null;
-        for (const t of this.teams) {
-          t.rank = rank++;
+            problem.statistics.acceptedNum++;
+            problem.statistics.attemptedNum += problemStatistics.failedCount + 1;
 
-          if (preTeam !== null) {
-            if (t.isEqualRank(preTeam)) {
-              t.rank = preTeam.rank;
+            if (
+              problem.statistics.firstSolveSubmissions.length === 0
+              || problem.statistics.firstSolveSubmissions[problem.statistics.firstSolveSubmissions.length - 1].timestamp === s.timestamp
+            ) {
+              problemStatistics.isFirstSolved = true;
+              problem.statistics.firstSolveSubmissions.push(s);
             }
-          }
-
-          preTeam = t;
-        }
-      }
 
-      if (this.contest.organization) {
-        let rank = 1;
-        let preTeam = null;
+            while (problem.statistics.lastSolveSubmissions.length > 0) {
+              problem.statistics.lastSolveSubmissions.pop();
+            }
 
-        const se = new Set<string>();
+            problem.statistics.lastSolveSubmissions.push(s);
 
-        for (const t of this.teams) {
-          const org = t.organization;
-          if (se.has(org)) {
-            continue;
+            team.lastSolvedProblem = problem;
+            team.lastSolvedProblemTimestamp = s.timestamp;
           }
 
-          se.add(org);
-          t.organizationRank = rank++;
-
-          if (preTeam !== null) {
-            if (t.isEqualRank(preTeam)) {
-              t.organizationRank = preTeam.organizationRank;
-            }
+          if (s.isRejected()) {
+            problemStatistics.failedCount++;
+            problem.statistics.rejectedNum++;
           }
 
-          preTeam = t;
+          if (s.isPending()) {
+            problemStatistics.pendingCount++;
+            problem.statistics.pendingNum++;
+          }
+        })();
+
+        if (s.timestampToMinute > preSubmissionTimestampToMinute || ix === allSubmissions.length - 1) {
+          this.teams.forEach(t => t.calcSolvedData());
+          this.teams.sort(Team.compare);
+          this.buildTeamRank();
+
+          this.teams.forEach(t =>
+            t.placeChartPoints.push(
+              {
+                timePoint: s.timestampToMinute,
+                rank: t.rank,
+                lastSolvedProblem: t.lastSolvedProblem,
+              },
+            ),
+          );
         }
+
+        preSubmissionTimestampToMinute = s.timestampToMinute;
       }
+
+      this.teams.forEach(t => t.postProcessPlaceChartPoints());
+      this.buildOrgRank();
     })();
 
     (() => {
@@ -198,6 +193,51 @@ export class Rank {
     return this;
   }
 
+  buildTeamRank() {
+    let rank = 1;
+    let preTeam = null;
+    for (const t of this.teams) {
+      t.rank = rank++;
+
+      if (preTeam !== null) {
+        if (t.isEqualRank(preTeam)) {
+          t.rank = preTeam.rank;
+        }
+      }
+
+      preTeam = t;
+    }
+  }
+
+  buildOrgRank() {
+    if (!this.contest.organization) {
+      return;
+    }
+
+    let rank = 1;
+    let preTeam = null;
+
+    const se = new Set<string>();
+
+    for (const t of this.teams) {
+      const org = t.organization;
+      if (se.has(org)) {
+        continue;
+      }
+
+      se.add(org);
+      t.organizationRank = rank++;
+
+      if (preTeam !== null) {
+        if (t.isEqualRank(preTeam)) {
+          t.organizationRank = preTeam.organizationRank;
+        }
+      }
+
+      preTeam = t;
+    }
+  }
+
   getSubmissions() {
     if (this.options.enableFilterSubmissionsByTimestamp === false) {
       return this.submissions;

package/src/submission.ts

@@ -41,6 +41,10 @@ export class Submission {
     return isNotCalculatedPenaltyStatus(this.status);
   }
 
+  get timestampToMinute() {
+    return Math.floor(this.timestamp / 60);
+  }
+
   static compare(lhs: Submission, rhs: Submission): number {
     if (lhs.timestamp !== rhs.timestamp) {
       return lhs.timestamp - rhs.timestamp;

package/src/team.ts

@@ -1,7 +1,20 @@
 import type { Team as ITeam, Teams as ITeams, Image } from "@xcpcio/types";
 
-import type { TeamProblemStatistics } from "./problem";
+import type { Problem, TeamProblemStatistics } from "./problem";
 import { calcDict } from "./utils";
+import type { Submissions } from "./submission";
+
+export class PlaceChartPointData {
+  timePoint: number;
+  rank: number;
+  lastSolvedProblem: Problem | null;
+
+  constructor() {
+    this.timePoint = 0;
+    this.rank = 0;
+    this.lastSolvedProblem = null;
+  }
+}
 
 export class Team {
   id: string;
@@ -21,6 +34,8 @@ export class Team {
 
   solvedProblemNum: number;
   attemptedProblemNum: number;
+
+  lastSolvedProblem: Problem | null;
   lastSolvedProblemTimestamp: number;
 
   penalty: number;
@@ -28,6 +43,10 @@ export class Team {
   problemStatistics: Array<TeamProblemStatistics>;
   problemStatisticsMap: Map<string, TeamProblemStatistics>;
 
+  submissions: Submissions;
+
+  placeChartPoints: Array<PlaceChartPointData>;
+
   constructor() {
     this.id = "";
     this.name = "";
@@ -42,12 +61,18 @@ export class Team {
 
     this.solvedProblemNum = 0;
     this.attemptedProblemNum = 0;
+
+    this.lastSolvedProblem = null;
     this.lastSolvedProblemTimestamp = 0;
 
     this.penalty = 0;
 
     this.problemStatistics = [];
     this.problemStatisticsMap = new Map<string, TeamProblemStatistics>();
+
+    this.submissions = [];
+
+    this.placeChartPoints = [];
   }
 
   reset() {
@@ -56,12 +81,18 @@ export class Team {
 
     this.solvedProblemNum = 0;
     this.attemptedProblemNum = 0;
+
+    this.lastSolvedProblem = null;
     this.lastSolvedProblemTimestamp = 0;
 
     this.penalty = 0;
 
     this.problemStatistics = [];
     this.problemStatisticsMap = new Map<string, TeamProblemStatistics>();
+
+    this.submissions = [];
+
+    this.placeChartPoints = [];
   }
 
   get penaltyToMinute() {
@@ -77,9 +108,10 @@ export class Team {
 
   calcSolvedData() {
     this.solvedProblemNum = 0;
-    this.penalty = 0;
     this.attemptedProblemNum = 0;
 
+    this.penalty = 0;
+
     for (const p of this.problemStatistics) {
       if (p.isAccepted) {
         this.solvedProblemNum++;
@@ -94,6 +126,30 @@ export class Team {
     return this.solvedProblemNum === otherTeam.solvedProblemNum && this.penalty === otherTeam.penalty;
   }
 
+  postProcessPlaceChartPoints() {
+    if (this.placeChartPoints.length === 0) {
+      return;
+    }
+
+    const res = [];
+    res.push(this.placeChartPoints[0]);
+
+    for (let i = 1; i < this.placeChartPoints.length - 1; i++) {
+      const p = this.placeChartPoints[i];
+      const preP = res[res.length - 1];
+
+      if (p.rank !== preP.rank || p.lastSolvedProblem !== preP.lastSolvedProblem) {
+        res.push(p);
+      }
+    }
+
+    if (this.placeChartPoints.length > 1) {
+      res.push(this.placeChartPoints[this.placeChartPoints.length - 1]);
+    }
+
+    this.placeChartPoints = res;
+  }
+
   static compare(lhs: Team, rhs: Team): number {
     if (lhs.solvedProblemNum !== rhs.solvedProblemNum) {
       return rhs.solvedProblemNum - lhs.solvedProblemNum;