core&ui: add problem_config

Co-authored-by: undefined <i@undefined.moe>

packages/utils/lib/cases.ts

@@ -1,5 +1,44 @@
 import { findFileSync, parseMemoryMB, parseTimeMS } from './utils';
 
+interface Re0 {
+    reg: RegExp,
+    output: ((a: RegExpExecArray) => string)[],
+    id: (a: RegExpExecArray) => number,
+}
+
+interface Re1 extends Re0 {
+    subtask: (a: RegExpExecArray) => number,
+}
+
+const RE0: Re0[] = [
+    {
+        reg: /^([^\d]*)(\d+).(in|txt)$/,
+        output: [
+            (a) => `${a[1] + a[2]}.out`,
+            (a) => `${a[1] + a[2]}.ans`,
+            (a) => `${a[1] + a[2]}.out`.replace(/input/g, 'output'),
+            (a) => (a[1].includes('input') ? `${a[1] + a[2]}.txt`.replace(/input/g, 'output') : null),
+        ],
+        id: (a) => +a[2],
+    },
+    {
+        reg: /^([^\d]*)\.in(\d+)$/,
+        output: [
+            (a) => `${a[1]}.ou${a[2]}`,
+            (a) => `${a[1]}.ou${a[2]}`.replace(/input/g, 'output'),
+        ],
+        id: (a) => +a[2],
+    },
+];
+const RE1: Re1[] = [
+    {
+        reg: /^([^\d]*)([0-9]+)([-_])([0-9]+).in$/,
+        output: [(a) => `${a[1] + a[2]}${a[3]}${a[4]}.out`],
+        subtask: (a) => +a[2],
+        id: (a) => +a[4],
+    },
+];
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export default async function readYamlCases(cfg: Record<string, any> = {}, checkFile = (s: string, errMsg: string) => s) {
     const config: any = {
@@ -98,3 +137,111 @@ export function convertIniConfig(ini: string) {
     }
     return res;
 }
+
+export async function readCasesFromFiles(files: string[], checkFile, cfg) {
+    const cases = [];
+    for (const file of files) {
+        for (const REG of RE0) {
+            if (REG.reg.test(file)) {
+                const data = REG.reg.exec(file);
+                const c = { input: file, output: '', id: REG.id(data) };
+                for (const func of REG.output) {
+                    if (cfg.noOutputFile) c.output = '/dev/null';
+                    else c.output = func(data);
+                    if (c.output && (c.output === '/dev/null' || checkFile(c.output))) {
+                        cases.push(c);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    cases.sort((a, b) => (a.id - b.id));
+    const extra = cases.length - (100 % cases.length);
+    const config = {
+        count: 0,
+        subtasks: [{
+            time: parseTimeMS(cfg.time || '1s'),
+            memory: parseMemoryMB(cfg.memory || '256m'),
+            type: 'sum',
+            cases: [],
+            score: Math.floor(100 / cases.length),
+        }],
+    };
+    for (let i = 0; i < extra; i++) {
+        config.count++;
+        config.subtasks[0].cases.push({
+            id: config.count,
+            input: checkFile(cases[i].input),
+            output: checkFile(cases[i].output),
+        });
+    }
+    if (extra < cases.length) {
+        config.subtasks.push({
+            time: parseTimeMS(cfg.time || '1s'),
+            memory: parseMemoryMB(cfg.memory || '256m'),
+            type: 'sum',
+            cases: [],
+            score: Math.floor(100 / cases.length) + 1,
+        });
+        for (let i = extra; i < cases.length; i++) {
+            config.count++;
+            config.subtasks[1].cases.push({
+                id: config.count,
+                input: checkFile(cases[i].input),
+                output: checkFile(cases[i].output),
+            });
+        }
+    }
+    return config;
+}
+
+export async function readSubtasksFromFiles(files: string[], checkFile, cfg, rst) {
+    const subtask = {};
+    for (const s of rst.subtasks) if (s.id) subtask[s.id] = s;
+    const subtasks = [];
+    for (const file of files) {
+        for (const REG of RE1) {
+            if (REG.reg.test(file)) {
+                const data = REG.reg.exec(file);
+                const sid = REG.subtask(data);
+                const c = { input: file, output: '', id: REG.id(data) };
+                for (const func of REG.output) {
+                    if (cfg.noOutputFile) c.output = '/dev/null';
+                    else c.output = func(data);
+                    if (c.output === '/dev/null' || checkFile(c.output)) {
+                        if (!subtask[sid]) {
+                            subtask[sid] = {
+                                time: parseTimeMS(cfg.time || '1s'),
+                                memory: parseMemoryMB(cfg.memory || '256m'),
+                                type: 'min',
+                                cases: [c],
+                            };
+                        } else if (!subtask[sid].cases) subtask[sid].cases = [c];
+                        else subtask[sid].cases.push(c);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    for (const i in subtask) {
+        subtask[i].cases.sort((a, b) => (a.id - b.id));
+        subtasks.push(subtask[i]);
+    }
+    const base = Math.floor(100 / subtasks.length);
+    const extra = subtasks.length - (100 % subtasks.length);
+    const config = { count: 0, subtasks };
+    const keys = Object.keys(subtask);
+    for (let i = 0; i < keys.length; i++) {
+        if (i >= extra) subtask[keys[i]].score = base + 1;
+        else subtask[keys[i]].score = base;
+        for (const j of subtask[keys[i]].cases) {
+            config.count++;
+            j.input = checkFile(j.input);
+            j.output = checkFile(j.output);
+            j.id = config.count;
+        }
+    }
+    return config;
+}