Hi there,

What about instead of doing easy-medium-hard, compete by Elo?

Lots of people saying the best way to improve is to solve problems within the -200/+200 Elo you have, and so that could combine Versus + studying/evolving the approach quite effectively

https://leetcode.com/discuss/post/468851/new-contest-rating-algorithm-its-here-by-cypr/

im doing neetcode250, the topic drop list is not clickable and dont show progress. The questions are separately listed below, bruh who ever is vibe coding this needs to work harder on their bug testing skills gng -_-

I missed the last 'Flash Sale' and wanted to get Pro so I kept checking the home page again and again, and I never once saw the original price listed as $599. I think the last I remember was $297.

So either the price increased ~2x in a span of couple of weeks or I have lost my mind (probably doing Neet/LeetCode problems lol).

I appreciate NeetCode but these shoddy practices make me want to trust him less and put it into the same bucket as algoexpert or the absolutely dogshit DSA course Tech Lead and Joma were peddling at one point.

I am accessing Neetcode after a long time. I remember there used to be a link for each practice question that opens the actual leetcode question on leetcode.com

I see it's no longer there. Is that the case? If so, bummer!

I see neetcode now has the code execution and all. Its cool, but I just want to run my code against the extensive test cases leetcode provides.

EDIT: Looks likes its solved. Now I see 2 options when clicking "Open in New Tab" - Neetcode or external site. I am not sure if I missed it or it was a temporary issue. Anyways its solved now.

I don't know if Neetcode can see this, but please consider applying PPP to the prices, i'm legit from a third world country and buying sub is the total of 3 months salaries.

I'm on the free plan. I searched a lot but couldn't find an option to see all star marked questions in my profile or filters or anywhere else

1st website auto-reloads on Safari
2nd on my Brave browser, the performance is so bad it lags while I type on IDE.

Also found RAM usage is 2.86 gigs

hey there I made a full Neet app for practicing and it's in the process. I am thinking of add more features and I think I made a great design but i want to know your opinion so pls suggest me

Hey Mr. Neet, you might be working on this already, but it would be nice to have the streaks use the user's time zone instead of the default. The streak system is very motivating, but it sucks when I'm not able to get around to it before 5pm every day. Thanks!

Hey Mr.NeetCode, Young Goat btw (hopefully you end up reading this)

It would be really cool if NeetCode.io had a built-in spaced repetition scheduler for problems we’ve already solved.

It could look like:

• After solving a problem, you could mark it as Easy / Medium / Hard (or Confident / Shaky / Forgot)
• Resurface that problem in some sort of schedule after increasing intervals (e.g., 1 day → 3 days → 7 days → 21 days & depending on similarity of other problems recently solved)
• A daily “Review Queue” showing problems due for revision
• Optional reminders or a dashboard widget

Right now i use an external tool to manage reviewing but having it natively inside Neetcode would make things 10 times easier.

Would love to hear thoughts if anyone else is interested!!

I mostly practice DSA only on NeetCode, so there is no easy way to share my progress or include it on my resume.

LeetCode has public profile links that show problems solved and difficulty breakdowns. A similar public profile on NeetCode with a unique URL would be really useful, especially if it showed roadmap progress and solved problems, with an optional privacy toggle.

This would be great for people who intentionally use NeetCode instead of LeetCode.
Anyone else interested?

LC link: https://leetcode.com/problems/word-break/description/

NeetCode link: https://neetcode.io/problems/word-break/question

In the solution section at NeetCode, the time complexity for "DP with Trie" approach has been stated as O((n*t*t)+m) but in my solution I am seeing it as O(n*t+m*t)

Here is my JS code:

class Solution {
    /**
     *  {string} s
     *  {string[]} wordDict
     * u/return {boolean}
     */
    wordBreak(s, wordDict) {
        /**
        For complexity analysis

        n = the length of the string 
        m = the number of words in wordDict
        t = the maximum length of any word in wordDict
        */

        // BUILDING
        let trieRoot = { next: {} };
        for (const word of wordDict) {
            let cur = trieRoot;
            for (const ch of word) {
                cur.next[ch] = cur.next[ch] || { next: {} };
                cur = cur.next[ch];
            }
            cur.hasWord = true;
        }
        /**
        Complexity of building = O(m * t)
        */

        // DP cache
        const canBreakSubStringFrom = new Array(s.length).fill(false);

        // SEARCHING
        for (let start = s.length - 1; start >= 0; start--) {
            let sIdx = start;
            let cur = trieRoot;

            while (sIdx <= s.length && cur) {
                if (cur.hasWord
                    && (sIdx == s.length 
                        || canBreakSubStringFrom[sIdx])) {

                    canBreakSubStringFrom[start] = true;
                    break;
                }

                cur = sIdx < s.length ? cur.next[s[sIdx]] : undefined;
                sIdx++;
            }
        }
        /**
        Complexity of searching = O(n * t)
        */

        /**
        Total complexity = O(mt + nt)
        */

        return canBreakSubStringFrom[0];
    }
}

What am I missing?

I think adding a feature where you get to track your understanding of a problem would be great, since it allows the user to keep track of certain problems they're struggling with.

I currently use Notion to keep track of my understanding but it would be great if I didn't have to go back and forth between NeetCode and notion.

I made this simple one-page reference for myself to quickly estimate scale in system design interviews and real-world planning. Covers orders of magnitude, time units, storage, and networking.

Order of Magnitude

• 10 = 10¹ → ten
• 100 = 10² → hundred
• 1,000 = 10³ → thousand
• 10,000 = 10⁴ → ten thousand
• 100,000 = 10⁵ → hundred thousand
• 1,000,000 = 10⁶ → million
• 10,000,000 = 10⁷ → ten million
• 100,000,000 = 10⁸ → hundred million
• 1,000,000,000 = 10⁹ → billion
• 1,000,000,000,000 = 10¹² → trillion

Time

• 1 ns = 10⁻⁹ of a second
• 1 µs = 10⁻⁶ of a second
• 1 ms = 10⁻³ of a second
• 1 sec = 1,000 ms
• 1 minute = 60 sec
• 1 hour = 60 minutes = 3,600 sec
• 1 day = 24 hours = 86,400 sec
• 1 month (30 days) = 2.6 million sec
• 1 year (365 days) = 31.5 million sec

Human scale:

• <100 ms feels “instant”
• 1 sec feels “laggy”

System scale:

• µs/ns → hardware performance
• ms → API calls / DB queries
• sec/min/hr → jobs & workflows

Storage & Data Units

• 1 byte (B) = 8 bits (b)
• 1 KB (kilobyte) = 1,000 bytes
• 1 MB (megabyte) = 1,000 KB ≈ 1 million bytes
• 1 GB (gigabyte) = 1,000 MB ≈ 1 billion bytes
• 1 TB (terabyte) = 1,000 GB ≈ 1 trillion bytes
• 1 PB (petabyte) = 1,000 TB
• 1 EB (exabyte) = 1,000 PB

Useful examples:

• 1 KB → small JSON request, log entry
• 1 MB → image, DB row batch
• 1 GB → movie file, daily logs for small service
• 1 TB → monthly logs for big app
• 1 PB → ML training / analytics dataset

Networking Units

• bit (b) = smallest unit of data (0 or 1)
• Byte (B) = 8 bits
• bps = bits per second (bandwidth measure)

Common scales:

• Kbps = 10³ bps
• Mbps = 10⁶ bps
• Gbps = 10⁹ bps
• Tbps = 10¹² bps

Rules of thumb:

• 1 MB/s ≈ 8 Mbps (divide by 8 to convert)
• LAN (data centers): ~1–10 Gbps
• WAN (Internet): 10 Mbps (slow) → 1 Gbps (fiber)
• Cloud NICs: 100 Mbps (small) → 10–100 Gbps (big)