# leetcode-patterns is a filing cabinet for a paywalled problem list > A pattern-based study index for technical interviews, delivered as a Next.js site whose questions live on leetcode.com, whose Java solutions sit on a separate branch, and whose list is regenerated by a scheduled workflow. The bucketing is the value; the tooling around it is thin. **seanprashad/leetcode-patterns** — A pattern-based approach to learn technical interview questions - Repository: https://github.com/seanprashad/leetcode-patterns - Website: https://seanprashad.com/leetcode-patterns/ - Stars: 14,115 · Forks: 2,273 - Language: TypeScript - License: NOASSERTION - Published: 2026-09-21 · Updated: 2026-09-21 · Language: en - Canonical page: https://hysenlabs.com/projects/seanprashad-leetcode-patterns ## Questions are filed by subtopic so you repeat a pattern, not a problem The organizing idea is repetition inside a bucket. Problems are grouped under their respective subtopic, in order to focus on repeatedly applying common patterns rather than randomly tackling questions. The full question list is not kept in the repository either. It lives at seanprashad.com/leetcode-patterns/, and the repo points there instead of duplicating the data, which means the site's table and the repo are two views of the same catalog. What the grouping cannot do is tell you where to start or declare a bucket finished. Nothing here records attempts, tracks a streak, schedules spaced review, or marks a question solved, so sequencing and self-assessment stay manual. The effect on a learner is narrower than it sounds: the site replaces a shuffled problem feed with a syllabus-shaped list, and the discipline of finishing one bucket before moving to the next remains entirely yours. ## Every question redirects to leetcode.com, and some of them cost money The corpus is not hosted here. All questions are available on leetcode.com, with some requiring leetcode premium, and the premium path points at the subscribe page. That makes the project an index over someone else's paywalled catalog rather than a self-contained course, and the consequences are concrete. Practice needs a second tab, and for the premium share of the list it needs a paid account, so your drill set shrinks silently if you are not subscribed and pattern work stops exactly where the paywall begins. Offline study is impossible, since the text you are solving lives on leetcode.com. And because the pattern label is local while the problem text is remote, an edit on leetcode's side leaves your grouping pointing at something slightly different from the version you practiced last week. ## The site is TypeScript, the solutions are Java, and they sit on another branch The repository's primary language is TypeScript because the website is written in TypeScript, not because the answers are. Solutions written in Java live on a separate solutions branch, so a TypeScript or Python reader has to check out a second branch to see them. The notes section points the same direction: the single extra reference is a pdf covering the main data structures in Java, and the methods it recommends knowing are Java's own, substring(), toCharArray(), Math.max(), Math.min() and Arrays.fill(), each linked to the Java 8 API documentation. Consequence for readers: the pattern taxonomy is language neutral and the worked answers are not. Translating a Java solution into the language your interview actually uses is left as an exercise, and the answers are one checkout away rather than sitting in the tree you already cloned. ## The fundamentals list is a prerequisite you have to bring The project expects a baseline that it does not supply. Knowing the methods and runtimes of arrays, maps, linked lists, queues, heaps, stacks, trees and graphs is described as highly recommended for the greatest amount of success when practicing, and the same section expects breadth-first search, depth-first search, binary search and recursion. None of it is taught in the repository. This is a map of what to practice, not a source for the underlying mechanics, so a shaky grasp of binary search or of the amortized cost of a queue gets amplified by the pattern buckets instead of repaired by them. The only supplementary material named is one pdf for the main data structures in Java, hosted on Google Drive, which means the entire Java foundation of this project sits behind a single external link with no mirror in the tree. ## A pre-push hook runs the suite, and npm install is what arms it Contribution is gated by the same test command you would run yourself. A Husky pre-push hook runs npm test automatically before every push, and it is set up for every clone via the prepare script, so the guard is installed during dependency installation rather than by a separate setup step. Four commands cover the whole loop: ```bash npm install npm run dev # http://localhost:3000 npm test # single run npm run test:watch # watch mode ``` In practice a red suite blocks your push instead of warning you, and the prepare script becomes load-bearing: the hook only arms on a normal dependency install, so a clone set up by some other route has no hook and no notice that it is missing. The repository also carries an .npmrc at the top level, so installs are not a plain default resolution, and next and react are pinned to exact versions rather than ranges, which is what keeps the lockfile and the hook describing the same tree. ## The build emits a service worker cache nobody documents The production build is not just next build. The build script is `next build && node scripts/generate-sw-precache.mjs`, a repository-local Node script that runs after compilation and writes a precache manifest. Nothing in the README explains which assets it covers or how a new release invalidates the cache, so offline behavior arrives as a side effect of a build step you discover only by reading package.json. Fork the project and your build now produces cache output you are responsible for, with no documented contract to hold you to. The private package name, leetcode-patterns-v2 at version 0.1.0, plus the absence of any GitHub release, mean there is nothing to pin: contributors track main, and you cannot check out a known-good build by version. The tree is not archived and its last push is dated 2026-10-01, so the site and its data pipeline are being worked on even though no tagged build exists. ## A workflow regenerates the question list, so it moves under you Two workflow badges sit at the top of the project, deploy.yml and update-questions.yml, and there is a cron directory in the tree. The reasonable reading is that one workflow publishes the site and the other refreshes the question data on a schedule, which means the catalog is generated rather than hand-maintained. For a learner that is both a feature and a hazard. A bucket can gain a question, a question can move to a different subtopic, and wording on leetcode.com can change, with nothing in your checkout announcing it. If your notes are keyed to a problem's position inside a pattern bucket, those notes age at whatever cadence the workflow runs. Contributors face the mirror image: a regenerated data file is a poor place to park a hand-written edit, because the next run decides whether it survives. ## Analytics and a Supabase client ship without appearing in the README The runtime dependency list includes @supabase/supabase-js at 2.99.0, and the front end is instrumented with Google Analytics through @next/third-parties. Neither appears in the README, which describes a Next.js App Router site on React 19, TypeScript, Tailwind CSS v4, TanStack Table v8 and Lucide React, then stops. That gap matters for a page people keep open while they study. You are not told whether the analytics request carries anything identifying, and you are handed a database client with no documented tables, no stated purpose, and no described data handling. If your study habits are sensitive or you run a fork on a shared domain, that call is yours to make deliberately, and the README gives you nothing to make it with. The license has a similar shape: a LICENSE file sits in the root while the repository metadata reports no asserted license, so read the file before you reuse anything. ## Conclusion Take it if you already know your data structures cold, if you are willing to follow buckets in order rather than sample problems at random, and if a LeetCode subscription or at least an open-network session is a given. Leave it if you need the questions themselves offline, if you want answers in TypeScript or Python, or if you want the fundamentals taught rather than listed as a prerequisite. Before you build anything on top of it, check the LICENSE file yourself, since the repository reports no asserted license, and read the dependency list, because a Supabase client and Google Analytics ship without appearing in the README. If you fork it, expect to own the precache manifest and the regenerated question data. ## FAQ ### What are 14 common patterns used in LeetCode? The project does not publish a fixed numbered set of 14 patterns; it groups each problem under its own subtopic instead. Its acknowledgements credit a hackernoon article on 14 patterns to ace any coding interview question, alongside Grokking the Coding Interview and the Blind 75 list, as the sources the questions were drawn from. ### Is LeetCode dead in 2026? Nothing here addresses the state of the platform as a company. What the repository documents is that all questions are hosted on leetcode.com with some requiring premium, and that its own tree is not archived, with a last push dated 2026-10-01 and a workflow for updating the question data. ### What is leetcode patterns and where are the problems? It is a pattern-based approach to learning technical interview questions, with problems grouped under their respective subtopic so you can repeat a pattern instead of tackling questions at random. The full question list is served at seanprashad.com/leetcode-patterns/, while the solutions written in Java live on a separate solutions branch. ### leetcode patterns and questions: how are questions and solutions linked? The repository does not host the question text. All questions are available on leetcode.com, with some requiring leetcode premium, so the pattern grouping is a local label and the problem statement is a redirect. Solutions written in Java are found on the solutions branch, and the site behind the list is built with Next.js, React 19, TypeScript and TanStack Table v8. ## Sources - [Issues](https://github.com/seanprashad/leetcode-patterns/issues) - [Project website](https://seanprashad.com/leetcode-patterns/) - [README](https://github.com/seanprashad/leetcode-patterns/blob/main/README.md) - [seanprashad/leetcode-patterns on GitHub](https://github.com/seanprashad/leetcode-patterns) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/seanprashad-leetcode-patterns