ronantakizawa/leetcode-assembly

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 API.

Dataset Summary

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

Usage

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 (383 solutions)
• —begeekmyfriend/leetcode (215 solutions)
• —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.