add USAMO 2025

USAMO/download_script/download.py

@@ -0,0 +1,75 @@
+# -----------------------------------------------------------------------------
+# Author: Jiawei Liu
+# Date: 2025-10-29
+# -----------------------------------------------------------------------------
+'''
+Download script for APMO
+To run: 
+`python USAMO/download_script/download.py`
+'''
+
+import re
+import requests
+from bs4 import BeautifulSoup
+from tqdm import tqdm
+from pathlib import Path
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+from urllib.parse import urljoin
+
+
+def build_session(
+    max_retries: int = 3,
+    backoff_factor: int = 2,
+    session: requests.Session = None
+) -> requests.Session:
+    """
+    Build a requests session with retries
+
+    Args:
+        max_retries (int, optional): Number of retries. Defaults to 3.
+        backoff_factor (int, optional): Backoff factor. Defaults to 2.
+        session (requests.Session, optional): Session object. Defaults to None.
+    """
+    session = session or requests.Session()
+    adapter = HTTPAdapter(max_retries=Retry(total=max_retries, backoff_factor=backoff_factor))
+    session.mount("http://", adapter)
+    session.mount("https://", adapter)
+    session.headers.update({
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
+    })
+
+    return session
+
+
+def main():
+    base_url = "https://web.evanchen.cc/problems.html"
+    req_session = build_session()
+
+    output_dir = Path(__file__).parent.parent / "raw"
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    resp = req_session.get(base_url)
+    soup = BeautifulSoup(resp.text, 'html.parser')
+
+    imo_exams = soup.find_all("a", href=lambda h: h and re.search(r"USAMO\-\d{4}\-notes.pdf$", h))
+    imo_pdf_links = [urljoin(base_url, link["href"]) for link in imo_exams]
+
+    for link in tqdm(imo_pdf_links):
+        output_file = output_dir / f"en-{Path(link).name}"
+
+        # Check if the file already exists
+        if output_file.exists():
+            continue
+
+        pdf_resp = req_session.get(link)
+
+        if pdf_resp.status_code != 200:
+            print(f"Failed to download {link}")
+            continue
+
+        output_file.write_bytes(pdf_resp.content)
+
+
+if __name__ == "__main__":
+    main()

USAMO/raw/en-USAMO-2025-notes.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cef35876f2d5ed088544a76d42656559c4c2759caa711337016bf6075a13cd5
+size 345456

USAMO/segment_script/segment_2025.py

@@ -0,0 +1,187 @@
+# -----------------------------------------------------------------------------
+# Author: Jiawei Liu
+# Date: 2025-10-29
+# -----------------------------------------------------------------------------
+import json
+import re
+from pathlib import Path
+
+from rapidfuzz import fuzz
+
+
+def clean_text(text: str):
+    text = re.sub(
+        r"\nAvailable online at.+?\.\s\s$", "", text, flags=re.DOTALL | re.MULTILINE
+    )
+    return text
+
+
+def extract_problems(markdown_text: str):
+    problems = {}
+
+    # 1. Find the block of text containing the problems
+    # Block starts with '## Problems'
+    # and ends before '## \(S 1\) Solutions to Day 1'
+    problems_section = re.search(
+        r"^## Problems\s*$(.*?)^##.*Solutions to Day 1",
+        markdown_text,
+        re.DOTALL | re.MULTILINE,
+    )
+
+    if not problems_section:
+        print("  - Not found '## Problems' section.")
+        return problems
+
+    problems_block = problems_section.group(1)
+
+    # 2. Split the block into individual problems
+    # Each problem starts with a number followed by a dot and space (e.g., '1. ')
+    matchs = list(re.finditer(r"^(\d+)\.\s+", problems_block, flags=re.MULTILINE))
+
+    # Split the text into parts using the problem numbers as delimiters
+    for i, m in enumerate(matchs):
+        problem_label = m.group(1)
+        problem = problems_block[
+            m.end() : matchs[i + 1].start()
+            if i + 1 < len(matchs)
+            else len(problems_block)
+        ]
+
+        problems[problem_label] = (problem.strip(), m.group())
+
+    print(f"  - Extracted {len(problems)} problems.")
+
+    return problems
+
+
+def extract_solutions(markdown_text):
+    solutions = {}
+
+    # 1. Find the block of text containing the solutions
+    # Block starts with '## \(S 1\) Solutions to Day 1' and end of document
+    solutions_section = re.search(
+        r"^##.*?Solutions to Day 1\s*$(.*)",
+        markdown_text,
+        re.DOTALL | re.MULTILINE,
+    )
+
+    if not solutions_section:
+        print("  - Not found Solutions section.")
+        return solutions
+
+    solutions_block = solutions_section.group(1)
+
+    ## \(\S 1.1\) USAMO 2025/1, proposed by John Berman  
+    # 2. Split the block into individual solutions
+    matchs = list(
+        re.finditer(r"^##.*?USAMO\s*?\d{4}\/(\d+).*?\n$", solutions_block, flags=re.MULTILINE)
+    )
+
+    # Split the text into parts using the solution numbers as delimiters
+    for i, m in enumerate(matchs):
+        problem_label = m.group(1)
+        solution = solutions_block[
+            m.end() : matchs[i + 1].start()
+            if i + 1 < len(matchs)
+            else len(solutions_block)
+        ]
+
+        solutions[problem_label] = (solution.strip(), m.group())
+
+    print(f"  - Extracted {len(solutions)} solutions.")
+
+    return solutions
+
+
+def join(problems: dict, solutions: dict):
+    pairs = []
+
+    for problem_label, (problem, p_match) in problems.items():
+        solution, s_match = solutions.get(problem_label)
+
+        # Clean solution by removing the part that overlaps with the problem statement
+        problem_align = fuzz.partial_ratio_alignment(solution, problem)
+        solution = solution.replace(
+            solution[problem_align.src_start : problem_align.src_end], ""
+        )
+        solution = re.sub(
+            r"^\s*## Problem statement", "", solution, flags=re.IGNORECASE
+        ).strip()
+
+        if not solution:
+            print(f"  - Warning: No solution found for problem {problem_label}.")
+        pairs.append((problem, solution, problem_label, p_match, s_match))
+
+    return pairs
+
+
+def write_pairs(output_file: Path, pairs: list, year: str, project_root: Path):
+    output_jsonl_text = ""
+    for problem, solution, problem_label, p_match, s_match in pairs:
+        output_jsonl_text += (
+            json.dumps(
+                {
+                    "year": year,
+                    "tier": "T1",
+                    "problem_label": problem_label,
+                    "problem_type": None,
+                    "exam": "USAMO",
+                    "problem": problem,
+                    "solution": solution,
+                    "metadata": {
+                        "resource_path": output_file.relative_to(
+                            project_root
+                        ).as_posix(),
+                        "problem_match": p_match,
+                        "solution_match": s_match,
+                    },
+                },
+                ensure_ascii=False,
+            )
+            + "\n"
+        )
+
+    output_file.write_text(output_jsonl_text, encoding="utf-8")
+
+
+if __name__ == "__main__":
+    compet_base_path = Path(__file__).resolve().parent.parent
+    compet_md_path = compet_base_path / "md"
+    seg_output_path = compet_base_path / "segmented"
+    project_root = compet_base_path.parent
+
+    num_problems = 0
+    num_solutions = 0
+
+    md_files = [
+        _
+        for _ in compet_md_path.glob("**/*.md")
+        if int(re.search(r"\d{4}", _.as_posix()).group()) in [2025]
+    ]
+    for md_file in md_files:
+        print(f"Processing {md_file}...")
+        output_file = seg_output_path / md_file.relative_to(compet_md_path).with_suffix(
+            ".jsonl"
+        )
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Read the markdown file
+        markdown_text = "\n" + md_file.read_text(encoding="utf-8")
+        markdown_text = clean_text(markdown_text)
+
+        problems = extract_problems(markdown_text)
+        solutions = extract_solutions(markdown_text)
+
+        num_problems += len(problems)
+        num_solutions += len(solutions)
+
+        pairs = join(problems, solutions)
+
+        year = re.search(r"\d{4}", output_file.stem).group()
+
+        write_pairs(output_file, pairs, year, project_root)
+
+        print()
+
+    print(f"Total problems extracted: {num_problems}")
+    print(f"Total solutions extracted: {num_solutions}")