stindardlogic/coding-interview-sft-100k

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

{
  "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