diff --git a/leetcode/.gitignore b/leetcode/.gitignore new file mode 100644 index 0000000..ceddaa3 --- /dev/null +++ b/leetcode/.gitignore @@ -0,0 +1 @@ +.cache/ diff --git a/leetcode/extract.mjs b/leetcode/extract.mjs new file mode 100644 index 0000000..54c66d7 --- /dev/null +++ b/leetcode/extract.mjs @@ -0,0 +1,353 @@ +#!/usr/bin/env node + +/** + * NeetCode Roadmap Extractor + * + * Fetches the NeetCode roadmap data (dependency graph + problems) + * from the live site and outputs structured JSON, DOT, and org-mode. + * + * Idempotent: same input always produces the same output. + * + * Usage: + * node extract.mjs # write to ./out/ + * node extract.mjs --stdout # print JSON to stdout + * node extract.mjs --cache /tmp/nc # cache downloads in dir + */ + +import { writeFileSync, mkdirSync, readFileSync, existsSync } from "node:fs"; +import { join, dirname } from "node:path"; +import { fileURLToPath } from "node:url"; + +const __dirname = dirname(fileURLToPath(import.meta.url)); + +// ── Config ────────────────────────────────────────────────────────────────── + +const BASE = "https://neetcode.io"; +const ROADMAP_CHUNK_ID = 8998; // exports ROADMAP_ROUTES +const GRAPH_DATA_CHUNK_ID = 7669; // contains the actual graph nodes +const LEETCODE_BASE = "https://leetcode.com/problems/"; +const GITHUB_SOLUTIONS = + "https://github.com/neetcode-gh/leetcode/blob/main/"; + +const args = process.argv.slice(2); +const stdoutMode = args.includes("--stdout"); +const cacheDir = args.includes("--cache") + ? args[args.indexOf("--cache") + 1] + : join(__dirname, ".cache"); +const outDir = join(__dirname, "out"); + +// ── Fetch with optional disk cache ────────────────────────────────────────── + +async function fetchText(url, cacheKey) { + const cachePath = join(cacheDir, cacheKey); + if (existsSync(cachePath)) { + return readFileSync(cachePath, "utf8"); + } + const res = await fetch(url); + if (!res.ok) throw new Error(`Failed to fetch ${url}: ${res.status}`); + const text = await res.text(); + mkdirSync(dirname(cachePath), { recursive: true }); + writeFileSync(cachePath, text, "utf8"); + return text; +} + +// ── Step 1: Get chunk hashes from runtime ─────────────────────────────────── + +async function getChunkHashes() { + const html = await fetchText(`${BASE}/roadmap`, "roadmap.html"); + const runtimeMatch = html.match(/src="(runtime\.[a-f0-9]+\.js)"/); + if (!runtimeMatch) throw new Error("Could not find runtime JS filename"); + const runtimeName = runtimeMatch[1]; + const runtime = await fetchText(`${BASE}/${runtimeName}`, runtimeName); + + const hashes = {}; + for (const id of [ROADMAP_CHUNK_ID, GRAPH_DATA_CHUNK_ID]) { + const m = runtime.match(new RegExp(`${id}:"([a-f0-9]+)"`)); + if (!m) throw new Error(`Could not find hash for chunk ${id}`); + hashes[id] = m[1]; + } + + const mainMatch = html.match(/src="(main\.[a-f0-9]+\.js)"/); + if (!mainMatch) throw new Error("Could not find main JS filename"); + hashes.main = mainMatch[1]; + + return hashes; +} + +// ── Step 2: Extract graph nodes from chunk 7669 ───────────────────────────── + +function extractGraphNodes(chunkSrc) { + const nodes = []; + const re = + /\{id:"(\d+)",name:"([^"]+)",backgroundColor:"([^"]+)"(?:,parentId:\[([^\]]*)\])?\}/g; + let m; + while ((m = re.exec(chunkSrc))) { + const [, id, name, , parentStr] = m; + const parents = parentStr + ? parentStr + .split(",") + .map((s) => s.replace(/"/g, "").trim()) + .filter(Boolean) + : []; + nodes.push({ id, name, prerequisites: parents }); + } + return nodes; +} + +// ── Step 3: Extract problems from main bundle ─────────────────────────────── + +function extractProblems(mainSrc) { + const problems = []; + const re = + /\{problem:"([^"]+)",pattern:"([^"]+)",link:"([^"]+)",video:"([^"]*)",difficulty:"(\w+)",code:"([^"]+)"/g; + let m; + while ((m = re.exec(mainSrc))) { + const [, name, pattern, link, video, difficulty, code] = m; + const obj = { name, pattern, difficulty, code, link }; + if (video) obj.video = video; + + const ctxStart = Math.max(0, m.index - 50); + const ctxEnd = Math.min(mainSrc.length, m.index + m[0].length + 200); + const ctx = mainSrc.slice(ctxStart, ctxEnd); + if (/neetcode150:!0/.test(ctx)) obj.neetcode150 = true; + if (/blind75:!0/.test(ctx)) obj.blind75 = true; + if (/neetcode250:!0/.test(ctx)) obj.neetcode250 = true; + if (/premium:!0/.test(ctx)) obj.premium = true; + + problems.push(obj); + } + return problems; +} + +// ── Step 4: Extract course links from chunk 7669 ──────────────────────────── + +function extractCourses(chunkSrc) { + const courses = {}; + const re = + /"([^"]+)":\[\{course:"([^"]+)",name:"([^"]+)",routerLink:"([^"]+)"\}/g; + let m; + while ((m = re.exec(chunkSrc))) { + const topic = m[1]; + const arrStart = m.index + topic.length + 2; + const arrEnd = chunkSrc.indexOf("]", arrStart); + const arrStr = chunkSrc.slice(arrStart, arrEnd + 1); + const items = []; + const itemRe = + /\{course:"([^"]+)",name:"([^"]+)",routerLink:"([^"]+)"\}/g; + let im; + while ((im = itemRe.exec(arrStr))) { + items.push({ course: im[1], name: im[2], routerLink: im[3] }); + } + if (items.length) courses[topic] = items; + } + return courses; +} + +// ── Topological sort ──────────────────────────────────────────────────────── + +function topoSort(nodes) { + const byId = Object.fromEntries(nodes.map((n) => [n.id, n])); + const visited = new Set(); + const result = []; + + function visit(id) { + if (visited.has(id)) return; + visited.add(id); + const node = byId[id]; + if (!node) return; + for (const p of node.prerequisites) visit(p); + result.push(node); + } + + for (const n of nodes) visit(n.id); + return result; +} + +// ── Build DOT graph ───────────────────────────────────────────────────────── + +function buildDot(nodes) { + const lines = [ + "digraph NeetCodeRoadmap {", + ' rankdir=TB;', + ' node [shape=box, style="rounded,filled", fillcolor="#3f4bd1", fontcolor=white, fontname="Helvetica"];', + ' edge [color="#555555", arrowsize=0.8];', + "", + ]; + + for (const n of nodes) { + const label = n.name.replace(/ \/ /g, "\\n").replace(/ /g, "\\n"); + lines.push(` "${n.id}" [label="${label}"];`); + } + lines.push(""); + + for (const n of nodes) { + for (const p of n.prerequisites) { + lines.push(` "${p}" -> "${n.id}";`); + } + } + + lines.push("}"); + return lines.join("\n") + "\n"; +} + +// ── Build org-mode file ───────────────────────────────────────────────────── + +function buildOrg(sortedNodes, problemsByTopic) { + const lines = []; + const now = new Date().toISOString().slice(0, 10); + + lines.push("#+TITLE: NeetCode Roadmap"); + lines.push(`#+DATE: ${now}`); + lines.push("#+TODO: TODO DONE"); + lines.push("#+STARTUP: overview"); + lines.push(""); + lines.push("Source: [[https://neetcode.io/roadmap][neetcode.io/roadmap]]"); + lines.push(""); + + const difficultyTag = (d) => + d === "Easy" ? "easy" : d === "Medium" ? "medium" : "hard"; + + for (const node of sortedNodes) { + const topicProblems = (problemsByTopic[node.name] || []).filter( + (p) => p.neetcode150 + ); + lines.push(`* TODO ${node.name} [/]`); + lines.push(""); + + if (topicProblems.length === 0) { + lines.push(" (no NeetCode 150 problems)"); + lines.push(""); + continue; + } + + for (const p of topicProblems) { + const tag = difficultyTag(p.difficulty); + const lcUrl = `${LEETCODE_BASE}${p.link}`; + const num = p.code.split("-")[0]; + lines.push(`- [ ] TODO ${num}. ${p.name} :${tag}:`); + lines.push(` - [ ] TODO Python: [[${GITHUB_SOLUTIONS}python/${p.code}.py][${p.code}.py]]`); + lines.push(` - [ ] TODO C++: [[${GITHUB_SOLUTIONS}cpp/${p.code}.cpp][${p.code}.cpp]]`); + lines.push(` - LeetCode: [[${lcUrl}][${p.link}]]`); + if (p.video) + lines.push( + ` - Video: [[https://youtube.com/watch?v=${p.video}][explanation]]` + ); + } + lines.push(""); + } + + return lines.join("\n"); +} + +// ── Main ──────────────────────────────────────────────────────────────────── + +async function main() { + const hashes = await getChunkHashes(); + + const [graphChunk, mainSrc] = await Promise.all([ + fetchText( + `${BASE}/${GRAPH_DATA_CHUNK_ID}.${hashes[GRAPH_DATA_CHUNK_ID]}.js`, + `${GRAPH_DATA_CHUNK_ID}.${hashes[GRAPH_DATA_CHUNK_ID]}.js` + ), + fetchText(`${BASE}/${hashes.main}`, hashes.main), + ]); + + const nodes = extractGraphNodes(graphChunk); + const problems = extractProblems(mainSrc); + const courses = extractCourses(graphChunk); + + // Build edges from prerequisites + const edges = []; + for (const n of nodes) { + for (const p of n.prerequisites) { + edges.push({ from: p, to: n.id, meaning: "prerequisite" }); + } + } + + // Group problems by topic + const problemsByTopic = {}; + for (const p of problems) { + if (!problemsByTopic[p.pattern]) problemsByTopic[p.pattern] = []; + problemsByTopic[p.pattern].push(p); + } + + // NeetCode 150 only + const nc150Problems = problems.filter((p) => p.neetcode150); + const nc150ByTopic = {}; + for (const p of nc150Problems) { + if (!nc150ByTopic[p.pattern]) nc150ByTopic[p.pattern] = []; + nc150ByTopic[p.pattern].push(p); + } + + // Topological sort for org output + const sorted = topoSort(nodes); + + const result = { + source: "https://neetcode.io/roadmap", + extracted: new Date().toISOString().slice(0, 10), + graph: { nodes, edges }, + problemsByTopic, + coursesByTopic: courses, + stats: { + topics: nodes.length, + edges: edges.length, + totalProblems: problems.length, + neetcode150: nc150Problems.length, + }, + }; + + if (stdoutMode) { + process.stdout.write(JSON.stringify(result, null, 2) + "\n"); + } else { + mkdirSync(outDir, { recursive: true }); + + // Full data + writeFileSync( + join(outDir, "roadmap.json"), + JSON.stringify(result, null, 2) + "\n", + "utf8" + ); + + // NeetCode 150 only + const nc150Result = { + source: result.source, + extracted: result.extracted, + graph: result.graph, + problemsByTopic: nc150ByTopic, + coursesByTopic: courses, + stats: { + topics: nodes.length, + edges: edges.length, + problems: nc150Problems.length, + }, + }; + writeFileSync( + join(outDir, "roadmap-neetcode150.json"), + JSON.stringify(nc150Result, null, 2) + "\n", + "utf8" + ); + + // DOT + writeFileSync(join(outDir, "roadmap.dot"), buildDot(nodes), "utf8"); + + // Org-mode + writeFileSync( + join(outDir, "roadmap.org"), + buildOrg(sorted, problemsByTopic), + "utf8" + ); + + console.log(`Wrote ${outDir}/roadmap.json (${result.stats.totalProblems} problems total)`); + console.log(`Wrote ${outDir}/roadmap-neetcode150.json (${result.stats.neetcode150} problems)`); + console.log(`Wrote ${outDir}/roadmap.dot`); + console.log(`Wrote ${outDir}/roadmap.org`); + console.log( + ` ${result.stats.topics} topics, ${result.stats.edges} edges` + ); + } +} + +main().catch((err) => { + console.error(err); + process.exit(1); +}); diff --git a/leetcode/neetcode-roadmap-graph.json b/leetcode/neetcode-roadmap-graph.json new file mode 100644 index 0000000..2f59cf5 --- /dev/null +++ b/leetcode/neetcode-roadmap-graph.json @@ -0,0 +1,47 @@ +{ + "source": "https://neetcode.io/roadmap", + "extracted": "2026-06-01", + "nodes": [ + { "id": "1", "name": "Arrays & Hashing" }, + { "id": "2", "name": "Two Pointers" }, + { "id": "3", "name": "Stack" }, + { "id": "4", "name": "Sliding Window" }, + { "id": "5", "name": "Linked List" }, + { "id": "6", "name": "Binary Search" }, + { "id": "7", "name": "Trees" }, + { "id": "8", "name": "Tries" }, + { "id": "9", "name": "Heap / Priority Queue" }, + { "id": "10", "name": "Backtracking" }, + { "id": "11", "name": "Graphs" }, + { "id": "12", "name": "1-D Dynamic Programming" }, + { "id": "13", "name": "Intervals" }, + { "id": "14", "name": "2-D Dynamic Programming" }, + { "id": "15", "name": "Bit Manipulation" }, + { "id": "16", "name": "Greedy" }, + { "id": "17", "name": "Advanced Graphs" }, + { "id": "18", "name": "Math & Geometry" } + ], + "edges": [ + { "from": "1", "to": "2", "meaning": "prerequisite" }, + { "from": "1", "to": "3", "meaning": "prerequisite" }, + { "from": "2", "to": "4", "meaning": "prerequisite" }, + { "from": "2", "to": "5", "meaning": "prerequisite" }, + { "from": "2", "to": "6", "meaning": "prerequisite" }, + { "from": "5", "to": "7", "meaning": "prerequisite" }, + { "from": "6", "to": "7", "meaning": "prerequisite" }, + { "from": "7", "to": "8", "meaning": "prerequisite" }, + { "from": "7", "to": "9", "meaning": "prerequisite" }, + { "from": "7", "to": "10", "meaning": "prerequisite" }, + { "from": "10", "to": "11", "meaning": "prerequisite" }, + { "from": "10", "to": "12", "meaning": "prerequisite" }, + { "from": "9", "to": "13", "meaning": "prerequisite" }, + { "from": "9", "to": "16", "meaning": "prerequisite" }, + { "from": "9", "to": "17", "meaning": "prerequisite" }, + { "from": "11", "to": "14", "meaning": "prerequisite" }, + { "from": "11", "to": "17", "meaning": "prerequisite" }, + { "from": "11", "to": "18", "meaning": "prerequisite" }, + { "from": "12", "to": "14", "meaning": "prerequisite" }, + { "from": "12", "to": "15", "meaning": "prerequisite" }, + { "from": "15", "to": "18", "meaning": "prerequisite" } + ] +} diff --git a/leetcode/neetcode-roadmap.dot b/leetcode/neetcode-roadmap.dot new file mode 100644 index 0000000..47a976f --- /dev/null +++ b/leetcode/neetcode-roadmap.dot @@ -0,0 +1,55 @@ +// NeetCode Roadmap — Topic Dependency Graph +// Source: https://neetcode.io/roadmap (chunk 7669) +// Extracted: 2026-06-01 +// +// Render: dot -Tpng neetcode-roadmap.dot -o neetcode-roadmap.png +// or: dot -Tsvg neetcode-roadmap.dot -o neetcode-roadmap.svg + +digraph NeetCodeRoadmap { + rankdir=TB; + node [shape=box, style="rounded,filled", fillcolor="#3f4bd1", fontcolor=white, fontname="Helvetica"]; + edge [color="#555555", arrowsize=0.8]; + + // Nodes + "1" [label="Arrays &\nHashing"]; + "2" [label="Two Pointers"]; + "3" [label="Stack"]; + "4" [label="Sliding Window"]; + "5" [label="Linked List"]; + "6" [label="Binary Search"]; + "7" [label="Trees"]; + "8" [label="Tries"]; + "9" [label="Heap /\nPriority Queue"]; + "10" [label="Backtracking"]; + "11" [label="Graphs"]; + "12" [label="1-D Dynamic\nProgramming"]; + "13" [label="Intervals"]; + "14" [label="2-D Dynamic\nProgramming"]; + "15" [label="Bit Manipulation"]; + "16" [label="Greedy"]; + "17" [label="Advanced Graphs"]; + "18" [label="Math &\nGeometry"]; + + // Edges (parentId → node means "parentId is a prerequisite of node") + "1" -> "2"; + "1" -> "3"; + "2" -> "4"; + "2" -> "5"; + "2" -> "6"; + "5" -> "7"; + "6" -> "7"; + "7" -> "8"; + "7" -> "9"; + "7" -> "10"; + "10" -> "11"; + "10" -> "12"; + "9" -> "13"; + "9" -> "16"; + "9" -> "17"; + "11" -> "14"; + "11" -> "17"; + "11" -> "18"; + "12" -> "14"; + "12" -> "15"; + "15" -> "18"; +} diff --git a/leetcode/out/roadmap-neetcode150.json b/leetcode/out/roadmap-neetcode150.json new file mode 100644 index 0000000..b071382 --- /dev/null +++ b/leetcode/out/roadmap-neetcode150.json @@ -0,0 +1,2510 @@ +{ + "source": "https://neetcode.io/roadmap", + "extracted": "2026-05-31", + "graph": { + "nodes": [ + { + "id": "1", + "name": "Arrays & Hashing", + "prerequisites": [] + }, + { + "id": "2", + "name": "Two Pointers", + "prerequisites": [ + "1" + ] + }, + { + "id": "6", + "name": "Binary Search", + "prerequisites": [ + "2" + ] + }, + { + "id": "3", + "name": "Stack", + "prerequisites": [ + "1" + ] + }, + { + "id": "4", + "name": "Sliding Window", + "prerequisites": [ + "2" + ] + }, + { + "id": "5", + "name": "Linked List", + "prerequisites": [ + "2" + ] + }, + { + "id": "7", + "name": "Trees", + "prerequisites": [ + "5", + "6" + ] + }, + { + "id": "8", + "name": "Tries", + "prerequisites": [ + "7" + ] + }, + { + "id": "9", + "name": "Heap / Priority Queue", + "prerequisites": [ + "7" + ] + }, + { + "id": "10", + "name": "Backtracking", + "prerequisites": [ + "7" + ] + }, + { + "id": "11", + "name": "Graphs", + "prerequisites": [ + "10" + ] + }, + { + "id": "12", + "name": "1-D Dynamic Programming", + "prerequisites": [ + "10" + ] + }, + { + "id": "13", + "name": "Intervals", + "prerequisites": [ + "9" + ] + }, + { + "id": "16", + "name": "Greedy", + "prerequisites": [ + "9" + ] + }, + { + "id": "17", + "name": "Advanced Graphs", + "prerequisites": [ + "9", + "11" + ] + }, + { + "id": "18", + "name": "Math & Geometry", + "prerequisites": [ + "11", + "15" + ] + }, + { + "id": "14", + "name": "2-D Dynamic Programming", + "prerequisites": [ + "11", + "12" + ] + }, + { + "id": "15", + "name": "Bit Manipulation", + "prerequisites": [ + "12" + ] + } + ], + "edges": [ + { + "from": "1", + "to": "2", + "meaning": "prerequisite" + }, + { + "from": "2", + "to": "6", + "meaning": "prerequisite" + }, + { + "from": "1", + "to": "3", + "meaning": "prerequisite" + }, + { + "from": "2", + "to": "4", + "meaning": "prerequisite" + }, + { + "from": "2", + "to": "5", + "meaning": "prerequisite" + }, + { + "from": "5", + "to": "7", + "meaning": "prerequisite" + }, + { + "from": "6", + "to": "7", + "meaning": "prerequisite" + }, + { + "from": "7", + "to": "8", + "meaning": "prerequisite" + }, + { + "from": "7", + "to": "9", + "meaning": "prerequisite" + }, + { + "from": "7", + "to": "10", + "meaning": "prerequisite" + }, + { + "from": "10", + "to": "11", + "meaning": "prerequisite" + }, + { + "from": "10", + "to": "12", + "meaning": "prerequisite" + }, + { + "from": "9", + "to": "13", + "meaning": "prerequisite" + }, + { + "from": "9", + "to": "16", + "meaning": "prerequisite" + }, + { + "from": "9", + "to": "17", + "meaning": "prerequisite" + }, + { + "from": "11", + "to": "17", + "meaning": "prerequisite" + }, + { + "from": "11", + "to": "18", + "meaning": "prerequisite" + }, + { + "from": "15", + "to": "18", + "meaning": "prerequisite" + }, + { + "from": "11", + "to": "14", + "meaning": "prerequisite" + }, + { + "from": "12", + "to": "14", + "meaning": "prerequisite" + }, + { + "from": "12", + "to": "15", + "meaning": "prerequisite" + } + ] + }, + "problemsByTopic": { + "Arrays & Hashing": [ + { + "name": "Contains Duplicate", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0217-contains-duplicate", + "link": "contains-duplicate/", + "video": "3OamzN90kPg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Valid Anagram", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0242-valid-anagram", + "link": "valid-anagram/", + "video": "9UtInBqnCgA", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Number of Senior Citizens", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "2678-number-of-senior-citizens", + "link": "number-of-senior-citizens/", + "video": "l6_wwKzFmVo", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Two Sum", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0001-two-sum", + "link": "two-sum/", + "video": "KLlXCFG5TnA", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "String Matching in an Array", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1408-string-matching-in-an-array", + "link": "string-matching-in-an-array/", + "video": "7K2BjgjCFDo", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Group Anagrams", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0049-group-anagrams", + "link": "group-anagrams/", + "video": "vzdNOK2oB2E", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Top K Frequent Elements", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0347-top-k-frequent-elements", + "link": "top-k-frequent-elements/", + "video": "YPTqKIgVk-k", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Encode and Decode Strings", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0271-encode-and-decode-strings", + "link": "encode-and-decode-strings/", + "video": "B1k_sxOSgv8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Product of Array Except Self", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0238-product-of-array-except-self", + "link": "product-of-array-except-self/", + "video": "bNvIQI2wAjk", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Minimum Number of Operations to Move All Balls to Each Box", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1769-minimum-number-of-operations-to-move-all-balls-to-each-box", + "link": "minimum-number-of-operations-to-move-all-balls-to-each-box/", + "video": "ZmH3gHiIqfI", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Valid Sudoku", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0036-valid-sudoku", + "link": "valid-sudoku/", + "video": "TjFXEUCMqI8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Longest Consecutive Sequence", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0128-longest-consecutive-sequence", + "link": "longest-consecutive-sequence/", + "video": "P6RZZMu_maU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + } + ], + "Two Pointers": [ + { + "name": "Reverse String", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0344-reverse-string", + "link": "reverse-string/", + "video": "_d0T_2Lk2qA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Valid Palindrome", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0125-valid-palindrome", + "link": "valid-palindrome/", + "video": "jJXJ16kPFWg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Two Sum II Input Array Is Sorted", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0167-two-sum-ii-input-array-is-sorted", + "link": "two-sum-ii-input-array-is-sorted/", + "video": "cQ1Oz4ckceM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "3Sum", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0015-3sum", + "link": "3sum/", + "video": "jzZsG8n2R9A", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Container With Most Water", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0011-container-with-most-water", + "link": "container-with-most-water/", + "video": "UuiTKBwPgAo", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "3Sum Smaller", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0259-3sum-smaller", + "link": "3sum-smaller/", + "neetcode150": true + }, + { + "name": "Trapping Rain Water", + "pattern": "Two Pointers", + "difficulty": "Hard", + "code": "0042-trapping-rain-water", + "link": "trapping-rain-water/", + "video": "ZI2z5pq0TqA", + "neetcode150": true, + "neetcode250": true + } + ], + "Sliding Window": [ + { + "name": "Best Time to Buy And Sell Stock", + "pattern": "Sliding Window", + "difficulty": "Easy", + "code": "0121-best-time-to-buy-and-sell-stock", + "link": "best-time-to-buy-and-sell-stock/", + "video": "1pkOgXD63yU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Longest Substring Without Repeating Characters", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0003-longest-substring-without-repeating-characters", + "link": "longest-substring-without-repeating-characters/", + "video": "wiGpQwVHdE0", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Longest Repeating Character Replacement", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0424-longest-repeating-character-replacement", + "link": "longest-repeating-character-replacement/", + "video": "gqXU1UyA8pk", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Permutation In String", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0567-permutation-in-string", + "link": "permutation-in-string/", + "video": "UbyhOgBN834", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Count of Substrings Containing Every Vowel and K Consonants II", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "3306-count-of-substrings-containing-every-vowel-and-k-consonants-ii", + "link": "count-of-substrings-containing-every-vowel-and-k-consonants-ii/", + "video": "2wANakxRZNo", + "neetcode150": true, + "blind75": true + }, + { + "name": "Minimum Window Substring", + "pattern": "Sliding Window", + "difficulty": "Hard", + "code": "0076-minimum-window-substring", + "link": "minimum-window-substring/", + "video": "jSto0O4AJbM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Sliding Window Maximum", + "pattern": "Sliding Window", + "difficulty": "Hard", + "code": "0239-sliding-window-maximum", + "link": "sliding-window-maximum/", + "video": "DfljaUwZsOk", + "neetcode150": true, + "neetcode250": true + } + ], + "Stack": [ + { + "name": "Baseball Game", + "pattern": "Stack", + "difficulty": "Easy", + "code": "0682-baseball-game", + "link": "baseball-game/", + "video": "Id_tqGdsZQI", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Valid Parentheses", + "pattern": "Stack", + "difficulty": "Easy", + "code": "0020-valid-parentheses", + "link": "valid-parentheses/", + "video": "WTzjTskDFMg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Make The String Great", + "pattern": "Stack", + "difficulty": "Easy", + "code": "1544-make-the-string-great", + "link": "make-the-string-great/", + "video": "10tBWNjzvtw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Min Stack", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0155-min-stack", + "link": "min-stack/", + "video": "qkLl7nAwDPo", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Evaluate Reverse Polish Notation", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0150-evaluate-reverse-polish-notation", + "link": "evaluate-reverse-polish-notation/", + "video": "iu0082c4HDE", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Daily Temperatures", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0739-daily-temperatures", + "link": "daily-temperatures/", + "video": "cTBiBSnjO3c", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Online Stock Span", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0901-online-stock-span", + "link": "online-stock-span/", + "video": "slYh0ZNEqSw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Car Fleet", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0853-car-fleet", + "link": "car-fleet/", + "video": "Pr6T-3yB9RM", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Largest Rectangle In Histogram", + "pattern": "Stack", + "difficulty": "Hard", + "code": "0084-largest-rectangle-in-histogram", + "link": "largest-rectangle-in-histogram/", + "video": "zx5Sw9130L0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Number of Atoms", + "pattern": "Stack", + "difficulty": "Hard", + "code": "0726-number-of-atoms", + "link": "number-of-atoms/", + "video": "iuK05gGBzJc", + "neetcode150": true, + "neetcode250": true + } + ], + "Binary Search": [ + { + "name": "Binary Search", + "pattern": "Binary Search", + "difficulty": "Easy", + "code": "0704-binary-search", + "link": "binary-search/", + "video": "s4DPM8ct1pI", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Successful Pairs of Spells and Potions", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "2300-successful-pairs-of-spells-and-potions", + "link": "successful-pairs-of-spells-and-potions/", + "video": "OKnm5oyAhWg", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Search a 2D Matrix", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0074-search-a-2d-matrix", + "link": "search-a-2d-matrix/", + "video": "Ber2pi2C0j0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Koko Eating Bananas", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0875-koko-eating-bananas", + "link": "koko-eating-bananas/", + "video": "U2SozAs9RzA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find Minimum In Rotated Sorted Array", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0153-find-minimum-in-rotated-sorted-array", + "link": "find-minimum-in-rotated-sorted-array/", + "video": "nIVW4P8b1VA", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Search In Rotated Sorted Array", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0033-search-in-rotated-sorted-array", + "link": "search-in-rotated-sorted-array/", + "video": "U8XENwh8Oy8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Time Based Key Value Store", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0981-time-based-key-value-store", + "link": "time-based-key-value-store/", + "video": "fu2cD_6E8Hw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find K-th Smallest Pair Distance", + "pattern": "Binary Search", + "difficulty": "Hard", + "code": "0719-find-k-th-smallest-pair-distance", + "link": "find-k-th-smallest-pair-distance/", + "video": "bQ-QcFKwsZc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Median of Two Sorted Arrays", + "pattern": "Binary Search", + "difficulty": "Hard", + "code": "0004-median-of-two-sorted-arrays", + "link": "median-of-two-sorted-arrays/", + "video": "q6IEA26hvXc", + "neetcode150": true, + "neetcode250": true + } + ], + "Linked List": [ + { + "name": "Reverse Linked List", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0206-reverse-linked-list", + "link": "reverse-linked-list/", + "video": "G0_I-ZF0S38", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Merge Two Sorted Lists", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0021-merge-two-sorted-lists", + "link": "merge-two-sorted-lists/", + "video": "XIdigk956u0", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Linked List Cycle", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0141-linked-list-cycle", + "link": "linked-list-cycle/", + "video": "gBTe7lFR3vc", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Remove Nodes From Linked List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "2487-remove-nodes-from-linked-list", + "link": "remove-nodes-from-linked-list/", + "video": "y783sRTezDg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Reorder List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0143-reorder-list", + "link": "reorder-list/", + "video": "S5bfdUTrKLM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Remove Nth Node From End of List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0019-remove-nth-node-from-end-of-list", + "link": "remove-nth-node-from-end-of-list/", + "video": "XVuQxVej6y8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Swapping Nodes in a Linked List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "1721-swapping-nodes-in-a-linked-list", + "link": "swapping-nodes-in-a-linked-list/", + "video": "4LsrgMyQIjQ", + "neetcode150": true + }, + { + "name": "Copy List With Random Pointer", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0138-copy-list-with-random-pointer", + "link": "copy-list-with-random-pointer/", + "video": "5Y2EiZST97Y", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Design Browser History", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "1472-design-browser-history", + "link": "design-browser-history/", + "video": "i1G-kKnBu8k", + "neetcode150": true + }, + { + "name": "Add Two Numbers", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0002-add-two-numbers", + "link": "add-two-numbers/", + "video": "wgFPrzTjm7s", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find The Duplicate Number", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0287-find-the-duplicate-number", + "link": "find-the-duplicate-number/", + "video": "wjYnzkAhcNk", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Split Linked List in Parts", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0725-split-linked-list-in-parts", + "link": "split-linked-list-in-parts/", + "video": "-OTlqdrxrVI", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "LRU Cache", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0146-lru-cache", + "link": "lru-cache/", + "video": "7ABFKPK2hD4", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Merge K Sorted Lists", + "pattern": "Linked List", + "difficulty": "Hard", + "code": "0023-merge-k-sorted-lists", + "link": "merge-k-sorted-lists/", + "video": "q5a5OiGbT6Q", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Reverse Nodes In K Group", + "pattern": "Linked List", + "difficulty": "Hard", + "code": "0025-reverse-nodes-in-k-group", + "link": "reverse-nodes-in-k-group/", + "video": "1UOPsfP85V4", + "neetcode150": true, + "neetcode250": true + } + ], + "Trees": [ + { + "name": "N-ary Tree Postorder Traversal", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0590-n-ary-tree-postorder-traversal", + "link": "n-ary-tree-postorder-traversal/", + "video": "GMUI91_pDmM", + "neetcode150": true + }, + { + "name": "Invert Binary Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0226-invert-binary-tree", + "link": "invert-binary-tree/", + "video": "OnSn2XEQ4MY", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Maximum Depth of Binary Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0104-maximum-depth-of-binary-tree", + "link": "maximum-depth-of-binary-tree/", + "video": "hTM3phVI6YQ", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Diameter of Binary Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0543-diameter-of-binary-tree", + "link": "diameter-of-binary-tree/", + "video": "K81C31ytOZE", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Balanced Binary Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0110-balanced-binary-tree", + "link": "balanced-binary-tree/", + "video": "QfJsau0ItOY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Same Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0100-same-tree", + "link": "same-tree/", + "video": "vRbbcKXCxOw", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Subtree of Another Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0572-subtree-of-another-tree", + "link": "subtree-of-another-tree/", + "video": "E36O5SWp-LE", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Lowest Common Ancestor of a Binary Search Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0235-lowest-common-ancestor-of-a-binary-search-tree", + "link": "lowest-common-ancestor-of-a-binary-search-tree/", + "video": "gs2LMfuOR9k", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Binary Tree Level Order Traversal", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0102-binary-tree-level-order-traversal", + "link": "binary-tree-level-order-traversal/", + "video": "6ZnyEApgFYg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Binary Tree Right Side View", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0199-binary-tree-right-side-view", + "link": "binary-tree-right-side-view/", + "video": "d4zLyf32e3I", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Time Needed to Inform All Employees", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1376-time-needed-to-inform-all-employees", + "link": "time-needed-to-inform-all-employees/", + "video": "zdBYi0p4L5Q", + "neetcode150": true + }, + { + "name": "Count Good Nodes In Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1448-count-good-nodes-in-binary-tree", + "link": "count-good-nodes-in-binary-tree/", + "video": "7cp5imvDzl4", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Validate Binary Search Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0098-validate-binary-search-tree", + "link": "validate-binary-search-tree/", + "video": "s6ATEkipzow", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Kth Smallest Element In a Bst", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0230-kth-smallest-element-in-a-bst", + "link": "kth-smallest-element-in-a-bst/", + "video": "5LUXSvjmGCw", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Construct Binary Tree From Preorder And Inorder Traversal", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0105-construct-binary-tree-from-preorder-and-inorder-traversal", + "link": "construct-binary-tree-from-preorder-and-inorder-traversal/", + "video": "ihj4IQGZ2zc", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Recover a Tree From Preorder Traversal", + "pattern": "Trees", + "difficulty": "Hard", + "code": "1028-recover-a-tree-from-preorder-traversal", + "link": "recover-a-tree-from-preorder-traversal/", + "video": "VroH6J47kIE", + "neetcode150": true, + "blind75": true + }, + { + "name": "Binary Tree Maximum Path Sum", + "pattern": "Trees", + "difficulty": "Hard", + "code": "0124-binary-tree-maximum-path-sum", + "link": "binary-tree-maximum-path-sum/", + "video": "Hr5cWUld4vU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Serialize And Deserialize Binary Tree", + "pattern": "Trees", + "difficulty": "Hard", + "code": "0297-serialize-and-deserialize-binary-tree", + "link": "serialize-and-deserialize-binary-tree/", + "video": "u4JAi2JJhI8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + } + ], + "Heap / Priority Queue": [ + { + "name": "Kth Largest Element In a Stream", + "pattern": "Heap / Priority Queue", + "difficulty": "Easy", + "code": "0703-kth-largest-element-in-a-stream", + "link": "kth-largest-element-in-a-stream/", + "video": "hOjcdrqMoQ8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Last Stone Weight", + "pattern": "Heap / Priority Queue", + "difficulty": "Easy", + "code": "1046-last-stone-weight", + "link": "last-stone-weight/", + "video": "B-QCq79-Vfw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "K Closest Points to Origin", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "0973-k-closest-points-to-origin", + "link": "k-closest-points-to-origin/", + "video": "rI2EBUEMfTk", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Kth Largest Element In An Array", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "0215-kth-largest-element-in-an-array", + "link": "kth-largest-element-in-an-array/", + "video": "XEmy13g1Qxc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Task Scheduler", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "0621-task-scheduler", + "link": "task-scheduler/", + "video": "s8p8ukTyA2I", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Design Twitter", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "0355-design-twitter", + "link": "design-twitter/", + "video": "pNichitDD2E", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find Median From Data Stream", + "pattern": "Heap / Priority Queue", + "difficulty": "Hard", + "code": "0295-find-median-from-data-stream", + "link": "find-median-from-data-stream/", + "video": "itmhHWaHupI", + "neetcode150": true, + "blind75": true, + "neetcode250": true + } + ], + "Backtracking": [ + { + "name": "Sum of All Subsets XOR Total", + "pattern": "Backtracking", + "difficulty": "Easy", + "code": "1863-sum-of-all-subset-xor-totals", + "link": "sum-of-all-subset-xor-totals/", + "video": "LI7YR-bwNYY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Subsets", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0078-subsets", + "link": "subsets/", + "video": "REOH22Xwdkk", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Combination Sum", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0039-combination-sum", + "link": "combination-sum/", + "video": "GBKI9VSKdGg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Combination Sum II", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0040-combination-sum-ii", + "link": "combination-sum-ii/", + "video": "FOyRpNUSFeA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Combinations", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0077-combinations", + "link": "combinations/", + "video": "q0s6m7AiM7o", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Permutations", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0046-permutations", + "link": "permutations/", + "video": "FZe0UqISmUw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Subsets II", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0090-subsets-ii", + "link": "subsets-ii/", + "video": "Vn2v6ajA7U0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Generate Parentheses", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0022-generate-parentheses", + "link": "generate-parentheses/", + "video": "s9fokUqJ76A", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Letter Tile Possibilities", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "1079-letter-tile-possibilities", + "link": "letter-tile-possibilities/", + "video": "8FrJX-P_DnE", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Word Search", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0079-word-search", + "link": "word-search/", + "video": "pfiQ_PS1g8E", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Palindrome Partitioning", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0131-palindrome-partitioning", + "link": "palindrome-partitioning/", + "video": "3jvWodd7ht0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Letter Combinations of a Phone Number", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0017-letter-combinations-of-a-phone-number", + "link": "letter-combinations-of-a-phone-number/", + "video": "0snEunUacZY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Android Unlock Patterns", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0351-android-unlock-patterns", + "link": "android-unlock-patterns/", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "N Queens", + "pattern": "Backtracking", + "difficulty": "Hard", + "code": "0051-n-queens", + "link": "n-queens/", + "video": "Ph95IHmRp5M", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "N Queens II", + "pattern": "Backtracking", + "difficulty": "Hard", + "code": "0052-n-queens-ii", + "link": "n-queens-ii/", + "video": "nalYyLZgvCY", + "neetcode150": true, + "neetcode250": true + } + ], + "Tries": [ + { + "name": "Implement Trie Prefix Tree", + "pattern": "Tries", + "difficulty": "Medium", + "code": "0208-implement-trie-prefix-tree", + "link": "implement-trie-prefix-tree/", + "video": "oobqoCJlHA0", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Design Add And Search Words Data Structure", + "pattern": "Tries", + "difficulty": "Medium", + "code": "0211-design-add-and-search-words-data-structure", + "link": "design-add-and-search-words-data-structure/", + "video": "BTf05gs_8iU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Design File System", + "pattern": "Tries", + "difficulty": "Medium", + "code": "1166-design-file-system", + "link": "design-file-system/", + "neetcode150": true, + "blind75": true + }, + { + "name": "Word Search II", + "pattern": "Tries", + "difficulty": "Hard", + "code": "0212-word-search-ii", + "link": "word-search-ii/", + "video": "asbcE9mZz_U", + "neetcode150": true, + "blind75": true, + "neetcode250": true + } + ], + "Graphs": [ + { + "name": "Find Champion II", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2924-find-champion-ii", + "link": "find-champion-ii/", + "video": "HjSmSLPR7S4", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Number of Islands", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0200-number-of-islands", + "link": "number-of-islands/", + "video": "pV2kpPD66nE", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Max Area of Island", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0695-max-area-of-island", + "link": "max-area-of-island/", + "video": "iJGr1OtmH0c", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Maximum Number of Fish in a Grid", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2658-maximum-number-of-fish-in-a-grid", + "link": "maximum-number-of-fish-in-a-grid/", + "video": "JhAz6CkRGHI", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Clone Graph", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0133-clone-graph", + "link": "clone-graph/", + "video": "mQeF6bN8hMk", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Walls And Gates", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0286-walls-and-gates", + "link": "walls-and-gates/", + "video": "e69C6xhiSQE", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Rotting Oranges", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0994-rotting-oranges", + "link": "rotting-oranges/", + "video": "y704fEOx0s0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Count Sub Islands", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1905-count-sub-islands", + "link": "count-sub-islands/", + "video": "mLpW3qfbNJ8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Pacific Atlantic Water Flow", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0417-pacific-atlantic-water-flow", + "link": "pacific-atlantic-water-flow/", + "video": "s-VkcjHqkGI", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Surrounded Regions", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0130-surrounded-regions", + "link": "surrounded-regions/", + "video": "9z2BunfoZ5Y", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find Eventual Safe States", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0802-find-eventual-safe-states", + "link": "find-eventual-safe-states/", + "video": "Re_v0j0CRsg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Course Schedule", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0207-course-schedule", + "link": "course-schedule/", + "video": "EgI5nU9etnU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Course Schedule II", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0210-course-schedule-ii", + "link": "course-schedule-ii/", + "video": "Akt3glAwyfY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Graph Valid Tree", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0261-graph-valid-tree", + "link": "graph-valid-tree/", + "video": "bXsUuownnoQ", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Number of Connected Components In An Undirected Graph", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0323-number-of-connected-components-in-an-undirected-graph", + "link": "number-of-connected-components-in-an-undirected-graph/", + "video": "8f1XPm4WOUc", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Redundant Connection", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0684-redundant-connection", + "link": "redundant-connection/", + "video": "1lNK80tOTfc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find All People With Secret", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "2092-find-all-people-with-secret", + "link": "find-all-people-with-secret/", + "video": "1XujGRSU1bQ", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Word Ladder", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "0127-word-ladder", + "link": "word-ladder/", + "video": "h9iTnkgv05E", + "neetcode150": true, + "neetcode250": true + } + ], + "Advanced Graphs": [ + { + "name": "Network Delay Time", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "0743-network-delay-time", + "link": "network-delay-time/", + "video": "EaphyqKU4PQ", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Reconstruct Itinerary", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "0332-reconstruct-itinerary", + "link": "reconstruct-itinerary/", + "video": "ZyB_gQ8vqGA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Min Cost to Connect All Points", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "1584-min-cost-to-connect-all-points", + "link": "min-cost-to-connect-all-points/", + "video": "f7JOBJIC-NA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find the Safest Path in a Grid", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "2812-find-the-safest-path-in-a-grid", + "link": "find-the-safest-path-in-a-grid/", + "video": "-5mQcNiVWTs", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Swim In Rising Water", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "0778-swim-in-rising-water", + "link": "swim-in-rising-water/", + "video": "amvrKlMLuGY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Alien Dictionary", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "0269-alien-dictionary", + "link": "alien-dictionary/", + "video": "6kTZYvNNyps", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Cheapest Flights Within K Stops", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "0787-cheapest-flights-within-k-stops", + "link": "cheapest-flights-within-k-stops/", + "video": "5eIK3zUdYmE", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Divide Nodes Into the Maximum Number of Groups", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "2493-divide-nodes-into-the-maximum-number-of-groups", + "link": "divide-nodes-into-the-maximum-number-of-groups/", + "video": "Gn0ADjje8Rg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + } + ], + "1-D Dynamic Programming": [ + { + "name": "Climbing Stairs", + "pattern": "1-D Dynamic Programming", + "difficulty": "Easy", + "code": "0070-climbing-stairs", + "link": "climbing-stairs/", + "video": "Y0lT9Fck7qI", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Min Cost Climbing Stairs", + "pattern": "1-D Dynamic Programming", + "difficulty": "Easy", + "code": "0746-min-cost-climbing-stairs", + "link": "min-cost-climbing-stairs/", + "video": "ktmzAZWkEZ0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "House Robber", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0198-house-robber", + "link": "house-robber/", + "video": "73r3KWiEvyk", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "House Robber II", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0213-house-robber-ii", + "link": "house-robber-ii/", + "video": "rWAJCfYYOvM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Longest Palindromic Substring", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0005-longest-palindromic-substring", + "link": "longest-palindromic-substring/", + "video": "XYQecbcd6_c", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Palindromic Substrings", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0647-palindromic-substrings", + "link": "palindromic-substrings/", + "video": "4RACzI5-du8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Decode Ways", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0091-decode-ways", + "link": "decode-ways/", + "video": "6aEyTjOwlJU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Coin Change", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0322-coin-change", + "link": "coin-change/", + "video": "H9bfqozjoqs", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Maximum Product Subarray", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0152-maximum-product-subarray", + "link": "maximum-product-subarray/", + "video": "lXVy6YWFcRM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Word Break", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0139-word-break", + "link": "word-break/", + "video": "Sx9NNgInc3A", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Longest Increasing Subsequence", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0300-longest-increasing-subsequence", + "link": "longest-increasing-subsequence/", + "video": "cjWnW0hdF1Y", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Partition Equal Subset Sum", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0416-partition-equal-subset-sum", + "link": "partition-equal-subset-sum/", + "video": "IsvocB5BJhw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Coin Path", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "0656-coin-path", + "link": "coin-path/", + "neetcode150": true, + "blind75": true + } + ], + "2-D Dynamic Programming": [ + { + "name": "Unique Paths", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0062-unique-paths", + "link": "unique-paths/", + "video": "IlEsdxuD4lY", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Longest Common Subsequence", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "1143-longest-common-subsequence", + "link": "longest-common-subsequence/", + "video": "Ua0GhsJSlWM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Best Time to Buy And Sell Stock With Cooldown", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0309-best-time-to-buy-and-sell-stock-with-cooldown", + "link": "best-time-to-buy-and-sell-stock-with-cooldown/", + "video": "I7j0F7AHpb8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Coin Change II", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0518-coin-change-ii", + "link": "coin-change-ii/", + "video": "Mjy4hd2xgrs", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Target Sum", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0494-target-sum", + "link": "target-sum/", + "video": "dwMOrl85Xes", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Interleaving String", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0097-interleaving-string", + "link": "interleaving-string/", + "video": "3Rw3p9LrgvE", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Longest Increasing Path In a Matrix", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0329-longest-increasing-path-in-a-matrix", + "link": "longest-increasing-path-in-a-matrix/", + "video": "wCc_nd-GiEc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Maximum Alternating Subsequence Sum", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "1911-maximum-alternating-subsequence-sum", + "link": "maximum-alternating-subsequence-sum/", + "video": "4v42XOuU1XA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Distinct Subsequences", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0115-distinct-subsequences", + "link": "distinct-subsequences/", + "video": "-RDzMJ33nx8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Edit Distance", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0072-edit-distance", + "link": "edit-distance/", + "video": "XYi2-LPrwm4", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Count Vowels Permutation", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1220-count-vowels-permutation", + "link": "count-vowels-permutation/", + "video": "VUVpTZVa7Ls", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Burst Balloons", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0312-burst-balloons", + "link": "burst-balloons/", + "video": "VFskby7lUbw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Regular Expression Matching", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0010-regular-expression-matching", + "link": "regular-expression-matching/", + "video": "HAA8mgxlov8", + "neetcode150": true, + "neetcode250": true + } + ], + "Greedy": [ + { + "name": "Minimum Increment to Make Array Unique", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0945-minimum-increment-to-make-array-unique", + "link": "minimum-increment-to-make-array-unique/", + "video": "XPPs2Wj2YSk", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Maximum Subarray", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0053-maximum-subarray", + "link": "maximum-subarray/", + "video": "5WZl3MMT0Eg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Longest Turbulent Subarray", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0978-longest-turbulent-subarray", + "link": "longest-turbulent-subarray/", + "video": "V_iHUhR8Dek", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Jump Game", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0055-jump-game", + "link": "jump-game/", + "video": "Yan0cv2cLy8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Jump Game II", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0045-jump-game-ii", + "link": "jump-game-ii/", + "video": "dJ7sWiOoK7g", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Jump Game VII", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1871-jump-game-vii", + "link": "jump-game-vii/", + "video": "v1HpZUnQ4Yo", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Gas Station", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0134-gas-station", + "link": "gas-station/", + "video": "lJwbPZGo05A", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Hand of Straights", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0846-hand-of-straights", + "link": "hand-of-straights/", + "video": "amnrMCVd2YI", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Merge Triplets to Form Target Triplet", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1899-merge-triplets-to-form-target-triplet", + "link": "merge-triplets-to-form-target-triplet/", + "video": "kShkQLQZ9K4", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Partition Labels", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0763-partition-labels", + "link": "partition-labels/", + "video": "B7m8UmZE-vw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Valid Parenthesis String", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0678-valid-parenthesis-string", + "link": "valid-parenthesis-string/", + "video": "QhPdNS143Qg", + "neetcode150": true, + "neetcode250": true + } + ], + "Intervals": [ + { + "name": "Insert Interval", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0057-insert-interval", + "link": "insert-interval/", + "video": "A8NUOmlwOlM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Merge Intervals", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0056-merge-intervals", + "link": "merge-intervals/", + "video": "44H3cEC2fFM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Non Overlapping Intervals", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0435-non-overlapping-intervals", + "link": "non-overlapping-intervals/", + "video": "nONCGxWoUfM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Interval List Intersections", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0986-interval-list-intersections", + "link": "interval-list-intersections/", + "neetcode150": true, + "blind75": true + }, + { + "name": "Meeting Rooms", + "pattern": "Intervals", + "difficulty": "Easy", + "code": "0252-meeting-rooms", + "link": "meeting-rooms/", + "video": "PaJxqZVPhbg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Meeting Rooms II", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0253-meeting-rooms-ii", + "link": "meeting-rooms-ii/", + "video": "FdzJmTCVyJU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Minimum Interval to Include Each Query", + "pattern": "Intervals", + "difficulty": "Hard", + "code": "1851-minimum-interval-to-include-each-query", + "link": "minimum-interval-to-include-each-query/", + "video": "5hQ5WWW5awQ", + "neetcode150": true, + "neetcode250": true + } + ], + "Math & Geometry": [ + { + "name": "Magic Squares In Grid", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0840-magic-squares-in-grid", + "link": "magic-squares-in-grid/", + "video": "FV52wWrivNc", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Rotate Image", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0048-rotate-image", + "link": "rotate-image/", + "video": "fMSJSS7eO1w", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Spiral Matrix", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0054-spiral-matrix", + "link": "spiral-matrix/", + "video": "BJnMZNwUk1M", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Spiral Matrix IV", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2326-spiral-matrix-iv", + "link": "spiral-matrix-iv/", + "video": "sOV1nRhmsMQ", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Set Matrix Zeroes", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0073-set-matrix-zeroes", + "link": "set-matrix-zeroes/", + "video": "T41rL0L3Pnw", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Happy Number", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0202-happy-number", + "link": "happy-number/", + "video": "ljz85bxOYJ0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Plus One", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0066-plus-one", + "link": "plus-one/", + "video": "jIaA8boiG1s", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Palindrome Number", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0009-palindrome-number", + "link": "palindrome-number/", + "video": "yubRKwixN-U", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Integer to Roman", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0012-integer-to-roman", + "link": "integer-to-roman/", + "video": "ohBNdSJyLh8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Pow(x, n)", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0050-powx-n", + "link": "powx-n/", + "video": "g9YQyYi4IQQ", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find the Punishment Number of an Integer", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2698-find-the-punishment-number-of-an-integer", + "link": "find-the-punishment-number-of-an-integer/", + "video": "LWgksJP-5SA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Check if Number is a Sum of Powers of Three", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "1780-check-if-number-is-a-sum-of-powers-of-three", + "link": "check-if-number-is-a-sum-of-powers-of-three/", + "video": "99ExTh_0Ycg", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Multiply Strings", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0043-multiply-strings", + "link": "multiply-strings/", + "video": "1vZswirL8Y8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Detect Squares", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2013-detect-squares", + "link": "detect-squares/", + "video": "bahebearrDc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Best Meeting Point", + "pattern": "Math & Geometry", + "difficulty": "Hard", + "code": "0296-best-meeting-point", + "link": "best-meeting-point/", + "neetcode150": true + } + ], + "Bit Manipulation": [ + { + "name": "Single Number", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0136-single-number", + "link": "single-number/", + "video": "qMPX1AOa83k", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Single Number III", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "0260-single-number-iii", + "link": "single-number-iii/", + "video": "faoVORjd-T8", + "neetcode150": true + }, + { + "name": "Number of 1 Bits", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0191-number-of-1-bits", + "link": "number-of-1-bits/", + "video": "5Km3utixwZs", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Counting Bits", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0338-counting-bits", + "link": "counting-bits/", + "video": "RyBM56RIWrM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Minimum Bit Flips to Convert Number", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "2220-minimum-bit-flips-to-convert-number", + "link": "minimum-bit-flips-to-convert-number/", + "video": "yz48myznqQY", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Reverse Bits", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0190-reverse-bits", + "link": "reverse-bits/", + "video": "UcoN6UjAI64", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Missing Number", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0268-missing-number", + "link": "missing-number/", + "video": "WnPLSRLSANE", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Power of Two", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0231-power-of-two", + "link": "power-of-two/", + "video": "H2bjttEV4Vc", + "neetcode150": true + }, + { + "name": "Sum of Two Integers", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "0371-sum-of-two-integers", + "link": "sum-of-two-integers/", + "video": "gVUrDV4tZfY", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Reverse Integer", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "0007-reverse-integer", + "link": "reverse-integer/", + "video": "HAgLH58IgJQ", + "neetcode150": true, + "neetcode250": true + } + ] + }, + "coursesByTopic": { + "Arrays & Hashing": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Dynamic Arrays", + "routerLink": "/courses/dsa-for-beginners/3" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Hash Usage", + "routerLink": "/courses/dsa-for-beginners/26" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Hash Implementation", + "routerLink": "/courses/dsa-for-beginners/27" + }, + { + "course": "Advanced Algorithms", + "name": "Prefix Sums", + "routerLink": "/courses/advanced-algorithms/4" + } + ], + "Two Pointers": [ + { + "course": "Advanced Algorithms", + "name": "Two Pointers", + "routerLink": "/courses/advanced-algorithms/3" + } + ], + "Binary Search": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Search Array", + "routerLink": "/courses/dsa-for-beginners/14" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Search Range", + "routerLink": "/courses/dsa-for-beginners/15" + } + ], + "Sliding Window": [ + { + "course": "Advanced Algorithms", + "name": "Sliding Window Fixed Size", + "routerLink": "/courses/advanced-algorithms/1" + }, + { + "course": "Advanced Algorithms", + "name": "Sliding Window Variable Size", + "routerLink": "/courses/advanced-algorithms/2" + } + ], + "Linked List": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Singly Linked Lists", + "routerLink": "/courses/dsa-for-beginners/5" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Doubly Linked Lists", + "routerLink": "/courses/dsa-for-beginners/6" + }, + { + "course": "Advanced Algorithms", + "name": "Fast and Slow Pointers", + "routerLink": "/courses/advanced-algorithms/5" + } + ], + "Heap / Priority Queue": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Heap Properties", + "routerLink": "/courses/dsa-for-beginners/23" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Push and Pop", + "routerLink": "/courses/dsa-for-beginners/24" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Heapify", + "routerLink": "/courses/dsa-for-beginners/25" + }, + { + "course": "Advanced Algorithms", + "name": "Two Heaps", + "routerLink": "/courses/advanced-algorithms/10" + } + ], + "Advanced Graphs": [ + { + "course": "Advanced Algorithms", + "name": "Dijkstra's", + "routerLink": "/courses/advanced-algorithms/14" + }, + { + "course": "Advanced Algorithms", + "name": "Prim's", + "routerLink": "/courses/advanced-algorithms/15" + }, + { + "course": "Advanced Algorithms", + "name": "Kruskal's", + "routerLink": "/courses/advanced-algorithms/16" + }, + { + "course": "Advanced Algorithms", + "name": "Topological Sort", + "routerLink": "/courses/advanced-algorithms/17" + } + ], + "1-D Dynamic Programming": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "1-Dimension DP", + "routerLink": "/courses/dsa-for-beginners/32" + }, + { + "course": "Advanced Algorithms", + "name": "Palindromes", + "routerLink": "/courses/advanced-algorithms/21" + } + ], + "2-D Dynamic Programming": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "2-Dimension DP", + "routerLink": "/courses/dsa-for-beginners/33" + }, + { + "course": "Advanced Algorithms", + "name": "0 / 1 Knapsack", + "routerLink": "/courses/advanced-algorithms/18" + }, + { + "course": "Advanced Algorithms", + "name": "Unbounded Knapsack", + "routerLink": "/courses/advanced-algorithms/19" + }, + { + "course": "Advanced Algorithms", + "name": "LCS", + "routerLink": "/courses/advanced-algorithms/20" + } + ], + "Bit Manipulation": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Bit Operations", + "routerLink": "/courses/dsa-for-beginners/34" + } + ] + }, + "stats": { + "topics": 18, + "edges": 21, + "problems": 199 + } +} diff --git a/leetcode/out/roadmap.dot b/leetcode/out/roadmap.dot new file mode 100644 index 0000000..d4bb5b0 --- /dev/null +++ b/leetcode/out/roadmap.dot @@ -0,0 +1,46 @@ +digraph NeetCodeRoadmap { + rankdir=TB; + node [shape=box, style="rounded,filled", fillcolor="#3f4bd1", fontcolor=white, fontname="Helvetica"]; + edge [color="#555555", arrowsize=0.8]; + + "1" [label="Arrays\n&\nHashing"]; + "2" [label="Two\nPointers"]; + "6" [label="Binary\nSearch"]; + "3" [label="Stack"]; + "4" [label="Sliding\nWindow"]; + "5" [label="Linked\nList"]; + "7" [label="Trees"]; + "8" [label="Tries"]; + "9" [label="Heap\nPriority\nQueue"]; + "10" [label="Backtracking"]; + "11" [label="Graphs"]; + "12" [label="1-D\nDynamic\nProgramming"]; + "13" [label="Intervals"]; + "16" [label="Greedy"]; + "17" [label="Advanced\nGraphs"]; + "18" [label="Math\n&\nGeometry"]; + "14" [label="2-D\nDynamic\nProgramming"]; + "15" [label="Bit\nManipulation"]; + + "1" -> "2"; + "2" -> "6"; + "1" -> "3"; + "2" -> "4"; + "2" -> "5"; + "5" -> "7"; + "6" -> "7"; + "7" -> "8"; + "7" -> "9"; + "7" -> "10"; + "10" -> "11"; + "10" -> "12"; + "9" -> "13"; + "9" -> "16"; + "9" -> "17"; + "11" -> "17"; + "11" -> "18"; + "15" -> "18"; + "11" -> "14"; + "12" -> "14"; + "12" -> "15"; +} diff --git a/leetcode/out/roadmap.json b/leetcode/out/roadmap.json new file mode 100644 index 0000000..261aaa4 --- /dev/null +++ b/leetcode/out/roadmap.json @@ -0,0 +1,8673 @@ +{ + "source": "https://neetcode.io/roadmap", + "extracted": "2026-05-31", + "graph": { + "nodes": [ + { + "id": "1", + "name": "Arrays & Hashing", + "prerequisites": [] + }, + { + "id": "2", + "name": "Two Pointers", + "prerequisites": [ + "1" + ] + }, + { + "id": "6", + "name": "Binary Search", + "prerequisites": [ + "2" + ] + }, + { + "id": "3", + "name": "Stack", + "prerequisites": [ + "1" + ] + }, + { + "id": "4", + "name": "Sliding Window", + "prerequisites": [ + "2" + ] + }, + { + "id": "5", + "name": "Linked List", + "prerequisites": [ + "2" + ] + }, + { + "id": "7", + "name": "Trees", + "prerequisites": [ + "5", + "6" + ] + }, + { + "id": "8", + "name": "Tries", + "prerequisites": [ + "7" + ] + }, + { + "id": "9", + "name": "Heap / Priority Queue", + "prerequisites": [ + "7" + ] + }, + { + "id": "10", + "name": "Backtracking", + "prerequisites": [ + "7" + ] + }, + { + "id": "11", + "name": "Graphs", + "prerequisites": [ + "10" + ] + }, + { + "id": "12", + "name": "1-D Dynamic Programming", + "prerequisites": [ + "10" + ] + }, + { + "id": "13", + "name": "Intervals", + "prerequisites": [ + "9" + ] + }, + { + "id": "16", + "name": "Greedy", + "prerequisites": [ + "9" + ] + }, + { + "id": "17", + "name": "Advanced Graphs", + "prerequisites": [ + "9", + "11" + ] + }, + { + "id": "18", + "name": "Math & Geometry", + "prerequisites": [ + "11", + "15" + ] + }, + { + "id": "14", + "name": "2-D Dynamic Programming", + "prerequisites": [ + "11", + "12" + ] + }, + { + "id": "15", + "name": "Bit Manipulation", + "prerequisites": [ + "12" + ] + } + ], + "edges": [ + { + "from": "1", + "to": "2", + "meaning": "prerequisite" + }, + { + "from": "2", + "to": "6", + "meaning": "prerequisite" + }, + { + "from": "1", + "to": "3", + "meaning": "prerequisite" + }, + { + "from": "2", + "to": "4", + "meaning": "prerequisite" + }, + { + "from": "2", + "to": "5", + "meaning": "prerequisite" + }, + { + "from": "5", + "to": "7", + "meaning": "prerequisite" + }, + { + "from": "6", + "to": "7", + "meaning": "prerequisite" + }, + { + "from": "7", + "to": "8", + "meaning": "prerequisite" + }, + { + "from": "7", + "to": "9", + "meaning": "prerequisite" + }, + { + "from": "7", + "to": "10", + "meaning": "prerequisite" + }, + { + "from": "10", + "to": "11", + "meaning": "prerequisite" + }, + { + "from": "10", + "to": "12", + "meaning": "prerequisite" + }, + { + "from": "9", + "to": "13", + "meaning": "prerequisite" + }, + { + "from": "9", + "to": "16", + "meaning": "prerequisite" + }, + { + "from": "9", + "to": "17", + "meaning": "prerequisite" + }, + { + "from": "11", + "to": "17", + "meaning": "prerequisite" + }, + { + "from": "11", + "to": "18", + "meaning": "prerequisite" + }, + { + "from": "15", + "to": "18", + "meaning": "prerequisite" + }, + { + "from": "11", + "to": "14", + "meaning": "prerequisite" + }, + { + "from": "12", + "to": "14", + "meaning": "prerequisite" + }, + { + "from": "12", + "to": "15", + "meaning": "prerequisite" + } + ] + }, + "problemsByTopic": { + "Arrays & Hashing": [ + { + "name": "Concatenation of Array", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1929-concatenation-of-array", + "link": "concatenation-of-array/", + "video": "68isPRHgcFQ", + "neetcode250": true + }, + { + "name": "Contains Duplicate", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0217-contains-duplicate", + "link": "contains-duplicate/", + "video": "3OamzN90kPg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Valid Anagram", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0242-valid-anagram", + "link": "valid-anagram/", + "video": "9UtInBqnCgA", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Replace Elements With Greatest Element On Right Side", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1299-replace-elements-with-greatest-element-on-right-side", + "link": "replace-elements-with-greatest-element-on-right-side/", + "video": "ZHjKhUjcsaU", + "blind75": true, + "neetcode250": true + }, + { + "name": "Is Subsequence", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0392-is-subsequence", + "link": "is-subsequence/", + "video": "99RVfqklbCE" + }, + { + "name": "Append Characters to String to Make Subsequence", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2486-append-characters-to-string-to-make-subsequence", + "link": "append-characters-to-string-to-make-subsequence/", + "video": "gKDmO8ZLRD8" + }, + { + "name": "Score of a String", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "3110-score-of-a-string", + "link": "score-of-a-string/", + "video": "imbrLFL20tQ" + }, + { + "name": "Length of Last Word", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0058-length-of-last-word", + "link": "length-of-last-word/", + "video": "KT9rltZTybQ" + }, + { + "name": "Valid Word Square", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0422-valid-word-square", + "link": "valid-word-square/" + }, + { + "name": "Perform String Shifts", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1427-perform-string-shifts", + "link": "perform-string-shifts/" + }, + { + "name": "Design Compressed String Iterator", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0604-design-compressed-string-iterator", + "link": "design-compressed-string-iterator/" + }, + { + "name": "Logger Rate Limiter", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0359-logger-rate-limiter", + "link": "logger-rate-limiter/" + }, + { + "name": "Moving Average from Data Stream", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0346-moving-average-from-data-stream", + "link": "moving-average-from-data-stream/" + }, + { + "name": "Maximum Distance in Arrays", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0624-maximum-distance-in-arrays", + "link": "maximum-distance-in-arrays/", + "video": "J0yYlj_oVTI" + }, + { + "name": "Lonely Pixel I", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0531-lonely-pixel-i", + "link": "lonely-pixel-i/" + }, + { + "name": "Sparse Matrix Multiplication", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0311-sparse-matrix-multiplication", + "link": "sparse-matrix-multiplication/" + }, + { + "name": "Candy Crush", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0723-candy-crush", + "link": "candy-crush/" + }, + { + "name": "Find Smallest Common Element in All Rows", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1198-find-smallest-common-element-in-all-rows", + "link": "find-smallest-common-element-in-all-rows/" + }, + { + "name": "One Edit Distance", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0161-one-edit-distance", + "link": "one-edit-distance/" + }, + { + "name": "Reverse Words in a String II", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0186-reverse-words-in-a-string-ii", + "link": "reverse-words-in-a-string-ii/" + }, + { + "name": "Shortest Way to Form String", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1055-shortest-way-to-form-string", + "link": "shortest-way-to-form-string/" + }, + { + "name": "First Unique Number", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1429-first-unique-number", + "link": "first-unique-number/" + }, + { + "name": "Design Tic-Tac-Toe", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0348-design-tic-tac-toe", + "link": "design-tic-tac-toe/" + }, + { + "name": "Design Snake Game", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0353-design-snake-game", + "link": "design-snake-game/" + }, + { + "name": "Zigzag Iterator", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0281-zigzag-iterator", + "link": "zigzag-iterator/" + }, + { + "name": "Design A Leaderboard", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1244-design-a-leaderboard", + "link": "design-a-leaderboard/" + }, + { + "name": "Number of Senior Citizens", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "2678-number-of-senior-citizens", + "link": "number-of-senior-citizens/", + "video": "l6_wwKzFmVo", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Two Sum", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0001-two-sum", + "link": "two-sum/", + "video": "KLlXCFG5TnA", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Max Consecutive Ones", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0485-max-consecutive-ones", + "link": "max-consecutive-ones/", + "neetcode250": true + }, + { + "name": "Longest Common Prefix", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0014-longest-common-prefix", + "link": "longest-common-prefix/", + "video": "0sWShKIJoo4", + "neetcode250": true + }, + { + "name": "String Matching in an Array", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1408-string-matching-in-an-array", + "link": "string-matching-in-an-array/", + "video": "7K2BjgjCFDo", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Group Anagrams", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0049-group-anagrams", + "link": "group-anagrams/", + "video": "vzdNOK2oB2E", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Pascals Triangle", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0118-pascals-triangle", + "link": "pascals-triangle/", + "video": "nPVEaB3AjUM", + "neetcode250": true + }, + { + "name": "Remove Element", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0027-remove-element", + "link": "remove-element/", + "video": "Pcd1ii9P9ZI", + "neetcode250": true + }, + { + "name": "Unique Email Addresses", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0929-unique-email-addresses", + "link": "unique-email-addresses/", + "video": "TC_xLIWl7qY", + "neetcode250": true + }, + { + "name": "Isomorphic Strings", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0205-isomorphic-strings", + "link": "isomorphic-strings/", + "video": "7yF-U1hLEqQ" + }, + { + "name": "Can Place Flowers", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0605-can-place-flowers", + "link": "can-place-flowers/", + "video": "ZGxqqjljpUI", + "neetcode250": true + }, + { + "name": "Majority Element", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0169-majority-element", + "link": "majority-element/", + "video": "7pnhv842keE", + "neetcode250": true + }, + { + "name": "Maximum Difference Between Even and Odd Frequency I", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "3442-maximum-difference-between-even-and-odd-frequency-i", + "link": "maximum-difference-between-even-and-odd-frequency-i/", + "neetcode250": true + }, + { + "name": "Next Greater Element I", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0496-next-greater-element-i", + "link": "next-greater-element-i/", + "video": "68a1Dc_qVq4" + }, + { + "name": "Longest Strictly Increasing or Strictly Decreasing Subarray", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "3105-longest-strictly-increasing-or-strictly-decreasing-subarray", + "link": "longest-strictly-increasing-or-strictly-decreasing-subarray/", + "video": "zDbApBI7UpE" + }, + { + "name": "Maximum Ascending Subarray Sum", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1800-maximum-ascending-subarray-sum", + "link": "maximum-ascending-subarray-sum/", + "video": "NcsmaL_e_Zg" + }, + { + "name": "Find Pivot Index", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0724-find-pivot-index", + "link": "find-pivot-index/", + "video": "u89i60lYx8U" + }, + { + "name": "Kth Distinct String in an Array", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "2053-kth-distinct-string-in-an-array", + "link": "kth-distinct-string-in-an-array/", + "video": "1KOnvGPv9Mo" + }, + { + "name": "Range Sum Query - Immutable", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0303-range-sum-query-immutable", + "link": "range-sum-query-immutable/", + "video": "2pndAmo_sMA" + }, + { + "name": "Find All Numbers Disappeared in An Array", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0448-find-all-numbers-disappeared-in-an-array", + "link": "find-all-numbers-disappeared-in-an-array/", + "video": "8i-f24YFWC4" + }, + { + "name": "Find Missing and Repeated Values", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "2965-find-missing-and-repeated-values", + "link": "find-missing-and-repeated-values/", + "video": "LQGmWiDuTw8" + }, + { + "name": "Maximum Number of Balloons", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1189-maximum-number-of-balloons", + "link": "maximum-number-of-balloons/", + "video": "G9xeB2-7PqY" + }, + { + "name": "Word Pattern", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0290-word-pattern", + "link": "word-pattern/", + "video": "W_akoecmCbM", + "neetcode250": true + }, + { + "name": "Design HashSet", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0705-design-hashset", + "link": "design-hashset/", + "video": "VymjPQUXjL8", + "neetcode250": true + }, + { + "name": "Design HashMap", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0706-design-hashmap", + "link": "design-hashmap/", + "video": "cNWsgbKwwoU", + "neetcode250": true + }, + { + "name": "Height Checker", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1051-height-checker", + "link": "height-checker/", + "video": "mQAoeYaE3Xk", + "neetcode250": true + }, + { + "name": "Find Lucky Integer in an Array", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1394-find-lucky-integer-in-an-array", + "link": "find-lucky-integer-in-an-array/" + }, + { + "name": "Special Array I", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "3151-special-array-i", + "link": "special-array-i/", + "video": "RY6P9V878-0" + }, + { + "name": "Check if Array Is Sorted and Rotated", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1752-check-if-array-is-sorted-and-rotated", + "link": "check-if-array-is-sorted-and-rotated/", + "video": "Vzs_vlCIFEw" + }, + { + "name": "Monotonic Array", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0896-monotonic-array", + "link": "monotonic-array/", + "video": "sqWOFIZ9Z0U" + }, + { + "name": "Divide Array Into Equal Pairs", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "2206-divide-array-into-equal-pairs", + "link": "divide-array-into-equal-pairs/", + "video": "vxcpdClAktE" + }, + { + "name": "Number of Good Pairs", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1512-number-of-good-pairs", + "link": "number-of-good-pairs/", + "video": "BqhDFUo1rjs" + }, + { + "name": "Pascal's Triangle II", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0119-pascals-triangle-ii", + "link": "pascals-triangle-ii/", + "video": "k1DNTyal77I" + }, + { + "name": "Find Words That Can Be Formed by Characters", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1160-find-words-that-can-be-formed-by-characters", + "link": "find-words-that-can-be-formed-by-characters/", + "video": "EQ5jTZdEn8Y" + }, + { + "name": "Count the Number of Consistent Strings", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1684-count-the-number-of-consistent-strings", + "link": "count-the-number-of-consistent-strings/", + "video": "CFa2TgIHMN0" + }, + { + "name": "Ransom Note", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0383-ransom-note", + "link": "ransom-note/" + }, + { + "name": "Largest 3-Same-Digit Number in String", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "2264-largest-3-same-digit-number-in-string", + "link": "largest-3-same-digit-number-in-string/", + "video": "vcrOpJQHsSE" + }, + { + "name": "Destination City", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1436-destination-city", + "link": "destination-city/", + "video": "Hi8vMnnTZHE" + }, + { + "name": "Maximum Product Difference Between Two Pairs", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1913-maximum-product-difference-between-two-pairs", + "link": "maximum-product-difference-between-two-pairs/", + "video": "wBPoEm3r3EA" + }, + { + "name": "Circular Sentence", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "2490-circular-sentence", + "link": "circular-sentence/", + "video": "9Ty_eRjoDNM" + }, + { + "name": "Maximum Score After Splitting a String", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1422-maximum-score-after-splitting-a-string", + "link": "maximum-score-after-splitting-a-string/", + "video": "mc_eSStDrWw" + }, + { + "name": "Path Crossing", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1496-path-crossing", + "link": "path-crossing/", + "video": "VWRJBNP7uH8" + }, + { + "name": "Minimum Changes To Make Alternating Binary String", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1758-minimum-changes-to-make-alternating-binary-string", + "link": "minimum-changes-to-make-alternating-binary-string/", + "video": "9vAQdmVU2ds" + }, + { + "name": "Redistribute Characters to Make All Strings Equal", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1897-redistribute-characters-to-make-all-strings-equal", + "link": "redistribute-characters-to-make-all-strings-equal/", + "video": "a3SmUiimBi8" + }, + { + "name": "Longest Palindrome", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0409-longest-palindrome", + "link": "longest-palindrome/", + "video": "_g9jrLuAphs" + }, + { + "name": "Largest Substring Between Two Equal Characters", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1624-largest-substring-between-two-equal-characters", + "link": "largest-substring-between-two-equal-characters/", + "video": "66b2V_rCuJw" + }, + { + "name": "Set Mismatch", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0645-set-mismatch", + "link": "set-mismatch/", + "video": "d-ulaeRBA64" + }, + { + "name": "First Unique Character in a String", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0387-first-unique-character-in-a-string", + "link": "first-unique-character-in-a-string/", + "video": "rBENYgWy3xU" + }, + { + "name": "Intersection of Two Arrays", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0349-intersection-of-two-arrays", + "link": "intersection-of-two-arrays/", + "video": "fwUTXaMom6U" + }, + { + "name": "Find Common Characters", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1002-find-common-characters", + "link": "find-common-characters/", + "video": "QEESBA2Q_88" + }, + { + "name": "Number of Students Unable to Eat Lunch", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1700-number-of-students-unable-to-eat-lunch", + "link": "number-of-students-unable-to-eat-lunch/", + "video": "d_cvtFwnOZg" + }, + { + "name": "Time Needed to Buy Tickets", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "2073-time-needed-to-buy-tickets", + "link": "time-needed-to-buy-tickets/", + "video": "cVmS9N6kf2Y" + }, + { + "name": "Special Array with X Elements Greater than or Equal X", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1608-special-array-with-x-elements-greater-than-or-equal-x", + "link": "special-array-with-x-elements-greater-than-or-equal-x/", + "video": "Z51jYCeBLVI" + }, + { + "name": "Array Transformation", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1243-array-transformation", + "link": "array-transformation/" + }, + { + "name": "Shortest Word Distance", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0243-shortest-word-distance", + "link": "shortest-word-distance/" + }, + { + "name": "Count Vowel Strings in Ranges", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2559-count-vowel-strings-in-ranges", + "link": "count-vowel-strings-in-ranges/", + "video": "TLJd7W-z-yc" + }, + { + "name": "Average Waiting Time", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1701-average-waiting-time", + "link": "average-waiting-time/", + "video": "2fN7uIgCIBA", + "neetcode250": true + }, + { + "name": "Sort an Array", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0912-sort-an-array", + "link": "sort-an-array/", + "video": "MsYZSinhuFo", + "neetcode250": true + }, + { + "name": "Sort Colors", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0075-sort-colors", + "link": "sort-colors/", + "video": "4xbWSRZHqac", + "neetcode250": true + }, + { + "name": "Relative Sort Array", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1122-relative-sort-array", + "link": "relative-sort-array/", + "video": "OPvcR1e4lfg", + "neetcode250": true + }, + { + "name": "Sort the People", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "2418-sort-the-people", + "link": "sort-the-people/", + "video": "Zv_gXqqslbw" + }, + { + "name": "Sort Array by Increasing Frequency", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1636-sort-array-by-increasing-frequency", + "link": "sort-array-by-increasing-frequency/", + "video": "Evq1SfUbhBg" + }, + { + "name": "Custom Sort String", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0791-custom-sort-string", + "link": "custom-sort-string/" + }, + { + "name": "Top K Frequent Elements", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0347-top-k-frequent-elements", + "link": "top-k-frequent-elements/", + "video": "YPTqKIgVk-k", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Encode and Decode Strings", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0271-encode-and-decode-strings", + "link": "encode-and-decode-strings/", + "video": "B1k_sxOSgv8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Range Sum Query 2D Immutable", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0304-range-sum-query-2d-immutable", + "link": "range-sum-query-2d-immutable/", + "video": "KE8MQuwE2yA", + "neetcode250": true + }, + { + "name": "Analyze User Website Visit Pattern", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1152-analyze-user-website-visit-pattern", + "link": "analyze-user-website-visit-pattern/" + }, + { + "name": "Product of Array Except Self", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0238-product-of-array-except-self", + "link": "product-of-array-except-self/", + "video": "bNvIQI2wAjk", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Minimum Number of Operations to Move All Balls to Each Box", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1769-minimum-number-of-operations-to-move-all-balls-to-each-box", + "link": "minimum-number-of-operations-to-move-all-balls-to-each-box/", + "video": "ZmH3gHiIqfI", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Valid Sudoku", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0036-valid-sudoku", + "link": "valid-sudoku/", + "video": "TjFXEUCMqI8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Longest Consecutive Sequence", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0128-longest-consecutive-sequence", + "link": "longest-consecutive-sequence/", + "video": "P6RZZMu_maU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Encode and Decode TinyURL", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0535-encode-and-decode-tinyurl", + "link": "encode-and-decode-tinyurl/", + "video": "VyBOaboQLGc" + }, + { + "name": "Brick Wall", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0554-brick-wall", + "link": "brick-wall/", + "video": "Kkmv2h48ekw" + }, + { + "name": "Best Time to Buy And Sell Stock II", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0122-best-time-to-buy-and-sell-stock-ii", + "link": "best-time-to-buy-and-sell-stock-ii/", + "video": "3SJ3pUkPQMc", + "neetcode250": true + }, + { + "name": "Majority Element II", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0229-majority-element-ii", + "link": "majority-element-ii/", + "video": "Eua-UrQ_ANo", + "neetcode250": true + }, + { + "name": "Minimum Index of a Valid Split", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2780-minimum-index-of-a-valid-split", + "link": "minimum-index-of-a-valid-split/", + "video": "XemmMMz_0mU", + "neetcode250": true + }, + { + "name": "Subarray Sum Equals K", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0560-subarray-sum-equals-k", + "link": "subarray-sum-equals-k/", + "video": "fFVZt-6sgyo", + "neetcode250": true + }, + { + "name": "Subarray Sums Divisible by K", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0974-subarray-sums-divisible-by-k", + "link": "subarray-sums-divisible-by-k/", + "video": "bcXy-T4Sc3E", + "neetcode250": true + }, + { + "name": "Make Sum Divisible by P", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1590-make-sum-divisible-by-p", + "link": "make-sum-divisible-by-p/", + "video": "tZXsLAyE0SE" + }, + { + "name": "Unique Length 3 Palindromic Subsequences", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1930-unique-length-3-palindromic-subsequences", + "link": "unique-length-3-palindromic-subsequences/", + "video": "3THUt0vAFLU" + }, + { + "name": "Number of Sub-arrays With Odd Sum", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1524-number-of-sub-arrays-with-odd-sum", + "link": "number-of-sub-arrays-with-odd-sum/", + "video": "AIlI-24oC6Q" + }, + { + "name": "Minimum Number of Swaps to Make The String Balanced", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1963-minimum-number-of-swaps-to-make-the-string-balanced", + "link": "minimum-number-of-swaps-to-make-the-string-balanced/", + "video": "3YDBT9ZrfaU" + }, + { + "name": "Number of Pairs of Interchangeable Rectangles", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2001-number-of-pairs-of-interchangeable-rectangles", + "link": "number-of-pairs-of-interchangeable-rectangles/", + "video": "lEQ8ZlLOuyQ" + }, + { + "name": "Maximum Product of The Length of Two Palindromic Subsequences", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2002-maximum-product-of-the-length-of-two-palindromic-subsequences", + "link": "maximum-product-of-the-length-of-two-palindromic-subsequences/", + "video": "aoHbYlO8vDg" + }, + { + "name": "Grid Game", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2017-grid-game", + "link": "grid-game/", + "video": "N4wDSOw65hI" + }, + { + "name": "Find All Anagrams in a String", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0438-find-all-anagrams-in-a-string", + "link": "find-all-anagrams-in-a-string/", + "video": "G8xtZy0fDKg" + }, + { + "name": "Find The Index of The First Occurrence in a String", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0028-find-the-index-of-the-first-occurrence-in-a-string", + "link": "find-the-index-of-the-first-occurrence-in-a-string/", + "video": "JoF0Z7nVSrA" + }, + { + "name": "Wiggle Sort", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0280-wiggle-sort", + "link": "wiggle-sort/", + "video": "vGsyTE4s34w" + }, + { + "name": "Largest Number", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0179-largest-number", + "link": "largest-number/", + "video": "WDx6Y4i4xJ8" + }, + { + "name": "Continuous Subarray Sum", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0523-continuous-subarray-sum", + "link": "continuous-subarray-sum/", + "video": "OKcrLfR-8mE" + }, + { + "name": "Push Dominoes", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0838-push-dominoes", + "link": "push-dominoes/", + "video": "evUFsOb_iLY" + }, + { + "name": "Repeated DNA Sequences", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0187-repeated-dna-sequences", + "link": "repeated-dna-sequences/", + "video": "FzTYfsmtOso" + }, + { + "name": "Insert Delete Get Random O(1)", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0380-insert-delete-getrandom-o1", + "link": "insert-delete-getrandom-o1/", + "video": "j4KwhBziOpg" + }, + { + "name": "Check if a String Contains all Binary Codes of Size K", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1461-check-if-a-string-contains-all-binary-codes-of-size-k", + "link": "check-if-a-string-contains-all-binary-codes-of-size-k/", + "video": "qU32rTy_kOM" + }, + { + "name": "Non Decreasing Array", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0665-non-decreasing-array", + "link": "non-decreasing-array/", + "video": "RegQckCegDk" + }, + { + "name": "Number of Ways to Split Array", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2270-number-of-ways-to-split-array", + "link": "number-of-ways-to-split-array/", + "video": "JK_zuiNYJOQ" + }, + { + "name": "Sign of An Array", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1822-sign-of-the-product-of-an-array", + "link": "sign-of-the-product-of-an-array/", + "video": "ILDLM86jNow" + }, + { + "name": "Find the Difference of Two Arrays", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "2215-find-the-difference-of-two-arrays", + "link": "find-the-difference-of-two-arrays/", + "video": "a4wqKR-znBE" + }, + { + "name": "Uncommon Words from Two Sentences", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "0884-uncommon-words-from-two-sentences", + "link": "uncommon-words-from-two-sentences/", + "video": "24IYW1kQdYU" + }, + { + "name": "Design Parking System", + "pattern": "Arrays & Hashing", + "difficulty": "Easy", + "code": "1603-design-parking-system", + "link": "design-parking-system/", + "video": "d5zCHesOrSk" + }, + { + "name": "Shifting Letters II", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2381-shifting-letters-ii", + "link": "shifting-letters-ii/", + "video": "eEUjVY7wK3k" + }, + { + "name": "Number of Zero-Filled Subarrays", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2348-number-of-zero-filled-subarrays", + "link": "number-of-zero-filled-subarrays/", + "video": "G-EWVGCcL_w" + }, + { + "name": "Word Subsets", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0916-word-subsets", + "link": "word-subsets/", + "video": "LFX61XMU22c" + }, + { + "name": "Optimal Partition of String", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2405-optimal-partition-of-string", + "link": "optimal-partition-of-string/", + "video": "CKZPdiXiQf0" + }, + { + "name": "Design Underground System", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1396-design-underground-system", + "link": "design-underground-system/", + "video": "W5QOLqXskZM" + }, + { + "name": "Minimum Penalty for a Shop", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2483-minimum-penalty-for-a-shop", + "link": "minimum-penalty-for-a-shop/", + "video": "0d7ShRoOFVE" + }, + { + "name": "Champagne Tower", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0799-champagne-tower", + "link": "champagne-tower/", + "video": "LQ8TuG_QADM" + }, + { + "name": "Sum of Absolute Differences in a Sorted Array", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1685-sum-of-absolute-differences-in-a-sorted-array", + "link": "sum-of-absolute-differences-in-a-sorted-array/", + "video": "3nkc-e66JmA" + }, + { + "name": "Design a Food Rating System", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2353-design-a-food-rating-system", + "link": "design-a-food-rating-system/", + "video": "Ikp8SgbgbEo" + }, + { + "name": "Convert an Array Into a 2D Array With Conditions", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2610-convert-an-array-into-a-2d-array-with-conditions", + "link": "convert-an-array-into-a-2d-array-with-conditions/", + "video": "9pl1QiaGgmI" + }, + { + "name": "Minimum Number of Operations to Make Array Empty", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2870-minimum-number-of-operations-to-make-array-empty", + "link": "minimum-number-of-operations-to-make-array-empty/", + "video": "_AcO35R0fss" + }, + { + "name": "Divide Array Into Arrays With Max Difference", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2966-divide-array-into-arrays-with-max-difference", + "link": "divide-array-into-arrays-with-max-difference/", + "video": "XleOio1oJeo" + }, + { + "name": "Sequential Digits", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1291-sequential-digits", + "link": "sequential-digits/", + "video": "Q-ca65wRJyI" + }, + { + "name": "Sort Characters By Frequency", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0451-sort-characters-by-frequency", + "link": "sort-characters-by-frequency/", + "video": "OXdXc9HTrIg" + }, + { + "name": "Sort the Jumbled Numbers", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2191-sort-the-jumbled-numbers", + "link": "sort-the-jumbled-numbers/", + "video": "rmkF2mxPoZM" + }, + { + "name": "Find Polygon with the Largest Perimeter", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2971-find-polygon-with-the-largest-perimeter", + "link": "find-polygon-with-the-largest-perimeter/", + "video": "Yk9Mor-Y488" + }, + { + "name": "Minimum Remove to Make Valid Parentheses", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1249-minimum-remove-to-make-valid-parentheses", + "link": "minimum-remove-to-make-valid-parentheses/", + "video": "mgQ4O9iUEbg" + }, + { + "name": "Contiguous Array", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0525-contiguous-array", + "link": "contiguous-array/", + "video": "agB1LyObUNE" + }, + { + "name": "Count Number of Bad Pairs", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2364-count-number-of-bad-pairs", + "link": "count-number-of-bad-pairs/", + "video": "h13Y9sDbQ6w" + }, + { + "name": "Find All Duplicates in an Array", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0442-find-all-duplicates-in-an-array", + "link": "find-all-duplicates-in-an-array/", + "video": "Y8x0iAVEITo" + }, + { + "name": "Find the Length of the Longest Common Prefix", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "3043-find-the-length-of-the-longest-common-prefix", + "link": "find-the-length-of-the-longest-common-prefix/", + "video": "06dIUJwdHlQ" + }, + { + "name": "Count Unguarded Cells in the Grid", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2257-count-unguarded-cells-in-the-grid", + "link": "count-unguarded-cells-in-the-grid/", + "video": "3WVHdSWHxxQ" + }, + { + "name": "Design Hit Counter", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0362-design-hit-counter", + "link": "design-hit-counter/" + }, + { + "name": "Shortest Word Distance II", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0244-shortest-word-distance-ii", + "link": "shortest-word-distance-ii/" + }, + { + "name": "Dot Product of Two Sparse Vectors", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1570-dot-product-of-two-sparse-vectors", + "link": "dot-product-of-two-sparse-vectors/" + }, + { + "name": "Brightest Position on Street", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "2021-brightest-position-on-street", + "link": "brightest-position-on-street/" + }, + { + "name": "Apply Substitutions", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "3481-apply-substitutions", + "link": "apply-substitutions/" + }, + { + "name": "The Earliest Moment When Everyone Become Friends", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1101-the-earliest-moment-when-everyone-become-friends", + "link": "the-earliest-moment-when-everyone-become-friends/" + }, + { + "name": "Range Sum Query 2D - Mutable", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0308-range-sum-query-2d-mutable", + "link": "range-sum-query-2d-mutable/" + }, + { + "name": "Synonymous Sentences", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "1258-synonymous-sentences", + "link": "synonymous-sentences/" + }, + { + "name": "Split Concatenated Strings", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0555-split-concatenated-strings", + "link": "split-concatenated-strings/" + }, + { + "name": "Design Phone Directory", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0379-design-phone-directory", + "link": "design-phone-directory/" + }, + { + "name": "Design Log Storage System", + "pattern": "Arrays & Hashing", + "difficulty": "Medium", + "code": "0635-design-log-storage-system", + "link": "design-log-storage-system/" + }, + { + "name": "Text Justification", + "pattern": "Arrays & Hashing", + "difficulty": "Hard", + "code": "0068-text-justification", + "link": "text-justification/", + "video": "TzMl4Z7pVh8" + }, + { + "name": "Naming a Company", + "pattern": "Arrays & Hashing", + "difficulty": "Hard", + "code": "2306-naming-a-company", + "link": "naming-a-company/", + "video": "NrHpgTScOcY" + }, + { + "name": "Number of Submatrices that Sum to Target", + "pattern": "Arrays & Hashing", + "difficulty": "Hard", + "code": "1074-number-of-submatrices-that-sum-to-target", + "link": "number-of-submatrices-that-sum-to-target/", + "video": "43DRBP2DUHg", + "neetcode250": true + }, + { + "name": "First Missing Positive", + "pattern": "Arrays & Hashing", + "difficulty": "Hard", + "code": "0041-first-missing-positive", + "link": "first-missing-positive/", + "video": "8g78yfzMlao", + "neetcode250": true + }, + { + "name": "Shortest Palindrome", + "pattern": "Arrays & Hashing", + "difficulty": "Hard", + "code": "0214-shortest-palindrome/", + "link": "shortest-palindrome/", + "video": "niOT-FK1RH8", + "neetcode250": true + }, + { + "name": "Number of Ships in a Rectangle", + "pattern": "Arrays & Hashing", + "difficulty": "Hard", + "code": "1274-number-of-ships-in-a-rectangle", + "link": "number-of-ships-in-a-rectangle/" + }, + { + "name": "Time Taken to Cross the Door", + "pattern": "Arrays & Hashing", + "difficulty": "Hard", + "code": "2534-time-taken-to-cross-the-door", + "link": "time-taken-to-cross-the-door/" + }, + { + "name": "Design Excel Sum Formula", + "pattern": "Arrays & Hashing", + "difficulty": "Hard", + "code": "0631-design-excel-sum-formula", + "link": "design-excel-sum-formula/", + "neetcode250": true + } + ], + "Two Pointers": [ + { + "name": "Reverse String", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0344-reverse-string", + "link": "reverse-string/", + "video": "_d0T_2Lk2qA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Valid Palindrome", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0125-valid-palindrome", + "link": "valid-palindrome/", + "video": "jJXJ16kPFWg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Valid Palindrome II", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0680-valid-palindrome-ii", + "link": "valid-palindrome-ii/", + "video": "JrxRYBwG6EI", + "neetcode250": true + }, + { + "name": "Valid Word Abbreviation", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0408-valid-word-abbreviation", + "link": "valid-word-abbreviation/", + "video": "m7U90fpD2j0", + "neetcode250": true + }, + { + "name": "Merge Strings Alternately", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "1768-merge-strings-alternately", + "link": "merge-strings-alternately/", + "video": "LECWOvTo-Sc", + "neetcode250": true + }, + { + "name": "Merge Sorted Array", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0088-merge-sorted-array", + "link": "merge-sorted-array/", + "video": "P1Ic85RarKY", + "neetcode250": true + }, + { + "name": "Merge Two 2D Arrays by Summing Values", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "2570-merge-two-2d-arrays-by-summing-values", + "link": "merge-two-2d-arrays-by-summing-values/", + "video": "5MT4KsvOXYs", + "neetcode250": true + }, + { + "name": "Move Zeroes", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0283-move-zeroes", + "link": "move-zeroes/", + "video": "aayNRwUN3Do" + }, + { + "name": "Remove Duplicates From Sorted Array", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0026-remove-duplicates-from-sorted-array", + "link": "remove-duplicates-from-sorted-array/", + "video": "DEJAZBq0FDA", + "neetcode250": true + }, + { + "name": "Squares of a Sorted Array", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0977-squares-of-a-sorted-array", + "link": "squares-of-a-sorted-array/", + "video": "FPCZsG_AkUg" + }, + { + "name": "Assign Cookies", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0455-assign-cookies", + "link": "assign-cookies/", + "video": "JW8fgvoxPTg" + }, + { + "name": "Find First Palindromic String in the Array", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "2108-find-first-palindromic-string-in-the-array", + "link": "find-first-palindromic-string-in-the-array/", + "video": "4JA5MW772N0" + }, + { + "name": "Sort Array by Parity", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0905-sort-array-by-parity", + "link": "sort-array-by-parity/", + "video": "QC4c9fyr8As" + }, + { + "name": "Reverse Words in a String III", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0557-reverse-words-in-a-string-iii", + "link": "reverse-words-in-a-string-iii/", + "video": "7kUEwiwwnlA" + }, + { + "name": "Backspace String Compare", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0844-backspace-string-compare", + "link": "backspace-string-compare/", + "video": "k2qrymM_DOo" + }, + { + "name": "Check If Two String Arrays are Equivalent", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "1662-check-if-two-string-arrays-are-equivalent", + "link": "check-if-two-string-arrays-are-equivalent/", + "video": "ejBwc2oE7ck" + }, + { + "name": "Apply Operations to an Array", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "2460-apply-operations-to-an-array", + "link": "apply-operations-to-an-array/", + "video": "ur0srHvM1cA" + }, + { + "name": "Strobogrammatic Number", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "0246-strobogrammatic-number", + "link": "strobogrammatic-number/" + }, + { + "name": "Two Sum Less Than K", + "pattern": "Two Pointers", + "difficulty": "Easy", + "code": "1099-two-sum-less-than-k", + "link": "two-sum-less-than-k/" + }, + { + "name": "Adding Spaces to a String", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "2109-adding-spaces-to-a-string", + "link": "adding-spaces-to-a-string/", + "video": "jziDtPZJ4fw" + }, + { + "name": "String Compression", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0443-string-compression", + "link": "string-compression/" + }, + { + "name": "Remove Duplicates From Sorted Array II", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0080-remove-duplicates-from-sorted-array-ii", + "link": "remove-duplicates-from-sorted-array-ii/", + "video": "ycAq8iqh0TI" + }, + { + "name": "Partition Array According to Given Pivot", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "2161-partition-array-according-to-given-pivot", + "link": "partition-array-according-to-given-pivot/", + "video": "OX0bCSG7EfE" + }, + { + "name": "Two Sum II Input Array Is Sorted", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0167-two-sum-ii-input-array-is-sorted", + "link": "two-sum-ii-input-array-is-sorted/", + "video": "cQ1Oz4ckceM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "3Sum", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0015-3sum", + "link": "3sum/", + "video": "jzZsG8n2R9A", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "4Sum", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0018-4sum", + "link": "4sum/", + "video": "EYeR-_1NRlQ", + "neetcode250": true + }, + { + "name": "Rotate Array", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0189-rotate-array", + "link": "rotate-array/", + "video": "BHr381Guz3Y", + "neetcode250": true + }, + { + "name": "Container With Most Water", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0011-container-with-most-water", + "link": "container-with-most-water/", + "video": "UuiTKBwPgAo", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Number of Subsequences That Satisfy The Given Sum Condition", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "1498-number-of-subsequences-that-satisfy-the-given-sum-condition", + "link": "number-of-subsequences-that-satisfy-the-given-sum-condition/", + "video": "xCsIkPLS4Ls", + "neetcode250": true + }, + { + "name": "Array With Elements Not Equal to Average of Neighbors", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "1968-array-with-elements-not-equal-to-average-of-neighbors", + "link": "array-with-elements-not-equal-to-average-of-neighbors/", + "video": "Wmb3YdVYfqM" + }, + { + "name": "Divide Players Into Teams of Equal Skill", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "2491-divide-players-into-teams-of-equal-skill", + "link": "divide-players-into-teams-of-equal-skill/", + "video": "cueOpK5QMEA", + "neetcode250": true + }, + { + "name": "Boats to Save People", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0881-boats-to-save-people", + "link": "boats-to-save-people/", + "video": "XbaxWuHIWUs", + "neetcode250": true + }, + { + "name": "K-th Symbol in Grammar", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0779-k-th-symbol-in-grammar", + "link": "k-th-symbol-in-grammar/", + "video": "pmD2HCKaqRQ", + "neetcode250": true + }, + { + "name": "Minimum Time To Make Rope Colorful", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "1578-minimum-time-to-make-rope-colorful", + "link": "minimum-time-to-make-rope-colorful/", + "video": "9_9jwd2DHMU" + }, + { + "name": "Rearrange Array Elements by Sign", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "2149-rearrange-array-elements-by-sign", + "link": "rearrange-array-elements-by-sign/", + "video": "SoPmcGzz9-E" + }, + { + "name": "Bag of Tokens", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0948-bag-of-tokens", + "link": "bag-of-tokens/", + "video": "prI82maTivg" + }, + { + "name": "Minimum Length of String after Deleting Similar Ends", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "1750-minimum-length-of-string-after-deleting-similar-ends", + "link": "minimum-length-of-string-after-deleting-similar-ends/", + "video": "318hrWVr_5U" + }, + { + "name": "Sentence Similarity III", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "1813-sentence-similarity-iii", + "link": "sentence-similarity-iii/", + "video": "tkLM-ClhwWM" + }, + { + "name": "Meeting Scheduler", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "1229-meeting-scheduler", + "link": "meeting-scheduler/" + }, + { + "name": "Product of Two Run Length Encoded Arrays", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "1868-product-of-two-run-length-encoded-arrays", + "link": "product-of-two-run-length-encoded-arrays/" + }, + { + "name": "Sort Transformed Array", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0360-sort-transformed-array", + "link": "sort-transformed-array/" + }, + { + "name": "3Sum Smaller", + "pattern": "Two Pointers", + "difficulty": "Medium", + "code": "0259-3sum-smaller", + "link": "3sum-smaller/", + "neetcode150": true + }, + { + "name": "Trapping Rain Water", + "pattern": "Two Pointers", + "difficulty": "Hard", + "code": "0042-trapping-rain-water", + "link": "trapping-rain-water/", + "video": "ZI2z5pq0TqA", + "neetcode150": true, + "neetcode250": true + } + ], + "Sliding Window": [ + { + "name": "Contains Duplicate II", + "pattern": "Sliding Window", + "difficulty": "Easy", + "code": "0219-contains-duplicate-ii", + "link": "contains-duplicate-ii/", + "video": "ypn0aZ0nrL4", + "neetcode250": true + }, + { + "name": "Best Time to Buy And Sell Stock", + "pattern": "Sliding Window", + "difficulty": "Easy", + "code": "0121-best-time-to-buy-and-sell-stock", + "link": "best-time-to-buy-and-sell-stock/", + "video": "1pkOgXD63yU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Minimum Recolors to Get K Consecutive Black Blocks", + "pattern": "Sliding Window", + "difficulty": "Easy", + "code": "2379-minimum-recolors-to-get-k-consecutive-black-blocks", + "link": "minimum-recolors-to-get-k-consecutive-black-blocks/", + "video": "cWz4_zUegxE", + "neetcode250": true + }, + { + "name": "Minimum Difference Between Highest And Lowest of K Scores", + "pattern": "Sliding Window", + "difficulty": "Easy", + "code": "1984-minimum-difference-between-highest-and-lowest-of-k-scores", + "link": "minimum-difference-between-highest-and-lowest-of-k-scores/", + "video": "JU5XdBZZtlk" + }, + { + "name": "Number of Sub Arrays of Size K and Avg Greater than or Equal to Threshold", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold", + "link": "number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold/", + "video": "D8B4tKxMTnY" + }, + { + "name": "Grumpy Bookstore Owner", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1052-grumpy-bookstore-owner", + "link": "grumpy-bookstore-owner/", + "video": "pXFbNuEIn8Q" + }, + { + "name": "Max Consecutive Ones II", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0487-max-consecutive-ones-ii", + "link": "max-consecutive-ones-ii/" + }, + { + "name": "Longest Substring with At Most Two Distinct Characters", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0159-longest-substring-with-at-most-two-distinct-characters", + "link": "longest-substring-with-at-most-two-distinct-characters/" + }, + { + "name": "Longest Substring with At Most K Distinct Characters", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0340-longest-substring-with-at-most-k-distinct-characters", + "link": "longest-substring-with-at-most-k-distinct-characters/" + }, + { + "name": "Find K-Length Substrings With No Repeated Characters", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1100-find-k-length-substrings-with-no-repeated-characters", + "link": "find-k-length-substrings-with-no-repeated-characters/" + }, + { + "name": "Alternating Groups II", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "3208-alternating-groups-ii", + "link": "alternating-groups-ii/", + "video": "Zexx16dNPX8" + }, + { + "name": "Longest Substring Without Repeating Characters", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0003-longest-substring-without-repeating-characters", + "link": "longest-substring-without-repeating-characters/", + "video": "wiGpQwVHdE0", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Longest Repeating Character Replacement", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0424-longest-repeating-character-replacement", + "link": "longest-repeating-character-replacement/", + "video": "gqXU1UyA8pk", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Permutation In String", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0567-permutation-in-string", + "link": "permutation-in-string/", + "video": "UbyhOgBN834", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Frequency of The Most Frequent Element", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1838-frequency-of-the-most-frequent-element", + "link": "frequency-of-the-most-frequent-element/", + "video": "vgBrQ0NM5vE", + "neetcode250": true + }, + { + "name": "Fruit into Basket", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0904-fruit-into-baskets", + "link": "fruit-into-baskets/", + "video": "yYtaV0G3mWQ" + }, + { + "name": "Maximum Number of Vowels in a Substring of Given Length", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1456-maximum-number-of-vowels-in-a-substring-of-given-length", + "link": "maximum-number-of-vowels-in-a-substring-of-given-length/", + "video": "kEfPSzgL-Ss" + }, + { + "name": "Minimum Number of Flips to Make The Binary String Alternating", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1888-minimum-number-of-flips-to-make-the-binary-string-alternating", + "link": "minimum-number-of-flips-to-make-the-binary-string-alternating/", + "video": "MOeuK6gaC2A" + }, + { + "name": "Defuse the Bomb", + "pattern": "Sliding Window", + "difficulty": "Easy", + "code": "1652-defuse-the-bomb", + "link": "defuse-the-bomb/", + "video": "c4oOIi5YTE4", + "neetcode250": true + }, + { + "name": "Minimum Size Subarray Sum", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0209-minimum-size-subarray-sum", + "link": "minimum-size-subarray-sum/", + "video": "aYqYMIqZx5s", + "neetcode250": true + }, + { + "name": "Find K Closest Elements", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0658-find-k-closest-elements", + "link": "find-k-closest-elements/", + "video": "o-YDQzHoaKM", + "neetcode250": true + }, + { + "name": "Minimum Operations to Reduce X to Zero", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1658-minimum-operations-to-reduce-x-to-zero", + "link": "minimum-operations-to-reduce-x-to-zero/", + "video": "xumn16n7njs", + "neetcode250": true + }, + { + "name": "Get Equal Substrings Within Budget", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1208-get-equal-substrings-within-budget", + "link": "get-equal-substrings-within-budget/", + "video": "3lsT1Le526U" + }, + { + "name": "Number of Substrings Containing All Three Characters", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1358-number-of-substrings-containing-all-three-characters", + "link": "number-of-substrings-containing-all-three-characters/", + "video": "iSf7d2ldp70" + }, + { + "name": "Binary Subarrays with Sum", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0930-binary-subarrays-with-sum", + "link": "binary-subarrays-with-sum/", + "video": "j4JDr4-jvo4" + }, + { + "name": "Count Number of Nice Subarrays", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1248-count-number-of-nice-subarrays", + "link": "count-number-of-nice-subarrays/", + "video": "4zNK0rhFfcA" + }, + { + "name": "Subarray Product Less Than K", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "0713-subarray-product-less-than-k", + "link": "subarray-product-less-than-k/", + "video": "Cg6_nF7YIks" + }, + { + "name": "Max Consecutive Ones III", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1004-max-consecutive-ones-iii", + "link": "max-consecutive-ones-iii/" + }, + { + "name": "Find the Power of K-Size Subarrays I", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "3254-find-the-power-of-k-size-subarrays-i", + "link": "find-the-power-of-k-size-subarrays-i/", + "video": "67QUp_zOIFg" + }, + { + "name": "Maximum Sum of Distinct Subarrays With Length K", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "2461-maximum-sum-of-distinct-subarrays-with-length-k", + "link": "maximum-sum-of-distinct-subarrays-with-length-k/", + "video": "pT-lOE1on3M" + }, + { + "name": "Length of Longest Subarray With at Most K Frequency", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "2958-length-of-longest-subarray-with-at-most-k-frequency", + "link": "length-of-longest-subarray-with-at-most-k-frequency/", + "video": "W_KYZGp2QzU" + }, + { + "name": "Count Subarrays Where Max Element Appears at Least K Times", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "2962-count-subarrays-where-max-element-appears-at-least-k-times", + "link": "count-subarrays-where-max-element-appears-at-least-k-times/", + "video": "CZ-z1ViskzE" + }, + { + "name": "Maximum Beauty of an Array After Applying Operation", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "2779-maximum-beauty-of-an-array-after-applying-operation", + "link": "maximum-beauty-of-an-array-after-applying-operation/", + "video": "x29QnzSBFVI" + }, + { + "name": "Take K of Each Character From Left and Right", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "2516-take-k-of-each-character-from-left-and-right", + "link": "take-k-of-each-character-from-left-and-right/", + "video": "QzcxeJZByNM" + }, + { + "name": "Count of Substrings Containing Every Vowel and K Consonants II", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "3306-count-of-substrings-containing-every-vowel-and-k-consonants-ii", + "link": "count-of-substrings-containing-every-vowel-and-k-consonants-ii/", + "video": "2wANakxRZNo", + "neetcode150": true, + "blind75": true + }, + { + "name": "Minimum Window Substring", + "pattern": "Sliding Window", + "difficulty": "Hard", + "code": "0076-minimum-window-substring", + "link": "minimum-window-substring/", + "video": "jSto0O4AJbM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Sliding Window Maximum", + "pattern": "Sliding Window", + "difficulty": "Hard", + "code": "0239-sliding-window-maximum", + "link": "sliding-window-maximum/", + "video": "DfljaUwZsOk", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Subarrays with K Different Integers", + "pattern": "Sliding Window", + "difficulty": "Hard", + "code": "0992-subarrays-with-k-different-integers", + "link": "subarrays-with-k-different-integers/", + "video": "etI6HqWVa8U", + "neetcode250": true + }, + { + "name": "Minimum Number of Operations to Make Array Continuous", + "pattern": "Sliding Window", + "difficulty": "Hard", + "code": "2009-minimum-number-of-operations-to-make-array-continuous", + "link": "minimum-number-of-operations-to-make-array-continuous/", + "video": "Dd-yJylrcOY" + }, + { + "name": "Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit", + "pattern": "Sliding Window", + "difficulty": "Medium", + "code": "1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit", + "link": "longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit/", + "video": "V-ecDfY5xEw" + }, + { + "name": "Smallest Range Covering Elements from K Lists", + "pattern": "Sliding Window", + "difficulty": "Hard", + "code": "0632-smallest-range-covering-elements-from-k-lists", + "link": "smallest-range-covering-elements-from-k-lists/", + "video": "L_0aPFMgGpU" + } + ], + "Stack": [ + { + "name": "Crawler Log Folder", + "pattern": "Stack", + "difficulty": "Easy", + "code": "1598-crawler-log-folder", + "link": "crawler-log-folder/", + "video": "Ur3saIXP7ro", + "neetcode250": true + }, + { + "name": "Baseball Game", + "pattern": "Stack", + "difficulty": "Easy", + "code": "0682-baseball-game", + "link": "baseball-game/", + "video": "Id_tqGdsZQI", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Valid Parentheses", + "pattern": "Stack", + "difficulty": "Easy", + "code": "0020-valid-parentheses", + "link": "valid-parentheses/", + "video": "WTzjTskDFMg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Implement Stack Using Queues", + "pattern": "Stack", + "difficulty": "Easy", + "code": "0225-implement-stack-using-queues", + "link": "implement-stack-using-queues/", + "video": "rW4vm0-DLYc", + "neetcode250": true + }, + { + "name": "Implement Queue using Stacks", + "pattern": "Stack", + "difficulty": "Easy", + "code": "0232-implement-queue-using-stacks", + "link": "implement-queue-using-stacks/", + "video": "eanwa3ht3YQ", + "neetcode250": true + }, + { + "name": "Final Prices With a Special Discount in a Shop", + "pattern": "Stack", + "difficulty": "Easy", + "code": "1475-final-prices-with-a-special-discount-in-a-shop", + "link": "final-prices-with-a-special-discount-in-a-shop/", + "video": "BYushAxaQOg" + }, + { + "name": "Make The String Great", + "pattern": "Stack", + "difficulty": "Easy", + "code": "1544-make-the-string-great", + "link": "make-the-string-great/", + "video": "10tBWNjzvtw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Min Stack", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0155-min-stack", + "link": "min-stack/", + "video": "qkLl7nAwDPo", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Evaluate Reverse Polish Notation", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0150-evaluate-reverse-polish-notation", + "link": "evaluate-reverse-polish-notation/", + "video": "iu0082c4HDE", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Removing Stars From a String", + "pattern": "Stack", + "difficulty": "Medium", + "code": "2390-removing-stars-from-a-string", + "link": "removing-stars-from-a-string/", + "video": "pRyFZIaKegA" + }, + { + "name": "Validate Stack Sequences", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0946-validate-stack-sequences", + "link": "validate-stack-sequences/", + "video": "mzua0r94kb8", + "neetcode250": true + }, + { + "name": "Asteroid Collision", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0735-asteroid-collision", + "link": "asteroid-collision/", + "video": "LN7KjRszjk4", + "neetcode250": true + }, + { + "name": "Daily Temperatures", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0739-daily-temperatures", + "link": "daily-temperatures/", + "video": "cTBiBSnjO3c", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Online Stock Span", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0901-online-stock-span", + "link": "online-stock-span/", + "video": "slYh0ZNEqSw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Car Fleet", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0853-car-fleet", + "link": "car-fleet/", + "video": "Pr6T-3yB9RM", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Simplify Path", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0071-simplify-path", + "link": "simplify-path/", + "video": "qYlHrAKJfyA", + "neetcode250": true + }, + { + "name": "Decode String", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0394-decode-string", + "link": "decode-string/", + "video": "qB0zZpBJlh8", + "neetcode250": true + }, + { + "name": "Remove K Digits", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0402-remove-k-digits", + "link": "remove-k-digits/", + "video": "cFabMOnJaq0", + "neetcode250": true + }, + { + "name": "Remove All Adjacent Duplicates In String II", + "pattern": "Stack", + "difficulty": "Medium", + "code": "1209-remove-all-adjacent-duplicates-in-string-ii", + "link": "remove-all-adjacent-duplicates-in-string-ii/", + "video": "w6LcypDgC4w" + }, + { + "name": "Reverse Substrings Between Each Pair of Parentheses", + "pattern": "Stack", + "difficulty": "Medium", + "code": "1190-reverse-substrings-between-each-pair-of-parentheses", + "link": "reverse-substrings-between-each-pair-of-parentheses/", + "video": "n_pCJmg-RyU" + }, + { + "name": "Ternary Expression Parser", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0439-ternary-expression-parser", + "link": "ternary-expression-parser/" + }, + { + "name": "Find Permutation", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0484-find-permutation", + "link": "find-permutation/" + }, + { + "name": "Basic Calculator III", + "pattern": "Stack", + "difficulty": "Hard", + "code": "0772-basic-calculator-iii", + "link": "basic-calculator-iii/" + }, + { + "name": "Max Stack", + "pattern": "Stack", + "difficulty": "Hard", + "code": "0716-max-stack", + "link": "max-stack/" + }, + { + "name": "Minimum String Length After Removing Substrings", + "pattern": "Stack", + "difficulty": "Easy", + "code": "2696-minimum-string-length-after-removing-substrings", + "link": "minimum-string-length-after-removing-substrings/", + "video": "yBdULgU_EvY" + }, + { + "name": "Clear Digits", + "pattern": "Stack", + "difficulty": "Easy", + "code": "3174-clear-digits", + "link": "clear-digits/", + "video": "f_u_9ixrktQ" + }, + { + "name": "Minimum Add to Make Parentheses Valid", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0921-minimum-add-to-make-parentheses-valid", + "link": "minimum-add-to-make-parentheses-valid/", + "video": "UizI7R6ND9Q" + }, + { + "name": "Maximum Width Ramp", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0962-maximum-width-ramp", + "link": "maximum-width-ramp/", + "video": "3pTEJ1vzgSI" + }, + { + "name": "Basic Calculator II", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0227-basic-calculator-ii", + "link": "basic-calculator-ii/" + }, + { + "name": "132 Pattern", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0456-132-pattern", + "link": "132-pattern/", + "video": "q5ANAl8Z458" + }, + { + "name": "Flatten Nested List Iterator", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0341-flatten-nested-list-iterator", + "link": "flatten-nested-list-iterator/", + "video": "4ILiBgLokM8" + }, + { + "name": "Sum of Subarray Minimums", + "pattern": "Stack", + "difficulty": "Medium", + "code": "0907-sum-of-subarray-minimums", + "link": "sum-of-subarray-minimums/", + "video": "aX1F2-DrBkQ", + "neetcode250": true + }, + { + "name": "Maximum Frequency Stack", + "pattern": "Stack", + "difficulty": "Hard", + "code": "0895-maximum-frequency-stack", + "link": "maximum-frequency-stack/", + "video": "Z6idIicFDOE", + "neetcode250": true + }, + { + "name": "Robot Collisions", + "pattern": "Stack", + "difficulty": "Hard", + "code": "2751-robot-collisions", + "link": "robot-collisions/", + "video": "FMV5Pp0tdXY", + "neetcode250": true + }, + { + "name": "Number of Visible People in a Queue", + "pattern": "Stack", + "difficulty": "Hard", + "code": "1944-number-of-visible-people-in-a-queue", + "link": "number-of-visible-people-in-a-queue/" + }, + { + "name": "Largest Rectangle In Histogram", + "pattern": "Stack", + "difficulty": "Hard", + "code": "0084-largest-rectangle-in-histogram", + "link": "largest-rectangle-in-histogram/", + "video": "zx5Sw9130L0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Shortest Subarray with Sum at Least K", + "pattern": "Stack", + "difficulty": "Hard", + "code": "0862-shortest-subarray-with-sum-at-least-k", + "link": "shortest-subarray-with-sum-at-least-k/", + "video": "5AY70aAHZiQ" + }, + { + "name": "Parsing A Boolean Expression", + "pattern": "Stack", + "difficulty": "Hard", + "code": "1106-parsing-a-boolean-expression", + "link": "parsing-a-boolean-expression/", + "video": "q2L6yHIIbs8" + }, + { + "name": "Number of Atoms", + "pattern": "Stack", + "difficulty": "Hard", + "code": "0726-number-of-atoms", + "link": "number-of-atoms/", + "video": "iuK05gGBzJc", + "neetcode150": true, + "neetcode250": true + } + ], + "Binary Search": [ + { + "name": "Binary Search", + "pattern": "Binary Search", + "difficulty": "Easy", + "code": "0704-binary-search", + "link": "binary-search/", + "video": "s4DPM8ct1pI", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Search Insert Position", + "pattern": "Binary Search", + "difficulty": "Easy", + "code": "0035-search-insert-position", + "link": "search-insert-position/", + "video": "K-RYzDZkzCI", + "neetcode250": true + }, + { + "name": "Guess Number Higher Or Lower", + "pattern": "Binary Search", + "difficulty": "Easy", + "code": "0374-guess-number-higher-or-lower", + "link": "guess-number-higher-or-lower/", + "video": "xW4QsTtaCa4", + "neetcode250": true + }, + { + "name": "Arranging Coins", + "pattern": "Binary Search", + "difficulty": "Easy", + "code": "0441-arranging-coins", + "link": "arranging-coins/", + "video": "5rHz_6s2Buw" + }, + { + "name": "Valid Perfect Square", + "pattern": "Binary Search", + "difficulty": "Easy", + "code": "0367-valid-perfect-square", + "link": "valid-perfect-square/", + "video": "Cg_wWPHJ2Sk", + "neetcode250": true + }, + { + "name": "Sqrt(x)", + "pattern": "Binary Search", + "difficulty": "Easy", + "code": "0069-sqrtx", + "link": "sqrtx/", + "video": "zdMhGxRWutQ", + "neetcode250": true + }, + { + "name": "Missing Number In Arithmetic Progression", + "pattern": "Binary Search", + "difficulty": "Easy", + "code": "1228-missing-number-in-arithmetic-progression", + "link": "missing-number-in-arithmetic-progression/", + "neetcode250": true + }, + { + "name": "Check If a Number Is Majority Element in a Sorted Array", + "pattern": "Binary Search", + "difficulty": "Easy", + "code": "1150-check-if-a-number-is-majority-element-in-a-sorted-array", + "link": "check-if-a-number-is-majority-element-in-a-sorted-array/" + }, + { + "name": "Missing Element in Sorted Array", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "1060-missing-element-in-sorted-array", + "link": "missing-element-in-sorted-array/" + }, + { + "name": "Find the Index of the Large Integer", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "1533-find-the-index-of-the-large-integer", + "link": "find-the-index-of-the-large-integer/" + }, + { + "name": "Divide Chocolate", + "pattern": "Binary Search", + "difficulty": "Hard", + "code": "1231-divide-chocolate", + "link": "divide-chocolate/" + }, + { + "name": "Maximum Average Subarray II", + "pattern": "Binary Search", + "difficulty": "Hard", + "code": "0644-maximum-average-subarray-ii", + "link": "maximum-average-subarray-ii/" + }, + { + "name": "Single Element in a Sorted Array", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0540-single-element-in-a-sorted-array", + "link": "single-element-in-a-sorted-array/", + "video": "HGtqdzyUJ3k" + }, + { + "name": "Find Peak Element", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0162-find-peak-element", + "link": "find-peak-element/", + "video": "kMzJy9es7Hc" + }, + { + "name": "Successful Pairs of Spells and Potions", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "2300-successful-pairs-of-spells-and-potions", + "link": "successful-pairs-of-spells-and-potions/", + "video": "OKnm5oyAhWg", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Search a 2D Matrix", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0074-search-a-2d-matrix", + "link": "search-a-2d-matrix/", + "video": "Ber2pi2C0j0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Koko Eating Bananas", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0875-koko-eating-bananas", + "link": "koko-eating-bananas/", + "video": "U2SozAs9RzA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Capacity to Ship Packages Within D Days", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "1011-capacity-to-ship-packages-within-d-days", + "link": "capacity-to-ship-packages-within-d-days/", + "video": "ER_oLmdc-nw", + "neetcode250": true + }, + { + "name": "Maximum Candies Allocated to K Children", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "2226-maximum-candies-allocated-to-k-children", + "link": "maximum-candies-allocated-to-k-children/", + "video": "jpKfrXetb9Q" + }, + { + "name": "House Robber IV", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "2560-house-robber-iv", + "link": "house-robber-iv/", + "video": "OHZqAc6h3Us" + }, + { + "name": "Minimize the Maximum Difference of Pairs", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "2616-minimize-the-maximum-difference-of-pairs", + "link": "minimize-the-maximum-difference-of-pairs/", + "video": "lf1Pxg7IrzQ" + }, + { + "name": "Minimized Maximum of Products Distributed to Any Store", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "2064-minimized-maximum-of-products-distributed-to-any-store", + "link": "minimized-maximum-of-products-distributed-to-any-store/", + "video": "GKSSr2xkR8A" + }, + { + "name": "Minimum Limit of Balls in a Bag", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "1760-minimum-limit-of-balls-in-a-bag", + "link": "minimum-limit-of-balls-in-a-bag/", + "video": "MQlC8EoOdZ0" + }, + { + "name": "Minimum Time to Repair Cars", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "2594-minimum-time-to-repair-cars", + "link": "minimum-time-to-repair-cars/", + "video": "RHct_Pz9EBo" + }, + { + "name": "Find Minimum In Rotated Sorted Array", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0153-find-minimum-in-rotated-sorted-array", + "link": "find-minimum-in-rotated-sorted-array/", + "video": "nIVW4P8b1VA", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Search In Rotated Sorted Array", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0033-search-in-rotated-sorted-array", + "link": "search-in-rotated-sorted-array/", + "video": "U8XENwh8Oy8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Search In Rotated Sorted Array II", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0081-search-in-rotated-sorted-array-ii", + "link": "search-in-rotated-sorted-array-ii/", + "video": "oUnF7o88_Xc", + "neetcode250": true + }, + { + "name": "Time Based Key Value Store", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0981-time-based-key-value-store", + "link": "time-based-key-value-store/", + "video": "fu2cD_6E8Hw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find First And Last Position of Element In Sorted Array", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0034-find-first-and-last-position-of-element-in-sorted-array", + "link": "find-first-and-last-position-of-element-in-sorted-array/", + "video": "4sQL7R5ySUU" + }, + { + "name": "Maximum Number of Removable Characters", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "1898-maximum-number-of-removable-characters", + "link": "maximum-number-of-removable-characters/", + "video": "NMP3nRPyX5g" + }, + { + "name": "Most Beautiful Item for Each Query", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "2070-most-beautiful-item-for-each-query", + "link": "most-beautiful-item-for-each-query/", + "video": "kybir7n8JJg" + }, + { + "name": "Random Pick with Weight", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "0528-random-pick-with-weight", + "link": "random-pick-with-weight/" + }, + { + "name": "Search Suggestions System", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "1268-search-suggestions-system", + "link": "search-suggestions-system/", + "video": "D4T2N0yAr20" + }, + { + "name": "Count the Number of Fair Pairs", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "2563-count-the-number-of-fair-pairs", + "link": "count-the-number-of-fair-pairs/", + "video": "TjthKf7Mc_8" + }, + { + "name": "Binary Searchable Numbers in an Unsorted Array", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "1966-binary-searchable-numbers-in-an-unsorted-array", + "link": "binary-searchable-numbers-in-an-unsorted-array/" + }, + { + "name": "Leftmost Column With at Least a One", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "1428-leftmost-column-with-at-least-a-one", + "link": "leftmost-column-with-at-least-a-one/" + }, + { + "name": "Cutting Ribbons", + "pattern": "Binary Search", + "difficulty": "Medium", + "code": "1891-cutting-ribbons", + "link": "cutting-ribbons/" + }, + { + "name": "Split Array Largest Sum", + "pattern": "Binary Search", + "difficulty": "Hard", + "code": "0410-split-array-largest-sum", + "link": "split-array-largest-sum/", + "video": "YUF3_eBdzsk", + "neetcode250": true + }, + { + "name": "Find K-th Smallest Pair Distance", + "pattern": "Binary Search", + "difficulty": "Hard", + "code": "0719-find-k-th-smallest-pair-distance", + "link": "find-k-th-smallest-pair-distance/", + "video": "bQ-QcFKwsZc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Median of Two Sorted Arrays", + "pattern": "Binary Search", + "difficulty": "Hard", + "code": "0004-median-of-two-sorted-arrays", + "link": "median-of-two-sorted-arrays/", + "video": "q6IEA26hvXc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find in Mountain Array", + "pattern": "Binary Search", + "difficulty": "Hard", + "code": "1095-find-in-mountain-array", + "link": "find-in-mountain-array/", + "video": "BGgYC-YkGvc", + "neetcode250": true + }, + { + "name": "Kth Smallest Product of Two Sorted Arrays", + "pattern": "Binary Search", + "difficulty": "Hard", + "code": "2040-kth-smallest-product-of-two-sorted-arrays", + "link": "kth-smallest-product-of-two-sorted-arrays/", + "neetcode250": true + }, + { + "name": "Minimize Max Distance to Gas Station", + "pattern": "Binary Search", + "difficulty": "Hard", + "code": "0774-minimize-max-distance-to-gas-station", + "link": "minimize-max-distance-to-gas-station/" + } + ], + "Linked List": [ + { + "name": "Reverse Linked List", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0206-reverse-linked-list", + "link": "reverse-linked-list/", + "video": "G0_I-ZF0S38", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Merge Two Sorted Lists", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0021-merge-two-sorted-lists", + "link": "merge-two-sorted-lists/", + "video": "XIdigk956u0", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Linked List Cycle", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0141-linked-list-cycle", + "link": "linked-list-cycle/", + "video": "gBTe7lFR3vc", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Palindrome Linked List", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0234-palindrome-linked-list", + "link": "palindrome-linked-list/", + "video": "yOzXms1J6Nk" + }, + { + "name": "Remove Linked List Elements", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0203-remove-linked-list-elements", + "link": "remove-linked-list-elements/", + "video": "JI71sxtHTng" + }, + { + "name": "Remove Duplicates From Sorted List", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0083-remove-duplicates-from-sorted-list", + "link": "remove-duplicates-from-sorted-list/", + "video": "p10f-VpO4nE" + }, + { + "name": "Middle of the Linked List", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0876-middle-of-the-linked-list", + "link": "middle-of-the-linked-list/", + "video": "A2_ldqM4QcY" + }, + { + "name": "Intersection of Two Linked Lists", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "0160-intersection-of-two-linked-lists", + "link": "intersection-of-two-linked-lists/", + "video": "D0X0BONOQhI" + }, + { + "name": "Delete N Nodes After M Nodes of a Linked List", + "pattern": "Linked List", + "difficulty": "Easy", + "code": "1474-delete-n-nodes-after-m-nodes-of-a-linked-list", + "link": "delete-n-nodes-after-m-nodes-of-a-linked-list/" + }, + { + "name": "Insert into a Sorted Circular Linked List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0708-insert-into-a-sorted-circular-linked-list", + "link": "insert-into-a-sorted-circular-linked-list/" + }, + { + "name": "Plus One Linked List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0369-plus-one-linked-list", + "link": "plus-one-linked-list/" + }, + { + "name": "Print Immutable Linked List in Reverse", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "1265-print-immutable-linked-list-in-reverse", + "link": "print-immutable-linked-list-in-reverse/" + }, + { + "name": "Merge in Between Linked Lists", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "1669-merge-in-between-linked-lists", + "link": "merge-in-between-linked-lists/", + "video": "pI775VutBxg" + }, + { + "name": "Merge Nodes in Between Zeros", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "2181-merge-nodes-in-between-zeros", + "link": "merge-nodes-in-between-zeros/", + "video": "jrSav7fulJY" + }, + { + "name": "Find the Minimum and Maximum Number of Nodes Between Critical Points", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points", + "link": "find-the-minimum-and-maximum-number-of-nodes-between-critical-points/", + "video": "UddDgt52h9g" + }, + { + "name": "Remove Nodes From Linked List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "2487-remove-nodes-from-linked-list", + "link": "remove-nodes-from-linked-list/", + "video": "y783sRTezDg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Reorder List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0143-reorder-list", + "link": "reorder-list/", + "video": "S5bfdUTrKLM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Maximum Twin Sum Of A Linked List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "2130-maximum-twin-sum-of-a-linked-list", + "link": "maximum-twin-sum-of-a-linked-list/", + "video": "doj95MelfSA", + "neetcode250": true + }, + { + "name": "Remove Nth Node From End of List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0019-remove-nth-node-from-end-of-list", + "link": "remove-nth-node-from-end-of-list/", + "video": "XVuQxVej6y8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Delete Nodes From Linked List Present in Array", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "3217-delete-nodes-from-linked-list-present-in-array", + "link": "delete-nodes-from-linked-list-present-in-array/", + "video": "3xZuqYD3EYA" + }, + { + "name": "Swapping Nodes in a Linked List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "1721-swapping-nodes-in-a-linked-list", + "link": "swapping-nodes-in-a-linked-list/", + "video": "4LsrgMyQIjQ", + "neetcode150": true + }, + { + "name": "Copy List With Random Pointer", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0138-copy-list-with-random-pointer", + "link": "copy-list-with-random-pointer/", + "video": "5Y2EiZST97Y", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Design Linked List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0707-design-linked-list", + "link": "design-linked-list/", + "video": "Wf4QhpdVFQo" + }, + { + "name": "Design Browser History", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "1472-design-browser-history", + "link": "design-browser-history/", + "video": "i1G-kKnBu8k", + "neetcode150": true + }, + { + "name": "Add Two Numbers", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0002-add-two-numbers", + "link": "add-two-numbers/", + "video": "wgFPrzTjm7s", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Add Two Numbers II", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0445-add-two-numbers-ii", + "link": "add-two-numbers-ii/", + "neetcode250": true + }, + { + "name": "Find The Duplicate Number", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0287-find-the-duplicate-number", + "link": "find-the-duplicate-number/", + "video": "wjYnzkAhcNk", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Swap Nodes In Pairs", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0024-swap-nodes-in-pairs", + "link": "swap-nodes-in-pairs/", + "video": "o811TZLAWOo", + "neetcode250": true + }, + { + "name": "Sort List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0148-sort-list", + "link": "sort-list/", + "video": "TGveA1oFhrc" + }, + { + "name": "Partition List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0086-partition-list", + "link": "partition-list/", + "video": "KT1iUciJr4g" + }, + { + "name": "Rotate List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0061-rotate-list", + "link": "rotate-list/", + "video": "UcGtPs2LE_c", + "neetcode250": true + }, + { + "name": "Reverse Linked List II", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0092-reverse-linked-list-ii", + "link": "reverse-linked-list-ii/", + "video": "RF_M9tX4Eag", + "neetcode250": true + }, + { + "name": "Design Circular Queue", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0622-design-circular-queue", + "link": "design-circular-queue/", + "video": "aBbsfn863oA", + "neetcode250": true + }, + { + "name": "Insertion Sort List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0147-insertion-sort-list", + "link": "insertion-sort-list/", + "video": "Kk6mXAzqX3Y", + "neetcode250": true + }, + { + "name": "Split Linked List in Parts", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0725-split-linked-list-in-parts", + "link": "split-linked-list-in-parts/", + "video": "-OTlqdrxrVI", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "LRU Cache", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "0146-lru-cache", + "link": "lru-cache/", + "video": "7ABFKPK2hD4", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Remove Duplicates From an Unsorted Linked List", + "pattern": "Linked List", + "difficulty": "Medium", + "code": "1836-remove-duplicates-from-an-unsorted-linked-list", + "link": "remove-duplicates-from-an-unsorted-linked-list/", + "neetcode250": true + }, + { + "name": "LFU Cache", + "pattern": "Linked List", + "difficulty": "Hard", + "code": "0460-lfu-cache", + "link": "lfu-cache/", + "video": "bLEIHn-DgoA", + "neetcode250": true + }, + { + "name": "Merge K Sorted Lists", + "pattern": "Linked List", + "difficulty": "Hard", + "code": "0023-merge-k-sorted-lists", + "link": "merge-k-sorted-lists/", + "video": "q5a5OiGbT6Q", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Reverse Nodes In K Group", + "pattern": "Linked List", + "difficulty": "Hard", + "code": "0025-reverse-nodes-in-k-group", + "link": "reverse-nodes-in-k-group/", + "video": "1UOPsfP85V4", + "neetcode150": true, + "neetcode250": true + } + ], + "Trees": [ + { + "name": "Binary Tree Inorder Traversal", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0094-binary-tree-inorder-traversal", + "link": "binary-tree-inorder-traversal/", + "video": "g_S5WuasWUE", + "neetcode250": true + }, + { + "name": "Binary Tree Preorder Traversal", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0144-binary-tree-preorder-traversal", + "link": "binary-tree-preorder-traversal/", + "video": "afTpieEZXck", + "neetcode250": true + }, + { + "name": "Binary Tree Postorder Traversal", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0145-binary-tree-postorder-traversal", + "link": "binary-tree-postorder-traversal/", + "video": "QhszUQhGGlA", + "neetcode250": true + }, + { + "name": "N-ary Tree Postorder Traversal", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0590-n-ary-tree-postorder-traversal", + "link": "n-ary-tree-postorder-traversal/", + "video": "GMUI91_pDmM", + "neetcode150": true + }, + { + "name": "Invert Binary Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0226-invert-binary-tree", + "link": "invert-binary-tree/", + "video": "OnSn2XEQ4MY", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Maximum Depth of Binary Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0104-maximum-depth-of-binary-tree", + "link": "maximum-depth-of-binary-tree/", + "video": "hTM3phVI6YQ", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Diameter of Binary Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0543-diameter-of-binary-tree", + "link": "diameter-of-binary-tree/", + "video": "K81C31ytOZE", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Balanced Binary Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0110-balanced-binary-tree", + "link": "balanced-binary-tree/", + "video": "QfJsau0ItOY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Same Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0100-same-tree", + "link": "same-tree/", + "video": "vRbbcKXCxOw", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Subtree of Another Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0572-subtree-of-another-tree", + "link": "subtree-of-another-tree/", + "video": "E36O5SWp-LE", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Convert Sorted Array to Binary Search Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0108-convert-sorted-array-to-binary-search-tree", + "link": "convert-sorted-array-to-binary-search-tree/", + "video": "0K0uCMYq5ng" + }, + { + "name": "Merge Two Binary Trees", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0617-merge-two-binary-trees", + "link": "merge-two-binary-trees/", + "video": "QHH6rIK3dDQ" + }, + { + "name": "Path Sum", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0112-path-sum", + "link": "path-sum/", + "video": "LSKQyOz_P8I" + }, + { + "name": "Range Sum of BST", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0938-range-sum-of-bst", + "link": "range-sum-of-bst/", + "video": "uLVG45n4Sbg" + }, + { + "name": "Leaf-Similar Trees", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0872-leaf-similar-trees", + "link": "leaf-similar-trees/", + "video": "Nr8dbnL0_cM" + }, + { + "name": "Evaluate Boolean Binary Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "2331-evaluate-boolean-binary-tree", + "link": "evaluate-boolean-binary-tree/", + "video": "9a_cP54jn8Q" + }, + { + "name": "Closest Binary Search Tree Value", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0270-closest-binary-search-tree-value", + "link": "closest-binary-search-tree-value/" + }, + { + "name": "Binary Tree Vertical Order Traversal", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0314-binary-tree-vertical-order-traversal", + "link": "binary-tree-vertical-order-traversal/", + "video": "-JFngYs21Y8" + }, + { + "name": "Binary Tree Longest Consecutive Sequence", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0298-binary-tree-longest-consecutive-sequence", + "link": "binary-tree-longest-consecutive-sequence/" + }, + { + "name": "Binary Tree Longest Consecutive Sequence II", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0549-binary-tree-longest-consecutive-sequence-ii", + "link": "binary-tree-longest-consecutive-sequence-ii/" + }, + { + "name": "Count Univalue Subtrees", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0250-count-univalue-subtrees", + "link": "count-univalue-subtrees/" + }, + { + "name": "Maximum Average Subtree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1120-maximum-average-subtree", + "link": "maximum-average-subtree/" + }, + { + "name": "Boundary of Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0545-boundary-of-binary-tree", + "link": "boundary-of-binary-tree/" + }, + { + "name": "Find Leaves of Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0366-find-leaves-of-binary-tree", + "link": "find-leaves-of-binary-tree/" + }, + { + "name": "Verify Preorder Sequence in Binary Search Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0255-verify-preorder-sequence-in-binary-search-tree", + "link": "verify-preorder-sequence-in-binary-search-tree/" + }, + { + "name": "Two Sum BSTs", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1214-two-sum-bsts", + "link": "two-sum-bsts/" + }, + { + "name": "Largest BST Subtree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0333-largest-bst-subtree", + "link": "largest-bst-subtree/" + }, + { + "name": "Clone N-ary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1490-clone-n-ary-tree", + "link": "clone-n-ary-tree/" + }, + { + "name": "Find Root of N-Ary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1506-find-root-of-n-ary-tree", + "link": "find-root-of-n-ary-tree/" + }, + { + "name": "Diameter of N-Ary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1522-diameter-of-n-ary-tree", + "link": "diameter-of-n-ary-tree/" + }, + { + "name": "Nested List Weight Sum II", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0364-nested-list-weight-sum-ii", + "link": "nested-list-weight-sum-ii/" + }, + { + "name": "Closest Binary Search Tree Value II", + "pattern": "Trees", + "difficulty": "Hard", + "code": "0272-closest-binary-search-tree-value-ii", + "link": "closest-binary-search-tree-value-ii/" + }, + { + "name": "Serialize and Deserialize N-ary Tree", + "pattern": "Trees", + "difficulty": "Hard", + "code": "0428-serialize-and-deserialize-n-ary-tree", + "link": "serialize-and-deserialize-n-ary-tree/" + }, + { + "name": "Encode N-ary Tree to Binary Tree", + "pattern": "Trees", + "difficulty": "Hard", + "code": "0431-encode-n-ary-tree-to-binary-tree", + "link": "encode-n-ary-tree-to-binary-tree/" + }, + { + "name": "Create Binary Tree From Descriptions", + "pattern": "Trees", + "difficulty": "Medium", + "code": "2196-create-binary-tree-from-descriptions", + "link": "create-binary-tree-from-descriptions/", + "video": "yWkrFfqO7NA" + }, + { + "name": "Populating Next Right Pointers In Each Node", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0116-populating-next-right-pointers-in-each-node", + "link": "populating-next-right-pointers-in-each-node/", + "video": "U4hFQCa1Cq0" + }, + { + "name": "Construct String From Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0606-construct-string-from-binary-tree", + "link": "construct-string-from-binary-tree/", + "video": "b1WpYxnuebQ" + }, + { + "name": "Lowest Common Ancestor of a Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0236-lowest-common-ancestor-of-a-binary-tree", + "link": "lowest-common-ancestor-of-a-binary-tree/" + }, + { + "name": "Lowest Common Ancestor of a Binary Tree III", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1650-lowest-common-ancestor-of-a-binary-tree-iii", + "link": "lowest-common-ancestor-of-a-binary-tree-iii/" + }, + { + "name": "Lowest Common Ancestor of a Binary Search Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0235-lowest-common-ancestor-of-a-binary-search-tree", + "link": "lowest-common-ancestor-of-a-binary-search-tree/", + "video": "gs2LMfuOR9k", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Insert into a Binary Search Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0701-insert-into-a-binary-search-tree", + "link": "insert-into-a-binary-search-tree/", + "video": "Cpg8f79luEA", + "neetcode250": true + }, + { + "name": "Delete Node in a BST", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0450-delete-node-in-a-bst", + "link": "delete-node-in-a-bst/", + "video": "LFzAoJJt92M", + "neetcode250": true + }, + { + "name": "Binary Tree Level Order Traversal", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0102-binary-tree-level-order-traversal", + "link": "binary-tree-level-order-traversal/", + "video": "6ZnyEApgFYg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Binary Tree Right Side View", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0199-binary-tree-right-side-view", + "link": "binary-tree-right-side-view/", + "video": "d4zLyf32e3I", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Reverse Odd Levels of Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "2415-reverse-odd-levels-of-binary-tree", + "link": "reverse-odd-levels-of-binary-tree/", + "video": "3x3JoCb8-tU" + }, + { + "name": "Minimum Number of Operations to Sort a Binary Tree by Level", + "pattern": "Trees", + "difficulty": "Medium", + "code": "2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level", + "link": "minimum-number-of-operations-to-sort-a-binary-tree-by-level/", + "video": "6mONZ_54rZg" + }, + { + "name": "Kth Largest Sum in a Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "2583-kth-largest-sum-in-a-binary-tree", + "link": "kth-largest-sum-in-a-binary-tree/", + "video": "Sh-IqBIg9dU" + }, + { + "name": "Cousins in Binary Tree II", + "pattern": "Trees", + "difficulty": "Medium", + "code": "2641-cousins-in-binary-tree-ii", + "link": "cousins-in-binary-tree-ii/", + "video": "xvwTd19SncE" + }, + { + "name": "Minimum Distance between BST Nodes", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0783-minimum-distance-between-bst-nodes", + "link": "minimum-distance-between-bst-nodes/", + "video": "joxx4hTYwcw" + }, + { + "name": "Symmetric Tree", + "pattern": "Trees", + "difficulty": "Easy", + "code": "0101-symmetric-tree", + "link": "symmetric-tree/", + "video": "Mao9uzxwvmc" + }, + { + "name": "Linked List in Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1367-linked-list-in-binary-tree", + "link": "linked-list-in-binary-tree/", + "video": "OaA9MgG00AE" + }, + { + "name": "Minimum Time to Collect All Apples in a Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1443-minimum-time-to-collect-all-apples-in-a-tree", + "link": "minimum-time-to-collect-all-apples-in-a-tree/", + "video": "Xdt5Z583auM" + }, + { + "name": "Binary Tree Zigzag Level Order Traversal", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0103-binary-tree-zigzag-level-order-traversal", + "link": "binary-tree-zigzag-level-order-traversal/", + "video": "igbboQbiwqw" + }, + { + "name": "Construct Quad Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0427-construct-quad-tree", + "link": "construct-quad-tree/", + "video": "UQ-1sBMV0v4", + "neetcode250": true + }, + { + "name": "Find Duplicate Subtrees", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0652-find-duplicate-subtrees", + "link": "find-duplicate-subtrees/", + "video": "kn0Z5_qPPzY", + "neetcode250": true + }, + { + "name": "Check Completeness of a Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0958-check-completeness-of-a-binary-tree", + "link": "check-completeness-of-a-binary-tree/", + "video": "olbiZ-EOSig" + }, + { + "name": "Construct Binary Tree from Inorder and Postorder Traversal", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0106-construct-binary-tree-from-inorder-and-postorder-traversal", + "link": "construct-binary-tree-from-inorder-and-postorder-traversal/", + "video": "vm63HuIU7kw" + }, + { + "name": "Maximum Width of Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0662-maximum-width-of-binary-tree", + "link": "maximum-width-of-binary-tree/", + "video": "FPzLE2L7uHs" + }, + { + "name": "Time Needed to Inform All Employees", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1376-time-needed-to-inform-all-employees", + "link": "time-needed-to-inform-all-employees/", + "video": "zdBYi0p4L5Q", + "neetcode150": true + }, + { + "name": "Count Good Nodes In Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1448-count-good-nodes-in-binary-tree", + "link": "count-good-nodes-in-binary-tree/", + "video": "7cp5imvDzl4", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Validate Binary Search Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0098-validate-binary-search-tree", + "link": "validate-binary-search-tree/", + "video": "s6ATEkipzow", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Kth Smallest Element In a Bst", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0230-kth-smallest-element-in-a-bst", + "link": "kth-smallest-element-in-a-bst/", + "video": "5LUXSvjmGCw", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Recover Binary Search Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0099-recover-binary-search-tree", + "link": "recover-binary-search-tree/" + }, + { + "name": "Construct Binary Tree From Preorder And Inorder Traversal", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0105-construct-binary-tree-from-preorder-and-inorder-traversal", + "link": "construct-binary-tree-from-preorder-and-inorder-traversal/", + "video": "ihj4IQGZ2zc", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Construct Binary Tree from Preorder and Postorder Traversal", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0889-construct-binary-tree-from-preorder-and-postorder-traversal", + "link": "construct-binary-tree-from-preorder-and-postorder-traversal/", + "video": "H1nBu3L-2gQ" + }, + { + "name": "Unique Binary Search Trees", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0096-unique-binary-search-trees", + "link": "unique-binary-search-trees/", + "video": "Ox0TenN3Zpg" + }, + { + "name": "Unique Binary Search Trees II", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0095-unique-binary-search-trees-ii", + "link": "unique-binary-search-trees-ii/", + "video": "m907FlQa2Yc" + }, + { + "name": "Number of Good Leaf Nodes Pairs", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1530-number-of-good-leaf-nodes-pairs", + "link": "number-of-good-leaf-nodes-pairs/", + "video": "f_epkBeS1LQ" + }, + { + "name": "Sum Root to Leaf Numbers", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0129-sum-root-to-leaf-numbers", + "link": "sum-root-to-leaf-numbers/", + "video": "Jk16lZGFWxE", + "neetcode250": true + }, + { + "name": "House Robber III", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0337-house-robber-iii", + "link": "house-robber-iii/", + "video": "nHR8ytpzz7c", + "neetcode250": true + }, + { + "name": "Flip Equivalent Binary Trees", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0951-flip-equivalent-binary-trees", + "link": "flip-equivalent-binary-trees/", + "video": "izRDc1il9Pk", + "neetcode250": true + }, + { + "name": "Operations On Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1993-operations-on-tree", + "link": "operations-on-tree/", + "video": "qK4PtjrVD0U" + }, + { + "name": "All Possible Full Binary Trees", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0894-all-possible-full-binary-trees", + "link": "all-possible-full-binary-trees/", + "video": "nZtrZPTTCAo" + }, + { + "name": "Find Bottom Left Tree Value", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0513-find-bottom-left-tree-value", + "link": "find-bottom-left-tree-value/", + "video": "u_by_cTsNJA" + }, + { + "name": "Trim a Binary Search Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0669-trim-a-binary-search-tree", + "link": "trim-a-binary-search-tree/", + "video": "jwt5mTjEXGc" + }, + { + "name": "Binary Search Tree Iterator", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0173-binary-search-tree-iterator", + "link": "binary-search-tree-iterator/", + "video": "RXy5RzGF5wo" + }, + { + "name": "Validate Binary Tree Nodes", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1361-validate-binary-tree-nodes", + "link": "validate-binary-tree-nodes/", + "video": "Mw67DTgUEqk" + }, + { + "name": "Find Largest Value in Tree Row", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0515-find-largest-value-in-each-tree-row", + "link": "find-largest-value-in-each-tree-row/", + "video": "wB9JOh7Z_cY" + }, + { + "name": "Pseudo-Palindromic Paths in a Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1457-pseudo-palindromic-paths-in-a-binary-tree", + "link": "pseudo-palindromic-paths-in-a-binary-tree/", + "video": "MBsSpQnaFzg" + }, + { + "name": "Even Odd Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1609-even-odd-tree", + "link": "even-odd-tree/", + "video": "FkNWN1Fj_TY" + }, + { + "name": "Smallest String Starting From Leaf", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0988-smallest-string-starting-from-leaf", + "link": "smallest-string-starting-from-leaf/", + "video": "UvdWfxQ_ZDs" + }, + { + "name": "Delete Leaves With a Given Value", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1325-delete-leaves-with-a-given-value", + "link": "delete-leaves-with-a-given-value/", + "video": "FqAoYAwbwV8", + "neetcode250": true + }, + { + "name": "Delete Nodes And Return Forest", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1110-delete-nodes-and-return-forest", + "link": "delete-nodes-and-return-forest/", + "video": "UhKu0q1yXHY" + }, + { + "name": "Distribute Coins in Binary Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0979-distribute-coins-in-binary-tree", + "link": "distribute-coins-in-binary-tree/", + "video": "YfdfIOeV_RU" + }, + { + "name": "Convert Bst to Greater Tree", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0538-convert-bst-to-greater-tree", + "link": "convert-bst-to-greater-tree/", + "video": "7vVEJwVvAlI" + }, + { + "name": "Step-By-Step Directions From a Binary Tree Node to Another", + "pattern": "Trees", + "difficulty": "Medium", + "code": "2096-step-by-step-directions-from-a-binary-tree-node-to-another", + "link": "step-by-step-directions-from-a-binary-tree-node-to-another/", + "video": "JegJNGcwtFg" + }, + { + "name": "Inorder Successor in BST II", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0510-inorder-successor-in-bst-ii", + "link": "inorder-successor-in-bst-ii/" + }, + { + "name": "Tree Diameter", + "pattern": "Trees", + "difficulty": "Medium", + "code": "1245-tree-diameter", + "link": "tree-diameter/" + }, + { + "name": "Convert Binary Search Tree to Sorted Doubly Linked List", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0426-convert-binary-search-tree-to-sorted-doubly-linked-list", + "link": "convert-binary-search-tree-to-sorted-doubly-linked-list/" + }, + { + "name": "Binary Tree Upside Down", + "pattern": "Trees", + "difficulty": "Medium", + "code": "0156-binary-tree-upside-down", + "link": "binary-tree-upside-down/" + }, + { + "name": "Recover a Tree From Preorder Traversal", + "pattern": "Trees", + "difficulty": "Hard", + "code": "1028-recover-a-tree-from-preorder-traversal", + "link": "recover-a-tree-from-preorder-traversal/", + "video": "VroH6J47kIE", + "neetcode150": true, + "blind75": true + }, + { + "name": "Binary Tree Maximum Path Sum", + "pattern": "Trees", + "difficulty": "Hard", + "code": "0124-binary-tree-maximum-path-sum", + "link": "binary-tree-maximum-path-sum/", + "video": "Hr5cWUld4vU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Serialize And Deserialize Binary Tree", + "pattern": "Trees", + "difficulty": "Hard", + "code": "0297-serialize-and-deserialize-binary-tree", + "link": "serialize-and-deserialize-binary-tree/", + "video": "u4JAi2JJhI8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + } + ], + "Heap / Priority Queue": [ + { + "name": "Kth Largest Element In a Stream", + "pattern": "Heap / Priority Queue", + "difficulty": "Easy", + "code": "0703-kth-largest-element-in-a-stream", + "link": "kth-largest-element-in-a-stream/", + "video": "hOjcdrqMoQ8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Last Stone Weight", + "pattern": "Heap / Priority Queue", + "difficulty": "Easy", + "code": "1046-last-stone-weight", + "link": "last-stone-weight/", + "video": "B-QCq79-Vfw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Take Gifts From the Richest Pile", + "pattern": "Heap / Priority Queue", + "difficulty": "Easy", + "code": "2558-take-gifts-from-the-richest-pile", + "link": "take-gifts-from-the-richest-pile/", + "video": "bHEQ4D_XcyY", + "neetcode250": true + }, + { + "name": "Final Array State After K Multiplication Operations I", + "pattern": "Heap / Priority Queue", + "difficulty": "Easy", + "code": "3264-final-array-state-after-k-multiplication-operations-i", + "link": "final-array-state-after-k-multiplication-operations-i/", + "video": "AaoytRXBXGs" + }, + { + "name": "High Five", + "pattern": "Heap / Priority Queue", + "difficulty": "Easy", + "code": "1086-high-five", + "link": "high-five/" + }, + { + "name": "Minimum Cost to Connect Sticks", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1167-minimum-cost-to-connect-sticks", + "link": "minimum-cost-to-connect-sticks/" + }, + { + "name": "Campus Bikes", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1057-campus-bikes", + "link": "campus-bikes/" + }, + { + "name": "Rearrange String k Distance Apart", + "pattern": "Heap / Priority Queue", + "difficulty": "Hard", + "code": "0358-rearrange-string-k-distance-apart", + "link": "rearrange-string-k-distance-apart/" + }, + { + "name": "K Closest Points to Origin", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "0973-k-closest-points-to-origin", + "link": "k-closest-points-to-origin/", + "video": "rI2EBUEMfTk", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Kth Largest Element In An Array", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "0215-kth-largest-element-in-an-array", + "link": "kth-largest-element-in-an-array/", + "video": "XEmy13g1Qxc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Task Scheduler", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "0621-task-scheduler", + "link": "task-scheduler/", + "video": "s8p8ukTyA2I", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Design Twitter", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "0355-design-twitter", + "link": "design-twitter/", + "video": "pNichitDD2E", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Least Number of Unique Integers after K Removal", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1481-least-number-of-unique-integers-after-k-removals", + "link": "least-number-of-unique-integers-after-k-removals/", + "video": "Nsp_ta7SlEk", + "neetcode250": true + }, + { + "name": "Furthest Building You Can Reach", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1642-furthest-building-you-can-reach", + "link": "furthest-building-you-can-reach/", + "video": "zyTeznvXCtg" + }, + { + "name": "Minimize Deviation in Array", + "pattern": "Heap / Priority Queue", + "difficulty": "Hard", + "code": "1675-minimize-deviation-in-array", + "link": "minimize-deviation-in-array/", + "video": "boHNFptxo2A" + }, + { + "name": "Maximum Subsequence Score", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "2542-maximum-subsequence-score", + "link": "maximum-subsequence-score/", + "video": "ax1DKi5lJwk", + "neetcode250": true + }, + { + "name": "Single Threaded CPU", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1834-single-threaded-cpu", + "link": "single-threaded-cpu/", + "video": "RR1n-d4oYqE", + "neetcode250": true + }, + { + "name": "Seat Reservation Manager", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1845-seat-reservation-manager", + "link": "seat-reservation-manager/", + "video": "ahobllKXEEY", + "neetcode250": true + }, + { + "name": "Process Tasks Using Servers", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1882-process-tasks-using-servers", + "link": "process-tasks-using-servers/", + "video": "XKA22PecuMQ" + }, + { + "name": "Find The Kth Largest Integer In The Array", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1985-find-the-kth-largest-integer-in-the-array", + "link": "find-the-kth-largest-integer-in-the-array/", + "video": "lRCaNiqO3xI", + "neetcode250": true + }, + { + "name": "Reorganize String", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "0767-reorganize-string", + "link": "reorganize-string/", + "video": "2g_b1aYTHeg", + "neetcode250": true + }, + { + "name": "Longest Happy String", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1405-longest-happy-string", + "link": "longest-happy-string/", + "video": "8u-H6O_XQKE", + "neetcode250": true + }, + { + "name": "Car Pooling", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1094-car-pooling", + "link": "car-pooling/", + "video": "08sn_w4LWEE", + "neetcode250": true + }, + { + "name": "Range Sum of Sorted Subarray Sums", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1508-range-sum-of-sorted-subarray-sums", + "link": "range-sum-of-sorted-subarray-sums/", + "video": "7XTGlO6b16A", + "neetcode250": true + }, + { + "name": "Maximum Transactions Without Negative Balance", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "3711-maximum-transactions-without-negative-balance", + "link": "maximum-transactions-without-negative-balance/" + }, + { + "name": "Path With Maximum Minimum Value", + "pattern": "Heap / Priority Queue", + "difficulty": "Medium", + "code": "1102-path-with-maximum-minimum-value", + "link": "path-with-maximum-minimum-value/" + }, + { + "name": "Find Median From Data Stream", + "pattern": "Heap / Priority Queue", + "difficulty": "Hard", + "code": "0295-find-median-from-data-stream", + "link": "find-median-from-data-stream/", + "video": "itmhHWaHupI", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Maximum Performance of a Team", + "pattern": "Heap / Priority Queue", + "difficulty": "Hard", + "code": "1383-maximum-performance-of-a-team", + "link": "maximum-performance-of-a-team/", + "video": "Y7UTvogADH0", + "neetcode250": true + }, + { + "name": "IPO", + "pattern": "Heap / Priority Queue", + "difficulty": "Hard", + "code": "0502-ipo", + "link": "ipo/", + "video": "1IUzNJ6TPEM", + "neetcode250": true + }, + { + "name": "Minimum Cost to Hire K Workers", + "pattern": "Heap / Priority Queue", + "difficulty": "Hard", + "code": "0857-minimum-cost-to-hire-k-workers", + "link": "minimum-cost-to-hire-k-workers/", + "video": "f879mUH6vJk", + "neetcode250": true + }, + { + "name": "Number of Flowers in Full Bloom", + "pattern": "Heap / Priority Queue", + "difficulty": "Hard", + "code": "2251-number-of-flowers-in-full-bloom", + "link": "number-of-flowers-in-full-bloom/", + "video": "zY3Uty9IwvY" + }, + { + "name": "Constrained Subsequence Sum", + "pattern": "Heap / Priority Queue", + "difficulty": "Hard", + "code": "1425-constrained-subsequence-sum", + "link": "constrained-subsequence-sum/", + "video": "-IYZv-nOSys" + }, + { + "name": "Find Building Where Alice and Bob Can Meet", + "pattern": "Heap / Priority Queue", + "difficulty": "Hard", + "code": "2940-find-building-where-alice-and-bob-can-meet", + "link": "find-building-where-alice-and-bob-can-meet/", + "video": "HJaSuUOUH90", + "neetcode250": true + } + ], + "Backtracking": [ + { + "name": "Sum of All Subsets XOR Total", + "pattern": "Backtracking", + "difficulty": "Easy", + "code": "1863-sum-of-all-subset-xor-totals", + "link": "sum-of-all-subset-xor-totals/", + "video": "LI7YR-bwNYY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Subsets", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0078-subsets", + "link": "subsets/", + "video": "REOH22Xwdkk", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Combination Sum", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0039-combination-sum", + "link": "combination-sum/", + "video": "GBKI9VSKdGg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Combination Sum II", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0040-combination-sum-ii", + "link": "combination-sum-ii/", + "video": "FOyRpNUSFeA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Combinations", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0077-combinations", + "link": "combinations/", + "video": "q0s6m7AiM7o", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Permutations", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0046-permutations", + "link": "permutations/", + "video": "FZe0UqISmUw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Subsets II", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0090-subsets-ii", + "link": "subsets-ii/", + "video": "Vn2v6ajA7U0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Permutations II", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0047-permutations-ii", + "link": "permutations-ii/", + "video": "qhBVWf0YafA", + "neetcode250": true + }, + { + "name": "Generate Parentheses", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0022-generate-parentheses", + "link": "generate-parentheses/", + "video": "s9fokUqJ76A", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Letter Tile Possibilities", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "1079-letter-tile-possibilities", + "link": "letter-tile-possibilities/", + "video": "8FrJX-P_DnE", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Word Search", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0079-word-search", + "link": "word-search/", + "video": "pfiQ_PS1g8E", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Palindrome Partitioning", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0131-palindrome-partitioning", + "link": "palindrome-partitioning/", + "video": "3jvWodd7ht0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Restore IP Addresses", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0093-restore-ip-addresses", + "link": "restore-ip-addresses/", + "video": "61tN4YEdiTM", + "neetcode250": true + }, + { + "name": "Letter Combinations of a Phone Number", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0017-letter-combinations-of-a-phone-number", + "link": "letter-combinations-of-a-phone-number/", + "video": "0snEunUacZY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "The k-th Lexicographical String of All Happy Strings of Length n", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n", + "link": "the-k-th-lexicographical-string-of-all-happy-strings-of-length-n/", + "video": "tRwXzsXJArI", + "neetcode250": true + }, + { + "name": "Matchsticks to Square", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0473-matchsticks-to-square", + "link": "matchsticks-to-square/", + "video": "hUe0cUKV-YY", + "neetcode250": true + }, + { + "name": "Splitting a String Into Descending Consecutive Values", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "1849-splitting-a-string-into-descending-consecutive-values", + "link": "splitting-a-string-into-descending-consecutive-values/", + "video": "eDtMmysldaw", + "neetcode250": true + }, + { + "name": "Construct Smallest Number From DI String", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "2375-construct-smallest-number-from-di-string", + "link": "construct-smallest-number-from-di-string/", + "video": "GgN8d22BEf0" + }, + { + "name": "Find Unique Binary String", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "1980-find-unique-binary-string", + "link": "find-unique-binary-string/", + "video": "aHqn4Dynd1k" + }, + { + "name": "Split a String Into the Max Number of Unique Substrings", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "1593-split-a-string-into-the-max-number-of-unique-substrings", + "link": "split-a-string-into-the-max-number-of-unique-substrings/", + "video": "fLjeVALxzjg" + }, + { + "name": "Maximum Length of a Concatenated String With Unique Characters", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "1239-maximum-length-of-a-concatenated-string-with-unique-characters", + "link": "maximum-length-of-a-concatenated-string-with-unique-characters/", + "video": "d4SPuvkaeoo" + }, + { + "name": "Partition to K Equal Sum Subsets", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0698-partition-to-k-equal-sum-subsets", + "link": "partition-to-k-equal-sum-subsets/", + "video": "mBk4I0X46oI", + "neetcode250": true + }, + { + "name": "The Number of Beautiful Subsets", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "2597-the-number-of-beautiful-subsets", + "link": "the-number-of-beautiful-subsets/", + "video": "Dle_SpjHTio" + }, + { + "name": "Different Ways to Add Parentheses", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0241-different-ways-to-add-parentheses", + "link": "different-ways-to-add-parentheses/", + "video": "cykVFFm5D3s" + }, + { + "name": "Construct the Lexicographically Largest Valid Sequence", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "1718-construct-the-lexicographically-largest-valid-sequence", + "link": "construct-the-lexicographically-largest-valid-sequence/", + "video": "rNv0vgNc4Ww" + }, + { + "name": "Count Number of Maximum Bitwise-OR Subsets", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "2044-count-number-of-maximum-bitwise-or-subsets", + "link": "count-number-of-maximum-bitwise-or-subsets/", + "video": "_wBj3IMV7tY" + }, + { + "name": "Strobogrammatic Number II", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0247-strobogrammatic-number-ii", + "link": "strobogrammatic-number-ii/" + }, + { + "name": "Factor Combinations", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0254-factor-combinations", + "link": "factor-combinations/" + }, + { + "name": "Brace Expansion", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "1087-brace-expansion", + "link": "brace-expansion/" + }, + { + "name": "Word Pattern II", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0291-word-pattern-ii", + "link": "word-pattern-ii/" + }, + { + "name": "Android Unlock Patterns", + "pattern": "Backtracking", + "difficulty": "Medium", + "code": "0351-android-unlock-patterns", + "link": "android-unlock-patterns/", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "N Queens", + "pattern": "Backtracking", + "difficulty": "Hard", + "code": "0051-n-queens", + "link": "n-queens/", + "video": "Ph95IHmRp5M", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "N Queens II", + "pattern": "Backtracking", + "difficulty": "Hard", + "code": "0052-n-queens-ii", + "link": "n-queens-ii/", + "video": "nalYyLZgvCY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Maximum Score Words Formed By Letters", + "pattern": "Backtracking", + "difficulty": "Hard", + "code": "1255-maximum-score-words-formed-by-letters", + "link": "maximum-score-words-formed-by-letters/", + "video": "1cV8Hq9IAk4", + "neetcode250": true + }, + { + "name": "Word Break II", + "pattern": "Backtracking", + "difficulty": "Hard", + "code": "0140-word-break-ii", + "link": "word-break-ii/", + "video": "QgLKdluDo08", + "neetcode250": true + }, + { + "name": "Robot Room Cleaner", + "pattern": "Backtracking", + "difficulty": "Hard", + "code": "0489-robot-room-cleaner", + "link": "robot-room-cleaner/", + "neetcode250": true + } + ], + "Tries": [ + { + "name": "Count Prefix and Suffix Pairs I", + "pattern": "Tries", + "difficulty": "Easy", + "code": "3042-count-prefix-and-suffix-pairs-i", + "link": "count-prefix-and-suffix-pairs-i/", + "video": "zQrtsvo8lgM" + }, + { + "name": "Implement Trie Prefix Tree", + "pattern": "Tries", + "difficulty": "Medium", + "code": "0208-implement-trie-prefix-tree", + "link": "implement-trie-prefix-tree/", + "video": "oobqoCJlHA0", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Design Add And Search Words Data Structure", + "pattern": "Tries", + "difficulty": "Medium", + "code": "0211-design-add-and-search-words-data-structure", + "link": "design-add-and-search-words-data-structure/", + "video": "BTf05gs_8iU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Counting Words With a Given Prefix", + "pattern": "Tries", + "difficulty": "Easy", + "code": "2185-counting-words-with-a-given-prefix", + "link": "counting-words-with-a-given-prefix/", + "video": "B26hW8fBMj0" + }, + { + "name": "Remove Sub-Folders from the Filesystem", + "pattern": "Tries", + "difficulty": "Medium", + "code": "1233-remove-sub-folders-from-the-filesystem", + "link": "remove-sub-folders-from-the-filesystem/", + "video": "WDDLp2l9TrM" + }, + { + "name": "Extra Characters in a String", + "pattern": "Tries", + "difficulty": "Medium", + "code": "2707-extra-characters-in-a-string", + "link": "extra-characters-in-a-string/", + "video": "ONstwO1cD7c", + "neetcode250": true + }, + { + "name": "Design File System", + "pattern": "Tries", + "difficulty": "Medium", + "code": "1166-design-file-system", + "link": "design-file-system/", + "neetcode150": true, + "blind75": true + }, + { + "name": "Word Search II", + "pattern": "Tries", + "difficulty": "Hard", + "code": "0212-word-search-ii", + "link": "word-search-ii/", + "video": "asbcE9mZz_U", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Sum of Prefix Scores of Strings", + "pattern": "Tries", + "difficulty": "Hard", + "code": "2416-sum-of-prefix-scores-of-strings", + "link": "sum-of-prefix-scores-of-strings/", + "video": "F-5cmvhLw90", + "neetcode250": true + }, + { + "name": "Count Prefix and Suffix Pairs II", + "pattern": "Tries", + "difficulty": "Hard", + "code": "3045-count-prefix-and-suffix-pairs-ii", + "link": "count-prefix-and-suffix-pairs-ii/", + "video": "zQrtsvo8lgM" + }, + { + "name": "Design In-Memory File System", + "pattern": "Tries", + "difficulty": "Hard", + "code": "0588-design-in-memory-file-system", + "link": "design-in-memory-file-system/" + }, + { + "name": "Design Search Autocomplete System", + "pattern": "Tries", + "difficulty": "Hard", + "code": "0642-design-search-autocomplete-system", + "link": "design-search-autocomplete-system/" + } + ], + "Graphs": [ + { + "name": "Island Perimeter", + "pattern": "Graphs", + "difficulty": "Easy", + "code": "0463-island-perimeter", + "link": "island-perimeter/", + "video": "fISIuAFRM2s", + "neetcode250": true + }, + { + "name": "Verifying An Alien Dictionary", + "pattern": "Graphs", + "difficulty": "Easy", + "code": "0953-verifying-an-alien-dictionary", + "link": "verifying-an-alien-dictionary/", + "video": "OVgPAJIyX6o", + "neetcode250": true + }, + { + "name": "Find the Town Judge", + "pattern": "Graphs", + "difficulty": "Easy", + "code": "0997-find-the-town-judge", + "link": "find-the-town-judge/", + "video": "QiGaxdUINJ8", + "neetcode250": true + }, + { + "name": "Flood Fill", + "pattern": "Graphs", + "difficulty": "Easy", + "code": "0733-flood-fill", + "link": "flood-fill/", + "neetcode250": true + }, + { + "name": "Count Servers that Communicate", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1267-count-servers-that-communicate", + "link": "count-servers-that-communicate/", + "video": "meTbkgqNNYM" + }, + { + "name": "Find Champion II", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2924-find-champion-ii", + "link": "find-champion-ii/", + "video": "HjSmSLPR7S4", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Number of Islands", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0200-number-of-islands", + "link": "number-of-islands/", + "video": "pV2kpPD66nE", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Max Area of Island", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0695-max-area-of-island", + "link": "max-area-of-island/", + "video": "iJGr1OtmH0c", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Maximum Number of Fish in a Grid", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2658-maximum-number-of-fish-in-a-grid", + "link": "maximum-number-of-fish-in-a-grid/", + "video": "JhAz6CkRGHI", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Clone Graph", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0133-clone-graph", + "link": "clone-graph/", + "video": "mQeF6bN8hMk", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Walls And Gates", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0286-walls-and-gates", + "link": "walls-and-gates/", + "video": "e69C6xhiSQE", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Rotting Oranges", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0994-rotting-oranges", + "link": "rotting-oranges/", + "video": "y704fEOx0s0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Count Sub Islands", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1905-count-sub-islands", + "link": "count-sub-islands/", + "video": "mLpW3qfbNJ8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Pacific Atlantic Water Flow", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0417-pacific-atlantic-water-flow", + "link": "pacific-atlantic-water-flow/", + "video": "s-VkcjHqkGI", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Surrounded Regions", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0130-surrounded-regions", + "link": "surrounded-regions/", + "video": "9z2BunfoZ5Y", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Reorder Routes to Make All Paths Lead to The City Zero", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1466-reorder-routes-to-make-all-paths-lead-to-the-city-zero", + "link": "reorder-routes-to-make-all-paths-lead-to-the-city-zero/", + "video": "m17yOR5_PpI", + "neetcode250": true + }, + { + "name": "Snakes And Ladders", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0909-snakes-and-ladders", + "link": "snakes-and-ladders/", + "video": "6lH4nO3JfLk", + "neetcode250": true + }, + { + "name": "Open The Lock", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0752-open-the-lock", + "link": "open-the-lock/", + "video": "Pzg3bCDY87w", + "neetcode250": true + }, + { + "name": "Find Eventual Safe States", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0802-find-eventual-safe-states", + "link": "find-eventual-safe-states/", + "video": "Re_v0j0CRsg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Course Schedule", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0207-course-schedule", + "link": "course-schedule/", + "video": "EgI5nU9etnU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Course Schedule II", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0210-course-schedule-ii", + "link": "course-schedule-ii/", + "video": "Akt3glAwyfY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Graph Valid Tree", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0261-graph-valid-tree", + "link": "graph-valid-tree/", + "video": "bXsUuownnoQ", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Course Schedule IV", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1462-course-schedule-iv", + "link": "course-schedule-iv/", + "video": "cEW05ofxhn0", + "blind75": true, + "neetcode250": true + }, + { + "name": "Check if Move Is Legal", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1958-check-if-move-is-legal", + "link": "check-if-move-is-legal/", + "video": "KxK33AcQZpQ", + "neetcode250": true + }, + { + "name": "Shortest Bridge", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0934-shortest-bridge", + "link": "shortest-bridge/", + "video": "gkINMhbbIbU" + }, + { + "name": "Shortest Path in Binary Matrix", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1091-shortest-path-in-binary-matrix", + "link": "shortest-path-in-binary-matrix/", + "video": "YnxUdAO7TAo" + }, + { + "name": "Number of Connected Components In An Undirected Graph", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0323-number-of-connected-components-in-an-undirected-graph", + "link": "number-of-connected-components-in-an-undirected-graph/", + "video": "8f1XPm4WOUc", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Redundant Connection", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0684-redundant-connection", + "link": "redundant-connection/", + "video": "1lNK80tOTfc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Accounts Merge", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0721-accounts-merge", + "link": "accounts-merge/", + "video": "6st4IxEF-90", + "neetcode250": true + }, + { + "name": "Find Closest Node to Given Two Nodes", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2359-find-closest-node-to-given-two-nodes", + "link": "find-closest-node-to-given-two-nodes/", + "video": "AZA8orksO4w", + "neetcode250": true + }, + { + "name": "As Far from Land as Possible", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1162-as-far-from-land-as-possible", + "link": "as-far-from-land-as-possible/", + "video": "fjxb1hQfrZk" + }, + { + "name": "Shortest Path with Alternating Colors", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1129-shortest-path-with-alternating-colors", + "link": "shortest-path-with-alternating-colors/", + "video": "69rcy6lb-HQ" + }, + { + "name": "Minimum Fuel Cost to Report to the Capital", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2477-minimum-fuel-cost-to-report-to-the-capital", + "link": "minimum-fuel-cost-to-report-to-the-capital/", + "video": "I3lnDUIzIG4" + }, + { + "name": "Minimum Score of a Path Between Two Cities", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2492-minimum-score-of-a-path-between-two-cities", + "link": "minimum-score-of-a-path-between-two-cities/", + "video": "K7-mXA0irhY" + }, + { + "name": "Number of Closed Islands", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1254-number-of-closed-islands", + "link": "number-of-closed-islands/", + "video": "X8k48xek8g8" + }, + { + "name": "Number of Enclaves", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1020-number-of-enclaves", + "link": "number-of-enclaves/", + "video": "gf0zsh1FIgE" + }, + { + "name": "Number of Provinces", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0547-number-of-provinces", + "link": "number-of-provinces/" + }, + { + "name": "Regions Cut By Slashes", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0959-regions-cut-by-slashes", + "link": "regions-cut-by-slashes/", + "video": "j8KrBYIxHK8" + }, + { + "name": "Minimum Number of Vertices to Reach all Nodes", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1557-minimum-number-of-vertices-to-reach-all-nodes", + "link": "minimum-number-of-vertices-to-reach-all-nodes/", + "video": "TLzcum7vrTc" + }, + { + "name": "Is Graph Bipartite?", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0785-is-graph-bipartite", + "link": "is-graph-bipartite/", + "video": "mev55LTubBY" + }, + { + "name": "Count the Number of Complete Components", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2685-count-the-number-of-complete-components", + "link": "count-the-number-of-complete-components/", + "video": "FjLirf3k9ao", + "neetcode250": true + }, + { + "name": "Evaluate Division", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0399-evaluate-division", + "link": "evaluate-division/", + "video": "Uei1fwDoyKk", + "neetcode250": true + }, + { + "name": "Detonate the Maximum Bombs", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2101-detonate-the-maximum-bombs", + "link": "detonate-the-maximum-bombs/", + "video": "8NPbAvVXKR4", + "neetcode250": true + }, + { + "name": "Find All Possible Recipes from Given Supplies", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2115-find-all-possible-recipes-from-given-supplies", + "link": "find-all-possible-recipes-from-given-supplies/", + "video": "AQrsAc3EcyQ" + }, + { + "name": "Shortest Distance After Road Addition Queries I", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "3243-shortest-distance-after-road-addition-queries-i", + "link": "shortest-distance-after-road-addition-queries-i/", + "video": "zCeZOyACpUQ", + "neetcode250": true + }, + { + "name": "Minimum Height Trees", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0310-minimum-height-trees", + "link": "minimum-height-trees/", + "video": "wQGQnyv_9hI", + "neetcode250": true + }, + { + "name": "Path with Maximum Gold", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1219-path-with-maximum-gold", + "link": "path-with-maximum-gold/", + "video": "I1wllM_pozY", + "neetcode250": true + }, + { + "name": "Most Profitable Path in a Tree", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "2467-most-profitable-path-in-a-tree", + "link": "most-profitable-path-in-a-tree/", + "video": "mESeQZKfvtY" + }, + { + "name": "Find the Celebrity", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0277-find-the-celebrity", + "link": "find-the-celebrity/" + }, + { + "name": "Kill Process", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0582-kill-process", + "link": "kill-process/" + }, + { + "name": "All Paths from Source Lead to Destination", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1059-all-paths-from-source-lead-to-destination", + "link": "all-paths-from-source-lead-to-destination/" + }, + { + "name": "Web Crawler", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1236-web-crawler", + "link": "web-crawler/" + }, + { + "name": "Number of Distinct Islands", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0694-number-of-distinct-islands", + "link": "number-of-distinct-islands/" + }, + { + "name": "Parallel Courses", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1136-parallel-courses", + "link": "parallel-courses/" + }, + { + "name": "The Maze", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0490-the-maze", + "link": "the-maze/" + }, + { + "name": "The Maze II", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0505-the-maze-ii", + "link": "the-maze-ii/" + }, + { + "name": "Minimum Knight Moves", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "1197-minimum-knight-moves", + "link": "minimum-knight-moves/" + }, + { + "name": "Number of Islands II", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "0305-number-of-islands-ii", + "link": "number-of-islands-ii/" + }, + { + "name": "The Maze III", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "0499-the-maze-iii", + "link": "the-maze-iii/" + }, + { + "name": "Shortest Distance from All Buildings", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "0317-shortest-distance-from-all-buildings", + "link": "shortest-distance-from-all-buildings/" + }, + { + "name": "Nested List Weight Sum", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0339-nested-list-weight-sum", + "link": "nested-list-weight-sum/" + }, + { + "name": "Maximum Number of Points From Grid Queries", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "2503-maximum-number-of-points-from-grid-queries", + "link": "maximum-number-of-points-from-grid-queries/", + "video": "NtH8cWBCu3Y" + }, + { + "name": "Maximum Number of K-Divisible Components", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "2872-maximum-number-of-k-divisible-components", + "link": "maximum-number-of-k-divisible-components/", + "video": "xlgOaIK-inc" + }, + { + "name": "Sliding Puzzle", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "0773-sliding-puzzle", + "link": "sliding-puzzle/", + "video": "C8wonkVDWz8" + }, + { + "name": "Largest Color Value in a Directed Graph", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "1857-largest-color-value-in-a-directed-graph", + "link": "largest-color-value-in-a-directed-graph/", + "video": "xLoDjKczUSk" + }, + { + "name": "Minimum Number of Days to Eat N Oranges", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "1553-minimum-number-of-days-to-eat-n-oranges", + "link": "minimum-number-of-days-to-eat-n-oranges/", + "video": "LziQ6Qx9sks" + }, + { + "name": "Find All People With Secret", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "2092-find-all-people-with-secret", + "link": "find-all-people-with-secret/", + "video": "1XujGRSU1bQ", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Word Ladder", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "0127-word-ladder", + "link": "word-ladder/", + "video": "h9iTnkgv05E", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Parallel Courses III", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "2050-parallel-courses-iii", + "link": "parallel-courses-iii/", + "video": "a_NlRPnqCrg", + "neetcode250": true + }, + { + "name": "Number of Distinct Islands II", + "pattern": "Graphs", + "difficulty": "Hard", + "code": "0711-number-of-distinct-islands-ii", + "link": "number-of-distinct-islands-ii/" + }, + { + "name": "Sentence Similarity II", + "pattern": "Graphs", + "difficulty": "Medium", + "code": "0737-sentence-similarity-ii", + "link": "sentence-similarity-ii/" + } + ], + "Advanced Graphs": [ + { + "name": "Path with Minimum Effort", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "1631-path-with-minimum-effort", + "link": "path-with-minimum-effort/", + "video": "XQlxCCx2vI4", + "neetcode250": true + }, + { + "name": "Network Delay Time", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "0743-network-delay-time", + "link": "network-delay-time/", + "video": "EaphyqKU4PQ", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Reconstruct Itinerary", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "0332-reconstruct-itinerary", + "link": "reconstruct-itinerary/", + "video": "ZyB_gQ8vqGA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Min Cost to Connect All Points", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "1584-min-cost-to-connect-all-points", + "link": "min-cost-to-connect-all-points/", + "video": "f7JOBJIC-NA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Path with Maximum Probability", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "1514-path-with-maximum-probability", + "link": "path-with-maximum-probability/", + "video": "kPsDTGcrzGM" + }, + { + "name": "Find the Safest Path in a Grid", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "2812-find-the-safest-path-in-a-grid", + "link": "find-the-safest-path-in-a-grid/", + "video": "-5mQcNiVWTs", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Swim In Rising Water", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "0778-swim-in-rising-water", + "link": "swim-in-rising-water/", + "video": "amvrKlMLuGY", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Alien Dictionary", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "0269-alien-dictionary", + "link": "alien-dictionary/", + "video": "6kTZYvNNyps", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Trapping Rain Water II", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "0407-trapping-rain-water-ii", + "link": "trapping-rain-water-ii/", + "video": "onA7_MaPGkM" + }, + { + "name": "Minimum Obstacle Removal to Reach Corner", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "2290-minimum-obstacle-removal-to-reach-corner", + "link": "minimum-obstacle-removal-to-reach-corner/", + "video": "VxeH7_QL-28" + }, + { + "name": "Minimum Cost to Make at Least One Valid Path in a Grid", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid", + "link": "minimum-cost-to-make-at-least-one-valid-path-in-a-grid/", + "video": "3DwA6AsQvDI" + }, + { + "name": "Minimum Time to Visit a Cell In a Grid", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "2577-minimum-time-to-visit-a-cell-in-a-grid", + "link": "minimum-time-to-visit-a-cell-in-a-grid/", + "video": "Kj98r8IgJOQ" + }, + { + "name": "Cheapest Flights Within K Stops", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "0787-cheapest-flights-within-k-stops", + "link": "cheapest-flights-within-k-stops/", + "video": "5eIK3zUdYmE", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find the City With the Smallest Number of Neighbors at a Threshold Distance", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "1334-find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance", + "link": "find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance/", + "video": "--wKPR3ByJc", + "neetcode250": true + }, + { + "name": "Minimum Cost to Convert String I", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "2976-minimum-cost-to-convert-string-i", + "link": "minimum-cost-to-convert-string-i/", + "video": "AVJhazQsNms" + }, + { + "name": "Number of Ways to Arrive at Destination", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "1976-number-of-ways-to-arrive-at-destination", + "link": "number-of-ways-to-arrive-at-destination/", + "video": "VFCzKOH1hnk" + }, + { + "name": "Sequence Reconstruction", + "pattern": "Advanced Graphs", + "difficulty": "Medium", + "code": "0444-sequence-reconstruction", + "link": "sequence-reconstruction/" + }, + { + "name": "Making A Large Island", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "0827-making-a-large-island", + "link": "making-a-large-island/", + "video": "pq61VNqXGvA" + }, + { + "name": "Minimum Cost Walk in Weighted Graph", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "3108-minimum-cost-walk-in-weighted-graph", + "link": "minimum-cost-walk-in-weighted-graph/", + "video": "UL8radjMPUM" + }, + { + "name": "Number of Good Paths", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "2421-number-of-good-paths", + "link": "number-of-good-paths/", + "video": "rv2GBYQm7xM" + }, + { + "name": "Maximum Employees to Be Invited to a Meeting", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "2127-maximum-employees-to-be-invited-to-a-meeting", + "link": "maximum-employees-to-be-invited-to-a-meeting/", + "video": "aPBELJa-LM8" + }, + { + "name": "Remove Max Number of Edges to Keep Graph Fully Traversable", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "1579-remove-max-number-of-edges-to-keep-graph-fully-traversable", + "link": "remove-max-number-of-edges-to-keep-graph-fully-traversable/", + "video": "booGwg5wYm4" + }, + { + "name": "Minimum Number of Days to Disconnect Island", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "1568-minimum-number-of-days-to-disconnect-island", + "link": "minimum-number-of-days-to-disconnect-island/", + "video": "aO-QbJ5eZwU" + }, + { + "name": "Second Minimum Time to Reach Destination", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "2045-second-minimum-time-to-reach-destination", + "link": "second-minimum-time-to-reach-destination/", + "video": "2F7gwxfy1CU" + }, + { + "name": "Find Minimum Diameter After Merging Two Trees", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "3203-find-minimum-diameter-after-merging-two-trees", + "link": "find-minimum-diameter-after-merging-two-trees/", + "video": "tK1TLnhmXzw" + }, + { + "name": "Find Critical and Pseudo Critical Edges in Minimum Spanning Tree", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "1489-find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree", + "link": "find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree/", + "video": "83JnUxrLKJU", + "neetcode250": true + }, + { + "name": "Bus Routes", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "0815-bus-routes", + "link": "bus-routes/" + }, + { + "name": "Build a Matrix With Conditions", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "2392-build-a-matrix-with-conditions", + "link": "build-a-matrix-with-conditions/", + "video": "khTKB1PzCuw", + "neetcode250": true + }, + { + "name": "Greatest Common Divisor Traversal", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "2709-greatest-common-divisor-traversal", + "link": "greatest-common-divisor-traversal/", + "video": "jZ-RVp5CVYY", + "neetcode250": true + }, + { + "name": "Divide Nodes Into the Maximum Number of Groups", + "pattern": "Advanced Graphs", + "difficulty": "Hard", + "code": "2493-divide-nodes-into-the-maximum-number-of-groups", + "link": "divide-nodes-into-the-maximum-number-of-groups/", + "video": "Gn0ADjje8Rg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + } + ], + "1-D Dynamic Programming": [ + { + "name": "Climbing Stairs", + "pattern": "1-D Dynamic Programming", + "difficulty": "Easy", + "code": "0070-climbing-stairs", + "link": "climbing-stairs/", + "video": "Y0lT9Fck7qI", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Min Cost Climbing Stairs", + "pattern": "1-D Dynamic Programming", + "difficulty": "Easy", + "code": "0746-min-cost-climbing-stairs", + "link": "min-cost-climbing-stairs/", + "video": "ktmzAZWkEZ0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "N-th Tribonacci Number", + "pattern": "1-D Dynamic Programming", + "difficulty": "Easy", + "code": "1137-n-th-tribonacci-number", + "link": "n-th-tribonacci-number/", + "video": "3lpNp5Ojvrw", + "neetcode250": true + }, + { + "name": "House Robber", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0198-house-robber", + "link": "house-robber/", + "video": "73r3KWiEvyk", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "House Robber II", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0213-house-robber-ii", + "link": "house-robber-ii/", + "video": "rWAJCfYYOvM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Paint House", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0256-paint-house", + "link": "paint-house/", + "video": "-w67-4tnH5U", + "neetcode250": true + }, + { + "name": "Paint Fence", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0276-paint-fence", + "link": "paint-fence/" + }, + { + "name": "4 Keys Keyboard", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0651-4-keys-keyboard", + "link": "4-keys-keyboard/" + }, + { + "name": "Handshakes That Don't Cross", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "1259-handshakes-that-dont-cross", + "link": "handshakes-that-dont-cross/" + }, + { + "name": "Longest Palindromic Substring", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0005-longest-palindromic-substring", + "link": "longest-palindromic-substring/", + "video": "XYQecbcd6_c", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Palindromic Substrings", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0647-palindromic-substrings", + "link": "palindromic-substrings/", + "video": "4RACzI5-du8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Decode Ways", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0091-decode-ways", + "link": "decode-ways/", + "video": "6aEyTjOwlJU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Coin Change", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0322-coin-change", + "link": "coin-change/", + "video": "H9bfqozjoqs", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Maximum Product Subarray", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0152-maximum-product-subarray", + "link": "maximum-product-subarray/", + "video": "lXVy6YWFcRM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Word Break", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0139-word-break", + "link": "word-break/", + "video": "Sx9NNgInc3A", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Longest Increasing Subsequence", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0300-longest-increasing-subsequence", + "link": "longest-increasing-subsequence/", + "video": "cjWnW0hdF1Y", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Partition Equal Subset Sum", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0416-partition-equal-subset-sum", + "link": "partition-equal-subset-sum/", + "video": "IsvocB5BJhw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Triangle", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0120-triangle", + "link": "triangle/", + "video": "OM1MTokvxs4" + }, + { + "name": "Delete And Earn", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0740-delete-and-earn", + "link": "delete-and-earn/", + "video": "7FCemBxvGw0" + }, + { + "name": "Filling Bookcase Shelves", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "1105-filling-bookcase-shelves", + "link": "filling-bookcase-shelves/", + "video": "lFYPPPTp8qE", + "neetcode250": true + }, + { + "name": "Combination Sum IV", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0377-combination-sum-iv", + "link": "combination-sum-iv/", + "video": "dw2nMCxG0ik", + "neetcode250": true + }, + { + "name": "Perfect Squares", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0279-perfect-squares", + "link": "perfect-squares/", + "video": "HLZLwjzIVGo", + "neetcode250": true + }, + { + "name": "Check if There is a Valid Partition For The Array", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "2369-check-if-there-is-a-valid-partition-for-the-array", + "link": "check-if-there-is-a-valid-partition-for-the-array/", + "video": "OxXPiwWFdTI", + "neetcode250": true + }, + { + "name": "Maximum Subarray Min Product", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "1856-maximum-subarray-min-product", + "link": "maximum-subarray-min-product/", + "video": "YLesLbNkyjA" + }, + { + "name": "Minimum Cost For Tickets", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0983-minimum-cost-for-tickets", + "link": "minimum-cost-for-tickets/", + "video": "4Kww-zIkWWY", + "neetcode250": true + }, + { + "name": "Integer Break", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0343-integer-break", + "link": "integer-break/", + "video": "in6QbUPMJ3I", + "neetcode250": true + }, + { + "name": "Number of Longest Increasing Subsequence", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0673-number-of-longest-increasing-subsequence", + "link": "number-of-longest-increasing-subsequence/", + "video": "Tuc-rjJbsXU", + "neetcode250": true + }, + { + "name": "Russian Doll Envelopes", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "0354-russian-doll-envelopes", + "link": "russian-doll-envelopes/" + }, + { + "name": "Stickers to Spell Word", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "0691-stickers-to-spell-word", + "link": "stickers-to-spell-word/", + "video": "hsomLb6mUdI" + }, + { + "name": "Uncrossed Lines", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "1035-uncrossed-lines", + "link": "uncrossed-lines/", + "video": "mnJF4vJ7GyE" + }, + { + "name": "Solving Questions With Brainpower", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "2140-solving-questions-with-brainpower", + "link": "solving-questions-with-brainpower/", + "video": "D7TD_ArkfkA" + }, + { + "name": "Count Ways to Build Good Strings", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "2466-count-ways-to-build-good-strings", + "link": "count-ways-to-build-good-strings/", + "video": "JKpVHG2mhbk" + }, + { + "name": "Ugly Number II", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0264-ugly-number-ii", + "link": "ugly-number-ii/", + "video": "1pj2a5bmziY" + }, + { + "name": "New 21 Game", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0837-new-21-game", + "link": "new-21-game/", + "video": "zKi4LzjK27k" + }, + { + "name": "Best Team with no Conflicts", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "1626-best-team-with-no-conflicts", + "link": "best-team-with-no-conflicts/", + "video": "7kURH3btcV4" + }, + { + "name": "Longest String Chain", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "1048-longest-string-chain", + "link": "longest-string-chain/", + "video": "7b0V1gT_TIk" + }, + { + "name": "Knight Dialer", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0935-knight-dialer", + "link": "knight-dialer/", + "video": "vlsUUm_qqsY" + }, + { + "name": "Partition Array for Maximum Sum", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "1043-partition-array-for-maximum-sum", + "link": "partition-array-for-maximum-sum/", + "video": "kWhy4ZUBdOY" + }, + { + "name": "Largest Divisible Subset", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0368-largest-divisible-subset", + "link": "largest-divisible-subset/", + "video": "LeRU6irRoW0" + }, + { + "name": "Count Strictly Increasing Subarrays", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "2393-count-strictly-increasing-subarrays", + "link": "count-strictly-increasing-subarrays/" + }, + { + "name": "Sentence Screen Fitting", + "pattern": "1-D Dynamic Programming", + "difficulty": "Medium", + "code": "0418-sentence-screen-fitting", + "link": "sentence-screen-fitting/" + }, + { + "name": "Stone Game III", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "1406-stone-game-iii", + "link": "stone-game-iii/", + "video": "HsLG5QW9CFQ", + "neetcode250": true + }, + { + "name": "Concatenated Words", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "0472-concatenated-words", + "link": "concatenated-words/", + "video": "iHp7fjw1R28", + "neetcode250": true + }, + { + "name": "Maximize Score after N Operations", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "1799-maximize-score-after-n-operations", + "link": "maximize-score-after-n-operations/", + "video": "RRQVDqp5RSE" + }, + { + "name": "Find the Longest Valid Obstacle Course at Each Position", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "1964-find-the-longest-valid-obstacle-course-at-each-position", + "link": "find-the-longest-valid-obstacle-course-at-each-position/", + "video": "Xq9VT7p0lic" + }, + { + "name": "Minimum Number of Removals to Make Mountain Array", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "1671-minimum-number-of-removals-to-make-mountain-array", + "link": "minimum-number-of-removals-to-make-mountain-array/", + "video": "Ys-q9qPpleY" + }, + { + "name": "Count all Valid Pickup and Delivery Options", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "1359-count-all-valid-pickup-and-delivery-options", + "link": "count-all-valid-pickup-and-delivery-options/", + "video": "OpgslsirW8s" + }, + { + "name": "Number of Ways to Divide a Long Corridor", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "2147-number-of-ways-to-divide-a-long-corridor", + "link": "number-of-ways-to-divide-a-long-corridor/", + "video": "YOTjCd4Eyhc" + }, + { + "name": "Maximum Sum of 3 Non-Overlapping Subarrays", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "0689-maximum-sum-of-3-non-overlapping-subarrays", + "link": "maximum-sum-of-3-non-overlapping-subarrays/", + "video": "SfjeJ1qyCVg" + }, + { + "name": "Maximum Profit in Job Scheduling", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "1235-maximum-profit-in-job-scheduling", + "link": "maximum-profit-in-job-scheduling/", + "video": "JLoWc3v0SiE" + }, + { + "name": "Student Attendance Record II", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "0552-student-attendance-record-ii", + "link": "student-attendance-record-ii/", + "video": "BPIJ5ROX0i4" + }, + { + "name": "Optimal Account Balancing", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "0465-optimal-account-balancing", + "link": "optimal-account-balancing/" + }, + { + "name": "Valid Palindrome III", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "1216-valid-palindrome-iii", + "link": "valid-palindrome-iii/" + }, + { + "name": "Encode String with Shortest Length", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "0471-encode-string-with-shortest-length", + "link": "encode-string-with-shortest-length/" + }, + { + "name": "Coin Path", + "pattern": "1-D Dynamic Programming", + "difficulty": "Hard", + "code": "0656-coin-path", + "link": "coin-path/", + "neetcode150": true, + "blind75": true + } + ], + "2-D Dynamic Programming": [ + { + "name": "Unique Paths", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0062-unique-paths", + "link": "unique-paths/", + "video": "IlEsdxuD4lY", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Unique Paths II", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0063-unique-paths-ii", + "link": "unique-paths-ii/", + "video": "d3UOz7zdE4I", + "blind75": true, + "neetcode250": true + }, + { + "name": "Minimum Path Sum", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0064-minimum-path-sum", + "link": "minimum-path-sum/", + "video": "pGMsrvt0fpk", + "neetcode250": true + }, + { + "name": "Maximum Number of Points with Cost", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "1937-maximum-number-of-points-with-cost", + "link": "maximum-number-of-points-with-cost/", + "video": "ik1y7fz8AOc", + "neetcode250": true + }, + { + "name": "Longest Common Subsequence", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "1143-longest-common-subsequence", + "link": "longest-common-subsequence/", + "video": "Ua0GhsJSlWM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Longest Palindromic Subsequence", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0516-longest-palindromic-subsequence", + "link": "longest-palindromic-subsequence/", + "video": "bUr8cNWI09Q" + }, + { + "name": "Length of Longest Fibonacci Subsequence", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0873-length-of-longest-fibonacci-subsequence", + "link": "length-of-longest-fibonacci-subsequence/", + "video": "33kCYPLnvcE", + "neetcode250": true + }, + { + "name": "Last Stone Weight II", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "1049-last-stone-weight-ii", + "link": "last-stone-weight-ii/", + "video": "gdXkkmzvR3c", + "neetcode250": true + }, + { + "name": "Best Time to Buy And Sell Stock With Cooldown", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0309-best-time-to-buy-and-sell-stock-with-cooldown", + "link": "best-time-to-buy-and-sell-stock-with-cooldown/", + "video": "I7j0F7AHpb8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Coin Change II", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0518-coin-change-ii", + "link": "coin-change-ii/", + "video": "Mjy4hd2xgrs", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Target Sum", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0494-target-sum", + "link": "target-sum/", + "video": "dwMOrl85Xes", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Interleaving String", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0097-interleaving-string", + "link": "interleaving-string/", + "video": "3Rw3p9LrgvE", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Stone Game", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0877-stone-game", + "link": "stone-game/", + "video": "uhgdXOlGYqE", + "neetcode250": true + }, + { + "name": "Stone Game II", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "1140-stone-game-ii", + "link": "stone-game-ii/", + "video": "I-z-u0zfQtg", + "neetcode250": true + }, + { + "name": "Longest Increasing Path In a Matrix", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0329-longest-increasing-path-in-a-matrix", + "link": "longest-increasing-path-in-a-matrix/", + "video": "wCc_nd-GiEc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Maximal Square", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0221-maximal-square", + "link": "maximal-square/", + "video": "6X7Ha2PrDmM" + }, + { + "name": "Count Square Submatrices with All Ones", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "1277-count-square-submatrices-with-all-ones", + "link": "count-square-submatrices-with-all-ones/", + "video": "5Li-cR5h_uw" + }, + { + "name": "Ones and Zeroes", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0474-ones-and-zeroes", + "link": "ones-and-zeroes/", + "video": "miZ3qV04b1g" + }, + { + "name": "2 Keys Keyboard", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0650-2-keys-keyboard", + "link": "2-keys-keyboard/", + "video": "jNfZH3mdjOA" + }, + { + "name": "Maximum Alternating Subsequence Sum", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "1911-maximum-alternating-subsequence-sum", + "link": "maximum-alternating-subsequence-sum/", + "video": "4v42XOuU1XA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Distinct Subsequences", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0115-distinct-subsequences", + "link": "distinct-subsequences/", + "video": "-RDzMJ33nx8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Edit Distance", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0072-edit-distance", + "link": "edit-distance/", + "video": "XYi2-LPrwm4", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Number of Dice Rolls with Target Sum", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "1155-number-of-dice-rolls-with-target-sum", + "link": "number-of-dice-rolls-with-target-sum/", + "video": "hfUxjdjVQN4", + "neetcode250": true + }, + { + "name": "Minimum Falling Path Sum", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0931-minimum-falling-path-sum", + "link": "minimum-falling-path-sum/", + "video": "b_F3mz9l-uQ" + }, + { + "name": "Out of Boundary Paths", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0576-out-of-boundary-paths", + "link": "out-of-boundary-paths/", + "video": "Bg5CLRqtNmk" + }, + { + "name": "Longest Ideal Subsequence", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "2370-longest-ideal-subsequence", + "link": "longest-ideal-subsequence/", + "video": "gR1E2oLQYSY" + }, + { + "name": "Count Number of Teams", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "1395-count-number-of-teams", + "link": "count-number-of-teams/", + "video": "zONHzIqCr-o" + }, + { + "name": "Shortest Common Supersequence", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1092-shortest-common-supersequence", + "link": "shortest-common-supersequence/", + "video": "JkjQNJSxXN0" + }, + { + "name": "Count Vowels Permutation", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1220-count-vowels-permutation", + "link": "count-vowels-permutation/", + "video": "VUVpTZVa7Ls", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Burst Balloons", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0312-burst-balloons", + "link": "burst-balloons/", + "video": "VFskby7lUbw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Number of Ways to Rearrange Sticks With K Sticks Visible", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible", + "link": "number-of-ways-to-rearrange-sticks-with-k-sticks-visible/", + "video": "O761YBjGxGA", + "neetcode250": true + }, + { + "name": "Regular Expression Matching", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0010-regular-expression-matching", + "link": "regular-expression-matching/", + "video": "HAA8mgxlov8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Flip String to Monotone Increasing", + "pattern": "2-D Dynamic Programming", + "difficulty": "Medium", + "code": "0926-flip-string-to-monotone-increasing", + "link": "flip-string-to-monotone-increasing/", + "video": "tMq9z5k3umQ" + }, + { + "name": "Maximum Value of K Coins from Piles", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "2218-maximum-value-of-k-coins-from-piles", + "link": "maximum-value-of-k-coins-from-piles/", + "video": "ZRdEd_eun8g" + }, + { + "name": "Number of Music Playlists", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0920-number-of-music-playlists", + "link": "number-of-music-playlists/", + "video": "gk4qzZSmyrs" + }, + { + "name": "Number of Ways to Form a Target String Given a Dictionary", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1639-number-of-ways-to-form-a-target-string-given-a-dictionary", + "link": "number-of-ways-to-form-a-target-string-given-a-dictionary/", + "video": "_GF-0T-YjW8" + }, + { + "name": "Profitable Schemes", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0879-profitable-schemes", + "link": "profitable-schemes/", + "video": "CcLKQLKvOl8" + }, + { + "name": "Minimum Cost to Cut a Stick", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1547-minimum-cost-to-cut-a-stick", + "link": "minimum-cost-to-cut-a-stick/", + "video": "EVxTO5I0d7w" + }, + { + "name": "Painting the Walls", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "2742-painting-the-walls", + "link": "painting-the-walls/", + "video": "qMZJunF5UaI" + }, + { + "name": "Number of Ways to Stay in the Same Place After Some Steps", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1269-number-of-ways-to-stay-in-the-same-place-after-some-steps", + "link": "number-of-ways-to-stay-in-the-same-place-after-some-steps/", + "video": "8YBGXG-8sRI" + }, + { + "name": "String Compression II", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1531-string-compression-ii", + "link": "string-compression-ii/", + "video": "ISIG3o-Xofg" + }, + { + "name": "Minimum Difficulty of a Job Schedule", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1335-minimum-difficulty-of-a-job-schedule", + "link": "minimum-difficulty-of-a-job-schedule/", + "video": "DAAULrZFeLI" + }, + { + "name": "Arithmetic Slices II", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0446-arithmetic-slices-ii-subsequence", + "link": "arithmetic-slices-ii-subsequence/", + "video": "YIMwwT9JdIE" + }, + { + "name": "K Inverse Pairs Array", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0629-k-inverse-pairs-array", + "link": "k-inverse-pairs-array/", + "video": "dglwb30bUKI" + }, + { + "name": "Cherry Pickup", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0741-cherry-pickup", + "link": "cherry-pickup/" + }, + { + "name": "Cherry Pickup II", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1463-cherry-pickup-ii", + "link": "cherry-pickup-ii/", + "video": "c1stwk2TbNk" + }, + { + "name": "Minimum Falling Path Sum II", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "1289-minimum-falling-path-sum-ii", + "link": "minimum-falling-path-sum-ii/", + "video": "_b8sptrsFEM" + }, + { + "name": "Freedom Trail", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0514-freedom-trail", + "link": "freedom-trail/", + "video": "NOgnlTXidSs" + }, + { + "name": "Split Array With Same Average", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0805-split-array-with-same-average", + "link": "split-array-with-same-average/" + }, + { + "name": "Paint House II", + "pattern": "2-D Dynamic Programming", + "difficulty": "Hard", + "code": "0265-paint-house-ii", + "link": "paint-house-ii/" + } + ], + "Greedy": [ + { + "name": "Buy Two Chocolates", + "pattern": "Greedy", + "difficulty": "Easy", + "code": "2706-buy-two-chocolates", + "link": "buy-two-chocolates/", + "video": "BTzNimiQdW4", + "neetcode250": true + }, + { + "name": "Lemonade Change", + "pattern": "Greedy", + "difficulty": "Easy", + "code": "860-lemonade-change", + "link": "lemonade-change/", + "video": "mSVAw0AUZgA", + "neetcode250": true + }, + { + "name": "Minimum Number of Moves to Seat Everyone", + "pattern": "Greedy", + "difficulty": "Easy", + "code": "2037-minimum-number-of-moves-to-seat-everyone", + "link": "minimum-number-of-moves-to-seat-everyone/", + "video": "wS7Ag33hf8E", + "neetcode250": true + }, + { + "name": "Maximum Odd Binary Number", + "pattern": "Greedy", + "difficulty": "Easy", + "code": "2864-maximum-odd-binary-number", + "link": "maximum-odd-binary-number/", + "video": "EUKLOAv4-IQ" + }, + { + "name": "Maximum Nesting Depth of the Parentheses", + "pattern": "Greedy", + "difficulty": "Easy", + "code": "1614-maximum-nesting-depth-of-the-parentheses", + "link": "maximum-nesting-depth-of-the-parentheses/", + "video": "FiQFJvCvWK4" + }, + { + "name": "Check if One String Swap Can Make Strings Equal", + "pattern": "Greedy", + "difficulty": "Easy", + "code": "1790-check-if-one-string-swap-can-make-strings-equal", + "link": "check-if-one-string-swap-can-make-strings-equal/", + "video": "-N4_SJ9hUdY" + }, + { + "name": "How Many Apples Can You Put into the Basket", + "pattern": "Greedy", + "difficulty": "Easy", + "code": "1196-how-many-apples-can-you-put-into-the-basket", + "link": "how-many-apples-can-you-put-into-the-basket/" + }, + { + "name": "Minimum Operations to Make Binary Array Elements Equal to One I", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "3191-minimum-operations-to-make-binary-array-elements-equal-to-one-i", + "link": "minimum-operations-to-make-binary-array-elements-equal-to-one-i/", + "video": "5dg_gAym75I" + }, + { + "name": "Buildings With an Ocean View", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1762-buildings-with-an-ocean-view", + "link": "buildings-with-an-ocean-view/", + "video": "ntzA9LS8kLM" + }, + { + "name": "Minimum Length of String After Operations", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "3223-minimum-length-of-string-after-operations", + "link": "minimum-length-of-string-after-operations/", + "video": "f-R9dqsI_FI" + }, + { + "name": "Construct K Palindrome Strings", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1400-construct-k-palindrome-strings", + "link": "construct-k-palindrome-strings/", + "video": "D00qGvqmqN0" + }, + { + "name": "Separate Black and White Balls", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2938-separate-black-and-white-balls", + "link": "separate-black-and-white-balls/", + "video": "-VVN0FI0KFo" + }, + { + "name": "Minimum Increment to Make Array Unique", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0945-minimum-increment-to-make-array-unique", + "link": "minimum-increment-to-make-array-unique/", + "video": "XPPs2Wj2YSk", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Maximum Subarray", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0053-maximum-subarray", + "link": "maximum-subarray/", + "video": "5WZl3MMT0Eg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Maximum Absolute Sum of Any Subarray", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1749-maximum-absolute-sum-of-any-subarray", + "link": "maximum-absolute-sum-of-any-subarray/", + "video": "y1VEygeHpGU", + "neetcode250": true + }, + { + "name": "Maximum Sum Circular Subarray", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0918-maximum-sum-circular-subarray", + "link": "maximum-sum-circular-subarray/", + "video": "fxT9KjakYPM", + "neetcode250": true + }, + { + "name": "Minimum Swaps to Group All 1's Together II", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2134-minimum-swaps-to-group-all-1s-together-ii", + "link": "minimum-swaps-to-group-all-1s-together-ii/", + "video": "BueoreUIkcE", + "neetcode250": true + }, + { + "name": "Longest Turbulent Subarray", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0978-longest-turbulent-subarray", + "link": "longest-turbulent-subarray/", + "video": "V_iHUhR8Dek", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Jump Game", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0055-jump-game", + "link": "jump-game/", + "video": "Yan0cv2cLy8", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Jump Game II", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0045-jump-game-ii", + "link": "jump-game-ii/", + "video": "dJ7sWiOoK7g", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Jump Game VII", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1871-jump-game-vii", + "link": "jump-game-vii/", + "video": "v1HpZUnQ4Yo", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Gas Station", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0134-gas-station", + "link": "gas-station/", + "video": "lJwbPZGo05A", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Hand of Straights", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0846-hand-of-straights", + "link": "hand-of-straights/", + "video": "amnrMCVd2YI", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Minimum Number of Changes to Make Binary String Beautiful", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2914-minimum-number-of-changes-to-make-binary-string-beautiful", + "link": "minimum-number-of-changes-to-make-binary-string-beautiful/", + "video": "qhxhrTA4HJw", + "neetcode250": true + }, + { + "name": "Minimize Maximum of Array", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2439-minimize-maximum-of-array", + "link": "minimize-maximum-of-array/", + "video": "AeHMvcKuR0Y" + }, + { + "name": "Maximize Y-Sum by Picking a Triplet of Distinct X-Values", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "3572-maximize-ysum-by-picking-a-triplet-of-distinct-xvalues", + "link": "maximize-ysum-by-picking-a-triplet-of-distinct-xvalues/" + }, + { + "name": "Minimum Difference Between Largest and Smallest Value in Three Moves", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1509-minimum-difference-between-largest-and-smallest-value-in-three-moves", + "link": "minimum-difference-between-largest-and-smallest-value-in-three-moves/", + "video": "S6cUjbQuTnE" + }, + { + "name": "Maximum Total Importance of Roads", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2285-maximum-total-importance-of-roads", + "link": "maximum-total-importance-of-roads/", + "video": "NIhXLEiQAPM" + }, + { + "name": "Minimum Number of Pushes to Type Word II", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "3016-minimum-number-of-pushes-to-type-word-ii", + "link": "minimum-number-of-pushes-to-type-word-ii/", + "video": "gvaYi6X6SQw", + "neetcode250": true + }, + { + "name": "Dota2 Senate", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0649-dota2-senate", + "link": "dota2-senate/", + "video": "zZA5KskfMuQ", + "neetcode250": true + }, + { + "name": "Maximum Points You Can Obtain From Cards", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1423-maximum-points-you-can-obtain-from-cards", + "link": "maximum-points-you-can-obtain-from-cards/", + "video": "TsA4vbtfCvo", + "neetcode250": true + }, + { + "name": "Merge Triplets to Form Target Triplet", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1899-merge-triplets-to-form-target-triplet", + "link": "merge-triplets-to-form-target-triplet/", + "video": "kShkQLQZ9K4", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Partition Labels", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0763-partition-labels", + "link": "partition-labels/", + "video": "B7m8UmZE-vw", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Valid Parenthesis String", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0678-valid-parenthesis-string", + "link": "valid-parenthesis-string/", + "video": "QhPdNS143Qg", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Check if a Parentheses String Can Be Valid", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2116-check-if-a-parentheses-string-can-be-valid", + "link": "check-if-a-parentheses-string-can-be-valid/", + "video": "KMIIGDiXLhY" + }, + { + "name": "Eliminate Maximum Number of Monsters", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1921-eliminate-maximum-number-of-monsters", + "link": "eliminate-maximum-number-of-monsters/", + "video": "6QQRayzOTD4" + }, + { + "name": "Two City Scheduling", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1029-two-city-scheduling", + "link": "two-city-scheduling/", + "video": "d-B_gk_gJtQ" + }, + { + "name": "Maximum Length of Pair Chain", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0646-maximum-length-of-pair-chain", + "link": "maximum-length-of-pair-chain/", + "video": "LcNNorqMVTw" + }, + { + "name": "Best Sightseeing Pair", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1014-best-sightseeing-pair", + "link": "best-sightseeing-pair/", + "video": "YAYnMfHbjz4" + }, + { + "name": "Make Lexicographically Smallest Array by Swapping Elements", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2948-make-lexicographically-smallest-array-by-swapping-elements", + "link": "make-lexicographically-smallest-array-by-swapping-elements/", + "video": "-FGl6dzPexY" + }, + { + "name": "Minimum Deletions to Make Character Frequencies Unique", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1647-minimum-deletions-to-make-character-frequencies-unique", + "link": "minimum-deletions-to-make-character-frequencies-unique/", + "video": "h8AZEN49gTc" + }, + { + "name": "Minimum Deletions to Make String Balanced", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1653-minimum-deletions-to-make-string-balanced", + "link": "minimum-deletions-to-make-string-balanced/", + "video": "WDStNufBUQ8", + "neetcode250": true + }, + { + "name": "Candy", + "pattern": "Greedy", + "difficulty": "Hard", + "code": "135-candy", + "link": "candy/", + "video": "1IzCRCcK17A", + "neetcode250": true + }, + { + "name": "Remove Colored Pieces if Both Neighbors are the Same Color", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2038-remove-colored-pieces-if-both-neighbors-are-the-same-color", + "link": "remove-colored-pieces-if-both-neighbors-are-the-same-color/", + "video": "T54GScWobZ4", + "neetcode250": true + }, + { + "name": "Maximum Score From Removing Substrings", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1717-maximum-score-from-removing-substrings", + "link": "maximum-score-from-removing-substrings/", + "video": "r_3a0oG1VcY" + }, + { + "name": "Maximum Element After Decreasing and Rearranging", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1846-maximum-element-after-decreasing-and-rearranging", + "link": "maximum-element-after-decreasing-and-rearranging/", + "video": "o_hVl8IXuIE" + }, + { + "name": "Number of Laser Beams in a Bank", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2125-number-of-laser-beams-in-a-bank", + "link": "number-of-laser-beams-in-a-bank/", + "video": "KLeKv59LAFY" + }, + { + "name": "Reveal Cards In Increasing Order", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0950-reveal-cards-in-increasing-order", + "link": "reveal-cards-in-increasing-order/", + "video": "i2QrUdwWlak" + }, + { + "name": "Construct String With Repeat Limit", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2182-construct-string-with-repeat-limit", + "link": "construct-string-with-repeat-limit/", + "video": "Um9_VT78nfg" + }, + { + "name": "Find Valid Matrix Given Row and Column Sums", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1605-find-valid-matrix-given-row-and-column-sums", + "link": "find-valid-matrix-given-row-and-column-sums/", + "video": "Ks6fGnXkHPg" + }, + { + "name": "Score After Flipping Matrix", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0861-score-after-flipping-matrix", + "link": "score-after-flipping-matrix/", + "video": "FbhzRA5den8" + }, + { + "name": "Flip Columns For Maximum Number of Equal Rows", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1072-flip-columns-for-maximum-number-of-equal-rows", + "link": "flip-columns-for-maximum-number-of-equal-rows/", + "video": "MsdLjL87BEo" + }, + { + "name": "Maximum Matrix Sum", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1975-maximum-matrix-sum", + "link": "maximum-matrix-sum/", + "video": "XonYlqE049I" + }, + { + "name": "Make Two Arrays Equal by Reversing Subarrays", + "pattern": "Greedy", + "difficulty": "Easy", + "code": "1460-make-two-arrays-equal-by-reversing-subarrays", + "link": "make-two-arrays-equal-by-reversing-subarrays/", + "video": "XJkd8HKGcQw" + }, + { + "name": "Shortest Subarray to be Removed to Make Array Sorted", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1574-shortest-subarray-to-be-removed-to-make-array-sorted", + "link": "shortest-subarray-to-be-removed-to-make-array-sorted/", + "video": "eHZLQIH1ruk" + }, + { + "name": "Max Chunks To Make Sorted", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0769-max-chunks-to-make-sorted", + "link": "max-chunks-to-make-sorted/", + "video": "wpHzXTkuVkY" + }, + { + "name": "Next Permutation", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "0031-next-permutation", + "link": "next-permutation/" + }, + { + "name": "Maximum Swap", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "670-maximum-swap", + "link": "maximum-swap/", + "video": "4FZtJ8420m8" + }, + { + "name": "Maximal Score After Applying K Operations", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "2530-maximal-score-after-applying-k-operations", + "link": "maximal-score-after-applying-k-operations/", + "video": "fiEXkZLwXGQ" + }, + { + "name": "Maximum Frequency After Subarray Operation", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "3434-maximum-frequency-after-subarray-operation", + "link": "maximum-frequency-after-subarray-operation/" + }, + { + "name": "Put Boxes Into the Warehouse I", + "pattern": "Greedy", + "difficulty": "Medium", + "code": "1564-put-boxes-into-the-warehouse-i", + "link": "put-boxes-into-the-warehouse-i/" + }, + { + "name": "Put Marbles in Bags", + "pattern": "Greedy", + "difficulty": "Hard", + "code": "2551-put-marbles-in-bags", + "link": "put-marbles-in-bags/", + "video": "lB_gLotpnuY" + }, + { + "name": "Minimum Number of K Consecutive Bit Flips", + "pattern": "Greedy", + "difficulty": "Hard", + "code": "0995-minimum-number-of-k-consecutive-bit-flips", + "link": "minimum-number-of-k-consecutive-bit-flips/", + "video": "Fv3M9uO5ovU" + }, + { + "name": "Maximum Score of a Good Subarray", + "pattern": "Greedy", + "difficulty": "Hard", + "code": "1793-maximum-score-of-a-good-subarray", + "link": "maximum-score-of-a-good-subarray/", + "video": "_K7oyQlAjv4" + }, + { + "name": "Find the Maximum Sum of Node Values", + "pattern": "Greedy", + "difficulty": "Hard", + "code": "3068-find-the-maximum-sum-of-node-values", + "link": "find-the-maximum-sum-of-node-values/", + "video": "bnBp6_b4GCw" + }, + { + "name": "Minimum Number of Increments on Subarrays to Form a Target Array", + "pattern": "Greedy", + "difficulty": "Hard", + "code": "1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array", + "link": "minimum-number-of-increments-on-subarrays-to-form-a-target-array/", + "video": "84mt0YWJd1w" + }, + { + "name": "Apply Operations to Maximize Score", + "pattern": "Greedy", + "difficulty": "Hard", + "code": "2818-apply-operations-to-maximize-score", + "link": "apply-operations-to-maximize-score/", + "video": "NH-Bkbmj7Sw" + } + ], + "Intervals": [ + { + "name": "Missing Ranges", + "pattern": "Intervals", + "difficulty": "Easy", + "code": "0163-missing-ranges", + "link": "missing-ranges/" + }, + { + "name": "Remove Interval", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "1272-remove-interval", + "link": "remove-interval/" + }, + { + "name": "Add Bold Tag in String", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0616-add-bold-tag-in-string", + "link": "add-bold-tag-in-string/" + }, + { + "name": "Insert Interval", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0057-insert-interval", + "link": "insert-interval/", + "video": "A8NUOmlwOlM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Merge Intervals", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0056-merge-intervals", + "link": "merge-intervals/", + "video": "44H3cEC2fFM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Non Overlapping Intervals", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0435-non-overlapping-intervals", + "link": "non-overlapping-intervals/", + "video": "nONCGxWoUfM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Interval List Intersections", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0986-interval-list-intersections", + "link": "interval-list-intersections/", + "neetcode150": true, + "blind75": true + }, + { + "name": "Meeting Rooms", + "pattern": "Intervals", + "difficulty": "Easy", + "code": "0252-meeting-rooms", + "link": "meeting-rooms/", + "video": "PaJxqZVPhbg", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Meeting Rooms II", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0253-meeting-rooms-ii", + "link": "meeting-rooms-ii/", + "video": "FdzJmTCVyJU", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Meeting Rooms III", + "pattern": "Intervals", + "difficulty": "Hard", + "code": "2402-meeting-rooms-iii", + "link": "meeting-rooms-iii/", + "video": "2VLwjvODQbA", + "neetcode250": true + }, + { + "name": "Divide Intervals Into Minimum Number of Groups", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "2406-divide-intervals-into-minimum-number-of-groups", + "link": "divide-intervals-into-minimum-number-of-groups/", + "video": "FVjKrhdMutc", + "neetcode250": true + }, + { + "name": "Remove Covered Intervals", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "1288-remove-covered-intervals", + "link": "remove-covered-intervals/", + "video": "nhAsMabiVkM" + }, + { + "name": "Minimum Number of Arrows to Burst Balloons", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0452-minimum-number-of-arrows-to-burst-balloons", + "link": "minimum-number-of-arrows-to-burst-balloons/", + "video": "lPmkKnvNPrw" + }, + { + "name": "The Number of the Smallest Unoccupied Chair", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "1942-the-number-of-the-smallest-unoccupied-chair", + "link": "the-number-of-the-smallest-unoccupied-chair/", + "video": "LqhxcaCctCc" + }, + { + "name": "Check if Grid can be Cut into Sections", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "3394-check-if-grid-can-be-cut-into-sections", + "link": "check-if-grid-can-be-cut-into-sections/", + "video": "X9QtxzsAsYo" + }, + { + "name": "My Calendar I", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0729-my-calendar-i", + "link": "my-calendar-i/", + "video": "fIxck3tlId4" + }, + { + "name": "My Calendar II", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "0731-my-calendar-ii", + "link": "my-calendar-ii/", + "video": "7utL5cTDcnA" + }, + { + "name": "Count Days Without Meetings", + "pattern": "Intervals", + "difficulty": "Medium", + "code": "3169-count-days-without-meetings", + "link": "count-days-without-meetings/", + "video": "VFYTULYpApM" + }, + { + "name": "Minimum Interval to Include Each Query", + "pattern": "Intervals", + "difficulty": "Hard", + "code": "1851-minimum-interval-to-include-each-query", + "link": "minimum-interval-to-include-each-query/", + "video": "5hQ5WWW5awQ", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Data Stream as Disjoint Intervals", + "pattern": "Intervals", + "difficulty": "Hard", + "code": "0352-data-stream-as-disjoint-intervals", + "link": "data-stream-as-disjoint-intervals/", + "video": "FavoZjPIWpo" + }, + { + "name": "Employee Free Time", + "pattern": "Intervals", + "difficulty": "Hard", + "code": "0759-employee-free-time", + "link": "employee-free-time/" + } + ], + "Math & Geometry": [ + { + "name": "Excel Sheet Column Title", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0168-excel-sheet-column-title", + "link": "excel-sheet-column-title/", + "video": "X_vJDpCCuoA", + "neetcode250": true + }, + { + "name": "Greatest Common Divisor of Strings", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1071-greatest-common-divisor-of-strings", + "link": "greatest-common-divisor-of-strings/", + "video": "i5I_wrbUdzM", + "neetcode250": true + }, + { + "name": "Insert Greatest Common Divisors in Linked List", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2807-insert-greatest-common-divisors-in-linked-list", + "link": "insert-greatest-common-divisors-in-linked-list/", + "video": "SS_IlBrocYQ", + "neetcode250": true + }, + { + "name": "Count Odd Numbers in an Interval Range", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1523-count-odd-numbers-in-an-interval-range", + "link": "count-odd-numbers-in-an-interval-range/", + "video": "wrIWye928JQ" + }, + { + "name": "Matrix Diagonal Sum", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1572-matrix-diagonal-sum", + "link": "matrix-diagonal-sum/", + "video": "WliTu6gIK7o" + }, + { + "name": "Calculate Money in Leetcode Bank", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1716-calculate-money-in-leetcode-bank", + "link": "calculate-money-in-leetcode-bank/", + "video": "tKK7gvPCQfs" + }, + { + "name": "Largest Odd Number in String", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1903-largest-odd-number-in-string", + "link": "largest-odd-number-in-string/", + "video": "svuPjFAUeDE", + "neetcode250": true + }, + { + "name": "Transpose Matrix", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0867-transpose-matrix", + "link": "transpose-matrix/", + "video": "DzMT3bDgVn0", + "neetcode250": true + }, + { + "name": "Image Smoother", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0661-image-smoother", + "link": "image-smoother/", + "video": "xa83GG1RIOY", + "neetcode250": true + }, + { + "name": "Count of Matches in Tournament", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1688-count-of-matches-in-tournament", + "link": "count-of-matches-in-tournament/", + "video": "lslcc0tumpU" + }, + { + "name": "Water Bottles", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1518-water-bottles", + "link": "water-bottles/", + "video": "V4d6xym5efE" + }, + { + "name": "Largest Local Values in a Matrix", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "2373-largest-local-values-in-a-matrix", + "link": "largest-local-values-in-a-matrix/", + "video": "wdTRu9sarFA" + }, + { + "name": "Power of Four", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0342-power-of-four", + "link": "power-of-four/", + "video": "qEYZPwnlM0U" + }, + { + "name": "Lucky Numbers in a Matrix", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1380-lucky-numbers-in-a-matrix", + "link": "lucky-numbers-in-a-matrix/", + "video": "ceuQgACqr78" + }, + { + "name": "Armstrong Number", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1134-armstrong-number", + "link": "armstrong-number/" + }, + { + "name": "Count Substrings with Only One Distinct Letter", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1180-count-substrings-with-only-one-distinct-letter", + "link": "count-substrings-with-only-one-distinct-letter/" + }, + { + "name": "Guess the Majority in a Hidden Array", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "1538-guess-the-majority-in-a-hidden-array", + "link": "guess-the-majority-in-a-hidden-array/" + }, + { + "name": "Maximum Number of Ones", + "pattern": "Math & Geometry", + "difficulty": "Hard", + "code": "1183-maximum-number-of-ones", + "link": "maximum-number-of-ones/" + }, + { + "name": "Maximum Points on a Line", + "pattern": "Math & Geometry", + "difficulty": "Hard", + "code": "0149-max-points-on-a-line", + "link": "max-points-on-a-line/", + "video": "Bb9lOXUOnFw" + }, + { + "name": "Magic Squares In Grid", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0840-magic-squares-in-grid", + "link": "magic-squares-in-grid/", + "video": "FV52wWrivNc", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Rotate Image", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0048-rotate-image", + "link": "rotate-image/", + "video": "fMSJSS7eO1w", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Spiral Matrix", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0054-spiral-matrix", + "link": "spiral-matrix/", + "video": "BJnMZNwUk1M", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Spiral Matrix II", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0059-spiral-matrix-ii", + "link": "spiral-matrix-ii/", + "video": "RvLrWFBJ9fM", + "neetcode250": true + }, + { + "name": "Spiral Matrix III", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0885-spiral-matrix-iii", + "link": "spiral-matrix-iii/", + "video": "Xf5Zm5Y8PKM" + }, + { + "name": "Spiral Matrix IV", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2326-spiral-matrix-iv", + "link": "spiral-matrix-iv/", + "video": "sOV1nRhmsMQ", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Set Matrix Zeroes", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0073-set-matrix-zeroes", + "link": "set-matrix-zeroes/", + "video": "T41rL0L3Pnw", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Happy Number", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0202-happy-number", + "link": "happy-number/", + "video": "ljz85bxOYJ0", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Plus One", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0066-plus-one", + "link": "plus-one/", + "video": "jIaA8boiG1s", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Palindrome Number", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0009-palindrome-number", + "link": "palindrome-number/", + "video": "yubRKwixN-U", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Ugly Number", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0263-ugly-number", + "link": "ugly-number/", + "video": "M0Zay1Qr9ws" + }, + { + "name": "Convert 1D Array Into 2D Array", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "2022-convert-1d-array-into-2d-array", + "link": "convert-1d-array-into-2d-array/", + "video": "l-VLzZ2riTc" + }, + { + "name": "Shift 2D Grid", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1260-shift-2d-grid", + "link": "shift-2d-grid/", + "video": "nJYFh4Dl-as", + "neetcode250": true + }, + { + "name": "Roman to Integer", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "0013-roman-to-integer", + "link": "roman-to-integer/", + "video": "3jdxYj3DD98", + "neetcode250": true + }, + { + "name": "Integer to Roman", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0012-integer-to-roman", + "link": "integer-to-roman/", + "video": "ohBNdSJyLh8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Pow(x, n)", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0050-powx-n", + "link": "powx-n/", + "video": "g9YQyYi4IQQ", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Find the Punishment Number of an Integer", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2698-find-the-punishment-number-of-an-integer", + "link": "find-the-punishment-number-of-an-integer/", + "video": "LWgksJP-5SA", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Check if Number is a Sum of Powers of Three", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "1780-check-if-number-is-a-sum-of-powers-of-three", + "link": "check-if-number-is-a-sum-of-powers-of-three/", + "video": "99ExTh_0Ycg", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Multiply Strings", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0043-multiply-strings", + "link": "multiply-strings/", + "video": "1vZswirL8Y8", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Detect Squares", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2013-detect-squares", + "link": "detect-squares/", + "video": "bahebearrDc", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Robot Bounded In Circle", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "1041-robot-bounded-in-circle", + "link": "robot-bounded-in-circle/", + "video": "nKv2LnC_g6E", + "neetcode250": true + }, + { + "name": "Walking Robot Simulation", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0874-walking-robot-simulation", + "link": "walking-robot-simulation/", + "video": "wpglWC6mnLg" + }, + { + "name": "Zigzag Conversion", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0006-zigzag-conversion", + "link": "zigzag-conversion/", + "video": "Q2Tw6gcVEwc" + }, + { + "name": "Rotating the Box", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "1861-rotating-the-box", + "link": "rotating-the-box/", + "video": "LZr1w0LVzFw" + }, + { + "name": "Sum of Square Numbers", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0633-sum-of-square-numbers", + "link": "sum-of-square-numbers/", + "video": "B0UrG_X2faA" + }, + { + "name": "Find Missing Observations", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2028-find-missing-observations", + "link": "find-missing-observations/", + "video": "86yKkaNi3sU" + }, + { + "name": "Minimum Time Difference", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0539-minimum-time-difference", + "link": "minimum-time-difference/", + "video": "LVBDzeUmNIQ" + }, + { + "name": "Minimum Operations to Make a Uni-Value Grid", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2033-minimum-operations-to-make-a-uni-value-grid", + "link": "minimum-operations-to-make-a-uni-value-grid/", + "video": "2LfVNDlx8mY" + }, + { + "name": "Largest Submatrix With Rearrangements", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "1727-largest-submatrix-with-rearrangements", + "link": "largest-submatrix-with-rearrangements/", + "video": "NYyIVuSCfOA" + }, + { + "name": "Wildest Vertical Area Between Two Points Containing No Points", + "pattern": "Math & Geometry", + "difficulty": "Easy", + "code": "1637-widest-vertical-area-between-two-points-containing-no-points", + "link": "widest-vertical-area-between-two-points-containing-no-points/", + "video": "6XnvNCTyJP4" + }, + { + "name": "Tuple with Same Product", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "1726-tuple-with-same-product", + "link": "tuple-with-same-product/", + "video": "SSwvMoOhiq0" + }, + { + "name": "Lexicographical Numbers", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0386-lexicographical-numbers", + "link": "lexicographical-numbers/", + "video": "QihtII-FvLo" + }, + { + "name": "Find the Winner of the Circular Game", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "1823-find-the-winner-of-the-circular-game", + "link": "find-the-winner-of-the-circular-game/", + "video": "PBBQgW_75e0" + }, + { + "name": "Count Total Number of Colored Cells", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2579-count-total-number-of-colored-cells", + "link": "count-total-number-of-colored-cells/", + "video": "Ajg7LRTBo6U" + }, + { + "name": "Prime Subtraction Operation", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2601-prime-subtraction-operation", + "link": "prime-subtraction-operation/", + "video": "G9cp9y45qEs" + }, + { + "name": "Closest Prime Numbers in Range", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2523-closest-prime-numbers-in-range", + "link": "closest-prime-numbers-in-range/", + "video": "lcdO8gSWZHw" + }, + { + "name": "Count Primes", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0204-count-primes", + "link": "count-primes/" + }, + { + "name": "Distribute Candies Among Children II", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "2929-distribute-candies-among-children-ii", + "link": "distribute-candies-among-children-ii/" + }, + { + "name": "Line Reflection", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0356-line-reflection", + "link": "line-reflection/" + }, + { + "name": "Minimum Factorization", + "pattern": "Math & Geometry", + "difficulty": "Medium", + "code": "0625-minimum-factorization", + "link": "minimum-factorization/" + }, + { + "name": "Minimum Number of One Bit Operations to Make Integers Zero", + "pattern": "Math & Geometry", + "difficulty": "Hard", + "code": "1611-minimum-one-bit-operations-to-make-integers-zero", + "link": "minimum-one-bit-operations-to-make-integers-zero/", + "video": "yRI18_MaG7k" + }, + { + "name": "K-th Smallest in Lexicographical Order", + "pattern": "Math & Geometry", + "difficulty": "Hard", + "code": "0440-k-th-smallest-in-lexicographical-order", + "link": "k-th-smallest-in-lexicographical-order/", + "video": "wRubz1zhVqk" + }, + { + "name": "Integer to English Words", + "pattern": "Math & Geometry", + "difficulty": "Hard", + "code": "0273-integer-to-english-words", + "link": "integer-to-english-words/", + "video": "SCtIlKd3mDM" + }, + { + "name": "Best Meeting Point", + "pattern": "Math & Geometry", + "difficulty": "Hard", + "code": "0296-best-meeting-point", + "link": "best-meeting-point/", + "neetcode150": true + } + ], + "Bit Manipulation": [ + { + "name": "Single Number", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0136-single-number", + "link": "single-number/", + "video": "qMPX1AOa83k", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Count Triplets with Even XOR Set Bits I", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "3199-count-triplets-with-even-xor-set-bits-i", + "link": "count-triplets-with-even-xor-set-bits-i/", + "neetcode250": true + }, + { + "name": "Single Number III", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "0260-single-number-iii", + "link": "single-number-iii/", + "video": "faoVORjd-T8", + "neetcode150": true + }, + { + "name": "Number of 1 Bits", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0191-number-of-1-bits", + "link": "number-of-1-bits/", + "video": "5Km3utixwZs", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Counting Bits", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0338-counting-bits", + "link": "counting-bits/", + "video": "RyBM56RIWrM", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Add Binary", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0067-add-binary", + "link": "add-binary/", + "video": "keuWJ47xG8g", + "neetcode250": true + }, + { + "name": "Minimum Bit Flips to Convert Number", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "2220-minimum-bit-flips-to-convert-number", + "link": "minimum-bit-flips-to-convert-number/", + "video": "yz48myznqQY", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Reverse Bits", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0190-reverse-bits", + "link": "reverse-bits/", + "video": "UcoN6UjAI64", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Missing Number", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0268-missing-number", + "link": "missing-number/", + "video": "WnPLSRLSANE", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Shuffle the Array", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "1470-shuffle-the-array", + "link": "shuffle-the-array/", + "video": "IvIKD_EU8BY", + "neetcode250": true + }, + { + "name": "Add to Array-Form of Integer", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0989-add-to-array-form-of-integer", + "link": "add-to-array-form-of-integer/", + "video": "eBTZQt1TWfk" + }, + { + "name": "Find the Difference", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0389-find-the-difference", + "link": "find-the-difference/", + "video": "oFmv4N4z00c" + }, + { + "name": "Power of Two", + "pattern": "Bit Manipulation", + "difficulty": "Easy", + "code": "0231-power-of-two", + "link": "power-of-two/", + "video": "H2bjttEV4Vc", + "neetcode150": true + }, + { + "name": "Sum of Two Integers", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "0371-sum-of-two-integers", + "link": "sum-of-two-integers/", + "video": "gVUrDV4tZfY", + "neetcode150": true, + "blind75": true, + "neetcode250": true + }, + { + "name": "Reverse Integer", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "0007-reverse-integer", + "link": "reverse-integer/", + "video": "HAgLH58IgJQ", + "neetcode150": true, + "neetcode250": true + }, + { + "name": "Bitwise XOR of All Pairings", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "2425-bitwise-xor-of-all-pairings", + "link": "bitwise-xor-of-all-pairings/", + "video": "H9zVwDf6Frk", + "neetcode250": true + }, + { + "name": "Largest Combination With Bitwise AND Greater Than Zero", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "2275-largest-combination-with-bitwise-and-greater-than-zero", + "link": "largest-combination-with-bitwise-and-greater-than-zero/", + "video": "rUYfBldVqLY" + }, + { + "name": "XOR Queries of a Subarray", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "1310-xor-queries-of-a-subarray", + "link": "xor-queries-of-a-subarray/", + "video": "1Q4lxfSlbPs" + }, + { + "name": "Maximum XOR for Each Query", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "1829-maximum-xor-for-each-query", + "link": "maximum-xor-for-each-query/", + "video": "FlSS5reeFyE" + }, + { + "name": "Neighboring Bitwise XOR", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "2633-neighboring-bitwise-xor", + "link": "neighboring-bitwise-xor/", + "video": "d2ntGf2tSDI" + }, + { + "name": "Shortest Subarray With OR at Least K II", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "3097-shortest-subarray-with-or-at-least-k-ii", + "link": "shortest-subarray-with-or-at-least-k-ii/", + "video": "Bq_BEsgBQOs" + }, + { + "name": "Bitwise AND of Numbers Range", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "0201-bitwise-and-of-numbers-range", + "link": "bitwise-and-of-numbers-range/", + "video": "R3T0olAhUq0", + "neetcode250": true + }, + { + "name": "Find Kth Bit in Nth Binary String", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "1545-find-kth-bit-in-nth-binary-string", + "link": "find-kth-bit-in-nth-binary-string/", + "video": "h9DOEqeb_ZA" + }, + { + "name": "Count Triplets That Can Form Two Arrays of Equal XOR", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "1442-count-triplets-that-can-form-two-arrays-of-equal-xor", + "link": "count-triplets-that-can-form-two-arrays-of-equal-xor/", + "video": "e4Yx9KjqzQ8", + "neetcode250": true + }, + { + "name": "Minimum Array End", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "3133-minimum-array-end", + "link": "minimum-array-end/", + "video": "4pP-0UpEok4", + "neetcode250": true + }, + { + "name": "Find if Array Can Be Sorted", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "3011-find-if-array-can-be-sorted", + "link": "find-if-array-can-be-sorted/", + "video": "OpOPUeGFjxE", + "neetcode250": true + }, + { + "name": "Longest Subarray With Maximum Bitwise AND", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "2419-longest-subarray-with-maximum-bitwise-and", + "link": "longest-subarray-with-maximum-bitwise-and/", + "video": "N8lRlRWA_1Q" + }, + { + "name": "Longest Nice Subarray", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "2401-longest-nice-subarray", + "link": "longest-nice-subarray/", + "video": "pcUmxsvTmP0" + }, + { + "name": "Find the Longest Substring Containing Vowels in Even Counts", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "1371-find-the-longest-substring-containing-vowels-in-even-counts", + "link": "find-the-longest-substring-containing-vowels-in-even-counts/", + "video": "o17MBWparrI" + }, + { + "name": "Minimize XOR", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "2429-minimize-xor", + "link": "minimize-xor/", + "video": "xhD78PX8Nss" + }, + { + "name": "IP to CIDR", + "pattern": "Bit Manipulation", + "difficulty": "Medium", + "code": "0751-ip-to-cidr", + "link": "ip-to-cidr/" + } + ], + "JavaScript": [ + { + "name": "Create Hello World Function", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2667-create-hello-world-function", + "link": "create-hello-world-function/", + "video": "P9Ldx1eTlRc" + }, + { + "name": "Counter", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2620-counter", + "link": "counter/", + "video": "yEGQQAG5V68" + }, + { + "name": "Counter II", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2665-counter-ii", + "link": "counter-ii/", + "video": "UXNXKGFZD08" + }, + { + "name": "Apply Transform over each Element in Array", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2635-apply-transform-over-each-element-in-array", + "link": "apply-transform-over-each-element-in-array/", + "video": "7FhJHA5jlYk" + }, + { + "name": "Filter Elements from Array", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2634-filter-elements-from-array", + "link": "filter-elements-from-array/", + "video": "w1o81gbEEJU" + }, + { + "name": "Array Reduce Transformation", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2626-array-reduce-transformation", + "link": "array-reduce-transformation/", + "video": "KmTbYfpGxdM" + }, + { + "name": "Function Composition", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2629-function-composition", + "link": "function-composition/", + "video": "mIFw1H7Ljco" + }, + { + "name": "Allow One Function Call", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2666-allow-one-function-call", + "link": "allow-one-function-call/", + "video": "m_SWhM9iX3s" + }, + { + "name": "Memoize", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2623-memoize", + "link": "memoize/", + "video": "oFXyzJt9VeU" + }, + { + "name": "Curry", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2632-curry", + "link": "curry/", + "video": "pi4kqMWQXxA" + }, + { + "name": "Sleep", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2621-sleep", + "link": "sleep/", + "video": "P0D9Z6H7O00" + }, + { + "name": "Promise Time Limit", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2637-promise-time-limit", + "link": "promise-time-limit/", + "video": "hfH57rdZhOk" + }, + { + "name": "Promise Pool", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2636-promise-pool", + "link": "promise-pool/", + "video": "DB8pAAg-9xw" + }, + { + "name": "Cache With Time Limit", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2622-cache-with-time-limit", + "link": "cache-with-time-limit/", + "video": "w772gtNK0Gw" + }, + { + "name": "Debounce", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2627-debounce", + "link": "debounce/", + "video": "1sxSpnxNx5w" + }, + { + "name": "Throttle", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2676-throttle", + "link": "throttle/", + "video": "zyGZV_fIQWk" + }, + { + "name": "JSON Deep Equal", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2628-json-deep-equal", + "link": "json-deep-equal/", + "video": "4JVZ-mVqJPg" + }, + { + "name": "Convert Object to JSON String", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2633-convert-object-to-json-string", + "link": "convert-object-to-json-string/", + "video": "f94fUbHU-FY" + }, + { + "name": "Array of Objects to Matrix", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2675-array-of-objects-to-matrix", + "link": "array-of-objects-to-matrix/", + "video": "LJwgAMHGcI0" + }, + { + "name": "Difference Between Two Objects", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2700-differences-between-two-objects", + "link": "differences-between-two-objects/", + "video": "gH7oZs1WZfg" + }, + { + "name": "Chunk Array", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2677-chunk-array", + "link": "chunk-array/", + "video": "VUN-O3B9ceY" + }, + { + "name": "Flatten Deeply Nested Array", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2625-flatten-deeply-nested-array", + "link": "flatten-deeply-nested-array/", + "video": "_DetLPKtFNk" + }, + { + "name": "Array Prototype Last", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2619-array-prototype-last", + "link": "array-prototype-last/", + "video": "3JdtfMBrUqc" + }, + { + "name": "Group By", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2631-group-by", + "link": "group-by/", + "video": "zs9axOyYHRE" + }, + { + "name": "Check if Object Instance of Class", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2618-check-if-object-instance-of-class", + "link": "check-if-object-instance-of-class/", + "video": "meIo-Q07Ba8" + }, + { + "name": "Call Function with Custom Context", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2693-call-function-with-custom-context", + "link": "call-function-with-custom-context/", + "video": "du_GH-Ooa8E" + }, + { + "name": "Event Emitter", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2694-event-emitter", + "link": "event-emitter/", + "video": "M69bjWFarU0" + }, + { + "name": "Array Wrapper", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2695-array-wrapper", + "link": "array-wrapper/", + "video": "XoGjPdPTAVA" + }, + { + "name": "Generate Fibonacci Sequence", + "pattern": "JavaScript", + "difficulty": "Easy", + "code": "2648-generate-fibonacci-sequence", + "link": "generate-fibonacci-sequence/", + "video": "T643rQ70Jlk" + }, + { + "name": "Nested Array Generator", + "pattern": "JavaScript", + "difficulty": "Medium", + "code": "2649-nested-array-generator", + "link": "nested-array-generator/", + "video": "yo-J1jQaZYU" + } + ] + }, + "coursesByTopic": { + "Arrays & Hashing": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Dynamic Arrays", + "routerLink": "/courses/dsa-for-beginners/3" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Hash Usage", + "routerLink": "/courses/dsa-for-beginners/26" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Hash Implementation", + "routerLink": "/courses/dsa-for-beginners/27" + }, + { + "course": "Advanced Algorithms", + "name": "Prefix Sums", + "routerLink": "/courses/advanced-algorithms/4" + } + ], + "Two Pointers": [ + { + "course": "Advanced Algorithms", + "name": "Two Pointers", + "routerLink": "/courses/advanced-algorithms/3" + } + ], + "Binary Search": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Search Array", + "routerLink": "/courses/dsa-for-beginners/14" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Search Range", + "routerLink": "/courses/dsa-for-beginners/15" + } + ], + "Sliding Window": [ + { + "course": "Advanced Algorithms", + "name": "Sliding Window Fixed Size", + "routerLink": "/courses/advanced-algorithms/1" + }, + { + "course": "Advanced Algorithms", + "name": "Sliding Window Variable Size", + "routerLink": "/courses/advanced-algorithms/2" + } + ], + "Linked List": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Singly Linked Lists", + "routerLink": "/courses/dsa-for-beginners/5" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Doubly Linked Lists", + "routerLink": "/courses/dsa-for-beginners/6" + }, + { + "course": "Advanced Algorithms", + "name": "Fast and Slow Pointers", + "routerLink": "/courses/advanced-algorithms/5" + } + ], + "Heap / Priority Queue": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Heap Properties", + "routerLink": "/courses/dsa-for-beginners/23" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Push and Pop", + "routerLink": "/courses/dsa-for-beginners/24" + }, + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Heapify", + "routerLink": "/courses/dsa-for-beginners/25" + }, + { + "course": "Advanced Algorithms", + "name": "Two Heaps", + "routerLink": "/courses/advanced-algorithms/10" + } + ], + "Advanced Graphs": [ + { + "course": "Advanced Algorithms", + "name": "Dijkstra's", + "routerLink": "/courses/advanced-algorithms/14" + }, + { + "course": "Advanced Algorithms", + "name": "Prim's", + "routerLink": "/courses/advanced-algorithms/15" + }, + { + "course": "Advanced Algorithms", + "name": "Kruskal's", + "routerLink": "/courses/advanced-algorithms/16" + }, + { + "course": "Advanced Algorithms", + "name": "Topological Sort", + "routerLink": "/courses/advanced-algorithms/17" + } + ], + "1-D Dynamic Programming": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "1-Dimension DP", + "routerLink": "/courses/dsa-for-beginners/32" + }, + { + "course": "Advanced Algorithms", + "name": "Palindromes", + "routerLink": "/courses/advanced-algorithms/21" + } + ], + "2-D Dynamic Programming": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "2-Dimension DP", + "routerLink": "/courses/dsa-for-beginners/33" + }, + { + "course": "Advanced Algorithms", + "name": "0 / 1 Knapsack", + "routerLink": "/courses/advanced-algorithms/18" + }, + { + "course": "Advanced Algorithms", + "name": "Unbounded Knapsack", + "routerLink": "/courses/advanced-algorithms/19" + }, + { + "course": "Advanced Algorithms", + "name": "LCS", + "routerLink": "/courses/advanced-algorithms/20" + } + ], + "Bit Manipulation": [ + { + "course": "Data Structures & Algorithms for Beginners", + "name": "Bit Operations", + "routerLink": "/courses/dsa-for-beginners/34" + } + ] + }, + "stats": { + "topics": 18, + "edges": 21, + "totalProblems": 965, + "neetcode150": 199 + } +} diff --git a/leetcode/out/roadmap.org b/leetcode/out/roadmap.org new file mode 100644 index 0000000..ea2a64f --- /dev/null +++ b/leetcode/out/roadmap.org @@ -0,0 +1,1049 @@ +#+TITLE: NeetCode Roadmap +#+DATE: 2026-05-31 +#+TODO: TODO DONE +#+STARTUP: overview + +Source: [[https://neetcode.io/roadmap][neetcode.io/roadmap]] + +* TODO Arrays & Hashing [0/12] + +- [ ] TODO 0217. Contains Duplicate :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0217-contains-duplicate.py][0217-contains-duplicate.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0217-contains-duplicate.cpp][0217-contains-duplicate.cpp]] + - LeetCode: [[https://leetcode.com/problems/contains-duplicate/][contains-duplicate/]] + - Video: [[https://youtube.com/watch?v=3OamzN90kPg][explanation]] +- [ ] TODO 0242. Valid Anagram :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0242-valid-anagram.py][0242-valid-anagram.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0242-valid-anagram.cpp][0242-valid-anagram.cpp]] + - LeetCode: [[https://leetcode.com/problems/valid-anagram/][valid-anagram/]] + - Video: [[https://youtube.com/watch?v=9UtInBqnCgA][explanation]] +- [ ] TODO 2678. Number of Senior Citizens :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2678-number-of-senior-citizens.py][2678-number-of-senior-citizens.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2678-number-of-senior-citizens.cpp][2678-number-of-senior-citizens.cpp]] + - LeetCode: [[https://leetcode.com/problems/number-of-senior-citizens/][number-of-senior-citizens/]] + - Video: [[https://youtube.com/watch?v=l6_wwKzFmVo][explanation]] +- [ ] TODO 0001. Two Sum :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0001-two-sum.py][0001-two-sum.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0001-two-sum.cpp][0001-two-sum.cpp]] + - LeetCode: [[https://leetcode.com/problems/two-sum/][two-sum/]] + - Video: [[https://youtube.com/watch?v=KLlXCFG5TnA][explanation]] +- [ ] TODO 1408. String Matching in an Array :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1408-string-matching-in-an-array.py][1408-string-matching-in-an-array.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1408-string-matching-in-an-array.cpp][1408-string-matching-in-an-array.cpp]] + - LeetCode: [[https://leetcode.com/problems/string-matching-in-an-array/][string-matching-in-an-array/]] + - Video: [[https://youtube.com/watch?v=7K2BjgjCFDo][explanation]] +- [ ] TODO 0049. Group Anagrams :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0049-group-anagrams.py][0049-group-anagrams.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0049-group-anagrams.cpp][0049-group-anagrams.cpp]] + - LeetCode: [[https://leetcode.com/problems/group-anagrams/][group-anagrams/]] + - Video: [[https://youtube.com/watch?v=vzdNOK2oB2E][explanation]] +- [ ] TODO 0347. Top K Frequent Elements :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0347-top-k-frequent-elements.py][0347-top-k-frequent-elements.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0347-top-k-frequent-elements.cpp][0347-top-k-frequent-elements.cpp]] + - LeetCode: [[https://leetcode.com/problems/top-k-frequent-elements/][top-k-frequent-elements/]] + - Video: [[https://youtube.com/watch?v=YPTqKIgVk-k][explanation]] +- [ ] TODO 0271. Encode and Decode Strings :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0271-encode-and-decode-strings.py][0271-encode-and-decode-strings.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0271-encode-and-decode-strings.cpp][0271-encode-and-decode-strings.cpp]] + - LeetCode: [[https://leetcode.com/problems/encode-and-decode-strings/][encode-and-decode-strings/]] + - Video: [[https://youtube.com/watch?v=B1k_sxOSgv8][explanation]] +- [ ] TODO 0238. Product of Array Except Self :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0238-product-of-array-except-self.py][0238-product-of-array-except-self.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0238-product-of-array-except-self.cpp][0238-product-of-array-except-self.cpp]] + - LeetCode: [[https://leetcode.com/problems/product-of-array-except-self/][product-of-array-except-self/]] + - Video: [[https://youtube.com/watch?v=bNvIQI2wAjk][explanation]] +- [ ] TODO 1769. Minimum Number of Operations to Move All Balls to Each Box :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.py][1769-minimum-number-of-operations-to-move-all-balls-to-each-box.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.cpp][1769-minimum-number-of-operations-to-move-all-balls-to-each-box.cpp]] + - LeetCode: [[https://leetcode.com/problems/minimum-number-of-operations-to-move-all-balls-to-each-box/][minimum-number-of-operations-to-move-all-balls-to-each-box/]] + - Video: [[https://youtube.com/watch?v=ZmH3gHiIqfI][explanation]] +- [ ] TODO 0036. Valid Sudoku :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0036-valid-sudoku.py][0036-valid-sudoku.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0036-valid-sudoku.cpp][0036-valid-sudoku.cpp]] + - LeetCode: [[https://leetcode.com/problems/valid-sudoku/][valid-sudoku/]] + - Video: [[https://youtube.com/watch?v=TjFXEUCMqI8][explanation]] +- [ ] TODO 0128. Longest Consecutive Sequence :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0128-longest-consecutive-sequence.py][0128-longest-consecutive-sequence.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0128-longest-consecutive-sequence.cpp][0128-longest-consecutive-sequence.cpp]] + - LeetCode: [[https://leetcode.com/problems/longest-consecutive-sequence/][longest-consecutive-sequence/]] + - Video: [[https://youtube.com/watch?v=P6RZZMu_maU][explanation]] + +* TODO Two Pointers [/] + +- [ ] TODO 0344. Reverse String :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0344-reverse-string.py][0344-reverse-string.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0344-reverse-string.cpp][0344-reverse-string.cpp]] + - LeetCode: [[https://leetcode.com/problems/reverse-string/][reverse-string/]] + - Video: [[https://youtube.com/watch?v=_d0T_2Lk2qA][explanation]] +- [ ] TODO 0125. Valid Palindrome :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0125-valid-palindrome.py][0125-valid-palindrome.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0125-valid-palindrome.cpp][0125-valid-palindrome.cpp]] + - LeetCode: [[https://leetcode.com/problems/valid-palindrome/][valid-palindrome/]] + - Video: [[https://youtube.com/watch?v=jJXJ16kPFWg][explanation]] +- [ ] TODO 0167. Two Sum II Input Array Is Sorted :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0167-two-sum-ii-input-array-is-sorted.py][0167-two-sum-ii-input-array-is-sorted.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0167-two-sum-ii-input-array-is-sorted.cpp][0167-two-sum-ii-input-array-is-sorted.cpp]] + - LeetCode: [[https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/][two-sum-ii-input-array-is-sorted/]] + - Video: [[https://youtube.com/watch?v=cQ1Oz4ckceM][explanation]] +- [ ] TODO 0015. 3Sum :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0015-3sum.py][0015-3sum.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0015-3sum.cpp][0015-3sum.cpp]] + - LeetCode: [[https://leetcode.com/problems/3sum/][3sum/]] + - Video: [[https://youtube.com/watch?v=jzZsG8n2R9A][explanation]] +- [ ] TODO 0011. Container With Most Water :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0011-container-with-most-water.py][0011-container-with-most-water.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0011-container-with-most-water.cpp][0011-container-with-most-water.cpp]] + - LeetCode: [[https://leetcode.com/problems/container-with-most-water/][container-with-most-water/]] + - Video: [[https://youtube.com/watch?v=UuiTKBwPgAo][explanation]] +- [ ] TODO 0259. 3Sum Smaller :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0259-3sum-smaller.py][0259-3sum-smaller.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0259-3sum-smaller.cpp][0259-3sum-smaller.cpp]] + - LeetCode: [[https://leetcode.com/problems/3sum-smaller/][3sum-smaller/]] +- [ ] TODO 0042. Trapping Rain Water :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0042-trapping-rain-water.py][0042-trapping-rain-water.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0042-trapping-rain-water.cpp][0042-trapping-rain-water.cpp]] + - LeetCode: [[https://leetcode.com/problems/trapping-rain-water/][trapping-rain-water/]] + - Video: [[https://youtube.com/watch?v=ZI2z5pq0TqA][explanation]] + +* TODO Binary Search [/] + +- [ ] TODO 0704. Binary Search :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0704-binary-search.py][0704-binary-search.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0704-binary-search.cpp][0704-binary-search.cpp]] + - LeetCode: [[https://leetcode.com/problems/binary-search/][binary-search/]] + - Video: [[https://youtube.com/watch?v=s4DPM8ct1pI][explanation]] +- [ ] TODO 2300. Successful Pairs of Spells and Potions :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2300-successful-pairs-of-spells-and-potions.py][2300-successful-pairs-of-spells-and-potions.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2300-successful-pairs-of-spells-and-potions.cpp][2300-successful-pairs-of-spells-and-potions.cpp]] + - LeetCode: [[https://leetcode.com/problems/successful-pairs-of-spells-and-potions/][successful-pairs-of-spells-and-potions/]] + - Video: [[https://youtube.com/watch?v=OKnm5oyAhWg][explanation]] +- [ ] TODO 0074. Search a 2D Matrix :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0074-search-a-2d-matrix.py][0074-search-a-2d-matrix.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0074-search-a-2d-matrix.cpp][0074-search-a-2d-matrix.cpp]] + - LeetCode: [[https://leetcode.com/problems/search-a-2d-matrix/][search-a-2d-matrix/]] + - Video: [[https://youtube.com/watch?v=Ber2pi2C0j0][explanation]] +- [ ] TODO 0875. Koko Eating Bananas :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0875-koko-eating-bananas.py][0875-koko-eating-bananas.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0875-koko-eating-bananas.cpp][0875-koko-eating-bananas.cpp]] + - LeetCode: [[https://leetcode.com/problems/koko-eating-bananas/][koko-eating-bananas/]] + - Video: [[https://youtube.com/watch?v=U2SozAs9RzA][explanation]] +- [ ] TODO 0153. Find Minimum In Rotated Sorted Array :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0153-find-minimum-in-rotated-sorted-array.py][0153-find-minimum-in-rotated-sorted-array.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0153-find-minimum-in-rotated-sorted-array.cpp][0153-find-minimum-in-rotated-sorted-array.cpp]] + - LeetCode: [[https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/][find-minimum-in-rotated-sorted-array/]] + - Video: [[https://youtube.com/watch?v=nIVW4P8b1VA][explanation]] +- [ ] TODO 0033. Search In Rotated Sorted Array :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0033-search-in-rotated-sorted-array.py][0033-search-in-rotated-sorted-array.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0033-search-in-rotated-sorted-array.cpp][0033-search-in-rotated-sorted-array.cpp]] + - LeetCode: [[https://leetcode.com/problems/search-in-rotated-sorted-array/][search-in-rotated-sorted-array/]] + - Video: [[https://youtube.com/watch?v=U8XENwh8Oy8][explanation]] +- [ ] TODO 0981. Time Based Key Value Store :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0981-time-based-key-value-store.py][0981-time-based-key-value-store.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0981-time-based-key-value-store.cpp][0981-time-based-key-value-store.cpp]] + - LeetCode: [[https://leetcode.com/problems/time-based-key-value-store/][time-based-key-value-store/]] + - Video: [[https://youtube.com/watch?v=fu2cD_6E8Hw][explanation]] +- [ ] TODO 0719. Find K-th Smallest Pair Distance :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0719-find-k-th-smallest-pair-distance.py][0719-find-k-th-smallest-pair-distance.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0719-find-k-th-smallest-pair-distance.cpp][0719-find-k-th-smallest-pair-distance.cpp]] + - LeetCode: [[https://leetcode.com/problems/find-k-th-smallest-pair-distance/][find-k-th-smallest-pair-distance/]] + - Video: [[https://youtube.com/watch?v=bQ-QcFKwsZc][explanation]] +- [ ] TODO 0004. Median of Two Sorted Arrays :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0004-median-of-two-sorted-arrays.py][0004-median-of-two-sorted-arrays.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0004-median-of-two-sorted-arrays.cpp][0004-median-of-two-sorted-arrays.cpp]] + - LeetCode: [[https://leetcode.com/problems/median-of-two-sorted-arrays/][median-of-two-sorted-arrays/]] + - Video: [[https://youtube.com/watch?v=q6IEA26hvXc][explanation]] + +* TODO Stack [/] + +- [ ] TODO 0682. Baseball Game :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0682-baseball-game.py][0682-baseball-game.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0682-baseball-game.cpp][0682-baseball-game.cpp]] + - LeetCode: [[https://leetcode.com/problems/baseball-game/][baseball-game/]] + - Video: [[https://youtube.com/watch?v=Id_tqGdsZQI][explanation]] +- [ ] TODO 0020. Valid Parentheses :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0020-valid-parentheses.py][0020-valid-parentheses.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0020-valid-parentheses.cpp][0020-valid-parentheses.cpp]] + - LeetCode: [[https://leetcode.com/problems/valid-parentheses/][valid-parentheses/]] + - Video: [[https://youtube.com/watch?v=WTzjTskDFMg][explanation]] +- [ ] TODO 1544. Make The String Great :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1544-make-the-string-great.py][1544-make-the-string-great.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1544-make-the-string-great.cpp][1544-make-the-string-great.cpp]] + - LeetCode: [[https://leetcode.com/problems/make-the-string-great/][make-the-string-great/]] + - Video: [[https://youtube.com/watch?v=10tBWNjzvtw][explanation]] +- [ ] TODO 0155. Min Stack :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0155-min-stack.py][0155-min-stack.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0155-min-stack.cpp][0155-min-stack.cpp]] + - LeetCode: [[https://leetcode.com/problems/min-stack/][min-stack/]] + - Video: [[https://youtube.com/watch?v=qkLl7nAwDPo][explanation]] +- [ ] TODO 0150. Evaluate Reverse Polish Notation :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0150-evaluate-reverse-polish-notation.py][0150-evaluate-reverse-polish-notation.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0150-evaluate-reverse-polish-notation.cpp][0150-evaluate-reverse-polish-notation.cpp]] + - LeetCode: [[https://leetcode.com/problems/evaluate-reverse-polish-notation/][evaluate-reverse-polish-notation/]] + - Video: [[https://youtube.com/watch?v=iu0082c4HDE][explanation]] +- [ ] TODO 0739. Daily Temperatures :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0739-daily-temperatures.py][0739-daily-temperatures.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0739-daily-temperatures.cpp][0739-daily-temperatures.cpp]] + - LeetCode: [[https://leetcode.com/problems/daily-temperatures/][daily-temperatures/]] + - Video: [[https://youtube.com/watch?v=cTBiBSnjO3c][explanation]] +- [ ] TODO 0901. Online Stock Span :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0901-online-stock-span.py][0901-online-stock-span.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0901-online-stock-span.cpp][0901-online-stock-span.cpp]] + - LeetCode: [[https://leetcode.com/problems/online-stock-span/][online-stock-span/]] + - Video: [[https://youtube.com/watch?v=slYh0ZNEqSw][explanation]] +- [ ] TODO 0853. Car Fleet :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0853-car-fleet.py][0853-car-fleet.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0853-car-fleet.cpp][0853-car-fleet.cpp]] + - LeetCode: [[https://leetcode.com/problems/car-fleet/][car-fleet/]] + - Video: [[https://youtube.com/watch?v=Pr6T-3yB9RM][explanation]] +- [ ] TODO 0084. Largest Rectangle In Histogram :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0084-largest-rectangle-in-histogram.py][0084-largest-rectangle-in-histogram.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0084-largest-rectangle-in-histogram.cpp][0084-largest-rectangle-in-histogram.cpp]] + - LeetCode: [[https://leetcode.com/problems/largest-rectangle-in-histogram/][largest-rectangle-in-histogram/]] + - Video: [[https://youtube.com/watch?v=zx5Sw9130L0][explanation]] +- [ ] TODO 0726. Number of Atoms :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0726-number-of-atoms.py][0726-number-of-atoms.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0726-number-of-atoms.cpp][0726-number-of-atoms.cpp]] + - LeetCode: [[https://leetcode.com/problems/number-of-atoms/][number-of-atoms/]] + - Video: [[https://youtube.com/watch?v=iuK05gGBzJc][explanation]] + +* TODO Sliding Window [/] + +- [ ] TODO 0121. Best Time to Buy And Sell Stock :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0121-best-time-to-buy-and-sell-stock.py][0121-best-time-to-buy-and-sell-stock.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0121-best-time-to-buy-and-sell-stock.cpp][0121-best-time-to-buy-and-sell-stock.cpp]] + - LeetCode: [[https://leetcode.com/problems/best-time-to-buy-and-sell-stock/][best-time-to-buy-and-sell-stock/]] + - Video: [[https://youtube.com/watch?v=1pkOgXD63yU][explanation]] +- [ ] TODO 0003. Longest Substring Without Repeating Characters :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0003-longest-substring-without-repeating-characters.py][0003-longest-substring-without-repeating-characters.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0003-longest-substring-without-repeating-characters.cpp][0003-longest-substring-without-repeating-characters.cpp]] + - LeetCode: [[https://leetcode.com/problems/longest-substring-without-repeating-characters/][longest-substring-without-repeating-characters/]] + - Video: [[https://youtube.com/watch?v=wiGpQwVHdE0][explanation]] +- [ ] TODO 0424. Longest Repeating Character Replacement :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0424-longest-repeating-character-replacement.py][0424-longest-repeating-character-replacement.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0424-longest-repeating-character-replacement.cpp][0424-longest-repeating-character-replacement.cpp]] + - LeetCode: [[https://leetcode.com/problems/longest-repeating-character-replacement/][longest-repeating-character-replacement/]] + - Video: [[https://youtube.com/watch?v=gqXU1UyA8pk][explanation]] +- [ ] TODO 0567. Permutation In String :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0567-permutation-in-string.py][0567-permutation-in-string.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0567-permutation-in-string.cpp][0567-permutation-in-string.cpp]] + - LeetCode: [[https://leetcode.com/problems/permutation-in-string/][permutation-in-string/]] + - Video: [[https://youtube.com/watch?v=UbyhOgBN834][explanation]] +- [ ] TODO 3306. Count of Substrings Containing Every Vowel and K Consonants II :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/3306-count-of-substrings-containing-every-vowel-and-k-consonants-ii.py][3306-count-of-substrings-containing-every-vowel-and-k-consonants-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/3306-count-of-substrings-containing-every-vowel-and-k-consonants-ii.cpp][3306-count-of-substrings-containing-every-vowel-and-k-consonants-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/count-of-substrings-containing-every-vowel-and-k-consonants-ii/][count-of-substrings-containing-every-vowel-and-k-consonants-ii/]] + - Video: [[https://youtube.com/watch?v=2wANakxRZNo][explanation]] +- [ ] TODO 0076. Minimum Window Substring :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0076-minimum-window-substring.py][0076-minimum-window-substring.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0076-minimum-window-substring.cpp][0076-minimum-window-substring.cpp]] + - LeetCode: [[https://leetcode.com/problems/minimum-window-substring/][minimum-window-substring/]] + - Video: [[https://youtube.com/watch?v=jSto0O4AJbM][explanation]] +- [ ] TODO 0239. Sliding Window Maximum :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0239-sliding-window-maximum.py][0239-sliding-window-maximum.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0239-sliding-window-maximum.cpp][0239-sliding-window-maximum.cpp]] + - LeetCode: [[https://leetcode.com/problems/sliding-window-maximum/][sliding-window-maximum/]] + - Video: [[https://youtube.com/watch?v=DfljaUwZsOk][explanation]] + +* TODO Linked List [/] + +- [ ] TODO 0206. Reverse Linked List :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0206-reverse-linked-list.py][0206-reverse-linked-list.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0206-reverse-linked-list.cpp][0206-reverse-linked-list.cpp]] + - LeetCode: [[https://leetcode.com/problems/reverse-linked-list/][reverse-linked-list/]] + - Video: [[https://youtube.com/watch?v=G0_I-ZF0S38][explanation]] +- [ ] TODO 0021. Merge Two Sorted Lists :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0021-merge-two-sorted-lists.py][0021-merge-two-sorted-lists.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0021-merge-two-sorted-lists.cpp][0021-merge-two-sorted-lists.cpp]] + - LeetCode: [[https://leetcode.com/problems/merge-two-sorted-lists/][merge-two-sorted-lists/]] + - Video: [[https://youtube.com/watch?v=XIdigk956u0][explanation]] +- [ ] TODO 0141. Linked List Cycle :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0141-linked-list-cycle.py][0141-linked-list-cycle.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0141-linked-list-cycle.cpp][0141-linked-list-cycle.cpp]] + - LeetCode: [[https://leetcode.com/problems/linked-list-cycle/][linked-list-cycle/]] + - Video: [[https://youtube.com/watch?v=gBTe7lFR3vc][explanation]] +- [ ] TODO 2487. Remove Nodes From Linked List :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2487-remove-nodes-from-linked-list.py][2487-remove-nodes-from-linked-list.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2487-remove-nodes-from-linked-list.cpp][2487-remove-nodes-from-linked-list.cpp]] + - LeetCode: [[https://leetcode.com/problems/remove-nodes-from-linked-list/][remove-nodes-from-linked-list/]] + - Video: [[https://youtube.com/watch?v=y783sRTezDg][explanation]] +- [ ] TODO 0143. Reorder List :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0143-reorder-list.py][0143-reorder-list.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0143-reorder-list.cpp][0143-reorder-list.cpp]] + - LeetCode: [[https://leetcode.com/problems/reorder-list/][reorder-list/]] + - Video: [[https://youtube.com/watch?v=S5bfdUTrKLM][explanation]] +- [ ] TODO 0019. Remove Nth Node From End of List :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0019-remove-nth-node-from-end-of-list.py][0019-remove-nth-node-from-end-of-list.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0019-remove-nth-node-from-end-of-list.cpp][0019-remove-nth-node-from-end-of-list.cpp]] + - LeetCode: [[https://leetcode.com/problems/remove-nth-node-from-end-of-list/][remove-nth-node-from-end-of-list/]] + - Video: [[https://youtube.com/watch?v=XVuQxVej6y8][explanation]] +- [ ] TODO 1721. Swapping Nodes in a Linked List :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1721-swapping-nodes-in-a-linked-list.py][1721-swapping-nodes-in-a-linked-list.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1721-swapping-nodes-in-a-linked-list.cpp][1721-swapping-nodes-in-a-linked-list.cpp]] + - LeetCode: [[https://leetcode.com/problems/swapping-nodes-in-a-linked-list/][swapping-nodes-in-a-linked-list/]] + - Video: [[https://youtube.com/watch?v=4LsrgMyQIjQ][explanation]] +- [ ] TODO 0138. Copy List With Random Pointer :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0138-copy-list-with-random-pointer.py][0138-copy-list-with-random-pointer.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0138-copy-list-with-random-pointer.cpp][0138-copy-list-with-random-pointer.cpp]] + - LeetCode: [[https://leetcode.com/problems/copy-list-with-random-pointer/][copy-list-with-random-pointer/]] + - Video: [[https://youtube.com/watch?v=5Y2EiZST97Y][explanation]] +- [ ] TODO 1472. Design Browser History :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1472-design-browser-history.py][1472-design-browser-history.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1472-design-browser-history.cpp][1472-design-browser-history.cpp]] + - LeetCode: [[https://leetcode.com/problems/design-browser-history/][design-browser-history/]] + - Video: [[https://youtube.com/watch?v=i1G-kKnBu8k][explanation]] +- [ ] TODO 0002. Add Two Numbers :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0002-add-two-numbers.py][0002-add-two-numbers.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0002-add-two-numbers.cpp][0002-add-two-numbers.cpp]] + - LeetCode: [[https://leetcode.com/problems/add-two-numbers/][add-two-numbers/]] + - Video: [[https://youtube.com/watch?v=wgFPrzTjm7s][explanation]] +- [ ] TODO 0287. Find The Duplicate Number :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0287-find-the-duplicate-number.py][0287-find-the-duplicate-number.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0287-find-the-duplicate-number.cpp][0287-find-the-duplicate-number.cpp]] + - LeetCode: [[https://leetcode.com/problems/find-the-duplicate-number/][find-the-duplicate-number/]] + - Video: [[https://youtube.com/watch?v=wjYnzkAhcNk][explanation]] +- [ ] TODO 0725. Split Linked List in Parts :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0725-split-linked-list-in-parts.py][0725-split-linked-list-in-parts.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0725-split-linked-list-in-parts.cpp][0725-split-linked-list-in-parts.cpp]] + - LeetCode: [[https://leetcode.com/problems/split-linked-list-in-parts/][split-linked-list-in-parts/]] + - Video: [[https://youtube.com/watch?v=-OTlqdrxrVI][explanation]] +- [ ] TODO 0146. LRU Cache :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0146-lru-cache.py][0146-lru-cache.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0146-lru-cache.cpp][0146-lru-cache.cpp]] + - LeetCode: [[https://leetcode.com/problems/lru-cache/][lru-cache/]] + - Video: [[https://youtube.com/watch?v=7ABFKPK2hD4][explanation]] +- [ ] TODO 0023. Merge K Sorted Lists :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0023-merge-k-sorted-lists.py][0023-merge-k-sorted-lists.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0023-merge-k-sorted-lists.cpp][0023-merge-k-sorted-lists.cpp]] + - LeetCode: [[https://leetcode.com/problems/merge-k-sorted-lists/][merge-k-sorted-lists/]] + - Video: [[https://youtube.com/watch?v=q5a5OiGbT6Q][explanation]] +- [ ] TODO 0025. Reverse Nodes In K Group :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0025-reverse-nodes-in-k-group.py][0025-reverse-nodes-in-k-group.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0025-reverse-nodes-in-k-group.cpp][0025-reverse-nodes-in-k-group.cpp]] + - LeetCode: [[https://leetcode.com/problems/reverse-nodes-in-k-group/][reverse-nodes-in-k-group/]] + - Video: [[https://youtube.com/watch?v=1UOPsfP85V4][explanation]] + +* TODO Trees [/] + +- [ ] TODO 0590. N-ary Tree Postorder Traversal :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0590-n-ary-tree-postorder-traversal.py][0590-n-ary-tree-postorder-traversal.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0590-n-ary-tree-postorder-traversal.cpp][0590-n-ary-tree-postorder-traversal.cpp]] + - LeetCode: [[https://leetcode.com/problems/n-ary-tree-postorder-traversal/][n-ary-tree-postorder-traversal/]] + - Video: [[https://youtube.com/watch?v=GMUI91_pDmM][explanation]] +- [ ] TODO 0226. Invert Binary Tree :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0226-invert-binary-tree.py][0226-invert-binary-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0226-invert-binary-tree.cpp][0226-invert-binary-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/invert-binary-tree/][invert-binary-tree/]] + - Video: [[https://youtube.com/watch?v=OnSn2XEQ4MY][explanation]] +- [ ] TODO 0104. Maximum Depth of Binary Tree :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0104-maximum-depth-of-binary-tree.py][0104-maximum-depth-of-binary-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0104-maximum-depth-of-binary-tree.cpp][0104-maximum-depth-of-binary-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/maximum-depth-of-binary-tree/][maximum-depth-of-binary-tree/]] + - Video: [[https://youtube.com/watch?v=hTM3phVI6YQ][explanation]] +- [ ] TODO 0543. Diameter of Binary Tree :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0543-diameter-of-binary-tree.py][0543-diameter-of-binary-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0543-diameter-of-binary-tree.cpp][0543-diameter-of-binary-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/diameter-of-binary-tree/][diameter-of-binary-tree/]] + - Video: [[https://youtube.com/watch?v=K81C31ytOZE][explanation]] +- [ ] TODO 0110. Balanced Binary Tree :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0110-balanced-binary-tree.py][0110-balanced-binary-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0110-balanced-binary-tree.cpp][0110-balanced-binary-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/balanced-binary-tree/][balanced-binary-tree/]] + - Video: [[https://youtube.com/watch?v=QfJsau0ItOY][explanation]] +- [ ] TODO 0100. Same Tree :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0100-same-tree.py][0100-same-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0100-same-tree.cpp][0100-same-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/same-tree/][same-tree/]] + - Video: [[https://youtube.com/watch?v=vRbbcKXCxOw][explanation]] +- [ ] TODO 0572. Subtree of Another Tree :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0572-subtree-of-another-tree.py][0572-subtree-of-another-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0572-subtree-of-another-tree.cpp][0572-subtree-of-another-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/subtree-of-another-tree/][subtree-of-another-tree/]] + - Video: [[https://youtube.com/watch?v=E36O5SWp-LE][explanation]] +- [ ] TODO 0235. Lowest Common Ancestor of a Binary Search Tree :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0235-lowest-common-ancestor-of-a-binary-search-tree.py][0235-lowest-common-ancestor-of-a-binary-search-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0235-lowest-common-ancestor-of-a-binary-search-tree.cpp][0235-lowest-common-ancestor-of-a-binary-search-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/][lowest-common-ancestor-of-a-binary-search-tree/]] + - Video: [[https://youtube.com/watch?v=gs2LMfuOR9k][explanation]] +- [ ] TODO 0102. Binary Tree Level Order Traversal :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0102-binary-tree-level-order-traversal.py][0102-binary-tree-level-order-traversal.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0102-binary-tree-level-order-traversal.cpp][0102-binary-tree-level-order-traversal.cpp]] + - LeetCode: [[https://leetcode.com/problems/binary-tree-level-order-traversal/][binary-tree-level-order-traversal/]] + - Video: [[https://youtube.com/watch?v=6ZnyEApgFYg][explanation]] +- [ ] TODO 0199. Binary Tree Right Side View :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0199-binary-tree-right-side-view.py][0199-binary-tree-right-side-view.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0199-binary-tree-right-side-view.cpp][0199-binary-tree-right-side-view.cpp]] + - LeetCode: [[https://leetcode.com/problems/binary-tree-right-side-view/][binary-tree-right-side-view/]] + - Video: [[https://youtube.com/watch?v=d4zLyf32e3I][explanation]] +- [ ] TODO 1376. Time Needed to Inform All Employees :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1376-time-needed-to-inform-all-employees.py][1376-time-needed-to-inform-all-employees.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1376-time-needed-to-inform-all-employees.cpp][1376-time-needed-to-inform-all-employees.cpp]] + - LeetCode: [[https://leetcode.com/problems/time-needed-to-inform-all-employees/][time-needed-to-inform-all-employees/]] + - Video: [[https://youtube.com/watch?v=zdBYi0p4L5Q][explanation]] +- [ ] TODO 1448. Count Good Nodes In Binary Tree :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1448-count-good-nodes-in-binary-tree.py][1448-count-good-nodes-in-binary-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1448-count-good-nodes-in-binary-tree.cpp][1448-count-good-nodes-in-binary-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/count-good-nodes-in-binary-tree/][count-good-nodes-in-binary-tree/]] + - Video: [[https://youtube.com/watch?v=7cp5imvDzl4][explanation]] +- [ ] TODO 0098. Validate Binary Search Tree :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0098-validate-binary-search-tree.py][0098-validate-binary-search-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0098-validate-binary-search-tree.cpp][0098-validate-binary-search-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/validate-binary-search-tree/][validate-binary-search-tree/]] + - Video: [[https://youtube.com/watch?v=s6ATEkipzow][explanation]] +- [ ] TODO 0230. Kth Smallest Element In a Bst :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0230-kth-smallest-element-in-a-bst.py][0230-kth-smallest-element-in-a-bst.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0230-kth-smallest-element-in-a-bst.cpp][0230-kth-smallest-element-in-a-bst.cpp]] + - LeetCode: [[https://leetcode.com/problems/kth-smallest-element-in-a-bst/][kth-smallest-element-in-a-bst/]] + - Video: [[https://youtube.com/watch?v=5LUXSvjmGCw][explanation]] +- [ ] TODO 0105. Construct Binary Tree From Preorder And Inorder Traversal :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0105-construct-binary-tree-from-preorder-and-inorder-traversal.py][0105-construct-binary-tree-from-preorder-and-inorder-traversal.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0105-construct-binary-tree-from-preorder-and-inorder-traversal.cpp][0105-construct-binary-tree-from-preorder-and-inorder-traversal.cpp]] + - LeetCode: [[https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/][construct-binary-tree-from-preorder-and-inorder-traversal/]] + - Video: [[https://youtube.com/watch?v=ihj4IQGZ2zc][explanation]] +- [ ] TODO 1028. Recover a Tree From Preorder Traversal :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1028-recover-a-tree-from-preorder-traversal.py][1028-recover-a-tree-from-preorder-traversal.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1028-recover-a-tree-from-preorder-traversal.cpp][1028-recover-a-tree-from-preorder-traversal.cpp]] + - LeetCode: [[https://leetcode.com/problems/recover-a-tree-from-preorder-traversal/][recover-a-tree-from-preorder-traversal/]] + - Video: [[https://youtube.com/watch?v=VroH6J47kIE][explanation]] +- [ ] TODO 0124. Binary Tree Maximum Path Sum :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0124-binary-tree-maximum-path-sum.py][0124-binary-tree-maximum-path-sum.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0124-binary-tree-maximum-path-sum.cpp][0124-binary-tree-maximum-path-sum.cpp]] + - LeetCode: [[https://leetcode.com/problems/binary-tree-maximum-path-sum/][binary-tree-maximum-path-sum/]] + - Video: [[https://youtube.com/watch?v=Hr5cWUld4vU][explanation]] +- [ ] TODO 0297. Serialize And Deserialize Binary Tree :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0297-serialize-and-deserialize-binary-tree.py][0297-serialize-and-deserialize-binary-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0297-serialize-and-deserialize-binary-tree.cpp][0297-serialize-and-deserialize-binary-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/serialize-and-deserialize-binary-tree/][serialize-and-deserialize-binary-tree/]] + - Video: [[https://youtube.com/watch?v=u4JAi2JJhI8][explanation]] + +* TODO Tries [/] + +- [ ] TODO 0208. Implement Trie Prefix Tree :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0208-implement-trie-prefix-tree.py][0208-implement-trie-prefix-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0208-implement-trie-prefix-tree.cpp][0208-implement-trie-prefix-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/implement-trie-prefix-tree/][implement-trie-prefix-tree/]] + - Video: [[https://youtube.com/watch?v=oobqoCJlHA0][explanation]] +- [ ] TODO 0211. Design Add And Search Words Data Structure :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0211-design-add-and-search-words-data-structure.py][0211-design-add-and-search-words-data-structure.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0211-design-add-and-search-words-data-structure.cpp][0211-design-add-and-search-words-data-structure.cpp]] + - LeetCode: [[https://leetcode.com/problems/design-add-and-search-words-data-structure/][design-add-and-search-words-data-structure/]] + - Video: [[https://youtube.com/watch?v=BTf05gs_8iU][explanation]] +- [ ] TODO 1166. Design File System :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1166-design-file-system.py][1166-design-file-system.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1166-design-file-system.cpp][1166-design-file-system.cpp]] + - LeetCode: [[https://leetcode.com/problems/design-file-system/][design-file-system/]] +- [ ] TODO 0212. Word Search II :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0212-word-search-ii.py][0212-word-search-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0212-word-search-ii.cpp][0212-word-search-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/word-search-ii/][word-search-ii/]] + - Video: [[https://youtube.com/watch?v=asbcE9mZz_U][explanation]] + +* TODO Heap / Priority Queue [/] + +- [ ] TODO 0703. Kth Largest Element In a Stream :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0703-kth-largest-element-in-a-stream.py][0703-kth-largest-element-in-a-stream.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0703-kth-largest-element-in-a-stream.cpp][0703-kth-largest-element-in-a-stream.cpp]] + - LeetCode: [[https://leetcode.com/problems/kth-largest-element-in-a-stream/][kth-largest-element-in-a-stream/]] + - Video: [[https://youtube.com/watch?v=hOjcdrqMoQ8][explanation]] +- [ ] TODO 1046. Last Stone Weight :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1046-last-stone-weight.py][1046-last-stone-weight.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1046-last-stone-weight.cpp][1046-last-stone-weight.cpp]] + - LeetCode: [[https://leetcode.com/problems/last-stone-weight/][last-stone-weight/]] + - Video: [[https://youtube.com/watch?v=B-QCq79-Vfw][explanation]] +- [ ] TODO 0973. K Closest Points to Origin :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0973-k-closest-points-to-origin.py][0973-k-closest-points-to-origin.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0973-k-closest-points-to-origin.cpp][0973-k-closest-points-to-origin.cpp]] + - LeetCode: [[https://leetcode.com/problems/k-closest-points-to-origin/][k-closest-points-to-origin/]] + - Video: [[https://youtube.com/watch?v=rI2EBUEMfTk][explanation]] +- [ ] TODO 0215. Kth Largest Element In An Array :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0215-kth-largest-element-in-an-array.py][0215-kth-largest-element-in-an-array.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0215-kth-largest-element-in-an-array.cpp][0215-kth-largest-element-in-an-array.cpp]] + - LeetCode: [[https://leetcode.com/problems/kth-largest-element-in-an-array/][kth-largest-element-in-an-array/]] + - Video: [[https://youtube.com/watch?v=XEmy13g1Qxc][explanation]] +- [ ] TODO 0621. Task Scheduler :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0621-task-scheduler.py][0621-task-scheduler.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0621-task-scheduler.cpp][0621-task-scheduler.cpp]] + - LeetCode: [[https://leetcode.com/problems/task-scheduler/][task-scheduler/]] + - Video: [[https://youtube.com/watch?v=s8p8ukTyA2I][explanation]] +- [ ] TODO 0355. Design Twitter :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0355-design-twitter.py][0355-design-twitter.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0355-design-twitter.cpp][0355-design-twitter.cpp]] + - LeetCode: [[https://leetcode.com/problems/design-twitter/][design-twitter/]] + - Video: [[https://youtube.com/watch?v=pNichitDD2E][explanation]] +- [ ] TODO 0295. Find Median From Data Stream :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0295-find-median-from-data-stream.py][0295-find-median-from-data-stream.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0295-find-median-from-data-stream.cpp][0295-find-median-from-data-stream.cpp]] + - LeetCode: [[https://leetcode.com/problems/find-median-from-data-stream/][find-median-from-data-stream/]] + - Video: [[https://youtube.com/watch?v=itmhHWaHupI][explanation]] + +* TODO Backtracking [/] + +- [ ] TODO 1863. Sum of All Subsets XOR Total :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1863-sum-of-all-subset-xor-totals.py][1863-sum-of-all-subset-xor-totals.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1863-sum-of-all-subset-xor-totals.cpp][1863-sum-of-all-subset-xor-totals.cpp]] + - LeetCode: [[https://leetcode.com/problems/sum-of-all-subset-xor-totals/][sum-of-all-subset-xor-totals/]] + - Video: [[https://youtube.com/watch?v=LI7YR-bwNYY][explanation]] +- [ ] TODO 0078. Subsets :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0078-subsets.py][0078-subsets.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0078-subsets.cpp][0078-subsets.cpp]] + - LeetCode: [[https://leetcode.com/problems/subsets/][subsets/]] + - Video: [[https://youtube.com/watch?v=REOH22Xwdkk][explanation]] +- [ ] TODO 0039. Combination Sum :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0039-combination-sum.py][0039-combination-sum.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0039-combination-sum.cpp][0039-combination-sum.cpp]] + - LeetCode: [[https://leetcode.com/problems/combination-sum/][combination-sum/]] + - Video: [[https://youtube.com/watch?v=GBKI9VSKdGg][explanation]] +- [ ] TODO 0040. Combination Sum II :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0040-combination-sum-ii.py][0040-combination-sum-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0040-combination-sum-ii.cpp][0040-combination-sum-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/combination-sum-ii/][combination-sum-ii/]] + - Video: [[https://youtube.com/watch?v=FOyRpNUSFeA][explanation]] +- [ ] TODO 0077. Combinations :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0077-combinations.py][0077-combinations.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0077-combinations.cpp][0077-combinations.cpp]] + - LeetCode: [[https://leetcode.com/problems/combinations/][combinations/]] + - Video: [[https://youtube.com/watch?v=q0s6m7AiM7o][explanation]] +- [ ] TODO 0046. Permutations :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0046-permutations.py][0046-permutations.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0046-permutations.cpp][0046-permutations.cpp]] + - LeetCode: [[https://leetcode.com/problems/permutations/][permutations/]] + - Video: [[https://youtube.com/watch?v=FZe0UqISmUw][explanation]] +- [ ] TODO 0090. Subsets II :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0090-subsets-ii.py][0090-subsets-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0090-subsets-ii.cpp][0090-subsets-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/subsets-ii/][subsets-ii/]] + - Video: [[https://youtube.com/watch?v=Vn2v6ajA7U0][explanation]] +- [ ] TODO 0022. Generate Parentheses :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0022-generate-parentheses.py][0022-generate-parentheses.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0022-generate-parentheses.cpp][0022-generate-parentheses.cpp]] + - LeetCode: [[https://leetcode.com/problems/generate-parentheses/][generate-parentheses/]] + - Video: [[https://youtube.com/watch?v=s9fokUqJ76A][explanation]] +- [ ] TODO 1079. Letter Tile Possibilities :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1079-letter-tile-possibilities.py][1079-letter-tile-possibilities.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1079-letter-tile-possibilities.cpp][1079-letter-tile-possibilities.cpp]] + - LeetCode: [[https://leetcode.com/problems/letter-tile-possibilities/][letter-tile-possibilities/]] + - Video: [[https://youtube.com/watch?v=8FrJX-P_DnE][explanation]] +- [ ] TODO 0079. Word Search :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0079-word-search.py][0079-word-search.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0079-word-search.cpp][0079-word-search.cpp]] + - LeetCode: [[https://leetcode.com/problems/word-search/][word-search/]] + - Video: [[https://youtube.com/watch?v=pfiQ_PS1g8E][explanation]] +- [ ] TODO 0131. Palindrome Partitioning :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0131-palindrome-partitioning.py][0131-palindrome-partitioning.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0131-palindrome-partitioning.cpp][0131-palindrome-partitioning.cpp]] + - LeetCode: [[https://leetcode.com/problems/palindrome-partitioning/][palindrome-partitioning/]] + - Video: [[https://youtube.com/watch?v=3jvWodd7ht0][explanation]] +- [ ] TODO 0017. Letter Combinations of a Phone Number :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0017-letter-combinations-of-a-phone-number.py][0017-letter-combinations-of-a-phone-number.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0017-letter-combinations-of-a-phone-number.cpp][0017-letter-combinations-of-a-phone-number.cpp]] + - LeetCode: [[https://leetcode.com/problems/letter-combinations-of-a-phone-number/][letter-combinations-of-a-phone-number/]] + - Video: [[https://youtube.com/watch?v=0snEunUacZY][explanation]] +- [ ] TODO 0351. Android Unlock Patterns :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0351-android-unlock-patterns.py][0351-android-unlock-patterns.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0351-android-unlock-patterns.cpp][0351-android-unlock-patterns.cpp]] + - LeetCode: [[https://leetcode.com/problems/android-unlock-patterns/][android-unlock-patterns/]] +- [ ] TODO 0051. N Queens :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0051-n-queens.py][0051-n-queens.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0051-n-queens.cpp][0051-n-queens.cpp]] + - LeetCode: [[https://leetcode.com/problems/n-queens/][n-queens/]] + - Video: [[https://youtube.com/watch?v=Ph95IHmRp5M][explanation]] +- [ ] TODO 0052. N Queens II :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0052-n-queens-ii.py][0052-n-queens-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0052-n-queens-ii.cpp][0052-n-queens-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/n-queens-ii/][n-queens-ii/]] + - Video: [[https://youtube.com/watch?v=nalYyLZgvCY][explanation]] + +* TODO Graphs [/] + +- [ ] TODO 2924. Find Champion II :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2924-find-champion-ii.py][2924-find-champion-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2924-find-champion-ii.cpp][2924-find-champion-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/find-champion-ii/][find-champion-ii/]] + - Video: [[https://youtube.com/watch?v=HjSmSLPR7S4][explanation]] +- [ ] TODO 0200. Number of Islands :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0200-number-of-islands.py][0200-number-of-islands.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0200-number-of-islands.cpp][0200-number-of-islands.cpp]] + - LeetCode: [[https://leetcode.com/problems/number-of-islands/][number-of-islands/]] + - Video: [[https://youtube.com/watch?v=pV2kpPD66nE][explanation]] +- [ ] TODO 0695. Max Area of Island :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0695-max-area-of-island.py][0695-max-area-of-island.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0695-max-area-of-island.cpp][0695-max-area-of-island.cpp]] + - LeetCode: [[https://leetcode.com/problems/max-area-of-island/][max-area-of-island/]] + - Video: [[https://youtube.com/watch?v=iJGr1OtmH0c][explanation]] +- [ ] TODO 2658. Maximum Number of Fish in a Grid :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2658-maximum-number-of-fish-in-a-grid.py][2658-maximum-number-of-fish-in-a-grid.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2658-maximum-number-of-fish-in-a-grid.cpp][2658-maximum-number-of-fish-in-a-grid.cpp]] + - LeetCode: [[https://leetcode.com/problems/maximum-number-of-fish-in-a-grid/][maximum-number-of-fish-in-a-grid/]] + - Video: [[https://youtube.com/watch?v=JhAz6CkRGHI][explanation]] +- [ ] TODO 0133. Clone Graph :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0133-clone-graph.py][0133-clone-graph.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0133-clone-graph.cpp][0133-clone-graph.cpp]] + - LeetCode: [[https://leetcode.com/problems/clone-graph/][clone-graph/]] + - Video: [[https://youtube.com/watch?v=mQeF6bN8hMk][explanation]] +- [ ] TODO 0286. Walls And Gates :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0286-walls-and-gates.py][0286-walls-and-gates.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0286-walls-and-gates.cpp][0286-walls-and-gates.cpp]] + - LeetCode: [[https://leetcode.com/problems/walls-and-gates/][walls-and-gates/]] + - Video: [[https://youtube.com/watch?v=e69C6xhiSQE][explanation]] +- [ ] TODO 0994. Rotting Oranges :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0994-rotting-oranges.py][0994-rotting-oranges.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0994-rotting-oranges.cpp][0994-rotting-oranges.cpp]] + - LeetCode: [[https://leetcode.com/problems/rotting-oranges/][rotting-oranges/]] + - Video: [[https://youtube.com/watch?v=y704fEOx0s0][explanation]] +- [ ] TODO 1905. Count Sub Islands :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1905-count-sub-islands.py][1905-count-sub-islands.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1905-count-sub-islands.cpp][1905-count-sub-islands.cpp]] + - LeetCode: [[https://leetcode.com/problems/count-sub-islands/][count-sub-islands/]] + - Video: [[https://youtube.com/watch?v=mLpW3qfbNJ8][explanation]] +- [ ] TODO 0417. Pacific Atlantic Water Flow :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0417-pacific-atlantic-water-flow.py][0417-pacific-atlantic-water-flow.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0417-pacific-atlantic-water-flow.cpp][0417-pacific-atlantic-water-flow.cpp]] + - LeetCode: [[https://leetcode.com/problems/pacific-atlantic-water-flow/][pacific-atlantic-water-flow/]] + - Video: [[https://youtube.com/watch?v=s-VkcjHqkGI][explanation]] +- [ ] TODO 0130. Surrounded Regions :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0130-surrounded-regions.py][0130-surrounded-regions.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0130-surrounded-regions.cpp][0130-surrounded-regions.cpp]] + - LeetCode: [[https://leetcode.com/problems/surrounded-regions/][surrounded-regions/]] + - Video: [[https://youtube.com/watch?v=9z2BunfoZ5Y][explanation]] +- [ ] TODO 0802. Find Eventual Safe States :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0802-find-eventual-safe-states.py][0802-find-eventual-safe-states.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0802-find-eventual-safe-states.cpp][0802-find-eventual-safe-states.cpp]] + - LeetCode: [[https://leetcode.com/problems/find-eventual-safe-states/][find-eventual-safe-states/]] + - Video: [[https://youtube.com/watch?v=Re_v0j0CRsg][explanation]] +- [ ] TODO 0207. Course Schedule :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0207-course-schedule.py][0207-course-schedule.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0207-course-schedule.cpp][0207-course-schedule.cpp]] + - LeetCode: [[https://leetcode.com/problems/course-schedule/][course-schedule/]] + - Video: [[https://youtube.com/watch?v=EgI5nU9etnU][explanation]] +- [ ] TODO 0210. Course Schedule II :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0210-course-schedule-ii.py][0210-course-schedule-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0210-course-schedule-ii.cpp][0210-course-schedule-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/course-schedule-ii/][course-schedule-ii/]] + - Video: [[https://youtube.com/watch?v=Akt3glAwyfY][explanation]] +- [ ] TODO 0261. Graph Valid Tree :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0261-graph-valid-tree.py][0261-graph-valid-tree.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0261-graph-valid-tree.cpp][0261-graph-valid-tree.cpp]] + - LeetCode: [[https://leetcode.com/problems/graph-valid-tree/][graph-valid-tree/]] + - Video: [[https://youtube.com/watch?v=bXsUuownnoQ][explanation]] +- [ ] TODO 0323. Number of Connected Components In An Undirected Graph :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0323-number-of-connected-components-in-an-undirected-graph.py][0323-number-of-connected-components-in-an-undirected-graph.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0323-number-of-connected-components-in-an-undirected-graph.cpp][0323-number-of-connected-components-in-an-undirected-graph.cpp]] + - LeetCode: [[https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph/][number-of-connected-components-in-an-undirected-graph/]] + - Video: [[https://youtube.com/watch?v=8f1XPm4WOUc][explanation]] +- [ ] TODO 0684. Redundant Connection :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0684-redundant-connection.py][0684-redundant-connection.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0684-redundant-connection.cpp][0684-redundant-connection.cpp]] + - LeetCode: [[https://leetcode.com/problems/redundant-connection/][redundant-connection/]] + - Video: [[https://youtube.com/watch?v=1lNK80tOTfc][explanation]] +- [ ] TODO 2092. Find All People With Secret :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2092-find-all-people-with-secret.py][2092-find-all-people-with-secret.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2092-find-all-people-with-secret.cpp][2092-find-all-people-with-secret.cpp]] + - LeetCode: [[https://leetcode.com/problems/find-all-people-with-secret/][find-all-people-with-secret/]] + - Video: [[https://youtube.com/watch?v=1XujGRSU1bQ][explanation]] +- [ ] TODO 0127. Word Ladder :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0127-word-ladder.py][0127-word-ladder.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0127-word-ladder.cpp][0127-word-ladder.cpp]] + - LeetCode: [[https://leetcode.com/problems/word-ladder/][word-ladder/]] + - Video: [[https://youtube.com/watch?v=h9iTnkgv05E][explanation]] + +* TODO 1-D Dynamic Programming [/] + +- [ ] TODO 0070. Climbing Stairs :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0070-climbing-stairs.py][0070-climbing-stairs.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0070-climbing-stairs.cpp][0070-climbing-stairs.cpp]] + - LeetCode: [[https://leetcode.com/problems/climbing-stairs/][climbing-stairs/]] + - Video: [[https://youtube.com/watch?v=Y0lT9Fck7qI][explanation]] +- [ ] TODO 0746. Min Cost Climbing Stairs :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0746-min-cost-climbing-stairs.py][0746-min-cost-climbing-stairs.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0746-min-cost-climbing-stairs.cpp][0746-min-cost-climbing-stairs.cpp]] + - LeetCode: [[https://leetcode.com/problems/min-cost-climbing-stairs/][min-cost-climbing-stairs/]] + - Video: [[https://youtube.com/watch?v=ktmzAZWkEZ0][explanation]] +- [ ] TODO 0198. House Robber :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0198-house-robber.py][0198-house-robber.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0198-house-robber.cpp][0198-house-robber.cpp]] + - LeetCode: [[https://leetcode.com/problems/house-robber/][house-robber/]] + - Video: [[https://youtube.com/watch?v=73r3KWiEvyk][explanation]] +- [ ] TODO 0213. House Robber II :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0213-house-robber-ii.py][0213-house-robber-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0213-house-robber-ii.cpp][0213-house-robber-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/house-robber-ii/][house-robber-ii/]] + - Video: [[https://youtube.com/watch?v=rWAJCfYYOvM][explanation]] +- [ ] TODO 0005. Longest Palindromic Substring :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0005-longest-palindromic-substring.py][0005-longest-palindromic-substring.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0005-longest-palindromic-substring.cpp][0005-longest-palindromic-substring.cpp]] + - LeetCode: [[https://leetcode.com/problems/longest-palindromic-substring/][longest-palindromic-substring/]] + - Video: [[https://youtube.com/watch?v=XYQecbcd6_c][explanation]] +- [ ] TODO 0647. Palindromic Substrings :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0647-palindromic-substrings.py][0647-palindromic-substrings.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0647-palindromic-substrings.cpp][0647-palindromic-substrings.cpp]] + - LeetCode: [[https://leetcode.com/problems/palindromic-substrings/][palindromic-substrings/]] + - Video: [[https://youtube.com/watch?v=4RACzI5-du8][explanation]] +- [ ] TODO 0091. Decode Ways :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0091-decode-ways.py][0091-decode-ways.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0091-decode-ways.cpp][0091-decode-ways.cpp]] + - LeetCode: [[https://leetcode.com/problems/decode-ways/][decode-ways/]] + - Video: [[https://youtube.com/watch?v=6aEyTjOwlJU][explanation]] +- [ ] TODO 0322. Coin Change :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0322-coin-change.py][0322-coin-change.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0322-coin-change.cpp][0322-coin-change.cpp]] + - LeetCode: [[https://leetcode.com/problems/coin-change/][coin-change/]] + - Video: [[https://youtube.com/watch?v=H9bfqozjoqs][explanation]] +- [ ] TODO 0152. Maximum Product Subarray :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0152-maximum-product-subarray.py][0152-maximum-product-subarray.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0152-maximum-product-subarray.cpp][0152-maximum-product-subarray.cpp]] + - LeetCode: [[https://leetcode.com/problems/maximum-product-subarray/][maximum-product-subarray/]] + - Video: [[https://youtube.com/watch?v=lXVy6YWFcRM][explanation]] +- [ ] TODO 0139. Word Break :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0139-word-break.py][0139-word-break.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0139-word-break.cpp][0139-word-break.cpp]] + - LeetCode: [[https://leetcode.com/problems/word-break/][word-break/]] + - Video: [[https://youtube.com/watch?v=Sx9NNgInc3A][explanation]] +- [ ] TODO 0300. Longest Increasing Subsequence :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0300-longest-increasing-subsequence.py][0300-longest-increasing-subsequence.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0300-longest-increasing-subsequence.cpp][0300-longest-increasing-subsequence.cpp]] + - LeetCode: [[https://leetcode.com/problems/longest-increasing-subsequence/][longest-increasing-subsequence/]] + - Video: [[https://youtube.com/watch?v=cjWnW0hdF1Y][explanation]] +- [ ] TODO 0416. Partition Equal Subset Sum :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0416-partition-equal-subset-sum.py][0416-partition-equal-subset-sum.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0416-partition-equal-subset-sum.cpp][0416-partition-equal-subset-sum.cpp]] + - LeetCode: [[https://leetcode.com/problems/partition-equal-subset-sum/][partition-equal-subset-sum/]] + - Video: [[https://youtube.com/watch?v=IsvocB5BJhw][explanation]] +- [ ] TODO 0656. Coin Path :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0656-coin-path.py][0656-coin-path.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0656-coin-path.cpp][0656-coin-path.cpp]] + - LeetCode: [[https://leetcode.com/problems/coin-path/][coin-path/]] + +* TODO Intervals [/] + +- [ ] TODO 0057. Insert Interval :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0057-insert-interval.py][0057-insert-interval.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0057-insert-interval.cpp][0057-insert-interval.cpp]] + - LeetCode: [[https://leetcode.com/problems/insert-interval/][insert-interval/]] + - Video: [[https://youtube.com/watch?v=A8NUOmlwOlM][explanation]] +- [ ] TODO 0056. Merge Intervals :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0056-merge-intervals.py][0056-merge-intervals.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0056-merge-intervals.cpp][0056-merge-intervals.cpp]] + - LeetCode: [[https://leetcode.com/problems/merge-intervals/][merge-intervals/]] + - Video: [[https://youtube.com/watch?v=44H3cEC2fFM][explanation]] +- [ ] TODO 0435. Non Overlapping Intervals :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0435-non-overlapping-intervals.py][0435-non-overlapping-intervals.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0435-non-overlapping-intervals.cpp][0435-non-overlapping-intervals.cpp]] + - LeetCode: [[https://leetcode.com/problems/non-overlapping-intervals/][non-overlapping-intervals/]] + - Video: [[https://youtube.com/watch?v=nONCGxWoUfM][explanation]] +- [ ] TODO 0986. Interval List Intersections :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0986-interval-list-intersections.py][0986-interval-list-intersections.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0986-interval-list-intersections.cpp][0986-interval-list-intersections.cpp]] + - LeetCode: [[https://leetcode.com/problems/interval-list-intersections/][interval-list-intersections/]] +- [ ] TODO 0252. Meeting Rooms :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0252-meeting-rooms.py][0252-meeting-rooms.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0252-meeting-rooms.cpp][0252-meeting-rooms.cpp]] + - LeetCode: [[https://leetcode.com/problems/meeting-rooms/][meeting-rooms/]] + - Video: [[https://youtube.com/watch?v=PaJxqZVPhbg][explanation]] +- [ ] TODO 0253. Meeting Rooms II :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0253-meeting-rooms-ii.py][0253-meeting-rooms-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0253-meeting-rooms-ii.cpp][0253-meeting-rooms-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/meeting-rooms-ii/][meeting-rooms-ii/]] + - Video: [[https://youtube.com/watch?v=FdzJmTCVyJU][explanation]] +- [ ] TODO 1851. Minimum Interval to Include Each Query :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1851-minimum-interval-to-include-each-query.py][1851-minimum-interval-to-include-each-query.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1851-minimum-interval-to-include-each-query.cpp][1851-minimum-interval-to-include-each-query.cpp]] + - LeetCode: [[https://leetcode.com/problems/minimum-interval-to-include-each-query/][minimum-interval-to-include-each-query/]] + - Video: [[https://youtube.com/watch?v=5hQ5WWW5awQ][explanation]] + +* TODO Greedy [/] + +- [ ] TODO 0945. Minimum Increment to Make Array Unique :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0945-minimum-increment-to-make-array-unique.py][0945-minimum-increment-to-make-array-unique.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0945-minimum-increment-to-make-array-unique.cpp][0945-minimum-increment-to-make-array-unique.cpp]] + - LeetCode: [[https://leetcode.com/problems/minimum-increment-to-make-array-unique/][minimum-increment-to-make-array-unique/]] + - Video: [[https://youtube.com/watch?v=XPPs2Wj2YSk][explanation]] +- [ ] TODO 0053. Maximum Subarray :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0053-maximum-subarray.py][0053-maximum-subarray.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0053-maximum-subarray.cpp][0053-maximum-subarray.cpp]] + - LeetCode: [[https://leetcode.com/problems/maximum-subarray/][maximum-subarray/]] + - Video: [[https://youtube.com/watch?v=5WZl3MMT0Eg][explanation]] +- [ ] TODO 0978. Longest Turbulent Subarray :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0978-longest-turbulent-subarray.py][0978-longest-turbulent-subarray.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0978-longest-turbulent-subarray.cpp][0978-longest-turbulent-subarray.cpp]] + - LeetCode: [[https://leetcode.com/problems/longest-turbulent-subarray/][longest-turbulent-subarray/]] + - Video: [[https://youtube.com/watch?v=V_iHUhR8Dek][explanation]] +- [ ] TODO 0055. Jump Game :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0055-jump-game.py][0055-jump-game.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0055-jump-game.cpp][0055-jump-game.cpp]] + - LeetCode: [[https://leetcode.com/problems/jump-game/][jump-game/]] + - Video: [[https://youtube.com/watch?v=Yan0cv2cLy8][explanation]] +- [ ] TODO 0045. Jump Game II :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0045-jump-game-ii.py][0045-jump-game-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0045-jump-game-ii.cpp][0045-jump-game-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/jump-game-ii/][jump-game-ii/]] + - Video: [[https://youtube.com/watch?v=dJ7sWiOoK7g][explanation]] +- [ ] TODO 1871. Jump Game VII :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1871-jump-game-vii.py][1871-jump-game-vii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1871-jump-game-vii.cpp][1871-jump-game-vii.cpp]] + - LeetCode: [[https://leetcode.com/problems/jump-game-vii/][jump-game-vii/]] + - Video: [[https://youtube.com/watch?v=v1HpZUnQ4Yo][explanation]] +- [ ] TODO 0134. Gas Station :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0134-gas-station.py][0134-gas-station.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0134-gas-station.cpp][0134-gas-station.cpp]] + - LeetCode: [[https://leetcode.com/problems/gas-station/][gas-station/]] + - Video: [[https://youtube.com/watch?v=lJwbPZGo05A][explanation]] +- [ ] TODO 0846. Hand of Straights :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0846-hand-of-straights.py][0846-hand-of-straights.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0846-hand-of-straights.cpp][0846-hand-of-straights.cpp]] + - LeetCode: [[https://leetcode.com/problems/hand-of-straights/][hand-of-straights/]] + - Video: [[https://youtube.com/watch?v=amnrMCVd2YI][explanation]] +- [ ] TODO 1899. Merge Triplets to Form Target Triplet :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1899-merge-triplets-to-form-target-triplet.py][1899-merge-triplets-to-form-target-triplet.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1899-merge-triplets-to-form-target-triplet.cpp][1899-merge-triplets-to-form-target-triplet.cpp]] + - LeetCode: [[https://leetcode.com/problems/merge-triplets-to-form-target-triplet/][merge-triplets-to-form-target-triplet/]] + - Video: [[https://youtube.com/watch?v=kShkQLQZ9K4][explanation]] +- [ ] TODO 0763. Partition Labels :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0763-partition-labels.py][0763-partition-labels.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0763-partition-labels.cpp][0763-partition-labels.cpp]] + - LeetCode: [[https://leetcode.com/problems/partition-labels/][partition-labels/]] + - Video: [[https://youtube.com/watch?v=B7m8UmZE-vw][explanation]] +- [ ] TODO 0678. Valid Parenthesis String :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0678-valid-parenthesis-string.py][0678-valid-parenthesis-string.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0678-valid-parenthesis-string.cpp][0678-valid-parenthesis-string.cpp]] + - LeetCode: [[https://leetcode.com/problems/valid-parenthesis-string/][valid-parenthesis-string/]] + - Video: [[https://youtube.com/watch?v=QhPdNS143Qg][explanation]] + +* TODO Advanced Graphs [/] + +- [ ] TODO 0743. Network Delay Time :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0743-network-delay-time.py][0743-network-delay-time.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0743-network-delay-time.cpp][0743-network-delay-time.cpp]] + - LeetCode: [[https://leetcode.com/problems/network-delay-time/][network-delay-time/]] + - Video: [[https://youtube.com/watch?v=EaphyqKU4PQ][explanation]] +- [ ] TODO 0332. Reconstruct Itinerary :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0332-reconstruct-itinerary.py][0332-reconstruct-itinerary.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0332-reconstruct-itinerary.cpp][0332-reconstruct-itinerary.cpp]] + - LeetCode: [[https://leetcode.com/problems/reconstruct-itinerary/][reconstruct-itinerary/]] + - Video: [[https://youtube.com/watch?v=ZyB_gQ8vqGA][explanation]] +- [ ] TODO 1584. Min Cost to Connect All Points :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1584-min-cost-to-connect-all-points.py][1584-min-cost-to-connect-all-points.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1584-min-cost-to-connect-all-points.cpp][1584-min-cost-to-connect-all-points.cpp]] + - LeetCode: [[https://leetcode.com/problems/min-cost-to-connect-all-points/][min-cost-to-connect-all-points/]] + - Video: [[https://youtube.com/watch?v=f7JOBJIC-NA][explanation]] +- [ ] TODO 2812. Find the Safest Path in a Grid :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2812-find-the-safest-path-in-a-grid.py][2812-find-the-safest-path-in-a-grid.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2812-find-the-safest-path-in-a-grid.cpp][2812-find-the-safest-path-in-a-grid.cpp]] + - LeetCode: [[https://leetcode.com/problems/find-the-safest-path-in-a-grid/][find-the-safest-path-in-a-grid/]] + - Video: [[https://youtube.com/watch?v=-5mQcNiVWTs][explanation]] +- [ ] TODO 0778. Swim In Rising Water :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0778-swim-in-rising-water.py][0778-swim-in-rising-water.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0778-swim-in-rising-water.cpp][0778-swim-in-rising-water.cpp]] + - LeetCode: [[https://leetcode.com/problems/swim-in-rising-water/][swim-in-rising-water/]] + - Video: [[https://youtube.com/watch?v=amvrKlMLuGY][explanation]] +- [ ] TODO 0269. Alien Dictionary :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0269-alien-dictionary.py][0269-alien-dictionary.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0269-alien-dictionary.cpp][0269-alien-dictionary.cpp]] + - LeetCode: [[https://leetcode.com/problems/alien-dictionary/][alien-dictionary/]] + - Video: [[https://youtube.com/watch?v=6kTZYvNNyps][explanation]] +- [ ] TODO 0787. Cheapest Flights Within K Stops :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0787-cheapest-flights-within-k-stops.py][0787-cheapest-flights-within-k-stops.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0787-cheapest-flights-within-k-stops.cpp][0787-cheapest-flights-within-k-stops.cpp]] + - LeetCode: [[https://leetcode.com/problems/cheapest-flights-within-k-stops/][cheapest-flights-within-k-stops/]] + - Video: [[https://youtube.com/watch?v=5eIK3zUdYmE][explanation]] +- [ ] TODO 2493. Divide Nodes Into the Maximum Number of Groups :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2493-divide-nodes-into-the-maximum-number-of-groups.py][2493-divide-nodes-into-the-maximum-number-of-groups.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2493-divide-nodes-into-the-maximum-number-of-groups.cpp][2493-divide-nodes-into-the-maximum-number-of-groups.cpp]] + - LeetCode: [[https://leetcode.com/problems/divide-nodes-into-the-maximum-number-of-groups/][divide-nodes-into-the-maximum-number-of-groups/]] + - Video: [[https://youtube.com/watch?v=Gn0ADjje8Rg][explanation]] + +* TODO Bit Manipulation [/] + +- [ ] TODO 0136. Single Number :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0136-single-number.py][0136-single-number.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0136-single-number.cpp][0136-single-number.cpp]] + - LeetCode: [[https://leetcode.com/problems/single-number/][single-number/]] + - Video: [[https://youtube.com/watch?v=qMPX1AOa83k][explanation]] +- [ ] TODO 0260. Single Number III :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0260-single-number-iii.py][0260-single-number-iii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0260-single-number-iii.cpp][0260-single-number-iii.cpp]] + - LeetCode: [[https://leetcode.com/problems/single-number-iii/][single-number-iii/]] + - Video: [[https://youtube.com/watch?v=faoVORjd-T8][explanation]] +- [ ] TODO 0191. Number of 1 Bits :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0191-number-of-1-bits.py][0191-number-of-1-bits.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0191-number-of-1-bits.cpp][0191-number-of-1-bits.cpp]] + - LeetCode: [[https://leetcode.com/problems/number-of-1-bits/][number-of-1-bits/]] + - Video: [[https://youtube.com/watch?v=5Km3utixwZs][explanation]] +- [ ] TODO 0338. Counting Bits :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0338-counting-bits.py][0338-counting-bits.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0338-counting-bits.cpp][0338-counting-bits.cpp]] + - LeetCode: [[https://leetcode.com/problems/counting-bits/][counting-bits/]] + - Video: [[https://youtube.com/watch?v=RyBM56RIWrM][explanation]] +- [ ] TODO 2220. Minimum Bit Flips to Convert Number :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2220-minimum-bit-flips-to-convert-number.py][2220-minimum-bit-flips-to-convert-number.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2220-minimum-bit-flips-to-convert-number.cpp][2220-minimum-bit-flips-to-convert-number.cpp]] + - LeetCode: [[https://leetcode.com/problems/minimum-bit-flips-to-convert-number/][minimum-bit-flips-to-convert-number/]] + - Video: [[https://youtube.com/watch?v=yz48myznqQY][explanation]] +- [ ] TODO 0190. Reverse Bits :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0190-reverse-bits.py][0190-reverse-bits.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0190-reverse-bits.cpp][0190-reverse-bits.cpp]] + - LeetCode: [[https://leetcode.com/problems/reverse-bits/][reverse-bits/]] + - Video: [[https://youtube.com/watch?v=UcoN6UjAI64][explanation]] +- [ ] TODO 0268. Missing Number :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0268-missing-number.py][0268-missing-number.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0268-missing-number.cpp][0268-missing-number.cpp]] + - LeetCode: [[https://leetcode.com/problems/missing-number/][missing-number/]] + - Video: [[https://youtube.com/watch?v=WnPLSRLSANE][explanation]] +- [ ] TODO 0231. Power of Two :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0231-power-of-two.py][0231-power-of-two.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0231-power-of-two.cpp][0231-power-of-two.cpp]] + - LeetCode: [[https://leetcode.com/problems/power-of-two/][power-of-two/]] + - Video: [[https://youtube.com/watch?v=H2bjttEV4Vc][explanation]] +- [ ] TODO 0371. Sum of Two Integers :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0371-sum-of-two-integers.py][0371-sum-of-two-integers.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0371-sum-of-two-integers.cpp][0371-sum-of-two-integers.cpp]] + - LeetCode: [[https://leetcode.com/problems/sum-of-two-integers/][sum-of-two-integers/]] + - Video: [[https://youtube.com/watch?v=gVUrDV4tZfY][explanation]] +- [ ] TODO 0007. Reverse Integer :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0007-reverse-integer.py][0007-reverse-integer.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0007-reverse-integer.cpp][0007-reverse-integer.cpp]] + - LeetCode: [[https://leetcode.com/problems/reverse-integer/][reverse-integer/]] + - Video: [[https://youtube.com/watch?v=HAgLH58IgJQ][explanation]] + +* TODO Math & Geometry [/] + +- [ ] TODO 0840. Magic Squares In Grid :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0840-magic-squares-in-grid.py][0840-magic-squares-in-grid.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0840-magic-squares-in-grid.cpp][0840-magic-squares-in-grid.cpp]] + - LeetCode: [[https://leetcode.com/problems/magic-squares-in-grid/][magic-squares-in-grid/]] + - Video: [[https://youtube.com/watch?v=FV52wWrivNc][explanation]] +- [ ] TODO 0048. Rotate Image :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0048-rotate-image.py][0048-rotate-image.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0048-rotate-image.cpp][0048-rotate-image.cpp]] + - LeetCode: [[https://leetcode.com/problems/rotate-image/][rotate-image/]] + - Video: [[https://youtube.com/watch?v=fMSJSS7eO1w][explanation]] +- [ ] TODO 0054. Spiral Matrix :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0054-spiral-matrix.py][0054-spiral-matrix.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0054-spiral-matrix.cpp][0054-spiral-matrix.cpp]] + - LeetCode: [[https://leetcode.com/problems/spiral-matrix/][spiral-matrix/]] + - Video: [[https://youtube.com/watch?v=BJnMZNwUk1M][explanation]] +- [ ] TODO 2326. Spiral Matrix IV :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2326-spiral-matrix-iv.py][2326-spiral-matrix-iv.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2326-spiral-matrix-iv.cpp][2326-spiral-matrix-iv.cpp]] + - LeetCode: [[https://leetcode.com/problems/spiral-matrix-iv/][spiral-matrix-iv/]] + - Video: [[https://youtube.com/watch?v=sOV1nRhmsMQ][explanation]] +- [ ] TODO 0073. Set Matrix Zeroes :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0073-set-matrix-zeroes.py][0073-set-matrix-zeroes.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0073-set-matrix-zeroes.cpp][0073-set-matrix-zeroes.cpp]] + - LeetCode: [[https://leetcode.com/problems/set-matrix-zeroes/][set-matrix-zeroes/]] + - Video: [[https://youtube.com/watch?v=T41rL0L3Pnw][explanation]] +- [ ] TODO 0202. Happy Number :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0202-happy-number.py][0202-happy-number.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0202-happy-number.cpp][0202-happy-number.cpp]] + - LeetCode: [[https://leetcode.com/problems/happy-number/][happy-number/]] + - Video: [[https://youtube.com/watch?v=ljz85bxOYJ0][explanation]] +- [ ] TODO 0066. Plus One :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0066-plus-one.py][0066-plus-one.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0066-plus-one.cpp][0066-plus-one.cpp]] + - LeetCode: [[https://leetcode.com/problems/plus-one/][plus-one/]] + - Video: [[https://youtube.com/watch?v=jIaA8boiG1s][explanation]] +- [ ] TODO 0009. Palindrome Number :easy: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0009-palindrome-number.py][0009-palindrome-number.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0009-palindrome-number.cpp][0009-palindrome-number.cpp]] + - LeetCode: [[https://leetcode.com/problems/palindrome-number/][palindrome-number/]] + - Video: [[https://youtube.com/watch?v=yubRKwixN-U][explanation]] +- [ ] TODO 0012. Integer to Roman :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0012-integer-to-roman.py][0012-integer-to-roman.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0012-integer-to-roman.cpp][0012-integer-to-roman.cpp]] + - LeetCode: [[https://leetcode.com/problems/integer-to-roman/][integer-to-roman/]] + - Video: [[https://youtube.com/watch?v=ohBNdSJyLh8][explanation]] +- [ ] TODO 0050. Pow(x, n) :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0050-powx-n.py][0050-powx-n.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0050-powx-n.cpp][0050-powx-n.cpp]] + - LeetCode: [[https://leetcode.com/problems/powx-n/][powx-n/]] + - Video: [[https://youtube.com/watch?v=g9YQyYi4IQQ][explanation]] +- [ ] TODO 2698. Find the Punishment Number of an Integer :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2698-find-the-punishment-number-of-an-integer.py][2698-find-the-punishment-number-of-an-integer.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2698-find-the-punishment-number-of-an-integer.cpp][2698-find-the-punishment-number-of-an-integer.cpp]] + - LeetCode: [[https://leetcode.com/problems/find-the-punishment-number-of-an-integer/][find-the-punishment-number-of-an-integer/]] + - Video: [[https://youtube.com/watch?v=LWgksJP-5SA][explanation]] +- [ ] TODO 1780. Check if Number is a Sum of Powers of Three :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1780-check-if-number-is-a-sum-of-powers-of-three.py][1780-check-if-number-is-a-sum-of-powers-of-three.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1780-check-if-number-is-a-sum-of-powers-of-three.cpp][1780-check-if-number-is-a-sum-of-powers-of-three.cpp]] + - LeetCode: [[https://leetcode.com/problems/check-if-number-is-a-sum-of-powers-of-three/][check-if-number-is-a-sum-of-powers-of-three/]] + - Video: [[https://youtube.com/watch?v=99ExTh_0Ycg][explanation]] +- [ ] TODO 0043. Multiply Strings :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0043-multiply-strings.py][0043-multiply-strings.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0043-multiply-strings.cpp][0043-multiply-strings.cpp]] + - LeetCode: [[https://leetcode.com/problems/multiply-strings/][multiply-strings/]] + - Video: [[https://youtube.com/watch?v=1vZswirL8Y8][explanation]] +- [ ] TODO 2013. Detect Squares :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/2013-detect-squares.py][2013-detect-squares.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/2013-detect-squares.cpp][2013-detect-squares.cpp]] + - LeetCode: [[https://leetcode.com/problems/detect-squares/][detect-squares/]] + - Video: [[https://youtube.com/watch?v=bahebearrDc][explanation]] +- [ ] TODO 0296. Best Meeting Point :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0296-best-meeting-point.py][0296-best-meeting-point.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0296-best-meeting-point.cpp][0296-best-meeting-point.cpp]] + - LeetCode: [[https://leetcode.com/problems/best-meeting-point/][best-meeting-point/]] + +* TODO 2-D Dynamic Programming [/] + +- [ ] TODO 0062. Unique Paths :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0062-unique-paths.py][0062-unique-paths.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0062-unique-paths.cpp][0062-unique-paths.cpp]] + - LeetCode: [[https://leetcode.com/problems/unique-paths/][unique-paths/]] + - Video: [[https://youtube.com/watch?v=IlEsdxuD4lY][explanation]] +- [ ] TODO 1143. Longest Common Subsequence :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1143-longest-common-subsequence.py][1143-longest-common-subsequence.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1143-longest-common-subsequence.cpp][1143-longest-common-subsequence.cpp]] + - LeetCode: [[https://leetcode.com/problems/longest-common-subsequence/][longest-common-subsequence/]] + - Video: [[https://youtube.com/watch?v=Ua0GhsJSlWM][explanation]] +- [ ] TODO 0309. Best Time to Buy And Sell Stock With Cooldown :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0309-best-time-to-buy-and-sell-stock-with-cooldown.py][0309-best-time-to-buy-and-sell-stock-with-cooldown.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0309-best-time-to-buy-and-sell-stock-with-cooldown.cpp][0309-best-time-to-buy-and-sell-stock-with-cooldown.cpp]] + - LeetCode: [[https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/][best-time-to-buy-and-sell-stock-with-cooldown/]] + - Video: [[https://youtube.com/watch?v=I7j0F7AHpb8][explanation]] +- [ ] TODO 0518. Coin Change II :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0518-coin-change-ii.py][0518-coin-change-ii.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0518-coin-change-ii.cpp][0518-coin-change-ii.cpp]] + - LeetCode: [[https://leetcode.com/problems/coin-change-ii/][coin-change-ii/]] + - Video: [[https://youtube.com/watch?v=Mjy4hd2xgrs][explanation]] +- [ ] TODO 0494. Target Sum :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0494-target-sum.py][0494-target-sum.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0494-target-sum.cpp][0494-target-sum.cpp]] + - LeetCode: [[https://leetcode.com/problems/target-sum/][target-sum/]] + - Video: [[https://youtube.com/watch?v=dwMOrl85Xes][explanation]] +- [ ] TODO 0097. Interleaving String :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0097-interleaving-string.py][0097-interleaving-string.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0097-interleaving-string.cpp][0097-interleaving-string.cpp]] + - LeetCode: [[https://leetcode.com/problems/interleaving-string/][interleaving-string/]] + - Video: [[https://youtube.com/watch?v=3Rw3p9LrgvE][explanation]] +- [ ] TODO 0329. Longest Increasing Path In a Matrix :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0329-longest-increasing-path-in-a-matrix.py][0329-longest-increasing-path-in-a-matrix.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0329-longest-increasing-path-in-a-matrix.cpp][0329-longest-increasing-path-in-a-matrix.cpp]] + - LeetCode: [[https://leetcode.com/problems/longest-increasing-path-in-a-matrix/][longest-increasing-path-in-a-matrix/]] + - Video: [[https://youtube.com/watch?v=wCc_nd-GiEc][explanation]] +- [ ] TODO 1911. Maximum Alternating Subsequence Sum :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1911-maximum-alternating-subsequence-sum.py][1911-maximum-alternating-subsequence-sum.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1911-maximum-alternating-subsequence-sum.cpp][1911-maximum-alternating-subsequence-sum.cpp]] + - LeetCode: [[https://leetcode.com/problems/maximum-alternating-subsequence-sum/][maximum-alternating-subsequence-sum/]] + - Video: [[https://youtube.com/watch?v=4v42XOuU1XA][explanation]] +- [ ] TODO 0115. Distinct Subsequences :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0115-distinct-subsequences.py][0115-distinct-subsequences.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0115-distinct-subsequences.cpp][0115-distinct-subsequences.cpp]] + - LeetCode: [[https://leetcode.com/problems/distinct-subsequences/][distinct-subsequences/]] + - Video: [[https://youtube.com/watch?v=-RDzMJ33nx8][explanation]] +- [ ] TODO 0072. Edit Distance :medium: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0072-edit-distance.py][0072-edit-distance.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0072-edit-distance.cpp][0072-edit-distance.cpp]] + - LeetCode: [[https://leetcode.com/problems/edit-distance/][edit-distance/]] + - Video: [[https://youtube.com/watch?v=XYi2-LPrwm4][explanation]] +- [ ] TODO 1220. Count Vowels Permutation :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/1220-count-vowels-permutation.py][1220-count-vowels-permutation.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/1220-count-vowels-permutation.cpp][1220-count-vowels-permutation.cpp]] + - LeetCode: [[https://leetcode.com/problems/count-vowels-permutation/][count-vowels-permutation/]] + - Video: [[https://youtube.com/watch?v=VUVpTZVa7Ls][explanation]] +- [ ] TODO 0312. Burst Balloons :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0312-burst-balloons.py][0312-burst-balloons.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0312-burst-balloons.cpp][0312-burst-balloons.cpp]] + - LeetCode: [[https://leetcode.com/problems/burst-balloons/][burst-balloons/]] + - Video: [[https://youtube.com/watch?v=VFskby7lUbw][explanation]] +- [ ] TODO 0010. Regular Expression Matching :hard: + - [ ] TODO Python: [[https://github.com/neetcode-gh/leetcode/blob/main/python/0010-regular-expression-matching.py][0010-regular-expression-matching.py]] + - [ ] TODO C++: [[https://github.com/neetcode-gh/leetcode/blob/main/cpp/0010-regular-expression-matching.cpp][0010-regular-expression-matching.cpp]] + - LeetCode: [[https://leetcode.com/problems/regular-expression-matching/][regular-expression-matching/]] + - Video: [[https://youtube.com/watch?v=HAA8mgxlov8][explanation]] diff --git a/org/questions/qn_00.org b/org/questions/qn_00.org index 6904eba..44bcb9b 100644 --- a/org/questions/qn_00.org +++ b/org/questions/qn_00.org @@ -695,18 +695,18 @@ Time: O(n * 32), Space: O(32) per step What is the master keyword-to-algorithm mapping for subarray problems? ** Back -| Problem Phrase | Array Property | Algorithm | -|---------------|---------------|-----------| -| "Continuous subarray + Sum = K" | Only positive numbers | **Sliding Window** (O(1) space) | -| "Continuous subarray + Sum = K" | Positive & negative | **Prefix Sum + Hash Map** (O(n) space) | -| "Divisible by K" or "Multiple of X" | Any numbers | **Prefix Remainder + Hash Map** (sum % K) | -| "Equal number of X and Y" | Any numbers | **Value Mapping** (X→1, Y→-1) + Prefix Sum Map | -| "Maximum / Minimum Sum" | Any numbers | **Kadane's Algorithm** (DP) | -| "Subarray Sum + Frequent Updates" | Element mutations | **Fenwick Tree / Segment Tree** | -| "Subarray product = K" | No zeros | **Prefix Product** (division) | -| "Subarray product positive/negative" | Any numbers | **Parity tracking** of negative count | -| "Subarray XOR = K" | Any numbers | **Prefix XOR + Hash Map** | -| "Subarray OR / AND" | Any numbers | **Set of results** (bounded by 32 changes) | +| Problem Phrase | Array Property | Algorithm | +|--------------------------------------+-----------------------+----------------------------------------------| +| "Continuous subarray + Sum = K" | Only positive numbers | **Sliding Window** (O(1) space) | +| "Continuous subarray + Sum = K" | Positive & negative | **Prefix Sum + Hash Map** (O(n) space) | +| "Divisible by K" or "Multiple of X" | Any numbers | **Prefix Remainder + Hash Map** (sum % K) | +| "Equal number of X and Y" | Any numbers | **Value Mapping** (X→1, Y→-1) + Prefix Sum Map | +| "Maximum / Minimum Sum" | Any numbers | **Kadane's Algorithm** (DP) | +| "Subarray Sum + Frequent Updates" | Element mutations | **Fenwick Tree / Segment Tree** | +| "Subarray product = K" | No zeros | **Prefix Product** (division) | +| "Subarray product positive/negative" | Any numbers | **Parity tracking** of negative count | +| "Subarray XOR = K" | Any numbers | **Prefix XOR + Hash Map** | +| "Subarray OR / AND" | Any numbers | **Set of results** (bounded by 32 changes) | * Subarray Sum — Modular Arithmetic Insight [algorithm:interview] :PROPERTIES: @@ -747,15 +747,15 @@ The core philosophy of prefix sums is: **accumulate history as you traverse line This generalizes far beyond addition: -| Problem | Mapping | Reduces To | -|---------|---------|-----------| -| Equal 0s and 1s | 0→-1, 1→+1 | Subarray sum = 0 | -| Equal odd/even | even→+1, odd→-1 | Subarray sum = 0 | -| Equal vowels/consonants | vowel→+1, consonant→-1 | Subarray sum = 0 | -| Equal A/B/C counts | Track (c_A-c_B, c_B-c_C) | Prefix state tuple repeats | -| Subarray product | Prefix product | Division (handle zeros) | -| Subarray XOR | Prefix XOR | XOR is invertible | -| Subarray sum | Prefix sum | Subtraction | +| Problem | Mapping | Reduces To | +|-------------------------+--------------------------+----------------------------| +| Equal 0s and 1s | 0→-1, 1→+1 | Subarray sum = 0 | +| Equal odd/even | even→+1, odd→-1 | Subarray sum = 0 | +| Equal vowels/consonants | vowel→+1, consonant→-1 | Subarray sum = 0 | +| Equal A/B/C counts | Track (c_A-c_B, c_B-c_C) | Prefix state tuple repeats | +| Subarray product | Prefix product | Division (handle zeros) | +| Subarray XOR | Prefix XOR | XOR is invertible | +| Subarray sum | Prefix sum | Subtraction | The pattern: 1. Define a state that accumulates as you traverse