Add dataset card

README.md

@@ -0,0 +1,127 @@
+---
+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