@xcpcio/core 0.4.2 → 0.4.3

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);
@@ -382,6 +390,17 @@ class Team {
     this.organizationRank = -1;
     this.solvedProblemNum = 0;
     this.attemptedProblemNum = 0;
+    this.lastSolvedProblemTimestamp = 0;
+    this.penalty = 0;
+    this.problemStatistics = [];
+    this.problemStatisticsMap = /* @__PURE__ */ new Map();
+  }
+  reset() {
+    this.rank = 0;
+    this.organizationRank = -1;
+    this.solvedProblemNum = 0;
+    this.attemptedProblemNum = 0;
+    this.lastSolvedProblemTimestamp = 0;
     this.penalty = 0;
     this.problemStatistics = [];
     this.problemStatisticsMap = /* @__PURE__ */ new Map();
@@ -406,6 +425,9 @@ class Team {
       }
     }
   }
+  isEqualRank(otherTeam) {
+    return this.solvedProblemNum === otherTeam.solvedProblemNum && this.penalty === otherTeam.penalty;
+  }
   static compare(lhs, rhs) {
     if (lhs.solvedProblemNum !== rhs.solvedProblemNum) {
       return rhs.solvedProblemNum - lhs.solvedProblemNum;
@@ -413,6 +435,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) {
@@ -629,6 +654,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 +677,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,7 +694,7 @@ class Rank {
       this.contest.problems.forEach((p) => {
         p.statistics.reset();
       });
-      for (const s of this.submissions) {
+      for (const s of this.getSubmissions()) {
         const teamId = s.teamId;
         const problemId = s.problemId;
         const team = this.teamsMap.get(teamId);
@@ -660,11 +702,6 @@ class Rank {
         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;
         submissions.push(s);
@@ -693,6 +730,7 @@ class Rank {
             problem.statistics.lastSolveSubmissions.pop();
           }
           problem.statistics.lastSolveSubmissions.push(s);
+          team.lastSolvedProblemTimestamp = s.timestamp;
         }
         if (s.isRejected()) {
           problemStatistics.failedCount++;
@@ -707,19 +745,34 @@ class Rank {
       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;
+            }
+          }
+          preTeam = t;
         }
       }
       if (this.contest.organization) {
         let rank = 1;
+        let preTeam = null;
         const se = /* @__PURE__ */ new Set();
         for (const t of this.teams) {
-          if (!se.has(t.organization)) {
-            se.add(t.organization);
-            t.organizationRank = rank;
-            rank++;
+          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;
         }
       }
     })();
@@ -732,6 +785,12 @@ class Rank {
     })();
     return this;
   }
+  getSubmissions() {
+    if (this.options.enableFilterSubmissionsByTimestamp === false) {
+      return this.submissions;
+    }
+    return this.submissions.filter((s) => s.timestamp <= this.options.timestamp).sort(Submission.compare);
+  }
 }
 
 class ResolverOperation {
@@ -829,6 +888,7 @@ exports.ContestIndexConfig = ContestIndexConfig;
 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

@@ -101,8 +101,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;
@@ -148,19 +148,30 @@ declare class Team {
     organizationRank: number;
     solvedProblemNum: number;
     attemptedProblemNum: number;
+    lastSolvedProblemTimestamp: number;
     penalty: number;
     problemStatistics: Array<TeamProblemStatistics>;
     problemStatisticsMap: Map<string, TeamProblemStatistics>;
     constructor();
+    reset(): void;
     get penaltyToMinute(): number;
     get dict(): number;
     calcSolvedData(): void;
+    isEqualRank(otherTeam: Team): boolean;
     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 +179,10 @@ 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;
+    getSubmissions(): Submissions;
 }
 
 declare class ResolverOperation {
@@ -198,4 +209,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, 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);
@@ -366,6 +374,17 @@ class Team {
     this.organizationRank = -1;
     this.solvedProblemNum = 0;
     this.attemptedProblemNum = 0;
+    this.lastSolvedProblemTimestamp = 0;
+    this.penalty = 0;
+    this.problemStatistics = [];
+    this.problemStatisticsMap = /* @__PURE__ */ new Map();
+  }
+  reset() {
+    this.rank = 0;
+    this.organizationRank = -1;
+    this.solvedProblemNum = 0;
+    this.attemptedProblemNum = 0;
+    this.lastSolvedProblemTimestamp = 0;
     this.penalty = 0;
     this.problemStatistics = [];
     this.problemStatisticsMap = /* @__PURE__ */ new Map();
@@ -390,6 +409,9 @@ class Team {
       }
     }
   }
+  isEqualRank(otherTeam) {
+    return this.solvedProblemNum === otherTeam.solvedProblemNum && this.penalty === otherTeam.penalty;
+  }
   static compare(lhs, rhs) {
     if (lhs.solvedProblemNum !== rhs.solvedProblemNum) {
       return rhs.solvedProblemNum - lhs.solvedProblemNum;
@@ -397,6 +419,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) {
@@ -613,6 +638,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 +661,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,7 +678,7 @@ class Rank {
       this.contest.problems.forEach((p) => {
         p.statistics.reset();
       });
-      for (const s of this.submissions) {
+      for (const s of this.getSubmissions()) {
         const teamId = s.teamId;
         const problemId = s.problemId;
         const team = this.teamsMap.get(teamId);
@@ -644,11 +686,6 @@ class Rank {
         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;
         submissions.push(s);
@@ -677,6 +714,7 @@ class Rank {
             problem.statistics.lastSolveSubmissions.pop();
           }
           problem.statistics.lastSolveSubmissions.push(s);
+          team.lastSolvedProblemTimestamp = s.timestamp;
         }
         if (s.isRejected()) {
           problemStatistics.failedCount++;
@@ -691,19 +729,34 @@ class Rank {
       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;
+            }
+          }
+          preTeam = t;
         }
       }
       if (this.contest.organization) {
         let rank = 1;
+        let preTeam = null;
         const se = /* @__PURE__ */ new Set();
         for (const t of this.teams) {
-          if (!se.has(t.organization)) {
-            se.add(t.organization);
-            t.organizationRank = rank;
-            rank++;
+          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;
         }
       }
     })();
@@ -716,6 +769,12 @@ class Rank {
     })();
     return this;
   }
+  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 +865,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, 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.4.3",
   "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.4.3"
   },
   "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,7 +77,7 @@ export class Rank {
         p.statistics.reset();
       });
 
-      for (const s of this.submissions) {
+      for (const s of this.getSubmissions()) {
         const teamId = s.teamId;
         const problemId = s.problemId;
         const team = this.teamsMap.get(teamId);
@@ -59,12 +87,6 @@ export class Rank {
           continue;
         }
 
-        if (options?.timestamp !== undefined && options?.timestamp !== null) {
-          if (s.timestamp > options.timestamp) {
-            break;
-          }
-        }
-
         const problemStatistics = team.problemStatisticsMap.get(problemId) as TeamProblemStatistics;
         const submissions = problemStatistics.submissions;
 
@@ -105,6 +127,7 @@ export class Rank {
           }
 
           problem.statistics.lastSolveSubmissions.push(s);
+          team.lastSolvedProblemTimestamp = s.timestamp;
         }
 
         if (s.isRejected()) {
@@ -123,21 +146,42 @@ export class Rank {
 
       {
         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;
         }
       }
 
       if (this.contest.organization) {
         let rank = 1;
+        let preTeam = null;
+
         const se = new Set<string>();
 
         for (const t of this.teams) {
-          if (!se.has(t.organization)) {
-            se.add(t.organization);
-            t.organizationRank = rank;
-            rank++;
+          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;
         }
       }
     })();
@@ -146,7 +190,6 @@ export class Rank {
       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 +197,12 @@ export class Rank {
 
     return this;
   }
+
+  getSubmissions() {
+    if (this.options.enableFilterSubmissionsByTimestamp === false) {
+      return this.submissions;
+    }
+
+    return this.submissions.filter(s => s.timestamp <= this.options.timestamp).sort(Submission.compare);
+  }
 }

package/src/team.ts

@@ -21,6 +21,7 @@ export class Team {
 
   solvedProblemNum: number;
   attemptedProblemNum: number;
+  lastSolvedProblemTimestamp: number;
 
   penalty: number;
 
@@ -41,6 +42,21 @@ export class Team {
 
     this.solvedProblemNum = 0;
     this.attemptedProblemNum = 0;
+    this.lastSolvedProblemTimestamp = 0;
+
+    this.penalty = 0;
+
+    this.problemStatistics = [];
+    this.problemStatisticsMap = new Map<string, TeamProblemStatistics>();
+  }
+
+  reset() {
+    this.rank = 0;
+    this.organizationRank = -1;
+
+    this.solvedProblemNum = 0;
+    this.attemptedProblemNum = 0;
+    this.lastSolvedProblemTimestamp = 0;
 
     this.penalty = 0;
 
@@ -74,6 +90,10 @@ export class Team {
     }
   }
 
+  isEqualRank(otherTeam: Team) {
+    return this.solvedProblemNum === otherTeam.solvedProblemNum && this.penalty === otherTeam.penalty;
+  }
+
   static compare(lhs: Team, rhs: Team): number {
     if (lhs.solvedProblemNum !== rhs.solvedProblemNum) {
       return rhs.solvedProblemNum - lhs.solvedProblemNum;
@@ -83,6 +103,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) {