File size: 5,671 Bytes
01709a6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 | ---
language:
- en
license: apache-2.0
size_categories:
- 100K<n<1M
task_categories:
- text-generation
pretty_name: Coding Interview SFT (100K)
tags:
- coding-interview
- algorithms
- data-structures
- system-design
- leetcode
- python
- software-engineering
- education
- technical-interview
- sft
- supervised-fine-tuning
- synthetic
configs:
- config_name: default
data_files:
- split: train
path: coding-interview-sft-100k.jsonl
---
# Coding Interview SFT (100K)
100,000 ShareGPT conversations demonstrating expert-level coding interview preparation across algorithms, data structures, system design, and behavioral questions. Each example provides a complete solution with detailed explanation of the approach, step-by-step reasoning, time/space complexity analysis, and edge case handling.
## Motivation
Coding interview preparation is one of the highest-demand AI assistant use cases. Models commonly fail by:
- **Giving the solution without explaining the intuition**: The reader gets code but doesn't understand why this approach works
- **Skipping the "why not brute force"**: Not explaining why an O(n²) approach is insufficient and what insight enables the O(n log n) solution
- **Missing edge cases**: Solutions that fail on empty input, single elements, or duplicate values
- **Wrong complexity analysis**: Claiming O(n) for an O(n log k) algorithm, or missing the space complexity
- **No pattern recognition**: Not connecting the problem to the underlying pattern (sliding window, monotonic stack, two pointers, etc.)
- **Inadequate behavioral question answers**: Vague stories without STAR structure or concrete outcomes
This dataset trains models to teach coding interviews at the level of an experienced mentor — not just providing correct answers, but building the candidate's understanding of *why* the solution works.
## Dataset Description
**100,000 conversations** across 7 problem categories and 3 difficulty levels:
### Problem Categories
| Category | Examples |
|---|---|
| `arrays_hashing` | Two Sum, Group Anagrams, Top K Frequent |
| `two_pointers` | Container With Most Water, 3Sum, Trapping Rain Water |
| `sliding_window` | Longest Substring Without Repeating Characters, Minimum Window Substring |
| `binary_search` | Search in Rotated Sorted Array, Koko Eating Bananas |
| `dynamic_programming` | Coin Change, LIS, Edit Distance, Knapsack |
| `trees` | Level Order Traversal, Diameter, Lowest Common Ancestor |
| `graphs` | Number of Islands, Course Schedule, Dijkstra's |
| `heap_priority_queue` | Top K Frequent, Merge K Sorted Lists, Task Scheduler |
| `stack_queue` | Daily Temperatures, Valid Parentheses, Monotonic Stack |
| `linked_list` | Reverse Linked List, Merge Sorted Lists, Detect Cycle |
| `backtracking` | Subsets, Permutations, Combination Sum |
| `system_design` | URL Shortener, Rate Limiter, Notification System |
| `behavioral` | Disagreement with manager, Significant mistakes, Leadership |
### Difficulty Distribution
- `easy`: ~25% — foundational problems with clear patterns
- `medium`: ~60% — the core of FAANG interviews
- `hard`: ~15% — advanced algorithms and system design
## Format
```json
{
"conversations": [
{
"from": "human",
"value": "**Two Sum** (Easy)\n\nGiven an array of integers `nums` and an integer `target`...\n\nPlease provide a solution in python with a clear explanation..."
},
{
"from": "gpt",
"value": "```python\ndef twoSum(nums, target):\n seen = {}\n for i, num in enumerate(nums):\n ...\n```\n\n**Approach: Hash Map (One Pass)**\n\nThe brute-force approach checks every pair in O(n²)..."
}
],
"metadata": {
"category": "arrays_hashing",
"difficulty": "easy",
"language": "python",
"title": "Two Sum"
},
"id": "abc123"
}
```
## Key Properties of Responses
**1. Pattern identification before code**: Every algorithmic response names the underlying pattern (sliding window, monotonic stack, BFS, etc.) and explains *why* this pattern applies to this problem.
**2. Brute force → optimization path**: Responses acknowledge the naive approach and explain the insight that enables a better solution — building the candidate's problem-solving intuition.
**3. Step-by-step trace**: Complex algorithms include a worked example tracing through the algorithm on a concrete input.
**4. Edge cases explicitly addressed**: Empty input, single elements, all-same elements, overflow conditions — named and handled.
**5. Complexity analysis with justification**: Not just "O(n)" but *why* — which operation is O(n) and how the algorithm avoids doing it more than necessary.
**6. Multiple approaches where relevant**: Many problems include both the clean main solution and a notable alternative (recursive vs. iterative, sorting vs. hash map, DP vs. greedy).
**7. System design depth**: System design problems include API design, data modeling, architecture diagrams, scaling decisions, and specific trade-off analysis — not just high-level overviews.
**8. Behavioral STAR format**: Behavioral questions include a model answer with Situation/Task/Action/Result structure, common mistakes to avoid, and follow-up questions to prepare for.
## Use Cases
- SFT fine-tuning for AI coding interview prep tools (AlgoExpert, LeetCode AI, Pramp)
- Training AI tutors for software engineering education
- Building AI interview coaches for bootcamps and universities
- Improving model performance on algorithmic reasoning benchmarks
- Training models for technical mentorship platforms
- Fine-tuning models for developer education and upskilling applications
## License
Apache 2.0
|