Algorithm Playground

Personal playground for learning algorithms, data structures and problem solving using Kotlin.

The goal of this repository is to become better at solving problems, understanding algorithmic patterns and writing clean, efficient solutions.

This is not a collection of copied LeetCode solutions. It is a long-term learning project that documents my progress, notes and different approaches to solving problems.

Technology

• Kotlin
• Gradle
• JUnit 5

Learning Principles

• Understand the problem before writing code.
• Find a simple solution first.
• Improve it step by step.
• Focus on reasoning instead of memorizing solutions.
• Learn patterns that can be reused in many problems.
• Write clean and readable Kotlin.
• Always analyze time and space complexity.

Workflow

Each problem follows the same process:

1. Understand the requirements.

2. Discuss possible approaches.

3. Identify the appropriate algorithm or data structure.

4. Write pseudocode.

5. Implement the solution in Kotlin.

6. Write unit tests.

7. Analyze:

   • Time complexity
   • Space complexity
   • Edge cases
   • Possible optimizations

8. Summarize the pattern and related problems.

Topics

• Arrays
• Strings
• HashMap / HashSet
• Two Pointers
• Sliding Window
• Stack
• Queue
• Binary Search
• Linked Lists
• Trees
• Heap / Priority Queue
• Graphs
• Backtracking
• Dynamic Programming
• Tries
• Union Find
• System Design

Project Structure

src
├── main
│   └── kotlin
│       └── training
│           ├── arrays
│           ├── hashmap
│           ├── strings
│           ├── twopointers
│           ├── slidingwindow
│           ├── stack
│           ├── queue
│           ├── binarysearch
│           ├── linkedlist
│           ├── trees
│           ├── heap
│           ├── graphs
│           ├── dp
│           └── utils
└── test

Problem Structure

Each problem contains:

• Kotlin solution
• Unit tests
• Complexity analysis
• Personal notes
• Related patterns and problems

The repository grows gradually. New packages are created only when they are needed.

Objective

Build a solid understanding of algorithms and data structures by recognizing patterns, reasoning about trade-offs and writing high-quality Kotlin solutions.