---
date: '2026-07-16'
description: complete public NVIDIA company-tag LeetCode inventory
id: question-bank
modified: 2026-07-16 13:15:50 GMT-04:00
tags:
  - cs
title: NVIDIA question bank
created: '2026-07-16'
published: '2026-07-16'
pageLayout: default
slug: hinterland/prep/nv/question-bank
permalink: https://aarnphm.xyz/hinterland/prep/nv/question-bank.md
generator:
  quartz: v4.6.0
  hostedProvider: Cloudflare
  baseUrl: aarnphm.xyz
full: https://aarnphm.xyz/llms-full.txt
---
# public company-tag pool

This is the complete 136-problem NVIDIA inventory in the [public company-tag dataset](https://github.com/liquidslr/interview-company-wise-problems/blob/main/Nvidia/5.%20All.csv), captured on July 16, 2026. The rendered [NVIDIA company page](https://codejeet.com/company/nvidia) reports the same total.

The pool contains 32 easy, 89 medium, and 15 hard problems. The largest overlapping topic labels are array (75), hash table (28), string (26), sorting (26), two pointers (23), math (21), dynamic programming (19), linked list (17), and heap or priority queue (14).

The public score is the dataset’s relative NVIDIA frequency score. It is useful for ordering within this pool. It is not the chance that an interviewer asks the problem, and the dataset does not publish enough sampling detail to treat it as one.

Use [[hinterland/prep/nv/core|the core set]] first. Use this page to fill a measured pattern gap.

| done  | id    | problem                                                                                                                                                                                | difficulty | public score | topics                                                                                                                |
| ----- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- | -----------: | --------------------------------------------------------------------------------------------------------------------- |
| \[ \] | NV001 | [Special Binary String](https://leetcode.com/problems/special-binary-string)                                                                                                           | hard       |        100.0 | String, Divide and Conquer, Sorting                                                                                   |
| \[ \] | NV002 | [LRU Cache](https://leetcode.com/problems/lru-cache)                                                                                                                                   | medium     |         87.5 | Hash Table, Linked List, Design, Doubly-Linked List                                                                   |
| \[ \] | NV003 | [Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters)                                                         | medium     |         85.0 | Hash Table, String, Sliding Window                                                                                    |
| \[ \] | NV004 | [Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock)                                                                                       | easy       |         82.1 | Array, Dynamic Programming                                                                                            |
| \[ \] | NV005 | [Two Sum](https://leetcode.com/problems/two-sum)                                                                                                                                       | easy       |         80.6 | Array, Hash Table                                                                                                     |
| \[ \] | NV006 | [Merge k Sorted Lists](https://leetcode.com/problems/merge-k-sorted-lists)                                                                                                             | hard       |         78.9 | Linked List, Divide and Conquer, Heap (Priority Queue), Merge Sort                                                    |
| \[ \] | NV007 | [Valid Parentheses](https://leetcode.com/problems/valid-parentheses)                                                                                                                   | easy       |         77.1 | String, Stack                                                                                                         |
| \[ \] | NV008 | [Group Anagrams](https://leetcode.com/problems/group-anagrams)                                                                                                                         | medium     |         77.1 | Array, Hash Table, String, Sorting                                                                                    |
| \[ \] | NV009 | [Minimum Operations to Reduce an Integer to 0](https://leetcode.com/problems/minimum-operations-to-reduce-an-integer-to-0)                                                             | medium     |         77.1 | Dynamic Programming, Greedy, Bit Manipulation                                                                         |
| \[ \] | NV010 | [Maximum Subarray](https://leetcode.com/problems/maximum-subarray)                                                                                                                     | medium     |         75.1 | Array, Divide and Conquer, Dynamic Programming                                                                        |
| \[ \] | NV011 | [Last Stone Weight](https://leetcode.com/problems/last-stone-weight)                                                                                                                   | easy       |         75.1 | Array, Heap (Priority Queue)                                                                                          |
| \[ \] | NV012 | [Maximize Greatness of an Array](https://leetcode.com/problems/maximize-greatness-of-an-array)                                                                                         | medium     |         75.1 | Array, Two Pointers, Greedy, Sorting                                                                                  |
| \[ \] | NV013 | [Number of Islands](https://leetcode.com/problems/number-of-islands)                                                                                                                   | medium     |         73.0 | Array, Depth-First Search, Breadth-First Search, Union-Find, Matrix                                                   |
| \[ \] | NV014 | [Maximum Number of Visible Points](https://leetcode.com/problems/maximum-number-of-visible-points)                                                                                     | hard       |         73.0 | Array, Math, Geometry, Sliding Window, Sorting                                                                        |
| \[ \] | NV015 | [Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array)                                                                                         | medium     |         70.6 | Array, Binary Search                                                                                                  |
| \[ \] | NV016 | [Fizz Buzz](https://leetcode.com/problems/fizz-buzz)                                                                                                                                   | easy       |         70.6 | Math, String, Simulation                                                                                              |
| \[ \] | NV017 | [Restore IP Addresses](https://leetcode.com/problems/restore-ip-addresses)                                                                                                             | medium     |         70.6 | String, Backtracking                                                                                                  |
| \[ \] | NV018 | [Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water)                                                                                                               | hard       |         67.9 | Array, Two Pointers, Dynamic Programming, Stack, Monotonic Stack                                                      |
| \[ \] | NV019 | [Reverse Bits](https://leetcode.com/problems/reverse-bits)                                                                                                                             | easy       |         67.9 | Divide and Conquer, Bit Manipulation                                                                                  |
| \[ \] | NV020 | [Missing Number](https://leetcode.com/problems/missing-number)                                                                                                                         | easy       |         64.9 | Array, Hash Table, Math, Binary Search, Bit Manipulation, Sorting                                                     |
| \[ \] | NV021 | [Dot Product of Two Sparse Vectors](https://leetcode.com/problems/dot-product-of-two-sparse-vectors)                                                                                   | medium     |         64.9 | Array, Hash Table, Two Pointers, Design                                                                               |
| \[ \] | NV022 | [Task Scheduler II](https://leetcode.com/problems/task-scheduler-ii)                                                                                                                   | medium     |         64.9 | Array, Hash Table, Simulation                                                                                         |
| \[ \] | NV023 | [Merge Intervals](https://leetcode.com/problems/merge-intervals)                                                                                                                       | medium     |         61.4 | Array, Sorting                                                                                                        |
| \[ \] | NV024 | [Move Zeroes](https://leetcode.com/problems/move-zeroes)                                                                                                                               | easy       |         61.4 | Array, Two Pointers                                                                                                   |
| \[ \] | NV025 | [Find the Duplicate Number](https://leetcode.com/problems/find-the-duplicate-number)                                                                                                   | medium     |         61.4 | Array, Two Pointers, Binary Search, Bit Manipulation                                                                  |
| \[ \] | NV026 | [Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string)                                                                                                   | medium     |         61.4 | Two Pointers, String                                                                                                  |
| \[ \] | NV027 | [4Sum](https://leetcode.com/problems/4sum)                                                                                                                                             | medium     |         61.4 | Array, Two Pointers, Sorting                                                                                          |
| \[ \] | NV028 | [Rotate List](https://leetcode.com/problems/rotate-list)                                                                                                                               | medium     |         61.4 | Linked List, Two Pointers                                                                                             |
| \[ \] | NV029 | [Container With Most Water](https://leetcode.com/problems/container-with-most-water)                                                                                                   | medium     |         61.4 | Array, Two Pointers, Greedy                                                                                           |
| \[ \] | NV030 | [Find The Original Array of Prefix Xor](https://leetcode.com/problems/find-the-original-array-of-prefix-xor)                                                                           | medium     |         61.4 | Array, Bit Manipulation                                                                                               |
| \[ \] | NV031 | [Add Two Numbers](https://leetcode.com/problems/add-two-numbers)                                                                                                                       | medium     |         57.3 | Linked List, Math, Recursion                                                                                          |
| \[ \] | NV032 | [Fibonacci Number](https://leetcode.com/problems/fibonacci-number)                                                                                                                     | easy       |         57.3 | Math, Dynamic Programming, Recursion, Memoization                                                                     |
| \[ \] | NV033 | [Insert Delete GetRandom O(1)](https://leetcode.com/problems/insert-delete-getrandom-o1)                                                                                               | medium     |         57.3 | Array, Hash Table, Math, Design, Randomized                                                                           |
| \[ \] | NV034 | [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list)                                                                                                               | easy       |         57.3 | Linked List, Recursion                                                                                                |
| \[ \] | NV035 | [Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array)                                                                                                                 | easy       |         57.3 | Array, Two Pointers, Sorting                                                                                          |
| \[ \] | NV036 | [Unique Paths II](https://leetcode.com/problems/unique-paths-ii)                                                                                                                       | medium     |         57.3 | Array, Dynamic Programming, Matrix                                                                                    |
| \[ \] | NV037 | [Max Sum of a Pair With Equal Sum of Digits](https://leetcode.com/problems/max-sum-of-a-pair-with-equal-sum-of-digits)                                                                 | medium     |         57.3 | Array, Hash Table, Sorting, Heap (Priority Queue)                                                                     |
| \[ \] | NV038 | [Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements)                                                                                                       | medium     |         57.3 | Array, Hash Table, Divide and Conquer, Sorting, Heap (Priority Queue), Bucket Sort, Counting, Quickselect             |
| \[ \] | NV039 | [Sliding Window Maximum](https://leetcode.com/problems/sliding-window-maximum)                                                                                                         | hard       |         57.3 | Array, Queue, Sliding Window, Heap (Priority Queue), Monotonic Queue                                                  |
| \[ \] | NV040 | [Rotate Image](https://leetcode.com/problems/rotate-image)                                                                                                                             | medium     |         52.3 | Array, Math, Matrix                                                                                                   |
| \[ \] | NV041 | [Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer)                                                                                           | medium     |         52.3 | Hash Table, Linked List                                                                                               |
| \[ \] | NV042 | [House Robber](https://leetcode.com/problems/house-robber)                                                                                                                             | medium     |         52.3 | Array, Dynamic Programming                                                                                            |
| \[ \] | NV043 | [Break a Palindrome](https://leetcode.com/problems/break-a-palindrome)                                                                                                                 | medium     |         52.3 | String, Greedy                                                                                                        |
| \[ \] | NV044 | [String to Integer (atoi)](https://leetcode.com/problems/string-to-integer-atoi)                                                                                                       | medium     |         52.3 | String                                                                                                                |
| \[ \] | NV045 | [Rectangle Area](https://leetcode.com/problems/rectangle-area)                                                                                                                         | medium     |         52.3 | Math, Geometry                                                                                                        |
| \[ \] | NV046 | [Serialize and Deserialize Binary Tree](https://leetcode.com/problems/serialize-and-deserialize-binary-tree)                                                                           | hard       |         52.3 | String, Tree, Depth-First Search, Breadth-First Search, Design, Binary Tree                                           |
| \[ \] | NV047 | [Remove Stones to Minimize the Total](https://leetcode.com/problems/remove-stones-to-minimize-the-total)                                                                               | medium     |         52.3 | Array, Greedy, Heap (Priority Queue)                                                                                  |
| \[ \] | NV048 | [String Compression](https://leetcode.com/problems/string-compression)                                                                                                                 | medium     |         52.3 | Two Pointers, String                                                                                                  |
| \[ \] | NV049 | [Asteroid Collision](https://leetcode.com/problems/asteroid-collision)                                                                                                                 | medium     |         52.3 | Array, Stack, Simulation                                                                                              |
| \[ \] | NV050 | [Jump Game](https://leetcode.com/problems/jump-game)                                                                                                                                   | medium     |         52.3 | Array, Dynamic Programming, Greedy                                                                                    |
| \[ \] | NV051 | [Power of Two](https://leetcode.com/problems/power-of-two)                                                                                                                             | easy       |         52.3 | Math, Bit Manipulation, Recursion                                                                                     |
| \[ \] | NV052 | [Subarray Sum Equals K](https://leetcode.com/problems/subarray-sum-equals-k)                                                                                                           | medium     |         52.3 | Array, Hash Table, Prefix Sum                                                                                         |
| \[ \] | NV053 | [Valid Anagram](https://leetcode.com/problems/valid-anagram)                                                                                                                           | easy       |         52.3 | Hash Table, String, Sorting                                                                                           |
| \[ \] | NV054 | [Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self)                                                                                             | medium     |         52.3 | Array, Prefix Sum                                                                                                     |
| \[ \] | NV055 | [Maximum Number of Events That Can Be Attended](https://leetcode.com/problems/maximum-number-of-events-that-can-be-attended)                                                           | medium     |         52.3 | Array, Greedy, Sorting, Heap (Priority Queue)                                                                         |
| \[ \] | NV056 | [Minimum Absolute Difference](https://leetcode.com/problems/minimum-absolute-difference)                                                                                               | easy       |         52.3 | Array, Sorting                                                                                                        |
| \[ \] | NV057 | [3Sum](https://leetcode.com/problems/3sum)                                                                                                                                             | medium     |         45.8 | Array, Two Pointers, Sorting                                                                                          |
| \[ \] | NV058 | [Generate Parentheses](https://leetcode.com/problems/generate-parentheses)                                                                                                             | medium     |         45.8 | String, Dynamic Programming, Backtracking                                                                             |
| \[ \] | NV059 | [Climbing Stairs](https://leetcode.com/problems/climbing-stairs)                                                                                                                       | easy       |         45.8 | Math, Dynamic Programming, Memoization                                                                                |
| \[ \] | NV060 | [Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes)                                                                                                                   | medium     |         45.8 | Array, Hash Table, Matrix                                                                                             |
| \[ \] | NV061 | [Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii)                                                                                                         | medium     |         45.8 | Linked List                                                                                                           |
| \[ \] | NV062 | [Find Peak Element](https://leetcode.com/problems/find-peak-element)                                                                                                                   | medium     |         45.8 | Array, Binary Search                                                                                                  |
| \[ \] | NV063 | [Maximal Square](https://leetcode.com/problems/maximal-square)                                                                                                                         | medium     |         45.8 | Array, Dynamic Programming, Matrix                                                                                    |
| \[ \] | NV064 | [Find Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream)                                                                                             | hard       |         45.8 | Two Pointers, Design, Sorting, Heap (Priority Queue), Data Stream                                                     |
| \[ \] | NV065 | [Counting Bits](https://leetcode.com/problems/counting-bits)                                                                                                                           | easy       |         45.8 | Dynamic Programming, Bit Manipulation                                                                                 |
| \[ \] | NV066 | [Maximum Sum of Distinct Subarrays With Length K](https://leetcode.com/problems/maximum-sum-of-distinct-subarrays-with-length-k)                                                       | medium     |         45.8 | Array, Hash Table, Sliding Window                                                                                     |
| \[ \] | NV067 | [Spiral Matrix](https://leetcode.com/problems/spiral-matrix)                                                                                                                           | medium     |         45.8 | Array, Matrix, Simulation                                                                                             |
| \[ \] | NV068 | [Remove Duplicates from Sorted List](https://leetcode.com/problems/remove-duplicates-from-sorted-list)                                                                                 | easy       |         45.8 | Linked List                                                                                                           |
| \[ \] | NV069 | [Course Schedule II](https://leetcode.com/problems/course-schedule-ii)                                                                                                                 | medium     |         45.8 | Depth-First Search, Breadth-First Search, Graph Theory, Topological Sort                                              |
| \[ \] | NV070 | [Count the Number of Good Subsequences](https://leetcode.com/problems/count-the-number-of-good-subsequences)                                                                           | medium     |         45.8 | Hash Table, Math, String, Combinatorics, Counting                                                                     |
| \[ \] | NV071 | [Sort Colors](https://leetcode.com/problems/sort-colors)                                                                                                                               | medium     |         45.8 | Array, Two Pointers, Sorting                                                                                          |
| \[ \] | NV072 | [Minimum Path Sum](https://leetcode.com/problems/minimum-path-sum)                                                                                                                     | medium     |         45.8 | Array, Dynamic Programming, Matrix                                                                                    |
| \[ \] | NV073 | [Linked List Cycle](https://leetcode.com/problems/linked-list-cycle)                                                                                                                   | easy       |         45.8 | Hash Table, Linked List, Two Pointers                                                                                 |
| \[ \] | NV074 | [First Unique Character in a String](https://leetcode.com/problems/first-unique-character-in-a-string)                                                                                 | easy       |         45.8 | Hash Table, String, Queue, Counting                                                                                   |
| \[ \] | NV075 | [Rotting Oranges](https://leetcode.com/problems/rotting-oranges)                                                                                                                       | medium     |         45.8 | Array, Breadth-First Search, Matrix                                                                                   |
| \[ \] | NV076 | [Find the Celebrity](https://leetcode.com/problems/find-the-celebrity)                                                                                                                 | medium     |         45.8 | Two Pointers, Graph Theory, Interactive                                                                               |
| \[ \] | NV077 | [Course Schedule](https://leetcode.com/problems/course-schedule)                                                                                                                       | medium     |         45.8 | Depth-First Search, Breadth-First Search, Graph Theory, Topological Sort                                              |
| \[ \] | NV078 | [Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence)                                                                                         | medium     |         45.8 | Array, Binary Search, Dynamic Programming                                                                             |
| \[ \] | NV079 | [Min Stack](https://leetcode.com/problems/min-stack)                                                                                                                                   | medium     |         45.8 | Stack, Design                                                                                                         |
| \[ \] | NV080 | [Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence)                                                                                             | medium     |         45.8 | Array, Hash Table, Union-Find                                                                                         |
| \[ \] | NV081 | [Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list)                                                                                                         | easy       |         45.8 | Linked List, Two Pointers, Stack, Recursion                                                                           |
| \[ \] | NV082 | [Minimum Knight Moves](https://leetcode.com/problems/minimum-knight-moves)                                                                                                             | medium     |         36.9 | Breadth-First Search                                                                                                  |
| \[ \] | NV083 | [Max Points on a Line](https://leetcode.com/problems/max-points-on-a-line)                                                                                                             | hard       |         36.9 | Array, Hash Table, Math, Geometry                                                                                     |
| \[ \] | NV084 | [Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array)                                                                                       | medium     |         36.9 | Array, Divide and Conquer, Sorting, Heap (Priority Queue), Quickselect                                                |
| \[ \] | NV085 | [H-Index](https://leetcode.com/problems/h-index)                                                                                                                                       | medium     |         36.9 | Array, Sorting, Counting Sort                                                                                         |
| \[ \] | NV086 | [Linked List Random Node](https://leetcode.com/problems/linked-list-random-node)                                                                                                       | medium     |         36.9 | Linked List, Math, Reservoir Sampling, Randomized                                                                     |
| \[ \] | NV087 | [Sliding Puzzle](https://leetcode.com/problems/sliding-puzzle)                                                                                                                         | hard       |         36.9 | Array, Dynamic Programming, Backtracking, Breadth-First Search, Memoization, Matrix                                   |
| \[ \] | NV088 | [All Possible Full Binary Trees](https://leetcode.com/problems/all-possible-full-binary-trees)                                                                                         | medium     |         36.9 | Dynamic Programming, Tree, Recursion, Memoization, Binary Tree                                                        |
| \[ \] | NV089 | [Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix)                                                                                                           | easy       |         36.9 | Array, String, Trie                                                                                                   |
| \[ \] | NV090 | [Minimum Size Subarray Sum](https://leetcode.com/problems/minimum-size-subarray-sum)                                                                                                   | medium     |         36.9 | Array, Binary Search, Sliding Window, Prefix Sum                                                                      |
| \[ \] | NV091 | [Delete Duplicate Folders in System](https://leetcode.com/problems/delete-duplicate-folders-in-system)                                                                                 | hard       |         36.9 | Array, Hash Table, String, Depth-First Search, Trie, Sorting, Hash Function                                           |
| \[ \] | NV092 | [Reverse String](https://leetcode.com/problems/reverse-string)                                                                                                                         | easy       |         36.9 | Two Pointers, String                                                                                                  |
| \[ \] | NV093 | [Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits)                                                                                                                     | easy       |         36.9 | Divide and Conquer, Bit Manipulation                                                                                  |
| \[ \] | NV094 | [Merge In Between Linked Lists](https://leetcode.com/problems/merge-in-between-linked-lists)                                                                                           | medium     |         36.9 | Linked List                                                                                                           |
| \[ \] | NV095 | [The Maze](https://leetcode.com/problems/the-maze)                                                                                                                                     | medium     |         36.9 | Array, Depth-First Search, Breadth-First Search, Matrix                                                               |
| \[ \] | NV096 | [Integer to English Words](https://leetcode.com/problems/integer-to-english-words)                                                                                                     | hard       |         36.9 | Math, String, Recursion                                                                                               |
| \[ \] | NV097 | [Task Scheduler](https://leetcode.com/problems/task-scheduler)                                                                                                                         | medium     |         36.9 | Array, Hash Table, Greedy, Sorting, Heap (Priority Queue), Counting                                                   |
| \[ \] | NV098 | [Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii)                                                                           | medium     |         36.9 | Linked List, Two Pointers                                                                                             |
| \[ \] | NV099 | [Largest Number](https://leetcode.com/problems/largest-number)                                                                                                                         | medium     |         36.9 | Array, String, Greedy, Sorting                                                                                        |
| \[ \] | NV100 | [Clone Graph](https://leetcode.com/problems/clone-graph)                                                                                                                               | medium     |         36.9 | Hash Table, Depth-First Search, Breadth-First Search, Graph Theory                                                    |
| \[ \] | NV101 | [Daily Temperatures](https://leetcode.com/problems/daily-temperatures)                                                                                                                 | medium     |         36.9 | Array, Stack, Monotonic Stack                                                                                         |
| \[ \] | NV102 | [Middle of the Linked List](https://leetcode.com/problems/middle-of-the-linked-list)                                                                                                   | easy       |         36.9 | Linked List, Two Pointers                                                                                             |
| \[ \] | NV103 | [Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists)                                                                                                         | easy       |         36.9 | Linked List, Recursion                                                                                                |
| \[ \] | NV104 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://leetcode.com/problems/longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit) | medium     |         36.9 | Array, Queue, Sliding Window, Heap (Priority Queue), Ordered Set, Monotonic Queue                                     |
| \[ \] | NV105 | [Number of Ways to Split Array](https://leetcode.com/problems/number-of-ways-to-split-array)                                                                                           | medium     |         36.9 | Array, Prefix Sum                                                                                                     |
| \[ \] | NV106 | [Pow(x, n)](https://leetcode.com/problems/powx-n)                                                                                                                                      | medium     |         36.9 | Math, Recursion                                                                                                       |
| \[ \] | NV107 | [Maximum Product of Three Numbers](https://leetcode.com/problems/maximum-product-of-three-numbers)                                                                                     | easy       |         36.9 | Array, Math, Sorting                                                                                                  |
| \[ \] | NV108 | [Sqrt(x)](https://leetcode.com/problems/sqrtx)                                                                                                                                         | easy       |         36.9 | Math, Binary Search                                                                                                   |
| \[ \] | NV109 | [Unique Paths](https://leetcode.com/problems/unique-paths)                                                                                                                             | medium     |         36.9 | Math, Dynamic Programming, Combinatorics                                                                              |
| \[ \] | NV110 | [Simplify Path](https://leetcode.com/problems/simplify-path)                                                                                                                           | medium     |         36.9 | String, Stack                                                                                                         |
| \[ \] | NV111 | [Word Pattern](https://leetcode.com/problems/word-pattern)                                                                                                                             | easy       |         36.9 | Hash Table, String                                                                                                    |
| \[ \] | NV112 | [The Skyline Problem](https://leetcode.com/problems/the-skyline-problem)                                                                                                               | hard       |         36.9 | Array, Divide and Conquer, Binary Indexed Tree, Segment Tree, Sweep Line, Sorting, Heap (Priority Queue), Ordered Set |
| \[ \] | NV113 | [Find K Closest Elements](https://leetcode.com/problems/find-k-closest-elements)                                                                                                       | medium     |         36.9 | Array, Two Pointers, Binary Search, Sliding Window, Sorting, Heap (Priority Queue)                                    |
| \[ \] | NV114 | [Third Maximum Number](https://leetcode.com/problems/third-maximum-number)                                                                                                             | easy       |         36.9 | Array, Sorting                                                                                                        |
| \[ \] | NV115 | [Decode String](https://leetcode.com/problems/decode-string)                                                                                                                           | medium     |         36.9 | String, Stack, Recursion                                                                                              |
| \[ \] | NV116 | [Median of Two Sorted Arrays](https://leetcode.com/problems/median-of-two-sorted-arrays)                                                                                               | hard       |         36.9 | Array, Binary Search, Divide and Conquer                                                                              |
| \[ \] | NV117 | [Number of Lines To Write String](https://leetcode.com/problems/number-of-lines-to-write-string)                                                                                       | easy       |         36.9 | Array, String                                                                                                         |
| \[ \] | NV118 | [Shuffle an Array](https://leetcode.com/problems/shuffle-an-array)                                                                                                                     | medium     |         36.9 | Array, Math, Design, Randomized                                                                                       |
| \[ \] | NV119 | [Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)                                                                                           | medium     |         36.9 | Two Pointers, String, Dynamic Programming                                                                             |
| \[ \] | NV120 | [Next Greater Element II](https://leetcode.com/problems/next-greater-element-ii)                                                                                                       | medium     |         36.9 | Array, Stack, Monotonic Stack                                                                                         |
| \[ \] | NV121 | [Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree)                                                                                                       | easy       |         36.9 | Tree, Depth-First Search, Binary Tree                                                                                 |
| \[ \] | NV122 | [Compare Version Numbers](https://leetcode.com/problems/compare-version-numbers)                                                                                                       | medium     |         36.9 | Two Pointers, String                                                                                                  |
| \[ \] | NV123 | [Maximum Product Subarray](https://leetcode.com/problems/maximum-product-subarray)                                                                                                     | medium     |         36.9 | Array, Dynamic Programming                                                                                            |
| \[ \] | NV124 | [Number of Visible People in a Queue](https://leetcode.com/problems/number-of-visible-people-in-a-queue)                                                                               | hard       |         36.9 | Array, Stack, Monotonic Stack                                                                                         |
| \[ \] | NV125 | [Count Primes](https://leetcode.com/problems/count-primes)                                                                                                                             | medium     |         36.9 | Array, Math, Enumeration, Number Theory                                                                               |
| \[ \] | NV126 | [All Nodes Distance K in Binary Tree](https://leetcode.com/problems/all-nodes-distance-k-in-binary-tree)                                                                               | medium     |         36.9 | Hash Table, Tree, Depth-First Search, Breadth-First Search, Binary Tree                                               |
| \[ \] | NV127 | [Add Two Numbers II](https://leetcode.com/problems/add-two-numbers-ii)                                                                                                                 | medium     |         36.9 | Linked List, Math, Stack                                                                                              |
| \[ \] | NV128 | [Contains Duplicate](https://leetcode.com/problems/contains-duplicate)                                                                                                                 | easy       |         36.9 | Array, Hash Table, Sorting                                                                                            |
| \[ \] | NV129 | [Design Memory Allocator](https://leetcode.com/problems/design-memory-allocator)                                                                                                       | medium     |         36.9 | Array, Hash Table, Design, Simulation                                                                                 |
| \[ \] | NV130 | [Fizz Buzz Multithreaded](https://leetcode.com/problems/fizz-buzz-multithreaded)                                                                                                       | medium     |         36.9 | Concurrency                                                                                                           |
| \[ \] | NV131 | [Longest Cycle in a Graph](https://leetcode.com/problems/longest-cycle-in-a-graph)                                                                                                     | hard       |         36.9 | Depth-First Search, Breadth-First Search, Graph Theory, Topological Sort                                              |
| \[ \] | NV132 | [Network Delay Time](https://leetcode.com/problems/network-delay-time)                                                                                                                 | medium     |         36.9 | Depth-First Search, Breadth-First Search, Graph Theory, Heap (Priority Queue), Shortest Path                          |
| \[ \] | NV133 | [Design Circular Queue](https://leetcode.com/problems/design-circular-queue)                                                                                                           | medium     |         36.9 | Array, Linked List, Design, Queue                                                                                     |
| \[ \] | NV134 | [Binary Subarrays With Sum](https://leetcode.com/problems/binary-subarrays-with-sum)                                                                                                   | medium     |         36.9 | Array, Hash Table, Sliding Window, Prefix Sum                                                                         |
| \[ \] | NV135 | [Previous Permutation With One Swap](https://leetcode.com/problems/previous-permutation-with-one-swap)                                                                                 | medium     |         36.9 | Array, Greedy                                                                                                         |
| \[ \] | NV136 | [Koko Eating Bananas](https://leetcode.com/problems/koko-eating-bananas)                                                                                                               | medium     |         36.9 | Array, Binary Search                                                                                                  |

## use rule

Choose the next problem by weak pattern, then public score. Stop after two clean problems of the same shape. Move to a different shape or run a mock. Repeating the same editorial with different nouns has sharply falling returns.

