@xcpcio/core 0.4.2 → 0.5.0

package/dist/index.cjs

@@ -86,6 +86,8 @@ class ProblemStatistics {
     this.rejectedNum = 0;
     this.pendingNum = 0;
     this.submittedNum = 0;
+    this.attemptedNum = 0;
+    this.ignoreNum = 0;
     this.firstSolveSubmissions = [];
     this.lastSolveSubmissions = [];
   }
@@ -217,19 +219,25 @@ class Contest {
     }
     return getTimeDiff(Math.floor(dayjs__default.duration(this.startTime.diff(baseTime)).asSeconds()));
   }
-  getContestRemainingTime(nowTime) {
+  getContestElapsedTime(nowTime) {
     let baseTime = createDayJS(nowTime);
     if (baseTime.isAfter(this.endTime)) {
       baseTime = this.endTime;
     }
-    return getTimeDiff(Math.floor(dayjs__default.duration(this.endTime.diff(baseTime)).asSeconds()));
+    if (baseTime.isBefore(this.startTime)) {
+      baseTime = this.startTime;
+    }
+    return getTimeDiff(Math.floor(dayjs__default.duration(baseTime.diff(this.startTime)).asSeconds()));
   }
-  getContestElapsedTime(nowTime) {
+  getContestRemainingTime(nowTime) {
     let baseTime = createDayJS(nowTime);
     if (baseTime.isAfter(this.endTime)) {
       baseTime = this.endTime;
     }
-    return getTimeDiff(Math.floor(dayjs__default.duration(baseTime.diff(this.startTime)).asSeconds()));
+    if (baseTime.isBefore(this.startTime)) {
+      baseTime = this.startTime;
+    }
+    return getTimeDiff(Math.floor(dayjs__default.duration(this.endTime.diff(baseTime)).asSeconds()));
   }
   getContestProgressRatio(nowTime) {
     const baseTime = createDayJS(nowTime);
@@ -371,6 +379,13 @@ class RankStatistics {
   }
 }
 
+class PlaceChartPointData {
+  constructor() {
+    this.timePoint = 0;
+    this.rank = 0;
+    this.lastSolvedProblem = null;
+  }
+}
 class Team {
   constructor() {
     this.id = "";
@@ -382,9 +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);
@@ -396,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++;
@@ -406,6 +438,27 @@ 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;
@@ -413,6 +466,9 @@ class Team {
     if (lhs.penalty !== rhs.penalty) {
       return lhs.penalty - rhs.penalty;
     }
+    if (lhs.lastSolvedProblemTimestamp !== rhs.lastSolvedProblemTimestamp) {
+      return lhs.lastSolvedProblemTimestamp - rhs.lastSolvedProblemTimestamp;
+    }
     if (lhs.name < rhs.name) {
       return -1;
     } else if (lhs.name > rhs.name) {
@@ -593,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;
@@ -629,6 +688,21 @@ function createSubmissions(submissionsJSON) {
   }
 }
 
+class RankOptions {
+  constructor() {
+    this.enableFilterSubmissionsByTimestamp = false;
+    this.width = 0;
+    this.timestamp = 0;
+  }
+  setWidth(width, contest) {
+    this.width = width;
+    this.timestamp = Math.floor((contest.endTime.unix() - contest.startTime.unix()) * this.width * 1e-4);
+    this.enableFilterSubmissionsByTimestamp = true;
+  }
+  disableFilterSubmissionByTimestamp() {
+    this.enableFilterSubmissionsByTimestamp = false;
+  }
+}
 class Rank {
   constructor(contest, teams, submissions) {
     this.contest = contest;
@@ -637,10 +711,12 @@ class Rank {
     this.submissions = ___default.cloneDeep(submissions).sort(Submission.compare);
     this.submissionsMap = new Map(this.submissions.map((s) => [s.id, s]));
     this.rankStatistics = new RankStatistics();
+    this.options = new RankOptions();
   }
-  buildRank(options) {
+  buildRank() {
     (() => {
       for (const t of this.teams) {
+        t.reset();
         t.problemStatistics = this.contest.problems.map((p) => {
           const ps = new TeamProblemStatistics();
           ps.problem = p;
@@ -652,76 +728,84 @@ class Rank {
       this.contest.problems.forEach((p) => {
         p.statistics.reset();
       });
-      for (const s of this.submissions) {
+      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;
-        }
-        if (options?.timestamp !== void 0 && options?.timestamp !== null) {
-          if (s.timestamp > options.timestamp) {
-            break;
+        (() => {
+          if (team === void 0 || problem === void 0) {
+            return;
           }
-        }
-        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);
+          const problemStatistics = team.problemStatisticsMap.get(problemId);
+          const submissions = problemStatistics.submissions;
+          submissions.push(s);
+          team.submissions.push(s);
+          problem.statistics.submittedNum++;
+          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);
-        }
-        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++;
-        }
-      }
-      if (this.contest.organization) {
-        let rank = 1;
-        const se = /* @__PURE__ */ new Set();
-        for (const t of this.teams) {
-          if (!se.has(t.organization)) {
-            se.add(t.organization);
-            t.organizationRank = rank;
-            rank++;
+          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;
+          }
+          if (s.isRejected()) {
+            problemStatistics.failedCount++;
+            problem.statistics.rejectedNum++;
           }
+          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();
     })();
     (() => {
       this.rankStatistics.reset();
@@ -732,6 +816,47 @@ 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;
+    }
+    return this.submissions.filter((s) => s.timestamp <= this.options.timestamp).sort(Submission.compare);
+  }
 }
 
 class ResolverOperation {
@@ -826,9 +951,11 @@ 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;
+exports.RankOptions = RankOptions;
 exports.RankStatistics = RankStatistics;
 exports.Resolver = Resolver;
 exports.Submission = Submission;

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>;
@@ -101,8 +102,8 @@ declare class Contest {
     getContestDuration(timeFormat?: string): string;
     getContestState(nowTime?: Date): ContestState;
     getContestPendingTime(nowTime?: Date): string;
-    getContestRemainingTime(nowTime?: Date): string;
     getContestElapsedTime(nowTime?: Date): string;
+    getContestRemainingTime(nowTime?: Date): string;
     getContestProgressRatio(nowTime?: Date): number;
 }
 declare function createContest(contestJSON: Contest$1): Contest;
@@ -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,19 +155,34 @@ 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>;
 declare function createTeam(teamJSON: Team$1): Team;
 declare function createTeams(teamsJSON: Teams$1): Teams;
 
+declare class RankOptions {
+    enableFilterSubmissionsByTimestamp: boolean;
+    width: number;
+    timestamp: number;
+    constructor();
+    setWidth(width: number, contest: Contest): void;
+    disableFilterSubmissionByTimestamp(): void;
+}
 declare class Rank {
     readonly contest: Contest;
     teams: Teams;
@@ -168,10 +190,12 @@ declare class Rank {
     submissions: Submissions;
     submissionsMap: Map<string, Submission>;
     rankStatistics: RankStatistics;
+    options: RankOptions;
     constructor(contest: Contest, teams: Teams, submissions: Submissions);
-    buildRank(options?: {
-        timestamp?: number;
-    }): this;
+    buildRank(): this;
+    buildTeamRank(): void;
+    buildOrgRank(): void;
+    getSubmissions(): Submissions;
 }
 
 declare class ResolverOperation {
@@ -198,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, 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

@@ -70,6 +70,8 @@ class ProblemStatistics {
     this.rejectedNum = 0;
     this.pendingNum = 0;
     this.submittedNum = 0;
+    this.attemptedNum = 0;
+    this.ignoreNum = 0;
     this.firstSolveSubmissions = [];
     this.lastSolveSubmissions = [];
   }
@@ -201,19 +203,25 @@ class Contest {
     }
     return getTimeDiff(Math.floor(dayjs.duration(this.startTime.diff(baseTime)).asSeconds()));
   }
-  getContestRemainingTime(nowTime) {
+  getContestElapsedTime(nowTime) {
     let baseTime = createDayJS(nowTime);
     if (baseTime.isAfter(this.endTime)) {
       baseTime = this.endTime;
     }
-    return getTimeDiff(Math.floor(dayjs.duration(this.endTime.diff(baseTime)).asSeconds()));
+    if (baseTime.isBefore(this.startTime)) {
+      baseTime = this.startTime;
+    }
+    return getTimeDiff(Math.floor(dayjs.duration(baseTime.diff(this.startTime)).asSeconds()));
   }
-  getContestElapsedTime(nowTime) {
+  getContestRemainingTime(nowTime) {
     let baseTime = createDayJS(nowTime);
     if (baseTime.isAfter(this.endTime)) {
       baseTime = this.endTime;
     }
-    return getTimeDiff(Math.floor(dayjs.duration(baseTime.diff(this.startTime)).asSeconds()));
+    if (baseTime.isBefore(this.startTime)) {
+      baseTime = this.startTime;
+    }
+    return getTimeDiff(Math.floor(dayjs.duration(this.endTime.diff(baseTime)).asSeconds()));
   }
   getContestProgressRatio(nowTime) {
     const baseTime = createDayJS(nowTime);
@@ -355,6 +363,13 @@ class RankStatistics {
   }
 }
 
+class PlaceChartPointData {
+  constructor() {
+    this.timePoint = 0;
+    this.rank = 0;
+    this.lastSolvedProblem = null;
+  }
+}
 class Team {
   constructor() {
     this.id = "";
@@ -366,9 +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);
@@ -380,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++;
@@ -390,6 +422,27 @@ 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;
@@ -397,6 +450,9 @@ class Team {
     if (lhs.penalty !== rhs.penalty) {
       return lhs.penalty - rhs.penalty;
     }
+    if (lhs.lastSolvedProblemTimestamp !== rhs.lastSolvedProblemTimestamp) {
+      return lhs.lastSolvedProblemTimestamp - rhs.lastSolvedProblemTimestamp;
+    }
     if (lhs.name < rhs.name) {
       return -1;
     } else if (lhs.name > rhs.name) {
@@ -577,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;
@@ -613,6 +672,21 @@ function createSubmissions(submissionsJSON) {
   }
 }
 
+class RankOptions {
+  constructor() {
+    this.enableFilterSubmissionsByTimestamp = false;
+    this.width = 0;
+    this.timestamp = 0;
+  }
+  setWidth(width, contest) {
+    this.width = width;
+    this.timestamp = Math.floor((contest.endTime.unix() - contest.startTime.unix()) * this.width * 1e-4);
+    this.enableFilterSubmissionsByTimestamp = true;
+  }
+  disableFilterSubmissionByTimestamp() {
+    this.enableFilterSubmissionsByTimestamp = false;
+  }
+}
 class Rank {
   constructor(contest, teams, submissions) {
     this.contest = contest;
@@ -621,10 +695,12 @@ class Rank {
     this.submissions = _.cloneDeep(submissions).sort(Submission.compare);
     this.submissionsMap = new Map(this.submissions.map((s) => [s.id, s]));
     this.rankStatistics = new RankStatistics();
+    this.options = new RankOptions();
   }
-  buildRank(options) {
+  buildRank() {
     (() => {
       for (const t of this.teams) {
+        t.reset();
         t.problemStatistics = this.contest.problems.map((p) => {
           const ps = new TeamProblemStatistics();
           ps.problem = p;
@@ -636,76 +712,84 @@ class Rank {
       this.contest.problems.forEach((p) => {
         p.statistics.reset();
       });
-      for (const s of this.submissions) {
+      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;
-        }
-        if (options?.timestamp !== void 0 && options?.timestamp !== null) {
-          if (s.timestamp > options.timestamp) {
-            break;
+        (() => {
+          if (team === void 0 || problem === void 0) {
+            return;
           }
-        }
-        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);
+          const problemStatistics = team.problemStatisticsMap.get(problemId);
+          const submissions = problemStatistics.submissions;
+          submissions.push(s);
+          team.submissions.push(s);
+          problem.statistics.submittedNum++;
+          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);
-        }
-        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++;
-        }
-      }
-      if (this.contest.organization) {
-        let rank = 1;
-        const se = /* @__PURE__ */ new Set();
-        for (const t of this.teams) {
-          if (!se.has(t.organization)) {
-            se.add(t.organization);
-            t.organizationRank = rank;
-            rank++;
+          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;
+          }
+          if (s.isRejected()) {
+            problemStatistics.failedCount++;
+            problem.statistics.rejectedNum++;
           }
+          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();
     })();
     (() => {
       this.rankStatistics.reset();
@@ -716,6 +800,47 @@ 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;
+    }
+    return this.submissions.filter((s) => s.timestamp <= this.options.timestamp).sort(Submission.compare);
+  }
 }
 
 class ResolverOperation {
@@ -806,4 +931,4 @@ class Resolver extends Rank {
   }
 }
 
-export { Contest, ContestIndex, ContestIndexConfig, Problem, ProblemStatistics, Rank, 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.2",
+  "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.2"
+    "@xcpcio/types": "0.5.0"
   },
   "devDependencies": {
     "@babel/types": "^7.22.4",

package/src/contest.ts

@@ -89,22 +89,30 @@ export class Contest {
     return getTimeDiff(Math.floor(dayjs.duration(this.startTime.diff(baseTime)).asSeconds()));
   }
 
-  getContestRemainingTime(nowTime?: Date): string {
+  getContestElapsedTime(nowTime?: Date): string {
     let baseTime = createDayJS(nowTime);
     if (baseTime.isAfter(this.endTime)) {
       baseTime = this.endTime;
     }
 
-    return getTimeDiff(Math.floor(dayjs.duration(this.endTime.diff(baseTime)).asSeconds()));
+    if (baseTime.isBefore(this.startTime)) {
+      baseTime = this.startTime;
+    }
+
+    return getTimeDiff(Math.floor(dayjs.duration(baseTime.diff(this.startTime)).asSeconds()));
   }
 
-  getContestElapsedTime(nowTime?: Date): string {
+  getContestRemainingTime(nowTime?: Date): string {
     let baseTime = createDayJS(nowTime);
     if (baseTime.isAfter(this.endTime)) {
       baseTime = this.endTime;
     }
 
-    return getTimeDiff(Math.floor(dayjs.duration(baseTime.diff(this.startTime)).asSeconds()));
+    if (baseTime.isBefore(this.startTime)) {
+      baseTime = this.startTime;
+    }
+
+    return getTimeDiff(Math.floor(dayjs.duration(this.endTime.diff(baseTime)).asSeconds()));
   }
 
   getContestProgressRatio(nowTime?: Date): number {

package/src/problem.ts

@@ -34,6 +34,8 @@ export class ProblemStatistics {
     this.pendingNum = 0;
 
     this.submittedNum = 0;
+    this.attemptedNum = 0;
+    this.ignoreNum = 0;
 
     this.firstSolveSubmissions = [];
     this.lastSolveSubmissions = [];

package/src/rank.ts

@@ -8,6 +8,28 @@ import { Submission } from "./submission";
 import { TeamProblemStatistics } from "./problem";
 import { RankStatistics } from "./rank-statistics";
 
+export class RankOptions {
+  enableFilterSubmissionsByTimestamp: boolean;
+  width: number;
+  timestamp: number;
+
+  constructor() {
+    this.enableFilterSubmissionsByTimestamp = false;
+    this.width = 0;
+    this.timestamp = 0;
+  }
+
+  setWidth(width: number, contest: Contest) {
+    this.width = width;
+    this.timestamp = Math.floor((contest.endTime.unix() - contest.startTime.unix()) * this.width * 0.0001);
+    this.enableFilterSubmissionsByTimestamp = true;
+  }
+
+  disableFilterSubmissionByTimestamp() {
+    this.enableFilterSubmissionsByTimestamp = false;
+  }
+}
+
 export class Rank {
   readonly contest: Contest;
 
@@ -19,6 +41,8 @@ export class Rank {
 
   rankStatistics: RankStatistics;
 
+  options: RankOptions;
+
   constructor(contest: Contest, teams: Teams, submissions: Submissions) {
     this.contest = contest;
 
@@ -29,11 +53,15 @@ export class Rank {
     this.submissionsMap = new Map(this.submissions.map(s => [s.id, s]));
 
     this.rankStatistics = new RankStatistics();
+
+    this.options = new RankOptions();
   }
 
-  buildRank(options?: { timestamp?: number }) {
+  buildRank() {
     (() => {
       for (const t of this.teams) {
+        t.reset();
+
         t.problemStatistics = this.contest.problems.map((p) => {
           const ps = new TeamProblemStatistics();
           ps.problem = p;
@@ -49,104 +77,114 @@ export class Rank {
         p.statistics.reset();
       });
 
-      for (const s of this.submissions) {
+      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;
-        }
+        (() => {
+          if (team === undefined || problem === undefined) {
+            return;
+          }
+
+          const problemStatistics = team.problemStatisticsMap.get(problemId) as TeamProblemStatistics;
+          const submissions = problemStatistics.submissions;
 
-        if (options?.timestamp !== undefined && options?.timestamp !== null) {
-          if (s.timestamp > options.timestamp) {
-            break;
+          submissions.push(s);
+          team.submissions.push(s);
+          problem.statistics.submittedNum++;
+
+          if (problemStatistics.isSolved) {
+            return;
           }
-        }
 
-        const problemStatistics = team.problemStatisticsMap.get(problemId) as TeamProblemStatistics;
-        const submissions = problemStatistics.submissions;
+          if (s.isIgnore || s.isNotCalculatedPenaltyStatus()) {
+            problem.statistics.ignoreNum++;
+            problemStatistics.ignoreCount++;
+            return;
+          }
 
-        submissions.push(s);
-        problem.statistics.submittedNum++;
+          problemStatistics.isSubmitted = true;
+          problemStatistics.lastSubmitTimestamp = s.timestamp;
+          problemStatistics.totalCount++;
 
-        if (problemStatistics.isSolved) {
-          continue;
-        }
+          if (s.isAccepted()) {
+            problemStatistics.isSolved = true;
+            problemStatistics.solvedTimestamp = s.timestamp;
 
-        if (s.isIgnore || s.isNotCalculatedPenaltyStatus()) {
-          problem.statistics.ignoreNum++;
-          problemStatistics.ignoreCount++;
-          continue;
-        }
+            problem.statistics.acceptedNum++;
+            problem.statistics.attemptedNum += problemStatistics.failedCount + 1;
 
-        problemStatistics.isSubmitted = true;
-        problemStatistics.lastSubmitTimestamp = s.timestamp;
-        problemStatistics.totalCount++;
+            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 (s.isAccepted()) {
-          problemStatistics.isSolved = true;
-          problemStatistics.solvedTimestamp = s.timestamp;
+            while (problem.statistics.lastSolveSubmissions.length > 0) {
+              problem.statistics.lastSolveSubmissions.pop();
+            }
 
-          problem.statistics.acceptedNum++;
-          problem.statistics.attemptedNum += problemStatistics.failedCount + 1;
+            problem.statistics.lastSolveSubmissions.push(s);
 
-          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);
+            team.lastSolvedProblem = problem;
+            team.lastSolvedProblemTimestamp = s.timestamp;
           }
 
-          while (problem.statistics.lastSolveSubmissions.length > 0) {
-            problem.statistics.lastSolveSubmissions.pop();
+          if (s.isRejected()) {
+            problemStatistics.failedCount++;
+            problem.statistics.rejectedNum++;
           }
 
-          problem.statistics.lastSolveSubmissions.push(s);
-        }
-
-        if (s.isRejected()) {
-          problemStatistics.failedCount++;
-          problem.statistics.rejectedNum++;
-        }
-
-        if (s.isPending()) {
-          problemStatistics.pendingCount++;
-          problem.statistics.pendingNum++;
+          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,
+              },
+            ),
+          );
         }
-      }
 
-      this.teams.forEach(t => t.calcSolvedData());
-      this.teams.sort(Team.compare);
-
-      {
-        let rank = 1;
-        for (const t of this.teams) {
-          t.rank = rank++;
-        }
+        preSubmissionTimestampToMinute = s.timestampToMinute;
       }
 
-      if (this.contest.organization) {
-        let rank = 1;
-        const se = new Set<string>();
-
-        for (const t of this.teams) {
-          if (!se.has(t.organization)) {
-            se.add(t.organization);
-            t.organizationRank = rank;
-            rank++;
-          }
-        }
-      }
+      this.teams.forEach(t => t.postProcessPlaceChartPoints());
+      this.buildOrgRank();
     })();
 
     (() => {
       this.rankStatistics.reset();
 
       this.rankStatistics.teamSolvedNum = Array(this.contest.problems.length + 1).fill(0);
-
       for (const t of this.teams) {
         this.rankStatistics.teamSolvedNum[t.solvedProblemNum]++;
       }
@@ -154,4 +192,57 @@ 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;
+    }
+
+    return this.submissions.filter(s => s.timestamp <= this.options.timestamp).sort(Submission.compare);
+  }
 }

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;
@@ -22,11 +35,18 @@ export class Team {
   solvedProblemNum: number;
   attemptedProblemNum: number;
 
+  lastSolvedProblem: Problem | null;
+  lastSolvedProblemTimestamp: number;
+
   penalty: number;
 
   problemStatistics: Array<TeamProblemStatistics>;
   problemStatisticsMap: Map<string, TeamProblemStatistics>;
 
+  submissions: Submissions;
+
+  placeChartPoints: Array<PlaceChartPointData>;
+
   constructor() {
     this.id = "";
     this.name = "";
@@ -42,10 +62,37 @@ 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() {
+    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 = new Map<string, TeamProblemStatistics>();
+
+    this.submissions = [];
+
+    this.placeChartPoints = [];
   }
 
   get penaltyToMinute() {
@@ -61,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++;
@@ -74,6 +122,34 @@ export class Team {
     }
   }
 
+  isEqualRank(otherTeam: 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;
@@ -83,6 +159,10 @@ export class Team {
       return lhs.penalty - rhs.penalty;
     }
 
+    if (lhs.lastSolvedProblemTimestamp !== rhs.lastSolvedProblemTimestamp) {
+      return lhs.lastSolvedProblemTimestamp - rhs.lastSolvedProblemTimestamp;
+    }
+
     if (lhs.name < rhs.name) {
       return -1;
     } else if (lhs.name > rhs.name) {