I Solved LeetCode for 600 Days Straight

Everyone knows about LeetCode — you can love it, hate it, despise it, or even fear it, but you definitely won't remain indifferent.

This article shares my impressions from a 600-day marathon on this platform, the dynamics of my skills, and the answer to the main question: "Should you solve problems there?"

Generally, people fall into two camps regarding LeetCode: enthusiasts who love LeetCode and algorithms, and haters who consider it a pointless waste of time.

For a long time I didn't belong to either camp, though I occasionally showed interest in LeetCode, but never got around to it.

Everything was calm until my friend and I made a bet — could we solve 100 problems before the end of 2023?

The 100-problem challenge turned out to be fairly easy — we greeted New Year's with a round number of completed problems on our profiles. I completed 50 problems in one month of December alone.

How the Streak Began

By the start of 2024, the colleague and I set a new goal of 200 problems. On February 24, 2024, LeetCode offered some decent and not too difficult problems in the daily challenge throughout the week, and I accidentally built up a streak of about 10 days in a row.

Breaking the streak felt wasteful — after all, it was a whole 10 days. And so began the long story of 600 days...

The streak extended to 600+ days and 700+ problems and continues to this day. There was clear interest for the first 100-200 days, after which it turned into routine and hard, disciplined work — it was important to set a personal record.

My solving algorithm was quite trivial: If the daily problem is solvable — I solve the daily. If I feel the daily needs more time than usual — I solve any problem that comes to hand. As a rule, Easy/Medium problems came to hand — enough to warm up my brain in the morning or before bed.

Growing Confidence

Over time, I began to more clearly feel an inner confidence before starting to solve a problem of any difficulty — a vivid sign that the time wasn't spent in vain.

Now, seeing a huge staircase of 10+ standard library function calls, there's no longer fear — just a clear chain of templated actions.

Is It Worth It?

Is it worth it? For a precise answer, you need to answer some clarifying questions: Do you work with a high-load system? Do you want to get into Big Tech? Are you attracted to algorithms and do they bring you joy?

If you answered "yes" to at least one question, then LeetCode is a suitable way to level up your algorithmic skills. At least for 100 problems.

What benefit can you extract from such an adventure?

Benefits of LeetCode

1. Algorithmic Complexity — you'll be able to spot it with the naked eye and immediately identify algorithm weaknesses. When you actually face an n² algorithm in production code, your experience with LeetCode will help optimize it to the proper complexity.

2. Learning the Language — possibly the best method for this. Humans are lazy creatures, and you surely won't want to write boilerplate code for a trivial task yet again when you could use a ready-made function instead.

Junior code:

fun countChars(s: String): Map<Char, Int> {
    val res = mutableMapOf<Char, Int>()
    for (c in s) {
        if (res.contains(c)) res[c] = res[c]!! + 1
        else res[c] = 1
    }
    return res
}

Senior code:

fun countChars(s: String): Map<Char, Int> =
    s.groupingBy { it }.eachCount()

3. Patterns — any basic algorithm will become a set of templated actions in a certain order for you. The most popular ones include: prefix sum, sliding window, hash table, DFS, binary search, two pointer, stack & queue.

4. Data Structures — if this is your weak spot, LeetCode will help fix it: arrays, lists, hash tables, trees, graphs, and even stacks with queues will be waiting for you.

At first, you'll have to look at other people's solutions — from them you can learn optimal problem-solving approaches and see patterns.

Why I Don't Solve Hard Problems

Looking at my profile statistics, you can immediately spot one important detail — I don't solve Hard problems at all.

Is that bad? Again, it depends on your goals and capabilities. If your goal is to prepare for an interview at Google or similar companies, then it's a must-have.

But for a basic understanding of algorithms and playing the long game, it would clearly be excessive — finishing an 8-hour workday, you probably won't want to spend another couple of hours solving a Hard-level puzzle.

The rule of habit works better here than fast-burning motivation, which won't take you far. As a rule, solving Hard problems requires decent preparation, a couple hours of free time, and strong nerves.

Three Types of Solutions

Of all the solutions I've seen during this time on LeetCode, I've identified the following groups:

1. Maximally performant and correct solutions. Based on patterns or even mathematics, giving "100% beats" to your solution. Standard library functions aren't used; instead, a "bicycle is invented" — but a very performant one.

2. Elegant but unperformant solutions. Abundant calls to standard library functions; clear and concise code.

3. "Just make it work." A significant share of solutions that combine everything possible — as long as it works.

Here's a comparison using the "Can Place Flowers" problem:

Performant version (~1ms):

fun canPlaceFlowers(flowerbed: IntArray, n: Int): Boolean {
    if (n == 0) return true
    var remaining = n
    var i = 0
    while (i < flowerbed.size) {
        if (flowerbed[i] == 0) {
            val prev = if (i == 0) 0 else flowerbed[i - 1]
            val next = if (i == flowerbed.size - 1) 0 else flowerbed[i + 1]
            if (prev == 0 && next == 0) {
                flowerbed[i] = 0
                remaining--
                if (remaining == 0) return true
                i++
            }
        }
        i++
    }
    return remaining == 0
}

Elegant version (~30ms):

fun canPlaceFlowers(flowerbed: IntArray, n: Int): Boolean = flowerbed
    .withIndex()
    .filter { it.value == 1 }
    .map { it.index }
    .let { listOf(-2) + it + (flowerbed.count()+1) }
    .zipWithNext { i, j -> (j - i - 2) / 2 }
    .sum() >= n

The code looks completely different, though the algorithm is practically identical.

Consistency Is the Secret

What's the secret? Honestly, there is none. Simple consistency and habit — whether it's a weekday, weekend, or holiday — in the evening I sit down and solve a problem of any difficulty that appeals to me at that moment.

It can take 2 minutes or 2 hours, but the problem will be solved and the square will fill in green.

The only downside with this approach: quite often it's just a problem for the sake of a problem — it doesn't teach anything new and no longer develops any skills in algorithms or language.

As I wrote above, around the 200+ day mark it simply turned into routine work that I do in one form or another every day.

If you have a specific end goal for this training, you'll likely be able to extract more benefit from solving problems and see more obvious progress.

Interviews and Preparation

The goal of solving these problems can vary: learning language functions, studying algorithms, a little brain warm-up, simple competitiveness in solutions, or training for interviews at Big Tech companies like Google, Yandex, and similar.

The last one is the most popular reason. Will LeetCode help you with this? More likely yes than no. It all depends on the approach to solving problems.

The main goal is to understand a certain solution pattern and gain the skill to apply it to analogous problems.

Based on colleagues' experience, to pass interview thresholds you need to solve at least 100 Easy/Medium problems. That said, this provides no guarantees and some may need far more.

From my experience, confidence starts appearing after roughly 300+ problems. However, don't be too overconfident — among 3,000 problems there's always one that can completely demolish your self-esteem.

Advice

Finally, I'd like to offer some advice:

• Define your goal. The right goal will set the right rhythm for your work! Perhaps you simply don't need it.
• Start simple. Few can immediately solve most Medium and Hard problems. Pay attention to the Acceptance Rate: the higher the percentage, the more likely you'll solve it.
• Don't be afraid to look at others' solutions. You can often find something new: algorithms, convenient functions, radically new perspectives.
• Experiment. Most problems have multiple solutions. Not all will be optimal, but they're still valid solutions. Perfect is the enemy of good.
• Habits are stronger than motivation. I would never have reached this many solved problems on motivation alone. Motivation typically lasts no more than a month. Take one small step every day, and in a year you'll be amazed at the path you've traveled.
• Share your solutions. If you write in a popular language, you can receive approval or advice from like-minded people. This will help you join the community and level up your skills.

Summary

At the very beginning, forcing myself even at the stage of solving Easy problems, I spent a colossal amount of effort and time.

After 600 days, I can confidently say — none of it was in vain.

LeetCode is a separate world with its own rules and not many points of contact with reality. But it will definitely help you understand what algorithms are and whether you need them: for work, interviews, studies, or general development.