CPRS — Cross-Platform Competitive Programming Problem Catalogue

45,903 competitive-programming problems from CodeChef, Codeforces, AtCoder and LeetCode, normalised onto a single difficulty scale and a single topic taxonomy so that problems from different platforms can be compared directly.

Built for CPRS, a cross-platform problem recommender (CM3070 final project, University of London).

Platform	Problems	With difficulty	With a topic	Topics from the NLP tagger
CodeChef	21,568	5,520	5,450	1,480
Codeforces	11,263	10,979	10,834	0
AtCoder	9,095	4,699	775	775
LeetCode	3,977	3,977	3,522	0
Total	45,903	25,175	20,581	2,255

Coverage is deliberately not uniform, and the table above is the first thing to read: a platform's row tells you how much of it is actually usable for difficulty-aware or topic-aware work.

Why this exists

Four of the largest competitive-programming judges describe difficulty in four incompatible ways and tag topics in four different vocabularies — and AtCoder publishes no topic tags at all. That makes it impossible to ask a question as basic as "what should this learner attempt next?" across platforms. This dataset is the normalisation layer: one [0,1] difficulty scale, one taxonomy of 44 canonical topics, and recovered topics where a platform published none.

Columns

Column	Type	Notes
cprs_id	string	Stable unified key, {platform}:{platform_id}
platform	string	codechef / codeforces / atcoder / leetcode
platform_id	string	Native identifier
name	string	Problem title
url	string	Canonical link to the problem on its platform
contest_id	string	Native contest identifier, where applicable
difficulty_raw	float	Native difficulty, not comparable across platforms
difficulty_source	string	Which native scale difficulty_raw is on
difficulty_normalized	float	[0,1], comparable across platforms
tags_original	list[string]	Platform's own tags, verbatim (empty for AtCoder)
tags_unified	list[string]	Mapped to the shared taxonomy
tags_predicted	bool	True where topics came from the NLP tagger, not a human
has_canonical_topic	bool	Has ≥1 real topic (not just an other: label)
solve_count	int64	Accepted solutions, where the platform reports it
acceptance_rate	float	Where the platform reports it
is_premium	bool	LeetCode paywalled problems

Difficulty normalisation

Platform	Native scale	Mapping to [0,1]
CodeChef	Difficulty rating, 200–4000	Clipped, then linear
Codeforces	Problemsetter rating, 800–3500	Clipped, then linear
AtCoder	kenkoooo Elo-style estimate, ≈ −500–4000	Clipped, then linear
LeetCode	Easy / Medium / Hard	0.2 / 0.5 / 0.85

The LeetCode mapping is the weak link: three bands cannot capture within-band spread, so LeetCode difficulty is coarser than the rest. Treat difficulty_normalized as ordinal-comparable, not interval-comparable.

difficulty_raw is null wherever no difficulty exists. CodeChef marks unrated problems with sentinel values (-1, 0, 9999) rather than leaving the field empty; those are normalised away here, so a sentinel never appears as though it were a difficulty of its own.

The taxonomy

The taxonomy defines 44 canonical topics, of which 44 occur in this snapshot. Alongside them are 55 unmapped platform labels carried through with an other: prefix (contest-series names such as other:abc, platform-specific oddities). other: labels are not topics — filter with has_canonical_topic rather than checking whether tags_unified is non-empty.

The 44 canonical topics present here

array, backtracking, bfs, binary_search, bitmask, brute_force, combinatorics, constructive, data_structures, design, dfs, divide_and_conquer, dynamic_programming, fft, game_theory, geometry, graphs, greedy, hash_table, hashing, heap, implementation, linked_list, math, matrix, monotonic_stack, network_flow, number_theory, prefix_sum, probability, queue, recursion, segment_tree, shortest_paths, simulation, sliding_window, sorting, stack, string_matching, strings, trees, trie, two_pointers, union_find

⚠️ Predicted tags: read this before using tags_unified

2,255 problems — CodeChef and AtCoder — carry tags from a TF-IDF + one-vs-rest logistic-regression classifier trained on tagged Codeforces statements and pointed at the other judges. These are model output, not ground truth. The two target platforms are tagged under different regimes:

• AtCoder (775 problems) publishes no topic tags at all, so the tagger writes into an empty field.
• CodeChef (1,480 problems) publishes its own coarse tags for part of its catalogue, so predictions fill only the gaps. A problem CodeChef labelled itself keeps its own label.

Quality varies enormously by tag:

Tag	Cross-validated F1
strings	0.74
game_theory	0.73
math	0.69
greedy	0.66
implementation	0.59
bitmask	0.53
…
data_structures	0.26
brute_force	0.25
binary_search	0.25
dynamic_programming	0.20
two_pointers	0.18
combinatorics	0.11

Macro-F1 across all 16 predicted tags is 0.44. Tags with a strong lexical signature (strings, math) transfer well; tags that describe a solution technique invisible in the problem text (dynamic_programming, two_pointers) are near-useless — a statement rarely says it wants a DP.

Read those figures as an upper bound. They are cross-validated on held-out Codeforces statements, which is the tagger's training domain; accuracy on AtCoder and CodeChef statements, written by different setters in a different house style, is not separately measured and is unlikely to be better.

Only tags above a confidence threshold were written, which is why a minority of each target platform is tagged rather than all of it. Filter on tags_predicted if you need human-assigned tags only.

Usage

from datasets import load_dataset

ds = load_dataset("znnr/cprs", split="train")

# Human-tagged problems in a difficulty band, across all 4 platforms
band = ds.filter(
    lambda r: not r["tags_predicted"]
    and r["difficulty_normalized"] is not None
    and 0.3 <= r["difficulty_normalized"] <= 0.5
)

Provenance and terms

All metadata was collected from public endpoints only, with a fixed polite request delay, exponential-backoff retries and resumable caching. No authenticated or private data was accessed.

Source	What it feeds
Codeforces API	Codeforces catalogue, problemsetter ratings, tags
kenkoooo AtCoder Problems	AtCoder catalogue and its difficulty estimates
CodeChef public problem endpoints	CodeChef catalogue, difficulty ratings, its own coarse tags
LeetCode public problem listing	LeetCode catalogue and Easy/Medium/Hard bands
atcoder.jp user contest history	Nothing in this dataset — contest ratings for the parent project's skill model

4 platforms, five sources: AtCoder takes two, and is the one platform whose metadata here is not first-party. It publishes neither topic tags nor an official difficulty, so difficulty comes from the community-run kenkoooo estimate and topics from the NLP tagger described above.

Problem statements are not included in this dataset. They remain the copyright of the respective platforms; the tagger was trained on them locally and only its predictions are published here.

No user data is included. The recommender in the parent project is trained on solve histories from real accounts; those are not released, in keeping with the project's commitment to use that cohort only in aggregate.

The cc-by-4.0 licence applies to this compilation and its derived columns — the normalised difficulty, the unified taxonomy and the predicted tags. Facts about the underlying problems (titles, identifiers, URLs, solve counts) are the platforms' own, and the AtCoder difficulty estimates are the kenkoooo project's. This dataset is not affiliated with or endorsed by Codeforces, AtCoder, LeetCode or the kenkoooo AtCoder Problems project.

Known limitations

• Snapshot, not a feed. Collected mid-2025; neither problems added since nor drifting solve counts are reflected.
• CodeChef is the largest platform here and the thinnest. It contributes 21,568 problems — more than any other — but only 5,520 (26%) carry a difficulty and 5,450 (25%) carry a topic. Its practice archive is largely unrated and untagged at source. Weight it accordingly: on raw counts it dominates the catalogue, but on rows usable for difficulty- or topic-aware work it does not.
• AtCoder topic coverage is low. 775 of 9,095 AtCoder problems have any topic at all, and only 4,699 have a difficulty estimate. The ceiling is corpus access, not modelling: most AtCoder statements could not be retrieved, so the tagger had nothing to score.
• Tag mapping is lossy. Collapsing four vocabularies into 44 topics merges distinctions some platforms make.
• LeetCode difficulty is three-valued, as noted above.
• solve_count semantics differ between platforms and are not directly comparable; use it for within-platform popularity only.

Citation

@misc{cprs2025,
  title  = {CPRS: A Cross-Platform Competitive Programming Problem Catalogue},
  author = {Diyas, Zhannur},
  year   = {2025},
  note   = {CM3070 Final Project, University of London},
  howpublished = {Hugging Face Datasets}
}