Sno Topic Difficulty

1 Arrays Easy
2 Arrays Easy
3 Arrays Easy
4 Arrays Easy
5 Arrays Easy
6 Arrays Easy
7 Arrays Easy
8 Arrays Easy
9 Arrays Easy
10 Arrays Easy
11 Arrays Easy
12 Arrays Easy
13 Arrays Easy
14 Arrays Easy
15 Arrays Easy
16 Arrays Easy
17 Arrays Easy
18 Arrays Easy
19 Arrays Easy
20 Arrays Easy
21 Arrays Easy
22 Arrays Easy
23 Arrays Easy
24 Arrays Easy
25 Arrays Easy
26 Arrays Easy
27 Arrays Easy
28 Arrays Easy
29 Arrays Easy
30 Arrays Easy
31 Arrays Easy
32 Arrays Easy
33 Arrays Easy
34 Arrays Easy
35 Arrays Easy
36 Arrays Easy
37 Arrays Easy
38 Arrays Easy
39 Arrays Easy
40 Arrays Easy
41 Arrays Easy
42 Arrays Easy
43 Arrays Easy
44 Arrays Easy
45 Arrays Easy
46 Arrays Easy
47 Arrays Easy
 48 Arrays Easy
49 Arrays Easy
50 Arrays Easy
51 Arrays Easy
52 Arrays Easy
53 Arrays Easy
54 Arrays Easy
55 Arrays Easy
56 Arrays Easy
57 Arrays Easy
58 Arrays Easy
59 Arrays Easy
60 Arrays Easy
61 Arrays Easy
62 Arrays Easy
63 Arrays Easy
64 Arrays Easy
65 Arrays Easy
-------------------- -------------------- --------------------
1 Arrays Medium
2 Arrays Medium
3 Arrays Medium
4 Arrays Medium
5 Arrays Medium
6 Arrays Medium
7 Arrays Medium
8 Arrays Medium
9 Arrays Medium
10 Arrays Medium
11 Arrays Medium
12 Arrays Medium
13 Arrays Medium
14 Arrays Medium
15 Arrays Medium
16 Arrays Medium
17 Arrays Medium
18 Arrays Medium
19 Arrays Medium
20 Arrays Medium
21 Arrays Medium
22 Arrays Medium
23 Arrays Medium
24 Arrays Medium
25 Arrays Medium
26 Arrays Medium
27 Arrays Medium
28 Arrays Medium
29 Arrays Medium
30 Arrays Medium
31 Arrays Medium
32 Arrays Medium
33 Arrays Medium
34 Arrays Medium
35 Arrays Medium
 36 Arrays Medium
37 Arrays Medium
38 Arrays Medium
39 Arrays Medium
40 Arrays Medium
41 Arrays Medium
42 Arrays Medium
43 Arrays Medium
44 Arrays Medium
45 Arrays Medium
46 Arrays Medium
47 Arrays Medium
48 Arrays Medium
49 Arrays Medium
50 Arrays Medium
51 Arrays Medium
52 Arrays Medium
53 Arrays Medium
54 Arrays Medium
55 Arrays Medium
56 Arrays Medium
57 Arrays Medium
58 Arrays Medium
59 Arrays Medium
60 Arrays Medium
61 Arrays Medium
-----------------------------------------------------
-----------------------------
1 Arrays Hard
2 Arrays Hard
3 Arrays Hard
4 Arrays Hard
5 Arrays Hard
6 Arrays Hard
7 Arrays Hard
8 Arrays Hard
9 Arrays Hard
10 Arrays Hard
11 Arrays Hard
12 Arrays Hard
---------------------------------------------------
-----------------------------------

1 Two Pointers Easy

2 Two Pointers Easy
3 Two Pointers Easy
4 Two Pointers Easy
5 Two Pointers Easy
6 Two Pointers Easy
7 Two Pointers Easy
8 Two Pointers Medium
9 Two Pointers Medium
10 Two Pointers Medium
11 Two Pointers Medium
12 Two Pointers Medium
13 Two Pointers Medium
 14 Two Pointers Medium
15 Two Pointers Medium

-------------------- ----------------------------
-----------------------------------------

1 Recursion Easy
2 Recursion Medium
3 Recursion Medium
4 Recursion Hard
5 Recursion Hard

--------------------- ---------------------
-------------------------------

1 Arrays Medium
2 Arrays Medium
3 Arrays Medium
4 Arrays Medium
5 Arrays Medium
6 Arrays Medium
7 Arrays Medium
8 Arrays Medium
9 Arrays Medium
10 Arrays Medium
11 Arrays Hard
12 Arrays Hard
13 Arrays Hard
14 Two Pointers Easy
15 BackTracking Medium
16 BackTracking Medium
17 Arrays Medium
18 BackTracking Medium
19 BackTracking Medium
20 Arrays Hard
21 DP Medium
22 DP Medium
23 DP Medium
Stack Hard
Tree Medium

---------------------
-------------------------------
--------------------------------

1 DFS Medium
2 DFS Medium
3 DFS Medium
4 DFS Medium
5 DFS Medium
6 DFS Medium
7 DFS Medium
8 DFS Easy
9 DFS Easy
10 DFS Medium
11 DFS Medium
---------------------
-------------------------------
--------------------------------

1 Binary Search Easy

1 BackTracking Medium
2 backTracking Hard
3 BackTracking hard
4 BackTracking Hard
5 BackTracking Medium
6 BackTracking Medium
7 BackTracking Medium
8 BackTracking Medium
9 Extra Medium
10 BackTracking Medium
11 BackTracking Medium

1 DP Easy
2 DP Easy
3 DP Easy
4 DP Easy
5 DP Easy
6 DP Medium
7 DP Medium
8 DP Medium
9 DP Medium
10 DP Medium
11 DP Medium
12 DP Medium
13 DP Medium
14 DP Medium
15 DP Medium
16 DP Medium
17 DP Medium
18 DP Medium
19 DP Medium
20 DP Medium
21 DP Medium
22 DP Medium
23 DP Medium
24 DP Medium
25 DP Medium
26 DP Medium
27 DP Medium
28 DP Medium
29 DP Medium
30 DP Medium
31 DP Medium
32 DP Medium
33 DP Medium
34 DP Medium
35 DP Medium
36 DP Medium
37 DP Medium
38 DP Medium
39 DP Medium
40 DP Medium
41 DP Medium
42 DP Medium
43 DP Medium
44 DP Medium
45 DP Medium
46 DP Medium
47 DP Medium
48 DP Medium
49 DP Medium
50 DP Medium
51 DP Medium
52 DP Medium
53 DP Medium
54 DP Medium
55 DP Medium
56 DP Medium
57 DP Medium
58 DP Medium
59 DP Medium
60 DP Medium
61 DP Medium

1 DP Hard
2 DP Hard
3 DP Hard
4 DP Hard
5 DP Hard
6 DP Hard
7 DP Hard

1 DC Easy
2 DC Easy
3 DC Medium
4 DC Medium
5 DC Medium
6 DC Hard
7 DC Hard

1 Stack Easy
2 Stack Easy
3 Stack Easy
4 Stack Medium
5 Stack Medium
6 Stack Medium
 7 Stack Medium
8 Stack Medium
9 Stack Medium
10 Stack Medium
11 Stack Medium
12 Stack Medium
13 Stack Medium
14 Stack Medium
15 Stack Medium
16 Stack Medium
17 Stack Medium
18 Stack Medium
19 Stack Medium
20 Stack Medium
21 Stack Medium
22 Stack Hard
23 Stack Hard
24 Stack Hard

1 Queue Easy
2 Queue Medium
3 Queue Medium
4 Queue Medium
5 Queue Hard

1 LL Easy
2 LL Easy
3 LL Easy
4 LL Easy
5 LL Easy
6 LL Easy
7 LL Easy
8 LL Easy
9 LL Easy
10 LL Medium
11 LL Medium
12 LL Medium
13 LL Medium
14 LL Medium
15 LL Medium
16 LL Medium
17 LL Medium
18 LL Medium
19 LL Medium
20 LL Medium
21 LL HARD
22 LL Medium
23 LL Medium
24 LL Medium

1 BT Easy
2 BT Easy
 3 BT Easy
4 BT Easy
5 BST Easy
6 BT Easy
7 BT Easy
8 BT Easy
9 BST Easy
10 BT Easy
11 GT Easy
12 BT Easy
13 BT Easy
14 BT Easy
15 BST Easy
16 BT Easy
17 GT Easy
18 GT Easy
19 GT Easy
20 BST Easy
21 BST Easy
22 BT Easy
23 BT Easy
24 BT Easy
25 BT Easy
26 BST Easy
27 BT Easy
28 BT Easy
29 BT Easy
30 BST Easy
31 BT Easy
32 BST Easy
33 BT Easy
34 BT Easy
35 BST Easy
36 BT Easy
37 BT Easy
38 BT Easy
39 BT Easy
40 BT Easy
41 BT Easy
42 BST Medium
43 BT Medium
44 BST Medium
45 BT Medium
46 BT Medium
47 BT Medium
48 BT Medium
49 BT Medium
50 BT Medium
51 BST Medium
52 BT Medium
53 BT Medium
54 BT Medium
55 BT Medium
56 BT Medium
57 BT Medium
58 BT Medium
59 BT Medium
60 BT Medium
61 BT Medium
62 BT Medium
63 BT Medium
64 BT Medium
65 BT Medium
66 BT Medium
67 BT Medium
68 BT Medium
69 BT Medium
70 BST Hard
71 BT Hard
72 BT Hard
73 BT Hard

1 HM Easy
2 HM Easy
3 HM Easy
4 HM Easy
5 HM Easy
6 HM Easy
7 HM Easy
8 HM Easy
9 HM Easy
10 HM Easy
11 HM Easy
12 HM Easy
13 HM Easy
14 HM Easy
15 HM Easy
16 HM Easy
17 HM Easy
18 HM Easy
19 HM Easy
20 HM Easy
21 HM Easy
22 HM Easy
23 HM Easy
24 HM Easy
25 HM Easy
26 HM Easy
26 HM Medium
27 HM Medium
28 HM Medium
29 HM Medium
30 HM Medium
31 HM Medium
32 HM Medium
33 HM Medium
34 HM Medium
35 HM Medium
36 HM Medium
37 HM Medium
38 HM Medium
39 HM Medium
40 HM Medium
41 HM Medium
42 HM Medium
43 HM Medium
44 HM Medium
45 HM Medium
46 HM Medium
47 HM Medium
48 HM Medium
49 HM Medium
50 HM Medium
51 HM Medium
52 HM Medium
45 HM Hard
46 HM Hard
47 HM Hard
48 HM Hard
49 HM Hard
50 HM Hard

1 Heap Easy
2 Heap Easy
3 Heap Medium
4 Heap Medium
5 Heap Medium
6 Heap Medium
7 Heap Medium
8 Heap Medium
9 Heap Medium
10 Heap Medium
11 Heap Medium
12 Heap Medium
13 Heap Hard
14 Heap Hard
15 BM Easy
16 BM Easy
17 BM Easy
18 BM Easy
19 BM Easy
20 BM Easy
21 BM Easy
22 BM Easy
23 BM Easy
24 BM Easy
25 BM Easy
26 BM Easy
27 BM Easy
28 BM Easy
29 BM Medium
30 BM Medium

1 Greedy Easy
2 Greedy Easy
3 Greedy Easy
4 Greedy Easy
5 Greedy Easy
6 Greedy Easy
7 Greedy Medium
8 Greedy Medium
9 Greedy Medium
10 Greedy Medium
11 Greedy Medium
12 Greedy Medium
13 Greedy Medium
14 Greedy Medium
15 Greedy Medium
16 Greedy Medium
17 Greedy Medium
18 Greedy Medium

1 Math Medium
2 DC, Stack, Bit Medium

1
2

1 Graph Easy
2 Graph Medium
3 Graph Medium
4 Graph Medium
5 Graph Medium
6 Graph Medium
7 Graph Medium
8 Graph Medium
9 Graph Medium
10 Graph Medium
11 Graph Medium
12 Graph Medium
13 Graph Medium
14 Graph Medium
15 Graph Medium
16 Graph Medium

1 Strings Easy
2 Strings Easy
3 Strings Easy
4 Strings Easy
5 Strings Easy
6 Strings Easy
7 Strings Easy
8 Strings Easy
9 Strings Easy
10 Strings Easy
11 Strings Easy
12 Strings Easy
13 Strings Easy
14 Strings Easy
15 Strings Easy
16 Strings Easy
17 Strings Easy
18 Strings Easy
19 Strings Easy
20 Strings Easy
21 Strings Easy
22 Strings Medium
23 Strings Medium
24 Strings Medium
25 Strings Medium
26 Strings Medium
27 Strings Medium
28 Strings Medium
29 Strings Medium
30 Strings Medium
31 Strings Medium
32 Strings Medium
33 Strings Medium
34 Strings Medium
35 Strings Medium
36 Strings Medium
37 Strings Medium
38 Strings Medium
39 Strings Medium
40 Strings Medium
41 Strings Medium
42 Strings Medium
43 Strings Medium
44 Strings Medium
45 Strings Medium
46 Strings Medium
47 Strings Medium
48 Strings Hard
49 Strings Hard
50 Strings Hard
 1 BS Easy
2 BS Easy
3 BS Easy
4 BS Easy
5 BS Easy
6 BS Easy
7 BS Easy
8 BS Easy
9 BS Easy
10 BS Easy
11 BS Easy
12 BS Hard
13 BS Hard
14 BS Hard
15 BS Hard
16 BS Hard
17 BS Hard
18 BS Hard

1 Sort Easy
2 Sort Easy
3 Sort Easy
4 Sort Medium
5 Sort Hard
[Link]
 Link Name

[Link] Two Sum

[Link] Remove Duplicates
[Link] Remove Element
[Link] Seach Insert Position
[Link] Sum Subarray
[Link] Plus One
[Link] Merge Sorted Array
[Link] Pascal Triangle - T(n3)S(1)
[Link] Pascal Triangle - T(n2)S(n2)
[Link] Pascal Triangle - T(n2)S(1)
[Link] Kth Row Pascal Traingle
[Link] Buy and Sell Stock
[Link] Buy and Sell Stock 2
[Link] Two Sum 2
[Link] Majority Element
[Link] Rotate Array
[Link] Contains in an Array
[Link] Contains in an Array 2
[Link] Missing Number
[Link] Move Zeros
[Link] Third Max Number
[Link] Numbers Disappeared
[Link] Max Consecutive Ones
[Link] Fibo Upto N
[Link] K Diff Pair in Array
[Link] Array Partition I
[Link] Reshape Matrix
[Link] Shortest unsorted subarray
[Link] Can Place Flowers
[Link] Max Product of Three Numbers
[Link] Max Avg Sum Subarray
[Link] Non Decreasing Array
[Link] Longest Continuous Inc Subseq
[Link] Find Pivot Index
[Link] Degree of Array
[Link] Min Most Climbing stairs
[Link] Toeplitz Matrix
[Link] Positions of Large Groups
[Link] Flipp the Image
[Link] Transpose
[Link] Fairy Candy
[Link] Monotonic
[Link] Sort Array by Parity
[Link] Sort Array by Parity - 2
[Link] Sq of Sorted Array
[Link] Sum of even number After Queries
[Link] Valid Mountain in Array
 [Link] 1 - bit and 2 - bit Character
[Link] Largest Perimeter
[Link] Image Smoother
[Link] Add 2 Array-Form
[Link] Magic Squares
[Link] X kind in a Deck of Cards
[Link] Song with Toal Durations
[Link] Height Checker
[Link] Available Captures for Rook
[Link] Prefix div by 5
[Link] Duplocate Zeros
[Link] Image Smoother
[Link] Dominoes Pairs
[Link] Compare by min Freq
[Link] Day of the week
[Link] Minimum absolute diff
[Link] Count odd values in matrix
[Link] Straight Line
-------------------------------------------------------------- -----------------------------------------
[Link] Contained With most Water
[Link] 3Sum
[Link] 3Sum Closest
[Link] 4Sum
[Link] Next Permutation
[Link] Search in Rotated Array
[Link]
First and Last in Sorted Array
[Link] Combination Sum
[Link] Combination Sum 2
[Link] Rotate by 90 Degree
[Link] Spiral
[Link] Jump Game
[Link] Merge Intervals
[Link] Unique Path
[Link] Unique Path 2
[Link] Minimum Path Sum
[Link] Set matrix to Zero
[Link] Search in 2-D Array
[Link] Sort Colors
[Link] remove Duplicates - 2
[Link] Binary Search in Rotated - 2
[Link] Subsets - 2
[Link] Triangle
[Link] Word Search
[Link] Max Product Subarray
[Link] Min in Rotated Array
[Link] Peak Element
[Link] Combination Sum 3
[Link] Summary Ranges
[Link] Majority Element - 2
[Link] Product of Array
[Link] Find Duplicate
[Link] Remove Duplicates in Array
[Link] Subarray with K sum
[Link] Array Nesting
[Link] Valid Triangle
[Link] Max Swap
[Link] Max Chunks
[Link] Global and local Inv
[Link] Matching Subseq
[Link] Bounded with Maximum
[Link] Appropriate Ages
[Link] Image Overlap
[Link] Longest Fibonacci Seq
[Link] Partition into Disjoint
[Link] Max Circular Sum
[Link] Monotone Inc String
[Link] Minimum Increment to Unique
[Link] Reveal cards
` Array of Double Pairs
[Link] Maximum Ramp
[Link] Turbulent
[Link] Subarray sum Div by K
[Link] Subarray Minimums
[Link] inset Delete getRandom
[Link] Teemo Attacking
[Link] Subarray Product less than K
[Link] Stock + transaction
[Link] My Calander 1
[Link] Sum of Subarray Minimums
[Link] Sum Divisible by k
---------------------------------------------------------------------- ------------------------------------------------
[Link] Find First Missing number
[Link] Rain Water Trapping
[Link] Jump Game 2
[Link] HistoGram
[Link] Longest Consecutive Subsequences
[Link] Insert Interval
[Link] Max Area Triangle
[Link] Min in Rotated Sorted - 2
[Link] Buy and Sell Stock Price 3
[Link] Kth Smallest Absolute Diff
[Link] Max Chunks To make Sorted
[Link] Subseq Width
--------------------------------------------------------------------- -------------------------------------------------
Two Pointers
[Link] Implement strStr
[Link] Reverse String
[Link] Reverse Vowels
[Link] BackSpace String Compare
[Link] Palindrome
[Link] Long Pressed name
[Link] Valid Palindrome
[Link] Permutation in String
[Link] Parition Labels
[Link] Assigning Work
[Link] Push Dominos
[Link] Longest Mountain
[Link] Boats to Save people
 [Link] Fruit Basket
[Link] 3Sum Multiplicity

-------------------------------------------------------------------------------- ------------------------------------------------------------
Recursion
[Link] Universal Path
[Link] Partition to k Equal subsets
[Link] Full BT Construct
[Link] Num of Atoms
[Link] Special Binary String

------------------------------------------------------------------- -------------------------------------------
Difficult Questions
[Link] Sum of Subarray Minimums
[Link] Image Overlap
[Link] Sum Divisible by k
[Link] Circular Array Loop
[Link] Task Scheduler
[Link] Beautiful Arrangement
[Link] My calander 2
[Link] RLE - Iterator
[Link] Pancake Flips
[Link] Max Area of island
Max-Sum-Of-Two-nonOverlapping Subarray
[Link]
[Link] Chess Board
[Link] Subseq Width
[Link] Permutation in String
[Link] GrayCode
[Link] Word Ladder
[Link] Word Search
[Link] Word search 2
[Link] Seach Word DS
[Link] Unique Letter String
[Link] CoolDown
[Link] Can I Win
[Link] Longest Arithmetic Seq
[Link] Leaved
[Link] Lannguage

------------------------------------------------------------------------ --------------------------------------------------
DFS
[Link] Subset
[Link] Subset - 2
[Link] Permutations
[Link] Permutations - 2
[Link] Combination Sum
[Link] Combination Sum - 3
[Link] Palindrome Partitioning
[Link] Permutation Letter
[Link] Binary watch
[Link] Keypad Combination
[Link] generate Parenthesis
 ------------------------------------------------------------------------ --------------------------------------------------
BINARY SEARCH
[Link] Guess the Number

BackTracking
[Link] Regukar Expression
[Link] Sudoku Solver
[Link] nQueens
[Link] NQueens Count
[Link] Permutation Sequence
[Link] Combinations
[Link] IpAddress
[Link] WordBreak 2
[Link] Word Break
[Link] GrayCode
[Link] Split into Fibo Seq
DP
[Link] Climbing Stairs
[Link] House Robber
[Link] Sum Query
[Link] Counting Bit
[Link] Ugly Numbers
[Link] Stone Game
[Link] Falling Sum
[Link] count Palindromic Substring
[Link] Delete minimum Ascii
[Link] Decode Ways
[Link] Ugly Numbers 2
[Link] Unique Binary Search Tree - count
[Link] Unique Binary Search Tree
[Link] House Robber - 2
[Link] Maximal Square
[Link] Perfect Square
[Link] Longest Increasing Subseq
[Link] Sum Query - 2
[Link] Integer Break
[Link] Count Number with Unique Digits
[Link] Guess Number 2
[Link] Wiggle Subseq
[Link] Combination Sum 4
[Link] Subset Sum Partition
[Link] Ones and Zeros
[Link] Palindromic Subseq Largest
[Link] Predict The Winner
[Link] Boundary Paths
[Link] 2 Keys KeyBoard
[Link] Target Sum
[Link] Delete and Earn
[Link] Minimum cost for Tickets
[Link] Maximum Diff Consequtive
[Link] Knight Dialer
[Link] Sum of Averages
[Link] Is Subsequences
[Link] Arithmetic Slices
[Link] Largest Divisible Subset
[Link] Cont Sub Sum % K
[Link] Number of Longest Inc Subseq
Minimum Swaps to make Seq Incre
[Link]
[Link] Largest Plus Sign
[Link] Can i win
[Link] Partition array for Max Sum
[Link] Sentence Screen Fitting
[Link] Wiggle Subseq
[Link] Longest Happy String
[Link] Longest arithmetic Seq
[Link] Minimum cost for Tickets
[Link] Knight Probability
[Link] k Concatenation max Sum
[Link] Maximum Length of pair
[Link] New 21 Game
[Link] Dice roll Simulation
[Link] Shortest way to Form String
[Link] Minmize rounding Error
[Link] Shopping Offers
[Link] 4 Keys Keyboard
[Link] No of LIS
[Link] No of corner rect
[Link] Delete Tree nodes

[Link] Palindromic Partition 2

[Link] Wild card Matching
[Link] Edit Distance
[Link] Egg Drop
[Link] Valid Parenthesis
[Link] Scrambles String
[Link] Dungeon Game

Divide and Conquer

[Link] Subarray Sum
[Link] Majority Element
[Link] Kth Largest
[Link] Search in 2D Matrix
[Link] Different ways to add Parenthesis
[Link] Medium of Two sorted Arrays
[Link] Merge K sorted Lists

Stack
[Link] Base Ball Game
[Link] Remove Outer Parenthesis
[Link] Remove Adjacent elements
[Link] PreOrder
[Link] Reverse Polish Notation
[Link] Binary Search Tree Iterator
[Link] Verify Preorder
[Link] Decode String
[Link] Remove k Digits
[Link] 132 Pattern
[Link] Next greater 2
[Link] Exclusive Time
[Link] Asteroid Collision
[Link] Daily Temperature
[Link] Car Fleet
[Link] Score of Parenthesis
[Link] Decode at String
[Link] Online Stock Span
[Link] Make Valid Parenthesis
[Link] Validate Stack Sequence
[Link] Next Greater Node
[Link] Post Order Traversal
[Link] Calculator
[Link] Maximum Freq Stack

Queue
[Link] Number of Recent calls
[Link] Implement Circular Deque
[Link] Circular Queue
[Link] Task Scheduler
[Link] Subarray sum atleast K

Linked List
[Link] Merge Two Sorted Arrays
[Link] Remove Duplicates from Sorted
[Link] Loop Detect
[Link] Remove LinkedList Elements
[Link] Reverse LinkedList
[Link] Delete a Node
[Link] Design a LL
[Link] Middle of Node
[Link] InterSection of Two LinkedList
[Link] Nth node from Last
[Link] Swap Nodes
[Link] Rotate List
[Link] Remove Duplicates 2
[Link] Parition List
[Link] Reverse Linked List
[Link] Reorder List
[Link] Insertion Sort
[Link] Sort List
[Link] Odd Even List
[Link] Add Two Numbers
[Link] Reverse K Groups
[Link] Split Linked List in Parts
[Link] Merge K sorted Lists
[Link] Components
Trees
[Link] Is Same
[Link] Symmetric Tree
[Link] Depth of Binary Tree
[Link] Level Order 2
[Link] Construct BST from sorted Array
[Link] Balanced Binary Tree
[Link] Minimum Depth
[Link] Path Sum
[Link] Common Ancestor
[Link] All root to leaf Paths
[Link] Level Order
[Link] Invert the Binary Tree
[Link] Path Sum 3
[Link] Sum of left online
[Link] Convert to Greater
[Link] Diameter of Tree
[Link] Depth of GT
[Link] Preorder GT
[Link] Post Order
[Link] Find modes in BST
[Link] Minimum Absolute Diff
[Link] Tilt BT
[Link] Is SubTree
[Link] Construct String from Binary Tree
[Link] Average Levels in Binary Tree
[Link] Two Sum - iv
[Link] Minimum Node in BT
[Link] Universal Path
[Link] Search in BST
[Link] Min Difference
[Link] Similar Trees
[Link] Increasing Order Search
[Link] Sum of Root to Leaf Binary
[Link] IsUnivariant
[Link] Range Sum of BST
[Link] Cousins
[Link] Flatten
[Link] Populate Next Pointer
[Link] Next Right Node Pointer
[Link] Root to Leaf Numbers
[Link] Right Side View
[Link] Kth Smallest in BST
[Link] Lowest Common Ancestor
[Link] Remove Nodes in BST
[Link] Find Bottom Left Tree
[Link] Find Largest Value in Levels
[Link] Count Nodes
[Link] House Robber 3
[Link] Frequent SubTree Sum
[Link] Add One to Row
[Link] Insert Into Binary Search Tree
[Link]
Construct - pre and post
[Link] Tree Pruning
[Link] All nodes at distance K
[Link] Subtree with Deepst Node
[Link] Complete Binary Tree Inserter
[Link] Flip Equivalent
[Link] Check Complete Binary Tree
[Link] BST from Preorder
[Link] Smallest String from Root
[Link] Vertical Order Print
Maximum Difference Between Ancestors
[Link]
[Link] Construct Max BT
[Link] Maximum Binary Tree
[Link] Flip to match Preorder
[Link] Maximum Width
[Link] Distribute Coins
[Link] Redundant Connection
[Link] Duplicate Subtree
[Link] Recover Binary Search Tree
[Link] Sum of distances in Tree
[Link] Maximum Path Sum
[Link] Post Order Traversal

HASHMAP
[Link] FInd Common Characters
[Link] Occurences after Bigrams
[Link] Happy Number
[Link] Valid Anagram
[Link] First Unique Character
[Link] Intersection 2
[Link] Intersection 2
[Link] Longest Palindrome
[Link] Boomerangs
[Link] Keyboard Row
[Link] Distribute Candies
[Link] Minimum Index Sum of Two Strings
[Link] Set MisMatch
[Link] Longest Harmonious Subseq
[Link] Design HashSet
[Link] Design HashMap
[Link] Longest Word in Dictionary
[Link] Jewels and the Stones
[Link] Uncommon Words
[Link] N Repeated Element
[Link] PowerFul Integers
[Link] Good Words
[Link] Subdomain visit
[Link] Verifying Alien Dict
[Link] Shortest Completing Word
[Link] Employee Importance
[Link] Valid Sudoku
[Link] Fraction to Recurring Decimal
[Link] Group Anagrams
[Link] H Index
[Link] Bulls and Cows
[Link] 4 Sum 2
[Link] Equal number of Zeros and Ones
[Link] Encode and Decode
[Link] Brick Wall
[Link] Replace Words
[Link] Subarray Sums Divisible by K
[Link] Time Based Key Value
[Link] FLip Columns for Max 1 in Row
[Link] Longest String Chain
[Link] Magic Dictionary
[Link] Subarrays With Sum
[Link] Minimum Area Rectangle
[Link] Prison after n Days
[Link] Minimum Window SubString
[Link] Largest values from Labels
[Link] Rabbit in Forest
[Link] Longest String Chain
[Link] Find all Anagrams
[Link]
Longest Substring wihout duplicate
[Link] Repeated DNA sequence
Smallest range Covering k elements
[Link]
[Link] No of Atoms
[Link] Substring with Concatenation
[Link] Sudoku
[Link] Maximal Rectangle
[Link] Max Points on a Line
[Link] Random Pick
[Link] Subarray with K diff elements
HEAP
[Link] Kth Largest in a Stream
[Link] Last Stone Weight
[Link] Barcodes
[Link] K Closest Points to Origin
[Link] Cheapest Flights within min stops
[Link] Reorganize String
[Link] Network Delay
[Link] TopKFrequentWords
[Link] Sort by Characters
[Link] Top K Frequent Elements
[Link] K Pairs with Smallest Sum
[Link] Super Ugly Number
[Link] SkyLine Problem
[Link] Sliding Window Maximum
[Link] Single Number
[Link] Reverse Bits
[Link] Number of 1 bits
[Link] is Power of Two ?
[Link] Missing Number
[Link] Power of Four
[Link] Sum of two Digits
[Link] Find the Difference
[Link] Convert to Hexadecimal
[Link] Hamming Distance
[Link] NUmbers Complement
[Link] Binary number with Alternate bits
[Link] of Prime set Bits
[Link] Letter Case Permutation
[Link] Single Number 2
[Link] Subsets

Greedy
[Link] Assign Cookies
[Link] Lemonade Change
[Link] Walking Robot Simulation
[Link] Two City Scheduling
[Link] Sum of Array After k Negotiations
[Link] Delete Columns to Make Sorted
[Link] Gas Station
[Link] is Subsequences
[Link] Remove K Digits
[Link] Reconstruction by Height
[Link] OverLapping Inervals
[Link] Minimum Number of Arrows
[Link] Task Scheduler
[Link] Split Array into Consequent subseq
[Link] CarPooling
[Link] Monotone Increasing Digits
[Link] Max Score After Flipping
[Link] Bag of Tokens

ChocoLate Question
[Link] Sorted Permutation Rank
[Link] Score of Parenthesis
[Link] Sorted Permutation Rank 2

Interview Question Bank

[Link] ATOI
[Link] Roman to Integer
[Link] Longest common Prefix
[Link] Power
[Link] Square root
[Link] Zeros in Factorial

Graph
[Link] Town Judge
[Link] Min Height Trees
[Link] Reconstruct Iineray
[Link] Sequence Reconstruction
[Link] Course Schedule - 4
[Link] Evaluate Division
Smallest no of neighbors with value
[Link]
[Link] Jump Game 3
[Link] Validate binary Tree
[Link] Shortest path with alternating color
[Link] as Far as land possible
[Link] Satisfiability of Equality
[Link] Keys and Rooms
[Link] Find eventual save states
[Link] Network delay Time
[Link] All paths from src to dst
Strings
[Link] Add Binary
[Link] Longest Uncommon String
[Link] Reverse Strings - 2
[Link] Student Attendance Record
[Link] Valid Palindrome
[Link] Repeated String Match
[Link] Unique Email Address
[Link] GCD of Two Strings
[Link] Defanging ip Address
[Link] Count Binary Strings
[Link] Morse Code
[Link] Common Words
[Link] Goat latin
[Link] Reverse only Letters
[Link] Count and Say
[Link] Length of last Word
[Link] Valid Palindrome
[Link] Ransom Note
[Link] Segments
[Link] String Compression
[Link] Detect Capital
[Link] Delete for Two Strings
[Link] Custom Sort
[Link] Shifting Letters
[Link] Word Subsets
[Link] Smallest Subseq
[Link] Spell Checker
[Link] Alphabet board Path
[Link] Reverse Word in String
[Link] Next Greater 3
[Link] Basic Calculator 2
[Link] Zig Zag Conversion
[Link] Remove Commands
[Link] Validate Ip Addresses
[Link] Simplify Path
[Link]
Binary Strings with Representation
[Link] CamelCase Matching
[Link] Integer to Roman
[Link] Complex Number Multiplication
[Link] Minimum Time Difference
[Link] Find and Replace Pattern
[Link] Check if Word is Valid
[Link] Optimal Division
[Link] Ambiguous Coordinates
[Link] Masking Personal Info
[Link] Find and Replace Pattern
[Link] Find Duplicate
[Link] Valid Number
[Link] Interleaving Strings
[Link] Distinct Subsequence
 Binary Search
[Link] Valid Perfect Square
[Link] Arranging Coins
[Link] Binary Search
[Link] Find Smallest Letter
[Link] Guess number or Higher
[Link] Peak index in Mountain array
[Link] First Bad Version
[Link] H - Index 2
[Link] Find K closest Elements
[Link] Koko Eating Bananas
[Link]
Maximum Nesting Deptth
[Link] Count of Smaller Number
[Link] Count of RangeSum
[Link] Russian Doll
[Link] Max sum of rectangles
[Link] Split array Sum less than K
[Link] Reverse Pairs
[Link] Preimage Using Trainling Zeros

Sort
[Link] Relative Sort
[Link] Matrix cells in distance
[Link] Largest Number
[Link] Containks Dupliacte 3
[Link] Maximam Gap
ava-Solutions/tree/master/Math/Problems
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
 1
1
1
1

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

1
-------------------

ping Subarray
 1
1

1
1
1
1
n Ancestors
1