87 lines
3.8 KiB
Python
87 lines
3.8 KiB
Python
import re
|
|
from runner import Runner
|
|
from collections import Counter
|
|
from pretty_print import Print_C
|
|
|
|
class Presenter:
|
|
kases = Runner.run_kases
|
|
splitter = re.compile('[-@ :\t\r\n]+')
|
|
scheme_time_print_template = "{0:<10} : {1:<10.0f}us"
|
|
|
|
def __init__(self, schemes, testcases):
|
|
self.schemes = schemes
|
|
self.testcases = testcases
|
|
|
|
def __diff(self, file1, file2):
|
|
file1_lines = open(file1).readlines()
|
|
file2_lines = open(file2).readlines()
|
|
return file1_lines == file2_lines
|
|
|
|
def __time_to_us(self, l):
|
|
hours = int(l[0][:-1])
|
|
minutes = int(l[1][:-1])
|
|
seconds = int(l[2][:-1])
|
|
us = int(l[3][:-2])
|
|
return hours * 60 * 60 * 1000000 + minutes * 60 * 1000000 + seconds * 1000000 + us
|
|
|
|
def present_single_testcase(self, testcase):
|
|
Print_C.print_subheader(f"[Checking {testcase}]")
|
|
|
|
scheme_time_counter = Counter({scheme: 0 for scheme in self.schemes}) # {scheme: time}
|
|
stage_scheme_time_dict = {}
|
|
wrong_schemes = []
|
|
for scheme in self.schemes:
|
|
stdout = f"testcases/{testcase}.out"
|
|
myout = f"build/output/{testcase}/{scheme}.out"
|
|
if not self.__diff(stdout, myout):
|
|
wrong_schemes.append(scheme)
|
|
continue
|
|
|
|
stage_time_counter = Counter({}) # {stage: time}
|
|
for kase in range(Presenter.kases):
|
|
runner_log = f"build/log/run_log/{testcase}/{scheme}_{kase}.out"
|
|
lines = open(runner_log).readlines()
|
|
# ['Timer', 'startLine', 'endLine', 'xH', 'xM', 'xS', 'xus'][1:]
|
|
parsed_lines = [Presenter.splitter.split(line)[1:] for line in lines][:-1]
|
|
stage_time = {f"{int(line[0])} ~ {int(line[1])}": self.__time_to_us(line[2:]) for line in parsed_lines}
|
|
stage_time_counter += Counter(stage_time)
|
|
|
|
for stage_time in stage_time_counter.items():
|
|
if not stage_time[0] in stage_scheme_time_dict:
|
|
stage_scheme_time_dict[stage_time[0]] = {}
|
|
stage_scheme_time_dict[stage_time[0]][scheme] = stage_time[1] / Presenter.kases
|
|
|
|
scheme_time_counter[scheme] = sum(stage_time_counter.values()) / Presenter.kases
|
|
|
|
Print_C.print_procedure("[AVERAGE TIME COUNT (sorted)]")
|
|
sorted_scheme_time_list = sorted(scheme_time_counter.items(), key=lambda scheme_time: scheme_time[1])
|
|
for scheme_time in sorted_scheme_time_list:
|
|
if not scheme_time[0] in wrong_schemes:
|
|
Print_C.print_pass(self.scheme_time_print_template.format(scheme_time[0], scheme_time[1]))
|
|
for scheme in wrong_schemes:
|
|
Print_C.print_error(f"{scheme} WA")
|
|
|
|
for stage_scheme_time in stage_scheme_time_dict.items():
|
|
Print_C.print_procedure(f"[Line {stage_scheme_time[0]}]")
|
|
|
|
sorted_stage_scheme_list = sorted(stage_scheme_time[1].items(), key=lambda scheme_time: scheme_time[1])
|
|
for scheme_time in sorted_stage_scheme_list:
|
|
print(self.scheme_time_print_template.format(scheme_time[0], scheme_time[1]))
|
|
|
|
return scheme_time_counter
|
|
|
|
def present_all_testcases(self):
|
|
Print_C.print_header(f"[Checking & Racing]")
|
|
scheme_tot_time_counter = Counter({scheme: 0 for scheme in self.schemes}) # {scheme: total_time}
|
|
|
|
for testcase in self.testcases:
|
|
scheme_tot_time_counter += Counter(self.present_single_testcase(testcase=testcase))
|
|
print()
|
|
|
|
print()
|
|
sorted_scheme_tot_time_list = sorted(scheme_tot_time_counter.items(), key=lambda scheme_tot_time: scheme_tot_time[1])
|
|
Print_C.print_header(f"[TOTAL TIME RANKING]")
|
|
for scheme_tot_time in sorted_scheme_tot_time_list:
|
|
print(self.scheme_time_print_template.format(scheme_tot_time[0], scheme_tot_time[1]))
|
|
print()
|
|
print() |