🎬 LeetCode Visual Storyteller

Transform any LeetCode solution into stunning educational animations automatically!

🚀 Revolutionary AI-Powered System: Just provide any LeetCode problem number, and watch as our intelligent framework analyzes the code, detects algorithms, and creates professional-grade visualizations automatically!

✨ What Makes This Special?

This isn't just another visualization tool - it's a complete AI-driven educational content creation system that:

🧠 Intelligently Analyzes your LeetCode solutions using AST parsing
🎯 Automatically Detects data structures, algorithms, and complexity patterns
🎨 Dynamically Generates custom Manim scenes with rich visual components
🎬 Creates Complete Videos with proper chronological flow
📚 Provides Educational Value with step-by-step algorithm demonstrations

🔥 Live Demo

# Simply run with any LeetCode problem number
python main.py 1    # Two Sum → Animated array + hashmap visualization
python main.py 4    # Median of Two Sorted Arrays → Array merging animation
python main.py 3    # Longest Substring → Enhanced array processing visualization

# That's it! Complete professional videos generated automatically! 🎉

� Key Features

🤖 AI-Powered Problem Analysis

• AST Code Parsing: Deep analysis of your solution structure
• Pattern Recognition: Automatically detects Two Sum, Median, Array Processing, etc.
• Data Structure Detection: Arrays, HashMaps, LinkedLists, Trees
• Algorithm Classification: Sorting, Searching, Dynamic Programming, and more

🎨 Dynamic Visual Generation

• Problem-Specific Routing: Each problem type gets specialized visualizations
• Rich Visual Components: Animated arrays, interactive hashmaps, step-by-step execution
• Algorithm Visualizations: median_of_two_sorted_arrays(), two_sum_visualization(), array_processing_visualization()
• Educational Animations: 10-27 animation sequences per problem

🎬 Professional Video Pipeline

• Complete Presentations: Problem Statement → Visualization → Code Solution → Thank You
• Automatic Video Combination: Perfect chronological ordering with FFmpeg
• Multiple Quality Options: 480p, 720p, 1080p rendering
• Professional Styling: Consistent colors, layouts, and animations

🏗️ Systematic Framework Architecture

📁 Project Structure

🎬 manim-coding-visualizer/
├── 🧠 src/leetcode/              # AI Analysis Engine
│   ├── analyzer.py               # AST parsing & pattern detection
│   ├── scene_generator.py        # Dynamic scene code generation
│   ├── manager.py                # Orchestration & workflow
│   ├── simple_visualizers.py     # Working array utilities
│   └── algorithm_visualizations.py # Specific algorithm templates
├── 🎯 src/data_structures/       # Generic Visualizers
│   ├── array_visualizer.py       # Arrays with cursors & highlighting
│   ├── hashmap_visualizer.py     # Interactive hash map operations
│   ├── linkedlist_visualizer.py  # Node-based visualizations
│   └── tree_visualizer.py        # Binary tree animations
├── 🏛️ src/framework/             # Core Framework
│   ├── problem_framework.py      # Standardized layouts
│   └── algorithm_visualizer.py   # Step tracking & monitoring
├── 📚 src/problems/              # Generated Solutions
│   ├── leetcode_1.py            # Auto-generated Two Sum scenes
│   ├── leetcode_4.py            # Auto-generated Median scenes
│   └── ...                      # Dynamically created files
├── 🎥 media/videos/              # Output Videos
│   ├── leetcode_1/720p30/       # Two Sum presentation
│   ├── leetcode_4/720p30/       # Median presentation
│   └── ...                      # All generated videos
├── 🗂️ leetcode/                  # Your LeetCode Solutions Repository
│   └── solutions/python3/       # Place your .py solution files here
├── ⚙️ main.py                    # Intelligent Main Runner
└── 📋 requirements.txt           # Dependencies

🚀 Getting Started

📦 Installation

# 1. Clone the repository
git clone <your-repo-url>
cd manim-coding-visualizer

# 2. Install dependencies
pip install -r requirements.txt

# 3. Ensure FFmpeg is installed for video processing
# Windows: Download from https://ffmpeg.org/download.html
# Mac: brew install ffmpeg  
# Linux: sudo apt install ffmpeg

🎯 Setup Your LeetCode Repository

# Clone your LeetCode solutions repository into the project
git clone https://github.com/your-username/leetcode-solutions.git leetcode

# Or create the structure manually:
mkdir -p leetcode/solutions/python3
# Place your LeetCode .py files in leetcode/solutions/python3/

⚡ Usage

🎬 Automatic Video Generation

# Generate complete video for any LeetCode problem
python main.py 1     # Two Sum
python main.py 4     # Median of Two Sorted Arrays  
python main.py 15    # 3Sum
python main.py 42    # Trapping Rain Water

# The system automatically:
# ✅ Detects the problem type
# ✅ Analyzes the solution code
# ✅ Generates appropriate visualizations
# ✅ Creates complete presentation video

🎮 Interactive Mode

python main.py
# Interactive prompt for problem selection and options

⚙️ Advanced Options

# Custom quality settings
python main.py 1 --quality high_quality    # 1080p60
python main.py 1 --quality medium_quality  # 720p30 (default)
python main.py 1 --quality low_quality     # 480p15

# Skip video combination (generate scenes only)
python main.py 1 --no-combine

🎨 Visualization Examples

🔢 Two Sum (Problem 1)

• Smart Detection: Recognizes hashmap + array pattern
• Visual Components: Animated array with index cursors, interactive hashmap operations
• Algorithm Steps: Target calculation, complement lookup, visual result highlighting
• Output: TwoSumVisualization.mp4 with 12 animation sequences

📊 Median of Two Sorted Arrays (Problem 4)

• Smart Detection: Identifies array merging algorithm
• Visual Components: Two sorted arrays, merge visualization, median calculation
• Algorithm Steps: Binary search approach, partitioning logic, final result
• Output: Problem4Visualization.mp4 with 10 animation sequences

🔄 Array Processing (Generic)

• Smart Detection: Fallback for complex array algorithms
• Visual Components: Dynamic array displays, step-by-step processing
• Algorithm Steps: Initialization, element processing, transformation logic
• Output: Enhanced visualization with 27 animation sequences

🧠 AI Analysis Engine

Problem Detection & Analysis

# Automatic problem analysis workflow:
problem_info = analyzer.analyze_solution_file(solution_path)
# → Detects: arrays, hashmaps, algorithm patterns, complexity

suggestions = analyzer.suggest_visualization_approach(problem_info)  
# → Routes: Two Sum, Median, LinkedList, Generic enhanced

scene_code = generator.generate_scenes_for_problem(problem_info)
# → Creates: Custom Manim scenes with appropriate visualizations

Smart Visualization Routing

• Problem 1 → AlgorithmVisualizations.two_sum_visualization()
• Problem 4 → AlgorithmVisualizations.median_of_two_sorted_arrays()
• Problem 3 → AlgorithmVisualizations.array_processing_visualization()
• LinkedList Problems → LinkedListVisualizer with node animations
• Unknown Problems → Enhanced generic visualization with actual visual components

🎥 Video Output Structure

Each generated video follows professional presentation structure:

1. 📋 Problem Statement - Clean problem introduction with examples
2. 🎯 Visualization - Algorithm execution with visual components
3. 💻 Code Solution - Formatted code with complexity analysis
4. 🎉 Thank You - Professional conclusion with key concepts recap

📁 media/videos/leetcode_1/720p30/
├── 🎬 CompleteLeetcode1Presentation.mp4    # Final combined video
├── 📋 TwoSumProblemStatement.mp4           # Scene 1: Problem intro
├── 🎯 TwoSumVisualization.mp4              # Scene 2: Algorithm demo  
├── 💻 TwoSumCodeSolution.mp4               # Scene 3: Code display
└── 🎉 TwoSumThankYou.mp4                   # Scene 4: Conclusion

🔧 Framework Components

🎨 Visual Components Library

# Array Operations
SimpleArrayVisualizer.create_array_display(data, title="Array")
SimpleArrayVisualizer.create_two_arrays_comparison(arr1, arr2)  
SimpleArrayVisualizer.create_merge_visualization(arrays)

# Algorithm Templates  
AlgorithmVisualizations.two_sum_visualization(scene, nums, target)
AlgorithmVisualizations.median_of_two_sorted_arrays(scene, nums1, nums2)
AlgorithmVisualizations.array_processing_visualization(scene, nums, operation)

🏗️ Problem Framework

# Standardized Problem Structure
framework = ProblemFramework(scene)
framework.create_title_section(problem_number, name, difficulty)
framework.create_problem_description(description, constraints)
framework.create_code_block(code, position)

🌟 Advanced Features

🔍 Code Analysis Capabilities

• AST Parsing: Deep structural analysis of Python code
• Import Detection: Automatically identifies required data structures
• Pattern Matching: Recognizes common algorithm patterns
• Complexity Analysis: Automatic time/space complexity detection

🎬 Animation Quality

• Professional Transitions: Smooth fade-ins, slide animations
• Color Coding: Consistent color schemes for different data types
• Timing Control: Optimized animation speeds for educational clarity
• Visual Hierarchy: Clear information organization and emphasis

⚡ Performance Optimization

• Caching System: Reuses previously rendered animations
• Parallel Processing: Efficient scene generation and rendering
• Memory Management: Optimized for large datasets and complex visualizations
• Error Recovery: Robust error handling and fallback mechanisms

🎯 Use Cases

📚 Educational Content Creation

• Create course materials for data structures & algorithms
• Generate visual explanations for complex concepts
• Build interactive learning resources

👨‍💻 Technical Interviews

• Visualize your solution approach
• Create compelling presentation materials
• Demonstrate problem-solving methodology

📖 Content Creation

• YouTube tutorials with professional animations
• Blog post visualizations and examples
• Social media educational content

🛠️ Extending the Framework

Adding New Data Structures

# Create new visualizer in src/data_structures/
class QueueVisualizer:
    def create_queue_display(self, items):
        # Implementation for queue visualization
        pass

Adding New Algorithm Patterns

# Extend algorithm_visualizations.py
class AlgorithmVisualizations:
    @staticmethod
    def binary_search_visualization(scene, array, target):
        # Custom binary search animation
        pass

Adding New Problem Types

# Update scene_generator.py routing
if problem_id == 33:  # Search in Rotated Sorted Array
    return self._generate_binary_search_visualization(problem_info, class_name_base)

📊 Technical Specifications

• Python: 3.10+ compatibility
• Manim: Community Edition v0.19.0
• Video Output: MP4 format with configurable quality
• Rendering: Hardware-accelerated when available
• Platform: Cross-platform (Windows, macOS, Linux)

🤝 Contributing

We welcome contributions! Here's how you can help:

1. 🆕 Add New Visualizations: Implement visualizers for graphs, heaps, tries
2. 🎨 Enhance Animations: Improve visual appeal and educational clarity
3. 🧠 Expand AI Analysis: Add detection for more algorithm patterns
4. 📚 Create Examples: Add more LeetCode problem demonstrations
5. 🐛 Bug Fixes: Report and fix issues you encounter

📜 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Manim Community for the powerful animation framework
• LeetCode for providing the problem platform
• FFmpeg for video processing capabilities
• Open Source Community for inspiration and support

---

🎬 Ready to Transform Your LeetCode Solutions into Visual Masterpieces?

git clone <your-repo-url>
cd manim-coding-visualizer
pip install -r requirements.txt
python main.py 1

# Watch the magic happen! ✨

Start creating stunning algorithm visualizations today! 🚀