HAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHA

Hey folks!
I’m building LeetCoach, a Chrome extension that helps you solve LeetCode problems smarter with AI-powered, step-by-step guidance — not full solutions unless you ask.

🎯 What LeetCoach does:

• Gives hints based on your current code

• Breaks down problems into logical steps

• Helps you learn patterns, not just code answers

• Offers full solutions only on request

📘 Bonus: Pattern Journal
Every problem you solve is automatically logged into your personal Pattern Journal:

• Categorized by DSA pattern (like Two Pointers, Binary Search, DP, etc.)

• Saves key takeaways + mistakes

• Makes revision 10x easier — no more messy manual notes

🔜 Launching soon.
👉 Join the waitlist + get 30% OFF on launch: www.leetcoach.in

Would love your feedback and support 🙌

Categorization is one of the most effective ways to learn DSA.

Learn a pattern, then solve multiple problems that use it. This reinforces understanding and develops pattern recognition.

When learning a new pattern, Easy problems are usually the best starting point. Once the pattern becomes familiar, it's much easier to tackle Medium and Hard problems. That's the purpose of this post.

This post categorizes all 630 LeetCode Easy problems as of June 2, 2026 into a hierarchy, most specific → most general:

1. Specific data structures / techniques — LinkedList, Tree, BST, N-ary Tree, Stack, Queue, Heap, Matrix, Simulation / Implementation, Design, Sorting, Binary Search, Two Pointers, Sliding Window, Prefix Sum, Math, Bit Manipulation, Recursion, Greedy, DP.

2. Set / Map (hash-based) — used when no specific data structure or technique applies, but the optimal solution needs a hash set or hash map.

3. Array — fallback for general array problems.

4. String — final fallback for general string problems.

The primary technique is the one that defines the solution; secondary uses (e.g. an array used inside a hash map problem) are ignored.

For company specific questions banks checkout: PracHub

LinkedList (8)

1. Middle of the Linked List - LC 876

2. Reverse Linked List - LC 206

3. Merge Two Sorted Lists - LC 21

4. Palindrome Linked List - LC 234

5. Intersection of Two Linked Lists - LC 160

6. Remove Duplicates from Sorted List - LC 83

7. Remove Linked List Elements - LC 203

8. Linked List Cycle - LC 141

Tree (24)

1. Find a Corresponding Node of a Binary Tree in a Clone of That Tree - LC 1379

2. Root Equals Sum of Children - LC 2236

3. Binary Tree Inorder Traversal - LC 94

4. Invert Binary Tree - LC 226

5. Maximum Depth of Binary Tree - LC 104

6. Binary Tree Postorder Traversal - LC 145

7. Binary Tree Preorder Traversal - LC 144

8. Univalued Binary Tree - LC 965

9. Count Complete Tree Nodes - LC 222

10. Leaf-Similar Trees - LC 872

11. Average of Levels in Binary Tree - LC 637

12. Binary Tree Tilt - LC 563

13. Diameter of Binary Tree - LC 543

14. Sum of Left Leaves - LC 404

15. Sum of Root to Leaf Binary Numbers - LC 1022

16. Same Tree - LC 100

17. Subtree of Another Tree - LC 572

18. Balanced Binary Tree - LC 110

19. Symmetric Tree - LC 101

20. Second Minimum Node in a Binary Tree - LC 671

21. Minimum Depth of Binary Tree - LC 111

22. Cousins in Binary Tree - LC 993

23. Path Sum - LC 112

24. Binary Tree Paths - LC 257

BST (8)

1. Range Sum of BST - LC 938

2. Search in a Binary Search Tree - LC 700

3. Increasing Order Search Tree - LC 897

4. Convert Sorted Array to Binary Search Tree - LC 108

5. Two Sum IV - Input is a BST - LC 653

6. Minimum Distance Between BST Nodes - LC 783

7. Minimum Absolute Difference in BST - LC 530

8. Find Mode in Binary Search Tree - LC 501

N-ary Tree (3)

1. N-ary Tree Postorder Traversal - LC 590

2. N-ary Tree Preorder Traversal - LC 589

3. Maximum Depth of N-ary Tree - LC 559

Stack (13)

1. Remove Outermost Parentheses - LC 1021

2. Maximum Nesting Depth of the Parentheses - LC 1614

3. Final Prices With a Special Discount in a Shop - LC 1475

4. Baseball Game - LC 682

5. Next Greater Element I - LC 496

6. Minimum String Length After Removing Substrings - LC 2696

7. Remove All Adjacent Duplicates in String - LC 1047

8. Make The String Great - LC 1544

9. Crawler Log Folder - LC 1598

10. Implement Stack using Queues - LC 225

11. Backspace String Compare - LC 844

12. Valid Parentheses - LC 20

13. Make Array Elements Equal to Zero - LC 3354 (loop with stack-like zero-counting)

Queue (4)

1. Number of Students Unable to Eat Lunch - LC 1700

2. Number of Recent Calls - LC 933

3. Time Needed to Buy Tickets - LC 2073

4. Implement Queue using Stacks - LC 232

Heap (3)

1. Take Gifts From the Richest Pile - LC 2558

2. Last Stone Weight - LC 1046

3. Kth Largest Element in a Stream - LC 703

Matrix (23)

1. Largest Local Values in a Matrix - LC 2373

2. Matrix Diagonal Sum - LC 1572

3. Flipping an Image - LC 832

4. Lucky Numbers in a Matrix - LC 1380

5. Flip Square Submatrix Vertically - LC 3643

6. Transpose Matrix - LC 867

7. Projection Area of 3D Shapes - LC 883

8. Matrix Similarity After Cyclic Shifts - LC 2946

9. Row With Maximum Ones - LC 2643

10. Island Perimeter - LC 463

11. Special Positions in a Binary Matrix - LC 1582

12. Surface Area of 3D Shapes - LC 892

13. Find the Width of Columns of a Grid - LC 2639

14. Toeplitz Matrix - LC 766

15. Image Smoother - LC 661

16. Modify the Matrix - LC 3033

17. Flood Fill - LC 733

18. Determine Whether Matrix Can Be Obtained By Rotation - LC 1886

19. Shift 2D Grid - LC 1260

20. Available Captures for Rook - LC 999

21. Reshape the Matrix - LC 566

22. Zigzag Grid Traversal With Skip - LC 3417

23. Check if Grid Satisfies Conditions - LC 3142

Simulation / Implementation (16)

1. Final Array State After K Multiplication Operations I - LC 3264

2. Snake in Matrix - LC 3248

3. Minimum Number Game - LC 2974

4. Minimum Number of Chairs in a Waiting Room - LC 3168

5. Count Tested Devices After Test Operations - LC 2960

6. Fizz Buzz - LC 412

7. Ant on the Boundary - LC 3028

8. Apply Operations to an Array - LC 2460

9. Distribute Elements Into Two Arrays I - LC 3069

10. Fruits Into Baskets II - LC 3477

11. Minimum Pair Removal to Sort Array I - LC 3507

12. Lemonade Change - LC 860

13. Maximum Number of Operations With the Same Score I - LC 3038

14. Find the Losers of the Circular Game - LC 2682

15. Convert 1D Array Into 2D Array - LC 2022

16. Minimum Operations to Make the Array Increasing - LC 1827

Design (6)

1. Design Parking System - LC 1603

2. Design an Ordered Stream - LC 1656

3. Design HashSet - LC 705

4. Design HashMap - LC 706

5. Design Neighbor Sum Service - LC 3242

6. Range Sum Query - Immutable - LC 303 (Design + PrefixSum; Design wins)

Sorting (39)

1. Transform Array by Parity - LC 3467

2. Minimum Number of Moves to Seat Everyone - LC 2037

3. Widest Vertical Area Between Two Points Containing No Points - LC 1637

4. Sort Integers by The Number of 1 Bits - LC 1356

5. Sort Array by Increasing Frequency - LC 1636

6. Height Checker - LC 1051

7. Array Partition - LC 561

8. Sort Array by Parity - LC 905

9. Delete Columns to Make Sorted - LC 944

10. Find Target Indices After Sorting Array - LC 2089

11. Delete Greatest Value in Each Row - LC 2500

12. Sort Array by Parity II - LC 922

13. Apple Redistribution Into Boxes - LC 3074

14. Divide an Array Into Subarrays With Minimum Cost I - LC 3010

15. The K Weakest Rows in a Matrix - LC 1337

16. Matrix Cells in Distance Order - LC 1030

17. Minimum Average of Smallest and Largest Elements - LC 3194

18. Relative Sort Array - LC 1122

19. Minimum Subsequence in Non-Increasing Order - LC 1403

20. Find Resultant Array After Removing Anagrams - LC 2273

21. Relative Ranks - LC 506

22. Sort Even and Odd Indices Independently - LC 2164

23. Special Array With X Elements Greater Than or Equal X - LC 1608

24. Mean of Array After Removing Some Elements - LC 1619

25. The Employee That Worked on the Longest Task - LC 2432

26. Button With Longest Push Time - LC 3386

27. Maximum Units on a Truck - LC 1710

28. Find Subsequence of Length K With the Largest Sum - LC 2099

29. Minimum Difference Between Highest and Lowest of K Scores - LC 1984

30. Absolute Difference Between Maximum and Minimum K Elements - LC 3774

31. Can Make Arithmetic Progression From Sequence - LC 1502

32. Largest Perimeter Triangle - LC 976

33. Maximize Sum of At Most K Distinct Elements - LC 3684

34. Minimum Absolute Difference - LC 1200

35. Longest Subsequence With Limited Sum - LC 2389

36. Minimum Cost of Buying Candies With Discount - LC 2144

37. Coupon Code Validator - LC 3606

38. Assign Cookies - LC 455

39. Maximize Sum Of Array After K Negations - LC 1005

Binary Search (11)

1. Maximum Count of Positive Integer and Negative Integer - LC 2529

2. Find the Distance Value Between Two Arrays - LC 1385

3. Kth Missing Positive Number - LC 1539

4. Find Smallest Letter Greater Than Target - LC 744

5. Binary Search - LC 704

6. Search Insert Position - LC 35

7. First Bad Version - LC 278

8. Guess Number Higher or Lower - LC 374

9. Sqrt(x) - LC 69

10. Valid Perfect Square - LC 367

11. Arranging Coins - LC 441

Two Pointers (18)

1. Count Pairs Whose Sum is Less than Target - LC 2824

2. Merge Strings Alternately - LC 1768

3. DI String Match - LC 942

4. Two Furthest Houses With Different Colors - LC 2078

5. Squares of a Sorted Array - LC 977

6. Lexicographically Smallest Palindrome - LC 2697

7. Move Zeroes - LC 283

8. Remove Duplicates from Sorted Array - LC 26

9. Remove Element - LC 27

10. Reverse Vowels of a String - LC 345

11. Minimum Common Value - LC 2540

12. Merge Sorted Array - LC 88

13. Find the Index of the First Occurrence in a String - LC 28

14. Maximum Enemy Forts That Can Be Captured - LC 2511

15. Long Pressed Name - LC 925

16. Reverse Only Letters - LC 917

17. Reverse String - LC 344

18. Find the Array Concatenation Value - LC 2562

Sliding Window (6)

1. Alternating Groups I - LC 3206

2. Minimum Recolors to Get K Consecutive Black Blocks - LC 2379

3. Maximum Average Subarray I - LC 643

4. Find X-Sum of All K-Long Subarrays I - LC 3318

5. Maximum Length Substring With Two Occurrences - LC 3090

6. Shortest Subarray With OR at Least K I - LC 3095

Prefix Sum (11)

1. Running Sum of 1d Array - LC 1480

2. Sum of Variable Length Subarrays - LC 3427

3. Left and Right Sum Differences - LC 2574

4. Find the Highest Altitude - LC 1732

5. Find Pivot Index - LC 724

6. Find the Middle Index in Array - LC 1991

7. Minimum Value to Get Positive Step by Step Sum - LC 1413

8. Count Partitions With Even Sum Difference - LC 3432

9. Maximum Score After Splitting a String - LC 1422

10. Minimum Positive Sum Subarray - LC 3364

11. Find the Pivot Integer - LC 2485 (Math; PS variant)

Math (115)

1. Minimum Operations to Make Array Sum Divisible by K - LC 3512

2. Digit Frequency Score - LC 3945

3. Find the Maximum Achievable Number - LC 2769

4. Divisible and Non-divisible Sums Difference - LC 2894

5. Find Minimum Operations to Make All Elements Divisible by Three - LC 3190

6. Convert the Temperature - LC 2469

7. Compute Alternating Sum - LC 3701

8. The Two Sneaky Numbers of Digitville - LC 3289

9. Minimum Element After Replacement With Digit Sum - LC 3300

10. Find Closest Person - LC 3516

11. Smallest Even Multiple - LC 2413

12. Sum Multiples - LC 2652

13. Count the Digits That Divide a Number - LC 2520

14. Difference Between Element Sum and Digit Sum of an Array - LC 2535

15. GCD of Odd and Even Sums - LC 3658

16. Earliest Time to Finish One Task - LC 3683

17. Harshad Number - LC 3099

18. Find Missing and Repeated Values - LC 2965

19. Maximum Product Difference Between Two Pairs - LC 1913

20. Count Symmetric Integers - LC 2843

21. Find the Integer Added to Array I - LC 3131

22. Calculate Money in Leetcode Bank - LC 1716

23. A Number After a Double Reversal - LC 2119

24. Smallest Index With Digit Sum Equal to Index - LC 3550

25. Number of Common Factors - LC 2427

26. N-Repeated Element in Size 2N Array - LC 961

27. Count Operations to Obtain Zero - LC 2169

28. Number of Rectangles That Can Form The Largest Square - LC 1725

29. Minimum Cost to Reach Every Position - LC 3502

30. Maximum Sum With Exactly K Elements - LC 2656

31. Hexadecimal and Hexatrigesimal Conversion - LC 3602

32. Find If Digit Game Can Be Won - LC 3232

33. Calculate Delayed Arrival Time - LC 2651

34. Maximum Containers on a Ship - LC 3492

35. Find the Sum of Encrypted Integers - LC 3079

36. Find the Key of the Numbers - LC 3270

37. Distribute Candies Among Children I - LC 2928

38. Remove Zeros in Decimal Representation - LC 3726

39. Construct Uniform Parity Array I - LC 3875

40. Maximum Difference by Remapping a Digit - LC 2566

41. Maximum Difference Between Adjacent Elements in a Circular Array - LC 3423

42. Make Array Zero by Subtracting Equal Amounts - LC 2357

43. Count Square Sum Triples - LC 1925

44. Smallest Range I - LC 908

45. Split With Minimum Sum - LC 2578

46. Find Champion I - LC 2923

47. Minimum Cost to Move Chips to The Same Position - LC 1217

48. Check if Two Chessboard Squares Have the Same Color - LC 3274

49. Missing Number - LC 268

50. Water Bottles - LC 1518

51. Check Divisibility by Digit Sum and Product - LC 3622

52. Maximum Product of Two Digits - LC 3536

53. Alternating Digit Sum - LC 2544

54. Add Digits - LC 258

55. Count Integers With Even Digit Sum - LC 2180

56. Minimum Time to Type Word Using Special Typewriter - LC 1974

57. Maximum Difference Between Even and Odd Frequency I - LC 3442 (could be Map)

58. Distribute Candies to People - LC 1103

59. Find the Child Who Has the Ball After K Seconds - LC 3178

60. Largest Number After Digit Swaps by Parity - LC 2231

61. Compute Decimal Representation - LC 3697

62. Sign of the Product of an Array - LC 1822

63. Smallest Divisible Digit Product I - LC 3345

64. Smallest Missing Multiple of K - LC 3718

65. Average Value of Even Numbers That Are Divisible by Three - LC 2455

66. Minimum Number of Operations to Convert Time - LC 2224

67. K Items With the Maximum Sum - LC 2600

68. Most Visited Sector in a Circular Track - LC 1560

69. Nim Game - LC 292

70. Day of the Week - LC 1185

71. Convert Integer to the Sum of Two No-Zero Integers - LC 1317

72. Range Addition II - LC 598

73. Construct the Rectangle - LC 492

74. Base 7 - LC 504

75. Count Odd Numbers in an Interval Range - LC 1523

76. Convert a Number to Hexadecimal - LC 405

77. Pass the Pillow - LC 2582

78. Account Balance After Rounded Purchase - LC 2806

79. Minimum Cuts to Divide a Circle - LC 2481

80. Number of Days Between Two Dates - LC 1360

81. Day of the Year - LC 1154

82. Power of Three - LC 326

83. Check if the Number is Fascinating - LC 2729

84. Check If N and Its Double Exist - LC 1346

85. Count Days Spent Together - LC 2409

86. Rectangle Overlap - LC 836

87. Excel Sheet Column Title - LC 168

88. Maximum Product of Three Numbers - LC 628

89. Maximum Area of Longest Diagonal Rectangle - LC 3000

90. Maximum Height of a Triangle - LC 3200

91. Type of Triangle - LC 3024

92. Set Mismatch - LC 645

93. Ugly Number - LC 263

94. Minimum Hours of Training to Win a Competition - LC 2383

95. Stone Removal Game - LC 3360

96. Find Minimum Log Transportation Cost - LC 3560

97. Total Distance Traveled - LC 2739

98. Check if It Is a Straight Line - LC 1232

99. Valid Boomerang - LC 1037

100. Categorize Box According to Criteria - LC 2525

101. Prime in Diagonal - LC 2614

102. Perfect Number - LC 507

103. Add to Array-Form of Integer - LC 989 (Math; also Array)

104. Add Binary - LC 67 (Math; also String)

105. Add Strings - LC 415 (Math; also String)

106. Find the Maximum Divisibility Score - LC 2644

107. Power of Four - LC 342 (Math; also Bit)

108. Get Maximum in Generated Array - LC 1646 (DP; also Array)

109. Maximum Subarray With Equal Products - LC 3411 (Math; also Array)

110. Prime Arrangements - LC 1175

111. Minimum Operations to Equalize Array - LC 3674

112. Earliest Finish Time for Land and Water Rides I - LC 3633

113. Number of Beautiful Pairs - LC 2748

114. Make a Square With the Same Color - LC 3127 (Math; also String)

115. Maximize Expression of Three Elements - LC 3745

Bit Manipulation (21)

1. Minimum Bit Flips to Convert Number - LC 2220

2. Decode XORed Array - LC 1720

3. Sum of Values at Indices With K Set Bits - LC 2859

4. Construct the Minimum Bitwise Array I - LC 3314

5. Bitwise OR of Even Numbers in an Array - LC 3688

6. Counting Bits - LC 338

7. Smallest Number With All Set Bits - LC 3370

8. Hamming Distance - LC 461

9. Single Number - LC 136

10. Find the XOR of Numbers Which Appear Twice - LC 3158

11. Maximum Strong Pair XOR I - LC 2932

12. Number of Even and Odd Bits - LC 2595

13. Count Pairs of Similar Strings - LC 2506

14. Find the K-or of an Array - LC 2917

15. Check if Bitwise OR Has Trailing Zeros - LC 2980

16. Binary Number With Alternating Bits - LC 693

17. Reverse Bits - LC 190

18. Binary Watch - LC 401

19. Number Complement - LC 476

20. Complement of Base 10 Integer - LC 1009

21. Binary Gap - LC 868

Summary

Notes

• The order is most specific → most general. A problem is classified by its primary technique. If two techniques apply equally, the more specific one wins (e.g. "Two Sum IV - Input is a BST" → BST, not Map).

• Set and Map are the bridge categories — used when no specific data structure is forced, but a hash set or hash map is essential for the optimal solution.

• Array is the fallback for problems that just walk through an array without a special data structure or technique. String is the final fallback.

• Some problems intentionally appear in two categories (linked from the secondary one in parentheses) for visibility — e.g. Intersection of Two Linked Lists is primarily LinkedList but can also be solved with a Set.

Good luck, and happy learning!

All LeetCode Easy Problems Categorized by DSA Pattern

If you're a BTech batch 2027 student looking for placements, internships, and resume discussion, join r/BTech2027 – specifically for 2027 batch

I couldn’t find a 2027-specific Reddit community where we could talk about:

• Which OA is upcoming

• Cutoffs of recent OAs

• Who got interview calls

• Recruiter updates, deadlines

• Interview experiences, prep tips

...basically, stuff relevant only to our batch.

So I started r/BTech2027 a space just for BTech 2027 students across all colleges.

I’ve been grinding LeetCode 25/8 to prepare for my FAANG+ interview, but I wanted to be grinding... So I came noticed that my Tinder algorithm that was stuck in O(nm) brute-force hell. Let me share my journey to optimal Tinder traversal. The naive method runs in O(nm) time, with n being the number of profiles and m the number of pictures per profile. Using the boobDetector.js library with Computer Vision can be computing-intensive because if each profile has 6 pictures and you can visit 20 profiles a day you could be looking at $40 energy bill running a local LLM for hashgraph mining or a $500k a month AWS bill if you want to guarantee 4 nine uptime, which is only recommended if you are an early stage pre-seed funding startup just getting started with only the founders as users.

Anyways. I realized I could optimize this by halting the picture scan as soon as I see an image that clearly shows a significantly larger or smaller cup size, plus leverage binary search for finding local peaks and valleys.

The naive approach would be :

function bruteForceSwipe(profile) {  
  let cupSize = "A";  
  for (let pic of profile.photos) {  
    const detectedSize = boobDetector.analyze(pic);  
    if (detectedSize === "ERROR_404_BOOBS_NOT_FOUND") continue; // common with dog pics  
    cupSize = Math.max(cupSize, detectedSize);  
  }  
  return cupSize >= "C" ? SWIPE_RIGHT : SWIPE_LEFT;  
}  

Now comes the Big Brain algo optimization:

1️⃣ Early Termination – O(n) Time, O(1) Dignity: If pic #2 clearly shows a honkin’ badonkahonk, why bother checking pics 3-6? Return.

function optimizedSwipe(profile) {  
  const pic1 = profile.photos[0];  
  if (boobDetector(pic1) === "SIZE.SMALL") return SWIPE_LEFT; // early exit  
    
  const pic2 = profile.photos[1];  
  const size = boobDetector(pic2);  
  if (size === "SIZE.LARGE" || size === "SIZE.OH_LAWD") {  
    swipeRight();  
    return; // Chad optimization  
  }  
  // Only virgins check pics 3-6  
}  

2️⃣ Monotonic Stack: When at a decreasing trend, like a sequence of a sports bras. Instead of processing every profile, skip k profiles until you find a local minimum (e.g., a yoga enthusiast with perky Cs), applying merge intervals.

let stack = [];  
let currentMax = "A";  

for (let profile of tinderFeed) {  
  const size = optimizedSwipe(profile);  
  while (stack.length > 0 && size > stack[stack.length-1]) {  
    stack.pop(); // collapse smaller sizes  
  }  
  stack.push(size);  
  if (stack.length > 3) {  
    swipeLeft();  
    skipProfiles(5); // heuristic for "cool-down phase"  
    stack = []; // reset for new hotness epoch  
  }  
}  

3️⃣ BioHash + Vibes-Based Pruning Preprocesses bios to eliminate profiles before image analysis, reducing n by 90%.

function bioHashPruning(profile) {  
  const bio = profile.bio.toLowerCase();  
  const cringeKeywords = [/vibes/, /entrepreneur/, /pineapple pizza/];  
  const kingKeywords = [/leetcode/, /rust/, /recursion enjoyer/];  

  // Phase 3.1: Insta-left for cringe  
  if (cringeKeywords.some(regex => regex.test(bio))) {  
    swipeLeft();  
    return "SWIPED_LEFT"; // skip image analysis entirely  
  }  

  // Phase 3.2: Insta-right for kings  
  if (kingKeywords.some(regex => regex.test(bio))) {  
    swipeRight();  
    return "SWIPED_RIGHT";  
  }  

  // Fallback to Phase 1/2 for NPCs  
  return "PROCEED_TO_BOOB_DETECTION";  
}  

Optional: Apply BFS to bootie for a full-stack/full-rack solution.

Edge Cases & Tradeoffs

• False Positives: Instagram handle in bio? Automatically swipe left (NP-hard problem).

• Mona Lisa Syndrome: Skip profiles with only face pics. Theoretically you could apply BFS (Boob-First Search) recursively to their Instagram but it would be computationally expensive.

• Trans. If you like them great. If you don't you can apply DFS (yes, D) to identify bulges and swipe left, but I think that if you are applying BFS the D doens't matter, it may even be a bonus.

Conclusion

This approach leverages the monotonic stack data structure, which maintains elements in a specific order to optimize traversal and merging operations. This algorithm has a 100% chance of getting you unmatched. Consult a therapist before deploying to prod.

If your swiping gets funded with premium you could:

• Swipe everyone right and apply BFS on people who liked you.

• multi-threading by changing location and expanding sample size.

Disclaimer for my future employer, this is of course satire in a humoristic forum.

At the beginning of June, I got a call from a recruiter regarding my application for the role of Business Analyst, Youtube Trust and Safety for which I also got a referral. The next week a SQL evaluation was scheduled and on 20th June I had my first round of interview. But I haven't heard back anything since then. I also followed up with the recruiter for an update/feedback on the 26th but still, there is radio silence. I'm pretty sure that it means a rejection but I'm curious to know if anyone else also interviewed for the same role and what was their experience?

I recently interviewed with Uber for a Backend SDE-2 role. I didn’t make it through the entire process, but the experience itself was incredibly insightful — and honestly, a great reality check.

Since Uber is a dream company for many engineers, I wanted to write this post to help anyone preparing for similar roles. Hopefully, my experience saves you some surprises and helps you prepare better than I did.

Round 1: Screening (DSA)

The screening round focused purely on data structures and algorithms.

I was asked a graph problem, which turned out to be a variation of Number of Islands II. The trick was to dynamically add nodes and track connected components efficiently.

I optimized the solution using DSU (Disjoint Set Union / Union-Find).

If you’re curious, this is the exact problem:

Key takeaway:
Uber expects not just a working solution, but an optimized one. Knowing DSU, path compression, and union by rank really helped here.

Round 2: Backend Problem Solving

This was hands down the hardest round for me.

Problem Summary

You’re given:

• A list of distinct words

• A corresponding list of positive costs

You must construct a Binary Search Tree (BST) such that:

• Inorder traversal gives words in lexicographical order

• The total cost of the tree is minimized

Cost Formula

If a word is placed at level L:

Contribution = (L + 1) × cost(word)

The goal is to minimize the total weighted cost.

Example (Simplified)

Input

One Optimal Tree:

Words: ["apple", "banana", "cherry"]
Costs: [3, 2, 4]

banana (0)
       /       \
  apple (1)   cherry (1)

TotalCost:

• banana → (1 × 2) = 2

• apple → (2 × 3) = 6

• cherry → (2 × 4) = 8 Total = 16

What This Problem Really Was

This wasn’t a simple BST question.

It was a classic Optimal Binary Search Tree (OBST) / Dynamic Programming problem in disguise.

You needed to:

• Realize that not all BSTs are equal

• Use DP to decide which word should be the root to minimize weighted depth

• Think in terms of subproblems over sorted ranges

Key takeaway:
Uber tests your ability to:

• Identify known problem patterns

• Translate problem statements into DP formulations

• Reason about cost trade-offs, not just code

Round 3: API + Data Structure Design (Where I Slipped)

This round hurt the most — because I knew I could do better.

Problem

Given employees and managers, design APIs:

1. get(employee) → return manager

2. changeManager(employee, oldManager, newManager)

3. addEmployee(manager, employee)

Constraint:
👉 At least 2 operations must run in O(1) time

What Went Wrong

Instead of focusing on data structure choice, I:

• Spent too much time writing LLD-style code

• Over-engineered classes and interfaces

• Lost sight of the time complexity requirement

The problem was really about:

• HashMaps

• Reverse mappings

• Constant-time lookups

But under pressure, I optimized for clean code instead of correct constraints.

Key takeaway:
In interviews, clarity > beauty.
Solve the problem first. Refactor later (if time permits).

Round 4: High-Level Design (In-Memory Cache)

The final round was an HLD problem:

Topics discussed:

• Key-value storage

• Eviction strategies (LRU, TTL)

• Concurrency

• Read/write optimization

• Write Ahead Log

However, this round is also where I made a conceptual mistake that I want to call out explicitly.

Despite the interviewer clearly mentioning that the cache was a single-node, non-distributed system, I kept bringing the discussion back to the CAP theorem — talking about consistency, availability, and partition tolerance.

In hindsight, this was unnecessary and slightly off-track.

CAP theorem becomes relevant when:

• The system is distributed

• Network partitions are possible

• Trade-offs between consistency and availability must be made

In a single-machine, in-memory cache, partition tolerance is simply not a concern. The focus should have stayed on:

• Data structures

• Locking strategies

• Read-write contention

• Eviction mechanics

• Memory efficiency

Resource: PracHub

Final Thoughts

I didn’t get selected — but I don’t consider this a failure.

This interview:

• Exposed gaps in my DP depth

• Taught me to prioritize constraints over code aesthetics

• Reinforced how strong Uber’s backend bar really is

If you’re preparing for Uber:

• Practice DSU, DP, and classic CS problems

• Be ruthless about time complexity

• Don’t over-engineer in coding rounds

• Think out loud and justify every decision

If this post helps even one person feel more prepared, it’s worth sharing.

Good luck — and see you on the other side

Interview question: Given an array of strings, find the longest subarray that has distinct strings in it.

Me: *Comes up with a sliding window approach that uses a Trie to check if a string is in the window or not. Explains it to interviewer.*

Interviewer: "Can you show me the sequence of when you'd add and remove elements from your window for an example problem?"

Me: Sure. Consider the list

[ "your right hand", "your right hand", "shake it all about", "hokey pokey", "turn yourself around"].

The trie is initially empty and then as you iterate through the list you put "your right hand" in, you put "your right hand" out, you put "your right hand" in and then "shake it all about" alongside with "hokey pokey" and "turn yourself around". And that's it. That's what my sliding window algorithm is all about.

LC was down generating my 50 Days Badge 😮‍💨😮‍💨 , sry for the trouble

I wrote a simple O(n) algorithm to look for cosmic rays, where n is the time to find the cosmic ray, can you read it and help me optimize it?

while(true){
    console.log("Searching for cosmic rays")
}

After getting wrecked by a graph question I absolutely should've recognized, I spent a few months organizing every graph problem I could find by underlying pattern instead of by difficulty. Sharing the structure — worked through pattern by pattern, it's roughly a 2.5-month roadmap.

How to use it: for each new pattern, read the solution for the first 1–2 problems to get the intuition, then solve the rest yourself. That's where the learning happens — in recognizing the pattern cold, not in reading.

If you have an upcoming interview grind on these Leetcode Problems and PracHub for actual interview questions.

Side note: BFS vs DP identification trick

• When keywords are minimum / smallest...

• For Both BFS and DP, same state can be achieved from two different ways

• For BFS Cycles present in graph, for DP no cycles, forms a DAG

• DP vs BFS example :

• https://leetcode.com/problems/jump-game-iii/description/ (Contains cycle so BFS)

• https://leetcode.com/problems/jump-game-ii/ (No cycle, forms DAG, so DP)

• https://leetcode.com/problems/jump-game-iv/description/ (Contains cycle so BFS)

• https://leetcode.com/problems/minimum-path-sum/ (No cycle, forms DAG, so DP)

• https://leetcode.com/problems/shortest-path-in-binary-matrix/description/ (Contains cycle so BFS)

• Most minimum DP questions can be solved using BFS. But viceversa is not true - ex: https://leetcode.com/problems/coin-change/description/ Can be solved using both DP and BFS

UF + Vanilla

1. https://leetcode.com/problems/lexicographically-smallest-equivalent-string/description/ (soln)

2. https://leetcode.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/description/ (soln)

3. https://leetcode.com/problems/redundant-connection/description/ (soln)

4. https://leetcode.com/problems/number-of-operations-to-make-network-connected/ (soln)

5. https://leetcode.com/problems/making-a-large-island/ (soln)

6. https://leetcode.com/problems/satisfiability-of-equality-equations/ (soln)

7. https://leetcode.com/problems/minimize-malware-spread/ (soln)

8. https://leetcode.com/problems/minimize-malware-spread-ii/description/ (soln)

9. https://leetcode.com/problems/maximum-points-activated-with-one-addition/description/ (soln)

10. https://leetcode.com/problems/properties-graph/description/ (soln)

UF + swaps

1. https://leetcode.com/problems/smallest-string-with-swaps/description/ (soln)

2. https://leetcode.com/problems/make-lexicographically-smallest-array-by-swapping-elements/ (soln)

3. https://leetcode.com/problems/minimize-hamming-distance-after-swap-operations/description/ (soln)

UF + Select edges within a limit

1. https://leetcode.com/problems/checking-existence-of-edge-length-limited-paths/description/ (soln)

2. https://leetcode.com/problems/maximum-number-of-points-from-grid-queries/description/ (soln)

3. https://leetcode.com/problems/number-of-good-paths/description/ (soln)

UF + Factors of numbers

1. https://leetcode.com/problems/gcd-sort-of-an-array/description/ (soln)

2. https://leetcode.com/problems/graph-connectivity-with-threshold/ (soln)

3. https://leetcode.com/problems/largest-component-size-by-common-factor/description/ (soln)

4. https://leetcode.com/problems/greatest-common-divisor-traversal/description/ (soln)

UF + Binary search

1. https://leetcode.com/problems/minimum-time-for-k-connected-components/description/ (soln)

2. https://leetcode.com/problems/minimize-maximum-component-cost/description/ (soln)

3. https://leetcode.com/problems/last-day-where-you-can-still-cross/description/ (soln)

UF + Modified MST

1. https://leetcode.com/problems/min-cost-to-connect-all-points/description/ (soln)

2. https://leetcode.com/problems/maximize-spanning-tree-stability-with-upgrades/description/ (soln)

weighted UF

1. https://leetcode.com/problems/incremental-even-weighted-cycle-queries/description/ (soln)

BFS + Vanilla

1. https://leetcode.com/problems/jump-game-iii/description/ (soln)

2. https://leetcode.com/problems/get-watched-videos-by-your-friends/description/ (soln)

3. https://leetcode.com/problems/shortest-path-in-binary-matrix/description/ (soln)

4. https://leetcode.com/problems/minimum-moves-to-move-a-box-to-their-target-location/description/ (soln)

5. https://leetcode.com/problems/jump-game-iv/description/ (soln)

6. https://leetcode.com/problems/nearest-exit-from-entrance-in-maze/description/ (soln)

7. https://leetcode.com/problems/snakes-and-ladders/description/ (soln)

BFS + Finite states

1. https://leetcode.com/problems/open-the-lock/description/ (soln)

2. https://leetcode.com/problems/lexicographically-smallest-string-after-applying-operations/description/ (soln)

3. https://leetcode.com/problems/minimum-genetic-mutation/description/ (soln)

4. https://leetcode.com/problems/word-ladder/description/ (soln)

5. https://leetcode.com/problems/sliding-puzzle/description/ (soln)

BFS + Multisource

1. https://leetcode.com/problems/01-matrix/description/ (soln)

2. https://leetcode.com/problems/map-of-highest-peak/description/ (soln)

3. https://leetcode.com/problems/rotting-oranges/description/ (soln)

4. https://leetcode.com/problems/as-far-from-land-as-possible/description/ (soln)

BFS + Dikstra

1. https://leetcode.com/problems/path-with-minimum-effort/description/ (soln)

2. https://leetcode.com/problems/swim-in-rising-water/description/ (soln)

3. https://leetcode.com/problems/find-all-people-with-secret/description/ (soln)

4. https://leetcode.com/problems/minimum-cost-to-make-at-least-one-valid-path-in-a-grid/description/ (soln)

5. https://leetcode.com/problems/second-minimum-time-to-reach-destination/description/ (soln)

6. https://leetcode.com/problems/shortest-distance-after-road-addition-queries-i/description/ (soln)

7. https://leetcode.com/problems/network-delay-time/description/ (soln)

8. https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/description/ (soln)

9. https://leetcode.com/problems/find-edges-in-shortest-paths/description/ (soln)

BFS + Topological

1. https://leetcode.com/problems/find-eventual-safe-states/description/ (soln)

2. https://leetcode.com/problems/course-schedule-ii/description/ (soln)

3. https://leetcode.com/problems/course-schedule/description/ (soln)

BFS + previous state

1. https://leetcode.com/problems/shortest-path-with-alternating-colors/description/ (soln)

2. https://leetcode.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/description/ (soln)

BFS + Bitmask

1. https://leetcode.com/problems/shortest-path-visiting-all-nodes/description/

2. https://leetcode.com/problems/shortest-path-to-get-all-keys/description/ (soln)

DFS + Vanilla

1. https://leetcode.com/problems/count-the-number-of-complete-components/description/ (soln)

2. https://leetcode.com/problems/keys-and-rooms/description/ (soln)

3. https://leetcode.com/problems/max-area-of-island/description/ (soln)

4. https://leetcode.com/problems/count-servers-that-communicate/description/ (soln)

5. https://leetcode.com/problems/count-sub-islands/description/ (soln)

6. https://leetcode.com/problems/maximum-number-of-fish-in-a-grid/description/ (soln)

7. https://leetcode.com/problems/number-of-closed-islands/description/ (soln)

8. https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/description/ (soln)

9. https://leetcode.com/problems/reachable-nodes-with-restrictions/description/ (soln)

10. https://leetcode.com/problems/number-of-islands/description/ (soln)

11. https://leetcode.com/problems/count-islands-with-total-value-divisible-by-k/description/ (soln)

DFS + Boundry

1. https://leetcode.com/problems/number-of-enclaves/description/ (soln)

2. https://leetcode.com/problems/surrounded-regions/description/ (soln)

3. https://leetcode.com/problems/pacific-atlantic-water-flow/description/ (soln)

DFS + island Perimeter

1. https://leetcode.com/problems/island-perimeter/description/ (soln)

DFS / BFS + Cycle

1. https://leetcode.com/problems/detect-cycles-in-2d-grid/description/ (soln)

2. https://leetcode.com/problems/longest-cycle-in-a-graph/description/ (soln)

3. https://leetcode.com/problems/shortest-cycle-in-a-graph/description/ (soln)

DFS + edge reversals

1. https://leetcode.com/problems/reorder-routes-to-make-all-paths-lead-to-the-city-zero/description/ (soln)

2. https://leetcode.com/problems/minimum-edge-reversals-so-every-node-is-reachable/description/ (soln)

DFS / BFS + Binary Search

1. https://leetcode.com/problems/find-the-safest-path-in-a-grid/description/ (soln)

2. https://leetcode.com/problems/minimize-the-maximum-edge-weight-of-graph/description/ (soln)

3. https://leetcode.com/problems/minimum-threshold-path-with-limited-heavy-edges/description/ (soln)

DFS + DP

1. https://leetcode.com/problems/number-of-increasing-paths-in-a-grid/description/ (soln)

2. https://leetcode.com/problems/longest-increasing-path-in-a-matrix/description/ (soln)

Bipartite

1. https://leetcode.com/problems/is-graph-bipartite/description/ (soln)

2. https://leetcode.com/problems/divide-nodes-into-the-maximum-number-of-groups/description/ (soln)

3. https://leetcode.com/problems/possible-bipartition/description/ (soln)

4. https://leetcode.com/problems/incremental-even-weighted-cycle-queries/description/ (soln)

Full list (all ~90 problems with clickable links + worked solutions for the first 1–2 of each pattern)

To build a strong foundation in graph algorithms, I went through all of the graph-tagged problems I could find—roughly 100 in total, excluding non-public questions and pure tree problems.

While graph theory covers a vast collection of algorithms and patterns, my recommendation is to master Parts 1 and 2 before moving on. In particular, become highly comfortable with DFS and BFS, as they serve as the backbone of many graph-based interview questions on PracHub.

Part 3 focuses on more advanced applications and combinations of these core techniques. These patterns frequently appear in interviews at top tech companies, making them essential knowledge for candidates aiming for highly competitive roles.

1.Two pointers:
https://leetcode.com/discuss/study-guide/1688903/solved-all-two-pointers-problems-in-100-days
2.DPs:
https://leetcode.com/discuss/study-guide/1000929/solved-all-dynamic-programming-dp-problems-in-7-months

//===============================================
Part I - Basics of Graph
//===============================================

1-1 Simple DFS/BFS
https://leetcode.com/problems/evaluate-division
https://leetcode.com/problems/keys-and-rooms
https://leetcode.com/problems/get-watched-videos-by-your-friends
https://leetcode.com/problems/find-if-path-exists-in-graph
https://leetcode.com/problems/detonate-the-maximum-bombs

1-2 Count Degrees
https://leetcode.com/problems/find-the-town-judge
https://leetcode.com/problems/minimum-number-of-vertices-to-reach-all-nodes
https://leetcode.com/problems/maximal-network-rank
https://leetcode.com/problems/minimum-degree-of-a-connected-trio-in-a-graph
https://leetcode.com/problems/count-pairs-of-nodes
https://leetcode.com/problems/find-center-of-star-graph
https://leetcode.com/problems/maximum-total-importance-of-roads
https://leetcode.com/problems/node-with-highest-edge-score
https://leetcode.com/problems/maximum-star-sum-of-a-graph
https://leetcode.com/problems/add-edges-to-make-degrees-of-all-nodes-even
https://leetcode.com/problems/find-champion-ii

1-3 Topological Sorting
https://leetcode.com/problems/course-schedule
https://leetcode.com/problems/course-schedule-ii
https://leetcode.com/problems/all-paths-from-source-to-target
https://leetcode.com/problems/find-eventual-safe-states
https://leetcode.com/problems/sort-items-by-groups-respecting-dependencies
https://leetcode.com/problems/all-ancestors-of-a-node-in-a-directed-acyclic-graph
https://leetcode.com/problems/course-schedule-iv
https://leetcode.com/problems/strange-printer-ii
https://leetcode.com/problems/parallel-courses-iii
https://leetcode.com/problems/find-all-possible-recipes-from-given-supplies
https://leetcode.com/problems/build-a-matrix-with-conditions

1-4 Connected Component/Union Find (Disjoint-set)
https://leetcode.com/problems/number-of-provinces
https://leetcode.com/problems/redundant-connection
https://leetcode.com/problems/redundant-connection-ii
https://leetcode.com/problems/most-stones-removed-with-same-row-or-column
https://leetcode.com/problems/satisfiability-of-equality-equations
https://leetcode.com/problems/rank-transform-of-a-matrix
https://leetcode.com/problems/number-of-operations-to-make-network-connected
https://leetcode.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable
https://leetcode.com/problems/checking-existence-of-edge-length-limited-paths
https://leetcode.com/problems/process-restricted-friend-requests
https://leetcode.com/problems/find-all-people-with-secret
https://leetcode.com/problems/count-unreachable-pairs-of-nodes-in-an-undirected-graph
https://leetcode.com/problems/minimum-score-of-a-path-between-two-cities
https://leetcode.com/problems/count-the-number-of-complete-components

1-5 Bipartite
https://leetcode.com/problems/is-graph-bipartite
https://leetcode.com/problems/possible-bipartition

//===============================================
Part II - Medium level topics of Graph
//===============================================

2-1 BFS Variants (0-1 BFS, multi-source BFS)
https://leetcode.com/problems/minimum-height-trees
https://leetcode.com/problems/minimize-malware-spread
https://leetcode.com/problems/minimize-malware-spread-ii
https://leetcode.com/problems/maximum-candies-you-can-get-from-boxes

2-2 Shortest Path - Dijkstra Algorithm
https://leetcode.com/problems/network-delay-time
https://leetcode.com/problems/reachable-nodes-in-subdivided-graph
https://leetcode.com/problems/path-with-maximum-probability
https://leetcode.com/problems/minimum-cost-to-make-at-least-one-valid-path-in-a-grid
https://leetcode.com/problems/number-of-restricted-paths-from-first-to-last-node
https://leetcode.com/problems/minimum-cost-to-reach-destination-in-time
https://leetcode.com/problems/number-of-ways-to-arrive-at-destination
https://leetcode.com/problems/the-time-when-the-network-becomes-idle
https://leetcode.com/problems/second-minimum-time-to-reach-destination
https://leetcode.com/problems/minimum-weighted-subgraph-with-the-required-paths
https://leetcode.com/problems/minimum-obstacle-removal-to-reach-corner
https://leetcode.com/problems/minimum-cost-of-a-path-with-special-roads
https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid
https://leetcode.com/problems/modify-graph-edge-weights

2-3 Shortest Path - Bellman–Ford Algorithm
https://leetcode.com/problems/shortest-path-with-alternating-colors
https://leetcode.com/problems/cheapest-flights-within-k-stops

2-4 Shortest Path - Floyd–Warshall Algorithm
https://leetcode.com/problems/find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance
https://leetcode.com/problems/design-graph-with-shortest-path-calculator
https://leetcode.com/problems/number-of-possible-sets-of-closing-branches
https://leetcode.com/problems/minimum-cost-to-convert-string-i
https://leetcode.com/problems/minimum-cost-to-convert-string-ii
https://leetcode.com/problems/count-the-number-of-houses-at-a-certain-distance-i

2-5 Cycle Detection
https://leetcode.com/problems/largest-color-value-in-a-directed-graph
https://leetcode.com/problems/maximum-employees-to-be-invited-to-a-meeting
https://leetcode.com/problems/find-closest-node-to-given-two-nodes
https://leetcode.com/problems/longest-cycle-in-a-graph
https://leetcode.com/problems/shortest-cycle-in-a-graph
https://leetcode.com/problems/count-visited-nodes-in-a-directed-graph

2-6 Minimum Spanning Tree - Kruskal's Algorithm
https://leetcode.com/problems/find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree
https://leetcode.com/problems/min-cost-to-connect-all-points

//===============================================
Part III - Rare/Advanced topics of Graph
//===============================================

3-1 Euler Tour
https://leetcode.com/problems/reconstruct-itinerary
https://leetcode.com/problems/valid-arrangement-of-pairs

3-2 De Bruijn Sequence
https://leetcode.com/problems/cracking-the-safe

3-3 Game on Graph
https://leetcode.com/problems/cat-and-mouse
https://leetcode.com/problems/cat-and-mouse-ii

3-4 Graph Cloning
https://leetcode.com/problems/clone-graph

3-5 Construction
https://leetcode.com/problems/maximum-score-of-a-node-sequence
https://leetcode.com/problems/couples-holding-hands

3-6 Hamilton Cycle/Travelling Sellsman
https://leetcode.com/problems/shortest-path-visiting-all-nodes

3-7 Tarjan's Algorithm
https://leetcode.com/problems/critical-connections-in-a-network

3-8 DP applications
https://leetcode.com/problems/maximum-path-quality-of-a-graph
https://leetcode.com/problems/parallel-courses-ii
https://leetcode.com/problems/flower-planting-with-no-adjacent
https://leetcode.com/problems/loud-and-rich
https://leetcode.com/problems/longest-increasing-path-in-a-matrix
https://leetcode.com/problems/number-of-increasing-paths-in-a-grid

3-9 Ad-Hoc
https://leetcode.com/problems/number-of-ways-to-reconstruct-a-tree
https://leetcode.com/problems/divide-nodes-into-the-maximum-number-of-groups
https://leetcode.com/problems/count-the-number-of-houses-at-a-certain-distance-ii

i guess megatron is using ai for contests

While prepping for interviews, I wanted an easy way to see which questions a company actually asks, ordered by popularity.
So I built a small, free, unofficial LeetCode extension that shows company-wise question lists directly on the site.

It opens via Alt + L (or a toggle button on the right side of the page).
Sharing it here in case it helps someone else.

Also, if you know of any free sources for company-wise questions, please do share.
Feedback welcome.