README.md

---
license: apache-2.0
task_categories:
  - text-generation
language:
  - en
tags:
  - assembly
  - c
  - leetcode
  - compiler
  - code
size_categories:
  - 10K<n<100K
---

# LeetCode Assembly Dataset

441 LeetCode problems solved in C, compiled to assembly across **4 architectures**, **2 compilers**, and **4 optimization levels** using GCC and Clang via the [Godbolt Compiler Explorer](https://godbolt.org) API.

## Dataset Summary

| Stat | Value |
|------|-------|
| Total rows | 14,112 |
| Unique problems | 441 |
| Architectures | x86-64, AArch64, MIPS64, RISC-V 64 |
| Compilers | GCC 15.2, Clang 21.1.0 |
| Optimization levels | -O0, -O1, -O2, -O3 |
| Compilation success rate | 100% |
| Difficulty split | Easy: 98, Medium: 259, Hard: 84 |

Each problem has **32 assembly variants** (4 architectures x 2 compilers x 4 optimization levels), making this useful for studying how the same algorithm compiles differently across ISAs, compilers, and optimization settings.

## Key Insights

- **-O3 often produces more code than -O0**, not less. Across all architectures, -O3 output is 37-73% larger on average due to aggressive inlining and loop unrolling.
- **-O1 consistently produces the most compact assembly** across all four architectures.
- **Recursive tree problems see extreme -O3 blowup.** The top 10 largest O3-vs-O0 ratios are all binary tree problems. Worst case: Longest Univalue Path goes from 90 lines (O0) to 3,809 lines (O3) -- a 42x increase.
- **Iterative and math problems shrink dramatically at -O3.** Flip String to Monotone Increasing drops from 89 to 8 lines (91% reduction). Nim Game compiles down to just 4 lines.
- **AArch64 produces the most compact assembly at -O2** (avg 153 lines), followed by x86-64 (170), RISC-V (170), and MIPS64 (236). MIPS is 39% more verbose than AArch64.
- **Hard problems produce 2x more assembly than Easy problems** at -O2 on x86-64 (247 vs 121 avg lines). Algorithmic complexity maps directly to code size.
- **The largest output is LFU Cache** (1,121 lines at -O0 on x86-64), a complex doubly-linked list plus hash table implementation.
- **The smallest output is Nim Game at -O3** (4 lines on x86-64) -- the entire solution optimizes to a single bitwise AND.

## Use Cases

- Training or evaluating models on C-to-assembly translation
- Studying how optimization levels affect generated code
- Compiler behavior research

## Schema

| Column | Type | Description |
|--------|------|-------------|
| `id` | int | Unique row identifier (0-14111) |
| `problem_id` | int | LeetCode problem number |
| `problem_title` | string | Problem name (e.g. "Two Sum") |
| `difficulty` | string | Easy, Medium, or Hard |
| `c_source` | string | Complete C source code |
| `architecture` | string | Target ISA: `x86-64`, `aarch64`, `mips64`, `riscv64` |
| `optimization` | string | Optimization flag: `-O0`, `-O1`, `-O2`, `-O3` |
| `compiler` | string | Compiler version used (e.g. `x86-64 gcc 15.2`, `x86-64 clang 21.1.0`) |
| `assembly` | string | Compiled assembly output |

## Usage

```python
from datasets import load_dataset

ds = load_dataset("ronantakizawa/leetcode-assembly", split="train")

# Get all x86-64 GCC assembly at -O2
x86_gcc_O2 = ds.filter(lambda r: r["architecture"] == "x86-64" and r["compiler"].startswith("x86-64 gcc") and r["optimization"] == "-O2")

# Compare GCC vs Clang for the same problem
two_sum = ds.filter(lambda r: r["problem_id"] == 1 and r["architecture"] == "x86-64" and r["optimization"] == "-O2")
for row in two_sum:
    print(f"--- {row['compiler']} ---")
    print(row["assembly"][:200])
    print()
```

## Sources

C solutions were collected from three open-source GitHub repositories of pure-C LeetCode solutions:

- [vli02/leetcode](https://github.com/vli02/leetcode) (383 solutions)
- [begeekmyfriend/leetcode](https://github.com/begeekmyfriend/leetcode) (215 solutions)
- [lennylxx/leetcode](https://github.com/lennylxx/leetcode) (159 solutions)

After deduplication, 441 unique problems remained. Solutions are self-contained C files using only the standard library (no C++ STL), producing clean and readable assembly output.