Files
leetcode/README.md

30 KiB

LeetCode Solutions

🧠 Why This Repository Exists

I'm practicing to master data structures, algorithms, and problem-solving patterns. This repository serves as my personal learning journey through LeetCode problems, helping me:

  • Build algorithmic thinking and problem-solving skills
  • Master fundamental data structures (arrays, linked lists, trees, graphs, etc.)
  • Learn advanced algorithms (dynamic programming, binary search, two pointers, etc.)
  • Track my progress and identify areas for improvement
  • Create a reference library of solutions for future review

Progress Overview

Current Status

  • Problems Solved: 90+ / 2000+ (LeetCode total)
  • Success Rate: ~95%
  • Streak: Active daily practice
  • Languages: Python (primary), TypeScript (secondary)

Difficulty Breakdown

Difficulty Count Percentage
🟢 Easy ~40 44%
🟡 Medium ~45 50%
🔴 Hard ~5 6%

Recent Activity

  • Last Solved: Multiple problems this week
  • Focus Areas: Dynamic Programming, Graph Algorithms
  • Next Goals: Advanced tree problems, system design concepts

🧩 Topics Covered

Mastered

  • Arrays & Strings - Two pointers, sliding window, prefix sums
  • Hash Tables - Lookup optimization, frequency counting
  • Binary Search - Standard and rotated array variations
  • Two Pointers - Array manipulation, linked list operations
  • Basic Dynamic Programming - Memoization, tabulation

🔄 In Progress

  • Advanced DP - State compression, optimization techniques
  • Graph Algorithms - BFS, DFS, topological sorting
  • Tree Structures - Binary trees, BST operations
  • Advanced Data Structures - Heaps, Tries, Union-Find

📚 Planned

  • System Design - Scalability, distributed systems
  • Advanced Algorithms - Segment trees, advanced graph algorithms
  • Competitive Programming - Advanced optimization techniques

📋 Problem Checklist

Core Data Structures

Topic Easy Medium Hard Total
Arrays 15 20 2 37
Strings 8 12 1 21
Linked Lists 1 4 0 5
Trees 0 0 0 0
Graphs 0 2 0 2
Stacks/Queues 2 3 0 5

Algorithmic Techniques

Technique Easy Medium Hard Total
Hash Tables 8 12 0 20
Two Pointers 6 15 0 21
Binary Search 2 8 0 10
Dynamic Programming 0 8 0 8
Greedy 0 6 0 6
Backtracking 0 3 0 3
Sliding Window 1 1 0 2

Problem Categories

Category Count Mastery Level
Array Manipulation 25
String Processing 18
Hash Table Usage 20
Binary Search 10
Dynamic Programming 8
Two Pointers 21
Linked Lists 5
Graphs 2
Stacks/Queues 5

🎯 Learning Roadmap

Phase 1: Fundamentals

  • Basic array operations
  • String manipulation
  • Hash table implementations
  • Two pointer techniques
  • Basic binary search

Phase 2: Intermediate 🔄

  • Dynamic programming basics
  • Linked list operations
  • Stack and queue problems
  • Greedy algorithms
  • Tree traversal algorithms
  • Graph basics (BFS/DFS)

Phase 3: Advanced 📚

  • Advanced DP techniques
  • Advanced tree structures
  • Graph algorithms
  • System design concepts
  • Competitive programming

Phase 4: Mastery 🏆

  • Advanced optimization
  • Algorithm design
  • Interview preparation
  • Teaching others

This repository contains my solutions to various LeetCode problems. Each solution is implemented in Python and follows a consistent structure.

📊 Statistics

  • Total Problems Solved: 90+
  • Languages: Python, TypeScript
  • Difficulty Distribution: Easy, Medium, Hard

📁 Solutions Index

🔢 Arrays & Strings

Easy

Medium

🔗 Linked Lists

🌳 Trees & Graphs

🧮 Dynamic Programming

🎯 Two Pointers

🗃️ Hash Tables

📚 Stacks & Queues

🔄 Backtracking

🎲 Greedy

🔢 Math

🧮 Bit Manipulation

🏗️ Design

🔗 Union Find

📊 Sorting

🔄 Recursion

🎯 Sliding Window

📐 Geometry

🔍 Divide and Conquer

📝 String Manipulation

📊 Matrix

🔢 Counting

📈 Progress Tracking

Difficulty Distribution

  • Easy: ~40 problems
  • Medium: ~45 problems
  • Hard: ~5 problems

Top Problem Types

  1. Arrays & Strings - Most common
  2. Hash Tables - Frequently used technique
  3. Two Pointers - Efficient array manipulation
  4. Binary Search - Optimization problems
  5. Dynamic Programming - Complex problem solving

🛠️ Solution Structure

Each solution follows a consistent structure:

  • Standard library imports
  • Type hints for better code clarity
  • Solution class with required method
  • Clean, readable implementation
  • Proper comments and documentation

🎯 Learning Focus Areas

Based on the solutions, key areas of expertise include:

  • Array manipulation and two-pointer techniques
  • Hash table optimization for lookups
  • Binary search for efficient searching
  • Dynamic programming for complex problems
  • String manipulation and palindrome problems
  • Linked list operations and cycle detection

📚 Resources


This index is automatically generated and organized by problem categories and difficulty levels. Each solution includes the relevant tags and techniques used.