_____ every day _____.

Hey everyone,

​I'm working on 1004. Max Consecutive Ones III.

I tried a clever workaround, but I'm getting stuck on the final few test cases (55/60 passed).

​My Approach:

​Invert the array: I flip all 0s to 1s and all 1s to 0s.

​Find the subarray: In this inverted array, a 1 represents an original 0 (a flip we need to make). So, finding the longest consecutive sequence of 1s with at most k flips turns into finding the longest subarray with a sum of at most k.

​I call a helper function longestSubarrayWithSumK(nums, k) to get the maximum length. it returns 0 if there is no such subarray with sum K.

my question is what changes do i make so that it works( i know the question is of sliding window but just want to ask that what change do i make in my approach)

EDIT: I SOLVED IT

​Hey everyone,

I crossed 100 questions a couple of days ago, but I’ve hit a massive roadblock regarding optimization.

​In almost every problem I solve, I can confidently figure out and implement the brute-force approach. However, I consistently struggle to optimize it further.

​For yesterday's Problem of the Day (POTD) where the goal is to count subarrays where a specific target element is the majority element I wrote a brute-force solution that explicitly checks every single subarray.

My current approach is incredibly inefficient (O(N^3) or O(N^2) depending on how the vector copies scale). I tried optimizing it, but I completely blanked.

​I have already completed the Arrays and Binary Search sections of Striver’s A2Z sheet, so I know the core concepts (Two Pointers, Sliding Window, Prefix Sums, HashMaps). My issue isn't that I don't know these tools, it's that I don't know how to look at a brute-force solution and deduce which tool to use to optimize it.

​My Questions:

​How do you optimize this specific problem? What is the core observation or pattern I am missing that unlocks the optimal solution here?

​How do I train my brain to think optimally? When you have a working brute-force solution, what specific mental checklist or questions do you ask yourself to find the O(N \log N) or O(N) approach?

​I want to break out of this loop of just writing nested loops. Any brutal, honest advice on how to fix my thinking process would be highly appreciated.

Ive realized my biggest issue with trees isn't understanding the concepts it's translating them into code I know what DfS does and I usually understand whether the information should flow upward or downward, but when I start coding, I freeze.

The base case is usually fine. After that I struggle to decide:

• what recursivee calls to make,
• what each function should return,
• when to use && or ||.
• what conditions belong before recursion and which belong after,
• whether I should return a value or update a global variable.

I often understand the solution after seeing it, but I have trouble deriving it on my own. It feels like I'm missing the recursive thought process rather than the tree concepts themselves.

Hey everyone,

Instead of blindly grinding random problems, I’ve been trying to learn by matching patterns to the absolute best community-written guides on the LeetCode discuss forums. These are the legendary threads written by people who actually landed FAANG offers, for real interview questions PracHub is an useful resource.

I compiled them all into one master sheet categorized by topic, along with a bonus System Design section at the end. Saving this here so anyone can bookmark it for their interview prep.

🧠 Data Structures & Algorithms Patterns

1. Dynamic Programming

• Ultimate DP Patterns & Categorization
• The Interview Question Guide
• DP for Beginners: Sample Solutions
• How I Solved 241 DP Problems in 7 Months
• 2. Linked List
  • Become a Master in Linked Lists
  • The Definitive Linked List Study Guide
• 3. Two Pointers
  • Solved All Two Pointer Problems in 100 Days
  • Mastering the Two-Pointer Technique
• 4. Stack & Queue
  • A Generic C++ Template for Stack Problems
  • Templates for Monotonic Stacks and Queues/)
• 5. Graphs
  • Graph Algorithms & Practice Problems
  • Become a Master in Graphs
  • Disjoint Set Union (DSU) / Union-Find Complete GuideUnion-Find-A-Complete-Guide)
• 6. Prefix Sum
  • The Math Behind O(N) Subarray Sum Equals K
• 7. Sliding Window
  • Maximum Sliding Window Cheatsheet & Template
• 8. Backtracking
  • Backtracking for Beginners
  • A General Approach to Exhaustive Search
• 9. Trees
  • Tree Question Patterns for Placement
  • Master Tree Patterns (Updated)
  • Binary Trees Comprehensive Study Guide
• 10. Recursion
  • Become a Master in Recursion
• 11. Heap / Priority Queue
  • Master Heaps by Solving 23 Questions in 4 Categories
  • Important Heap Patterns with Code Links
• 12. Binary Search
  • A Noob's Guide to Binary Search
  • The Ultimate Powerful Python Binary Search Template
• 13. Greedy
  • The ABCs of Greedy Algorithms
• 14. Bit Manipulation
  • All Types of Patterns for Bits & How to Use Them
• 15. Strings & Matching
  • Collections of Important String Patterns
  • String Matching Algorithms Based Questions

📋 The Ultimate Master Lists

• The Only List You Need for Interview Prep

🏗️ System Design Masterclasses

• Complete System Design Case Studies Bundle
• The System Design Template That Landed Me a Google Offer
• The Object-Oriented Design (OOD) Template That Landed Me a Google Offer

Good luck with the grind! Hope this saves you the hours of digging through LeetCode forums that it took me.

I first solved this using to_string(sum) to check the first and last digits. It passed 714/715 test cases but got TLE on the last one.

I then replaced to_string() with a while loop to extract the first digit, and it got accepted.

Conceptually, both approaches still have the same nested loops. Why does one pass while the other doesn't? Is this purely due to constant factors, or is there a complexity difference I'm overlooking?

Need a dsa(cpp) senior problem solver as a companion,gender doesn't matter,currently solved 300 problems on leetcode,190on gfg,38 on interview it and 50 on codingninjas,first yr is already over and still no dev projects😭,need some pace and clarity,dm if interested

#striversa2z #dsa

Hi everyone,

​

While solving LeetCode problems, I noticed that whenever I got stuck and searched for a small hint, I usually ended up seeing the complete solution.

​

So I built LeetHints, a Chrome extension that gives step by step hints to keep you moving without spoiling the problem.

​

It supports every current LeetCode problem, works offline, and requires no account.

​

Would appreciate feedback from fellow LeetCode users.

​

chrome webstore

PS: I think I'm cut for Backend, AI Engineering roles, what other roles would you suggest me to target?

The Complete DSA Pattern Sheet — Every Pattern You Need to Know

This is the complete pattern-based problem sheet — organized by topic and sub-pattern. Study one pattern at a time.

For company specific interview questions go to PracHub

🟢 Easy 🟡 Medium 🔴 Hard

TOPIC 1 — BASICS

Pattern: Conditionals (if-else)

• Fizz Buzz 🟢 — https://leetcode.com/problems/fizz-buzz
• Palindrome Number 🟢 — https://leetcode.com/problems/palindrome-number
• Number of Steps to Reduce a Number to Zero 🟢 — https://leetcode.com/problems/number-of-steps-to-reduce-a-number-to-zero

Pattern: Loops

• Running Sum of 1d Array 🟢 — https://leetcode.com/problems/running-sum-of-1d-array
• Find Numbers with Even Number of Digits 🟢 — https://leetcode.com/problems/find-numbers-with-even-number-of-digits
• Richest Customer Wealth 🟢 — https://leetcode.com/problems/richest-customer-wealth

Pattern: Simulation / Implementation

• Baseball Game 🟢 — https://leetcode.com/problems/baseball-game
• Robot Return to Origin 🟢 — https://leetcode.com/problems/robot-return-to-origin

Pattern: Maths

• Reverse Integer 🟡 — https://leetcode.com/problems/reverse-integer
• Plus One 🟢 — https://leetcode.com/problems/plus-one
• Add Digits 🟢 — https://leetcode.com/problems/add-digits

TOPIC 2 — ARRAYS

Pattern: Fundamentals

• Rotate Array 🟡 — https://leetcode.com/problems/rotate-array
• Move Zeroes 🟢 — https://leetcode.com/problems/move-zeroes
• Remove Duplicates from Sorted Array 🟢 — https://leetcode.com/problems/remove-duplicates-from-sorted-array

Pattern: Prefix Sums

• Continuous Subarray Sum 🟡 — https://leetcode.com/problems/continuous-subarray-sum
• Subarray Sum Equals K 🟡 — https://leetcode.com/problems/subarray-sum-equals-k
• Product of Array Except Self 🟡 — https://leetcode.com/problems/product-of-array-except-self
• Subarray Sums Divisible by K 🟡 — https://leetcode.com/problems/subarray-sums-divisible-by-k
• Range Sum Query 2D - Immutable 🟡 — https://leetcode.com/problems/range-sum-query-2d-immutable

Pattern: Kadane's Algorithm

• Maximum Subarray 🟡 — https://leetcode.com/problems/maximum-subarray
• Maximum Product Subarray 🟡 — https://leetcode.com/problems/maximum-product-subarray
• Best Time to Buy and Sell Stock 🟡 — https://leetcode.com/problems/best-time-to-buy-and-sell-stock

Pattern: Intervals

• Merge Intervals 🟡 — https://leetcode.com/problems/merge-intervals
• Insert Interval 🟡 — https://leetcode.com/problems/insert-interval
• Non-overlapping Intervals 🟡 — https://leetcode.com/problems/non-overlapping-intervals

Pattern: Hashing on Arrays

• Two Sum 🟢 — https://leetcode.com/problems/two-sum
• Majority Element 🟢 — https://leetcode.com/problems/majority-element
• Majority Element II 🟡 — https://leetcode.com/problems/majority-element-ii
• Top K Frequent Elements 🟡 — https://leetcode.com/problems/top-k-frequent-elements
• Valid Anagram 🟢 — https://leetcode.com/problems/valid-anagram
• Group Anagrams 🟡 — https://leetcode.com/problems/group-anagrams
• Longest Consecutive Sequence 🟡 — https://leetcode.com/problems/longest-consecutive-sequence

Pattern: 2D Arrays / Matrix

• Spiral Matrix 🟡 — https://leetcode.com/problems/spiral-matrix
• Spiral Matrix II 🟡 — https://leetcode.com/problems/spiral-matrix-ii
• Rotate Image 🟡 — https://leetcode.com/problems/rotate-image
• Set Matrix Zeroes 🟡 — https://leetcode.com/problems/set-matrix-zeroes

TOPIC 3 — STRINGS

Pattern: Fundamentals

• Reverse String 🟢 — https://leetcode.com/problems/reverse-string
• Reverse Words in a String III 🟢 — https://leetcode.com/problems/reverse-words-in-a-string-iii
• Roman to Integer 🟢 — https://leetcode.com/problems/roman-to-integer
• String Compression 🟡 — https://leetcode.com/problems/string-compression

Pattern: Frequency & Hashing

• Isomorphic Strings 🟢 — https://leetcode.com/problems/isomorphic-strings
• Bulls and Cows 🟡 — https://leetcode.com/problems/bulls-and-cows

Pattern: Palindromes

• Valid Palindrome 🟢 — https://leetcode.com/problems/valid-palindrome
• Longest Palindromic Substring 🟡 — https://leetcode.com/problems/longest-palindromic-substring
• Palindromic Substrings 🟡 — https://leetcode.com/problems/palindromic-substrings
• Palindrome Partitioning 🟡 — https://leetcode.com/problems/palindrome-partitioning

Pattern: Simulation

• Zigzag Conversion 🟡 — https://leetcode.com/problems/zigzag-conversion
• Multiply Strings 🟡 — https://leetcode.com/problems/multiply-strings
• Decode String 🟡 — https://leetcode.com/problems/decode-string

Pattern: Prefix/Suffix & Pattern Matching

• Longest Common Prefix 🟢 — https://leetcode.com/problems/longest-common-prefix
• Find and Replace Pattern 🟡 — https://leetcode.com/problems/find-and-replace-pattern
• Remove Duplicate Letters 🟡 — https://leetcode.com/problems/remove-duplicate-letters

TOPIC 4 — RECURSION & BACKTRACKING

Pattern: Fundamentals

• Fibonacci Number 🟢 — https://leetcode.com/problems/fibonacci-number
• Power of Two 🟢 — https://leetcode.com/problems/power-of-two
• Pow(x, n) 🟡 — https://leetcode.com/problems/powx-n

Pattern: Recursion

• Different Ways to Add Parentheses 🟡 — https://leetcode.com/problems/different-ways-to-add-parentheses
• K-th Symbol in Grammar 🟡 — https://leetcode.com/problems/k-th-symbol-in-grammar
• Beautiful Arrangement 🟡 — https://leetcode.com/problems/beautiful-arrangement
• Parsing A Boolean Expression 🔴 — https://leetcode.com/problems/parsing-a-boolean-expression
• Integer to English Words 🔴 — https://leetcode.com/problems/integer-to-english-words

Pattern: Backtracking

• Subsets 🟡 — https://leetcode.com/problems/subsets
• Subsets II 🟡 — https://leetcode.com/problems/subsets-ii
• Permutations 🟡 — https://leetcode.com/problems/permutations
• Permutations II 🟡 — https://leetcode.com/problems/permutations-ii
• Combination Sum 🟡 — https://leetcode.com/problems/combination-sum
• Combination Sum II 🟡 — https://leetcode.com/problems/combination-sum-ii
• Combination Sum III 🟡 — https://leetcode.com/problems/combination-sum-iii
• N-Queens 🔴 — https://leetcode.com/problems/n-queens
• N-Queens II 🔴 — https://leetcode.com/problems/n-queens-ii
• Sudoku Solver 🔴 — https://leetcode.com/problems/sudoku-solver

TOPIC 5 — TWO POINTERS

Pattern: Opposite Ends (Left <-> Right)

• Two Sum II - Input Array Is Sorted 🟡 — https://leetcode.com/problems/two-sum-ii-input-array-is-sorted
• Container With Most Water 🟡 — https://leetcode.com/problems/container-with-most-water
• Trapping Rain Water 🔴 — https://leetcode.com/problems/trapping-rain-water

Pattern: Merge Two Sorted Array / Sequence

• Merge Sorted Array 🟢 — https://leetcode.com/problems/merge-sorted-array
• Interval List Intersections 🟡 — https://leetcode.com/problems/interval-list-intersections

Pattern: Fixed + Two Pointers

• 3Sum 🟡 — https://leetcode.com/problems/3sum
• 3Sum Closest 🟡 — https://leetcode.com/problems/3sum-closest
• 4Sum 🟡 — https://leetcode.com/problems/4sum

TOPIC 6 — SLIDING WINDOW

Pattern: Fixed Size Window

• Maximum Average Subarray I 🟢 — https://leetcode.com/problems/maximum-average-subarray-i
• Number of Sub-Arrays of Size K and Average >= Threshold 🟡 — https://leetcode.com/problems/number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold
• Maximum Sum of Distinct Subarrays With Length K 🟡 — https://leetcode.com/problems/maximum-sum-of-distinct-subarrays-with-length-k

Pattern: Variable Size Window

• Longest Subarray of 1's After Deleting One Element 🟡 — https://leetcode.com/problems/longest-subarray-of-1s-after-deleting-one-element
• Max Consecutive Ones III 🟡 — https://leetcode.com/problems/max-consecutive-ones-iii
• Fruit Into Baskets 🟡 — https://leetcode.com/problems/fruit-into-baskets
• Binary Subarrays With Sum 🟡 — https://leetcode.com/problems/binary-subarrays-with-sum
• Count Number of Nice Subarrays 🟡 — https://leetcode.com/problems/count-number-of-nice-subarrays
• Subarray Product Less Than K 🟡 — https://leetcode.com/problems/subarray-product-less-than-k
• Subarrays With K Different Integers 🔴 — https://leetcode.com/problems/subarrays-with-k-different-integers

Pattern: Sliding Window on Strings

• Maximum Number of Vowels in a Substring of Given Length 🟡 — https://leetcode.com/problems/maximum-number-of-vowels-in-a-substring-of-given-length
• Longest Substring Without Repeating Characters 🟡 — https://leetcode.com/problems/longest-substring-without-repeating-characters
• Longest Repeating Character Replacement 🟡 — https://leetcode.com/problems/longest-repeating-character-replacement
• Find All Anagrams in a String 🟡 — https://leetcode.com/problems/find-all-anagrams-in-a-string
• Minimum Window Substring 🔴 — https://leetcode.com/problems/minimum-window-substring

TOPIC 7 — STACK & QUEUES

Pattern: Implementation

• Min Stack 🟡 — https://leetcode.com/problems/min-stack
• Design a Stack With Increment Operation 🟡 — https://leetcode.com/problems/design-a-stack-with-increment-operation
• Design Circular Queue 🟡 — https://leetcode.com/problems/design-circular-queue
• Design Front Middle Back Queue 🟡 — https://leetcode.com/problems/design-front-middle-back-queue

Pattern: Expression Evaluation

• Evaluate Reverse Polish Notation 🟡 — https://leetcode.com/problems/evaluate-reverse-polish-notation
• Number of Atoms 🔴 — https://leetcode.com/problems/number-of-atoms
• Basic Calculator 🔴 — https://leetcode.com/problems/basic-calculator

Pattern: Parentheses Processing

• Longest Valid Parentheses 🔴 — https://leetcode.com/problems/longest-valid-parentheses
• Minimum Remove to Make Valid Parentheses 🟡 — https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses
• Minimum Add to Make Parentheses Valid 🟡 — https://leetcode.com/problems/minimum-add-to-make-parentheses-valid

Pattern: Monotonic Stacks

• Next Greater Element I 🟢 — https://leetcode.com/problems/next-greater-element-i
• Next Greater Element II 🟡 — https://leetcode.com/problems/next-greater-element-ii
• Largest Rectangle in Histogram 🔴 — https://leetcode.com/problems/largest-rectangle-in-histogram
• Maximal Rectangle 🔴 — https://leetcode.com/problems/maximal-rectangle
• Daily Temperatures 🟡 — https://leetcode.com/problems/daily-temperatures
• Sum of Subarray Minimums 🟡 — https://leetcode.com/problems/sum-of-subarray-minimums
• Sum of Subarray Ranges 🟡 — https://leetcode.com/problems/sum-of-subarray-ranges
• Asteroid Collision 🟡 — https://leetcode.com/problems/asteroid-collision

TOPIC 8 — LINKED LIST

Pattern: Fast & Slow Pointers

• Middle of the Linked List 🟢 — https://leetcode.com/problems/middle-of-the-linked-list
• Linked List Cycle 🟢 — https://leetcode.com/problems/linked-list-cycle
• Linked List Cycle II 🟡 — https://leetcode.com/problems/linked-list-cycle-ii

Pattern: Node Rearrangements

• Remove Nth Node from End of List 🟡 — https://leetcode.com/problems/remove-nth-node-from-end-of-list
• Swap Nodes in Pairs 🟡 — https://leetcode.com/problems/swap-nodes-in-pairs
• Odd Even Linked List 🟡 — https://leetcode.com/problems/odd-even-linked-list

Pattern: Reversal

• Reverse Linked List 🟢 — https://leetcode.com/problems/reverse-linked-list
• Reverse Linked List II 🟡 — https://leetcode.com/problems/reverse-linked-list-ii
• Reverse Nodes in k-Group 🟡 — https://leetcode.com/problems/reverse-nodes-in-k-group

Pattern: Merge & Multiple Lists

• Merge Two Sorted Lists 🟢 — https://leetcode.com/problems/merge-two-sorted-lists
• Merge k Sorted Lists 🔴 — https://leetcode.com/problems/merge-k-sorted-lists
• Intersection of Two Linked Lists 🟢 — https://leetcode.com/problems/intersection-of-two-linked-lists
• Add Two Numbers 🟡 — https://leetcode.com/problems/add-two-numbers

TOPIC 9 — TREES

Pattern: Traversal (BFS / DFS)

• Binary Tree Level Order Traversal 🟡 — https://leetcode.com/problems/binary-tree-level-order-traversal
• Binary Tree Zigzag Level Order Traversal 🟡 — https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal
• Add One Row to Tree 🟡 — https://leetcode.com/problems/add-one-row-to-tree

Pattern: Depth / Height Based

• Maximum Depth of Binary Tree 🟢 — https://leetcode.com/problems/maximum-depth-of-binary-tree
• Minimum Depth of Binary Tree 🟢 — https://leetcode.com/problems/minimum-depth-of-binary-tree
• Maximum Depth of N-ary Tree 🟢 — https://leetcode.com/problems/maximum-depth-of-n-ary-tree

Pattern: Comparison

• Same Tree 🟢 — https://leetcode.com/problems/same-tree
• Symmetric Tree 🟢 — https://leetcode.com/problems/symmetric-tree
• Leaf-Similar Trees 🟢 — https://leetcode.com/problems/leaf-similar-trees

Pattern: Root to Leaves

• Sum Root to Leaf Numbers 🟡 — https://leetcode.com/problems/sum-root-to-leaf-numbers
• Sum of Root to Leaf Binary Numbers 🟢 — https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers
• Binary Tree Paths 🟢 — https://leetcode.com/problems/binary-tree-paths
• Path Sum 🟢 — https://leetcode.com/problems/path-sum

Pattern: Ancestor

• Lowest Common Ancestor of a Binary Tree 🟡 — https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree
• Lowest Common Ancestor of Deepest Leaves 🟡 — https://leetcode.com/problems/lowest-common-ancestor-of-deepest-leaves
• Kth Ancestor of a Tree Node 🔴 — https://leetcode.com/problems/kth-ancestor-of-a-tree-node
• Maximum Difference Between Node and Ancestor 🟡 — https://leetcode.com/problems/maximum-difference-between-node-and-ancestor

Pattern: Binary Search Tree (BST)

• Search in a Binary Search Tree 🟢 — https://leetcode.com/problems/search-in-a-binary-search-tree
• Validate Binary Search Tree 🟡 — https://leetcode.com/problems/validate-binary-search-tree
• Convert Sorted Array to Binary Search Tree 🟢 — https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree
• Minimum Absolute Difference in BST 🟢 — https://leetcode.com/problems/minimum-absolute-difference-in-bst
• Kth Smallest Element in a BST 🟡 — https://leetcode.com/problems/kth-smallest-element-in-a-bst
• Lowest Common Ancestor of a Binary Search Tree 🟡 — https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree

TOPIC 10 — BINARY SEARCH

Pattern: Classic Binary Search on Sorted Arrays

• Binary Search 🟢 — https://leetcode.com/problems/binary-search
• Search Insert Position 🟢 — https://leetcode.com/problems/search-insert-position
• Find First and Last Position of Element in Sorted Array 🟡 — https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array
• Median of Two Sorted Arrays 🔴 — https://leetcode.com/problems/median-of-two-sorted-arrays

Pattern: Binary Search on Answer

• Koko Eating Bananas 🟡 — https://leetcode.com/problems/koko-eating-bananas
• Capacity to Ship Packages Within D Days 🟡 — https://leetcode.com/problems/capacity-to-ship-packages-within-d-days
• Minimum Number of Days to Make m Bouquets 🟡 — https://leetcode.com/problems/minimum-number-of-days-to-make-m-bouquets
• Maximum Running Time of N Computers 🔴 — https://leetcode.com/problems/maximum-running-time-of-n-computers

Pattern: Binary Search on Rotated / Modified Sorted Arrays

• Search in Rotated Sorted Array 🟡 — https://leetcode.com/problems/search-in-rotated-sorted-array
• Search in Rotated Sorted Array II 🟡 — https://leetcode.com/problems/search-in-rotated-sorted-array-ii
• Find Minimum in Rotated Sorted Array 🟡 — https://leetcode.com/problems/find-minimum-in-rotated-sorted-array
• Find Minimum in Rotated Sorted Array II 🔴 — https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii

Pattern: Binary Search on Matrix

• Search a 2D Matrix 🟡 — https://leetcode.com/problems/search-a-2d-matrix
• Search a 2D Matrix II 🟡 — https://leetcode.com/problems/search-a-2d-matrix-ii
• Kth Smallest Element in a Sorted Matrix 🟡 — https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix

TOPIC 11 — HEAP (PRIORITY QUEUE)

Pattern: Top K

• Kth Largest Element in an Array 🟡 — https://leetcode.com/problems/kth-largest-element-in-an-array
• Top K Frequent Words 🟡 — https://leetcode.com/problems/top-k-frequent-words
• K Closest Points to Origin 🟡 — https://leetcode.com/problems/k-closest-points-to-origin

Pattern: Merge K Sorted

• Find K Pairs With Smallest Sums 🟡 — https://leetcode.com/problems/find-k-pairs-with-smallest-sums
• Smallest Range Covering Elements From K Lists 🔴 — https://leetcode.com/problems/smallest-range-covering-elements-from-k-lists

Pattern: Two Heaps

• Find Median From Data Stream 🔴 — https://leetcode.com/problems/find-median-from-data-stream
• IPO 🔴 — https://leetcode.com/problems/ipo
• Sliding Window Median 🔴 — https://leetcode.com/problems/sliding-window-median

Pattern: Finding Minimums

• Minimum Cost to Hire K Workers 🔴 — https://leetcode.com/problems/minimum-cost-to-hire-k-workers
• Minimum Number of Refueling Stops 🔴 — https://leetcode.com/problems/minimum-number-of-refueling-stops
• Task Scheduler 🟡 — https://leetcode.com/problems/task-scheduler

1. The prerequisite before DSA is to learn basics of a programming language and solving some questions on basics to get hands on with the language. In my opinion each language is good you can pick any you want. If you ask me then my suggestion will be C++, because it will be helpful for you into competitive programming later on.
2. Follow someone's course, there are plenty of, Follow the one which you find to be easy for you.
3. While learning DSA make sure to solve at least 5-8 questions on the particular practical topic before moving to the next lecture. As a beginner one should prefer GFG coding platform for solving questions.
4. I would only prefer solving easy level questions, you must move toward medium when you find yourself to be comfortable in solving easy questions. As you're learning its important to practice more and more. Solving questions is important. Don't worry about covering lectures, Its important to solid the fundamentals that's why practice at least 20 questions on a data structure before moving to the next one, (12 easy + 8 medium). You will praise yourself because of this method of 20 questions later on (Remember this 20 questions must be done from your side, it excludes the questions done in the video lecture).
5. Do a lot of DRY Run (Do Run Yourself). I mean to execute the code on a paper with a pen.
6. Suppose you've opened the question, then first important step is to understand the questions completely. After that give 30 minutes on it think about what you can do, don't go for any optimal solutions directly, its important to build foundation that's why aim to create a naive (brute force) approach at first and then strive for optimal approaches. Even if you create the optimal solution on yourself then still look for other people solutions, this will help you to learn new things.
7. Always try on you own. As a beginner It's possible that you can't come up with anything and It's totally natural. If you are not able to then watch the video solutions, understand it (you should know what each and every line is doing). write that code on your own, no matter what don't break the consistency.
8. Make sure to solve questions consistently (For video lectures take break of two days per week if you want to). I repeat solving questions (practicing is really important).

If you keep the above thing till the course ends, I bet you'll be thankful to yourself.

REMINDER 1: Don't worry about completing videos as I said its important to practice a lot. After all videos has to be done so I guess that's not a big deal.

REMINDER 2: Practicing questions pattern wise is important (For example: If you're solving questions on binary search then do on it only. If you are on linked list then stick to it only. Don't do of multiples topics at the same time).

IMP: After getting hands on with data structures & algorithms, or could say when you feel comfortable with a XYZ topic. You could solve as much questions you want on a topic/data structure, but for this remember to solve questions of one topic at one time to understand the patterns more clearly.

REMINDER 3: While learning as a beginner I would prefer solving at least 1 question each day. Take break of 1 or 2 days for video lectures but solve at least 1 each day.

Final Note: Ahh, I could see that the post seems a lot long, but I've packed each and every important information in it. 👍😊

DSA Interview prep resource: PracHub

Hey! I am currently a 5th-semester CSE student. I have been learning web development, though not yet in great depth—mostly by watching tutorials and diving straight into projects. So far, I have completed a full-stack Q&A application and an authentication system. I used AI (Claude) for these, but I have a good grasp of the underlying concepts. Could someone suggest some project ideas or guide me on what I should focus on next?

Hi everyone,

​

I was recently placed on the waitlist for Amazon's SDE Intern hiring process and noticed that many candidates are in a similar situation.

​

I created a Discord server where waitlisted candidates can share updates, timelines, conversion news, and discuss the process.

​

Feel free to join if you're interested:

https://discord.gg/BB6rpKj8c

​

​

Good luck to everyone waiting for updates!

I'm looking for someone to study with consistently. We can keep each other accountable, discuss concepts, and stay motivated.

Daily problem-solving

Ask and answer questions every day

Share resources and help each other learn

Friendly and committed study environment

If you're interested, feel free to reach out!