Star's Blog

1
timelimit='2' # 单位是 s
2
special_run='I_cmp' # （可选）如果不需要 spj 或者交互器可以无视，发现导出的里面有个这条，但是不加好像也没事
3
color='#ab812c' # （可选）气球颜色

1
name: Liuxx怎么这么能跑啊
2
validation: 'custom interactive' # （可选）验证方法，交互题 custem interactive，一般 spj 用 custom
3
# （可选）浮点数误差 validator_flags: 'float_tolerance 1E-6'
4
limits:
5
    memory: 256 # 单位是 MB

1
"""
2
解析 tex 用
3
"""
4
from TexSoup import TexSoup
5
from TexSoup.data import TexNode, TexArgs
6

7

8
def tex_info(content: str):
9
    # 解析LaTeX内容
10
    soup = TexSoup(content)
11
    # 初始化返回值
12
    title = ""
13
    timelimit = ""
14
    memlimit = ""
15
    samples = []
16

17
    # 1. 提取problem环境的参数（时间限制、内存限制）
18
    problem_env = soup.find("problem")
19
    if problem_env and hasattr(problem_env, 'args') and len(problem_env.args) >= 5:
20
        # problem环境参数：{Title}{standard input}{standard output}{2 seconds}{256 megabytes}
21
        title = str(problem_env.args[0]).strip("{}")
22
        time_arg = str(problem_env.args[3]).strip("{}")  # 第4个参数是时间限制
23
        mem_arg = str(problem_env.args[4]).strip("{}")  # 第5个参数是内存限制
24

25
        timelimit = int(_get_arg_text(time_arg).split()[0])
26
        memlimit = int(_get_arg_text(mem_arg).split()[0])
27

28
    # 2. 提取example环境中的样例输入输出
29
    example_envs = soup.find_all("example")
30
    for example in example_envs:
31
        # 找到exmp命令（样例输入输出的容器）
32
        exmp_cmd = example.find("exmp")
33
        if exmp_cmd and hasattr(exmp_cmd, 'args') and len(exmp_cmd.args) >= 2:
34
            # exmp的第一个参数是输入，第二个是输出
35
            in_arg = exmp_cmd.args[0]
36
            ans_arg = exmp_cmd.args[1]
37

38
            # 提取输入输出文本并清理格式
39
            in_text = _clean_sample_text(_get_arg_text(in_arg))
40
            ans_text = _clean_sample_text(_get_arg_text(ans_arg))
41

42
            if in_text or ans_text:
43
                samples.append({
44
                    "in": in_text,
45
                    "ans": ans_text
46
                })
47

48
    return title, timelimit, memlimit, samples
49

50

51
def _get_arg_text(arg) -> str:
52
    """辅助函数：提取TexArgs/TexNode的文本内容"""
53
    if isinstance(arg, (TexArgs, TexNode)):
54
        # 直接取text属性，若没有则转为字符串
55
        return getattr(arg, 'text', str(arg))
56
    return str(arg)
57

58

59
def _clean_sample_text(text: str) -> str:
60
    """辅助函数：清理样例文本中的多余符号和空白"""
61
    return text.strip("{}%\n").replace("\r\n", "\n")

1
from pathlib import Path
2
from shutil import rmtree
3
from tex_info import tex_info
4

5
basedir = Path("/Users/wangyafei/Documents/学校事务/社团管理/2025社团管理/2026校赛/contests/正式赛/problems")
6
tex_path = basedir / "LaTeX" # tex 的目录，每道题是一个单独的 tex，文件名如 A.tex
7
std_path = basedir / "std" # 标程的目录，文件名如 std-a.cpp
8
input_path = basedir / '数据' # 测试数据
9
output_path = basedir / 'norm_output'
10
output_path.mkdir(exist_ok=True) # 创建目录
11

12
for dir in input_path.iterdir():
13
    if dir.is_dir():
14
        label = dir.stem.upper()
15
        print(f"Processing Problem {label}")
16
        out_dir = output_path / label
17
        rmtree(out_dir, ignore_errors=True)
18
        out_dir.mkdir(exist_ok=True)
19
        content = (tex_path / f"{label}.tex").read_text()
20
        title, timelimit, memlimit, samples = tex_info(content)
21

22
        # domjudge-problem.ini
23
        print("Writing domjudge-problem.ini")
24
        (out_dir / 'domjudge-problem.ini').write_text(f"timelimit = {timelimit}")
25

26
        # problem.yaml
27
        print("Writing problem.yaml")
28
        (out_dir / 'problem.yaml').write_text(f"name: \"{title}\"\nlimits:\n    memory: {memlimit}")
29

30
        # submissions/accepted
31
        try:
32
            print("Writing submissions/correct/solve.cpp")
33
            std_dir = out_dir / 'submissions' / 'accepted'
34
            std_dir.mkdir(parents=True, exist_ok=True)
35
            (std_dir / 'solve.cpp').write_text((std_path / f"std-{label.lower()}.cpp").read_text())
36
        except Exception as e:
37
            print(f'error: {e}')
38

39
        # data/sample
40
        print("Writing samples")
41
        sample_dir = out_dir / 'data' / 'sample'
42
        sample_dir.mkdir(parents=True)
43
        for i, data in enumerate(samples):
44
            (sample_dir / f"{i}.in").write_text(data.get("in"))
45
            (sample_dir / f"{i}.ans").write_text(data.get("ans"))
46

47
        # data/secret
48
        print("Copying testcases")
49
        data_dir = out_dir / 'data' / 'secret'
50
        data_dir.mkdir(parents=True)
51
        for file in (dir / 'data' / 'secret').iterdir():
52
            filename = file.name if file.suffix == ".in" else file.stem + ".ans" # 没错这都有人不看，用了 .out，所以不是 in 都认为是输出了
53
            out_file_path = data_dir / filename
54
            out_file_path.write_text(file.read_text().replace('\r\n', '\n'))

1
import os
2
import zipfile
3
from pathlib import Path
4

5
def zip_folders_in_output(output_dir: str = "output", archives_dir: str = "archives"):
6
    """
7
    遍历output路径下的所有文件夹，将文件夹内容打包为zip包（散列内容），输出到archives路径
8

9
    Args:
10
        output_dir (str): 源文件夹路径，默认"output"
11
        archives_dir (str): 压缩包输出路径，默认"archives"
12
    """
13
    # 转换为Path对象，方便路径操作
14
    output_path = Path(output_dir)
15
    archives_path = Path(archives_dir)
16

17
    # 检查output目录是否存在
18
    if not output_path.exists():
19
        print(f"错误：{output_dir} 目录不存在！")
20
        return
21

22
    # 创建archives目录（若不存在）
23
    archives_path.mkdir(exist_ok=True)
24

25
    # 遍历output下的所有一级子目录
26
    for item in output_path.iterdir():
27
        if item.is_dir():
28
            folder_name = item.name  # 文件夹名称（作为zip包名）
29
            zip_file_path = archives_path / f"{folder_name}.zip"  # zip包路径
30

31
            # 创建zip文件（压缩模式为DEFLATED，即有压缩效果）
32
            with zipfile.ZipFile(zip_file_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
33
                # 遍历文件夹内的所有文件和子目录
34
                for root, dirs, files in os.walk(item):
35
                    # 计算相对路径（去掉外层文件夹，实现散列打包）
36
                    relative_root = os.path.relpath(root, item)
37

38
                    # 先添加子目录（确保空目录也被打包）
39
                    for dir_name in dirs:
40
                        dir_path = os.path.join(root, dir_name)
41
                        relative_dir_path = os.path.join(relative_root, dir_name)
42
                        # 写入目录到zip包
43
                        zipf.write(dir_path, relative_dir_path)
44

45
                    # 再添加文件
46
                    for file_name in files:
47
                        file_path = os.path.join(root, file_name)
48
                        relative_file_path = os.path.join(relative_root, file_name)
49
                        # 写入文件到zip包（使用相对路径，避免外层文件夹）
50
                        zipf.write(file_path, relative_file_path)
51

52
            print(f"成功打包：{zip_file_path}")
53

54
if __name__ == "__main__":
55
    # 调用函数，可自定义output和archives路径
56
    zip_folders_in_output(output_dir="output", archives_dir="archives")

1
import requests
2

3
API_URL = "<替换成domjudge的ip或域名>/api/v4"
4
USERNAME = "admin"
5
PASSWORD = "<替换成管理员密码>"
6
CONTEST_ID = "upcpc2026"
7

8
def upload_problem(zip_path):
9
    endpoint = f"{API_URL}/contests/{CONTEST_ID}/problems"
10

11
    with open(zip_path, 'rb') as f:
12
        files = {'zip': f}
13
        response = requests.post(
14
            endpoint,
15
            auth=(USERNAME, PASSWORD),
16
            files=files
17
        )
18

19
    if response.status_code == 200:
20
        print("Successfully uploaded!")
21
        print("Response:", response.json())
22
    else:
23
        print(f"Failed! Status code: {response.status_code}")
24
        print("Error:", response.text)
25

26
for i in range(0, 13):
27
    upload_problem(f'./{chr(i + ord('A'))}.zip') # 如果这样写就必须要 cd 到压缩包那个目录下跑，也可以写死目录或者写好相对路径