DSA for Interns & New Grads: The 2025 Survival Guide

You're about to apply for your first tech internship or new grad role. Everyone tells you to "grind LeetCode." But where do you start? There are 3,000+ problems.

This guide is specifically designed for students and new graduates with limited time and experience. We'll cover exactly what to learn, in what order, and which problems matter most for entry-level interviews.

The Reality of Intern/New Grad Interviews

Here's what most students don't understand: intern interviews are easier than senior interviews.

Companies know you don't have years of experience. They're evaluating potential, not expertise. Here's what they actually test:

The good news: You can prepare for this in 4-8 weeks.

The Learning Roadmap

Phase 1: Fundamentals (Week 1-2)

Before solving problems, you need to understand the building blocks.

Data Structures to Know Cold

Priority Order:
1. Arrays ████████████ (Essential)
2. Strings ██████████ (Essential)
3. Hash Maps █████████ (Essential)
4. Linked Lists ██████ (Important)
5. Stacks/Queues █████ (Important)
6. Trees ███████████ (Important)
7. Graphs ████ (Good to know)
8. Heaps ███ (Good to know)

For each data structure, know:

• How to implement it from scratch
• Time complexity of operations (insert, delete, search)
• When to use it vs. alternatives
• Common interview patterns

Big O: What You Actually Need

You don't need to prove complexity proofs. You need to:

1. Identify the time complexity of your solution
2. Explain why it's that complexity
3. Suggest how to improve it

Quick reference:

Phase 2: Pattern Recognition (Week 3-4)

The secret to solving problems quickly is pattern recognition. Learn these patterns:

The 7 Patterns That Cover 80% of Intern Questions

1. Two Pointers

• When: Sorted arrays, finding pairs
• Examples: Two Sum II, Container With Most Water

function twoSumSorted(nums: number[], target: number): number[] {
  let left = 0, right = nums.length - 1;
  while (left < right) {
    const sum = nums[left] + nums[right];
    if (sum === target) return [left, right];
    if (sum < target) left++;
    else right--;
  }
  return [];
}

2. Sliding Window

• When: Contiguous subarrays/substrings
• Examples: Max Sum Subarray, Longest Substring Without Repeating

3. Hash Map Lookup

• When: Finding pairs, counting, grouping
• Examples: Two Sum, Group Anagrams

4. Binary Search

• When: Sorted data, finding boundaries
• Examples: Search Insert Position, First Bad Version

5. BFS/DFS

• When: Trees, graphs, grids
• Examples: Number of Islands, Max Depth of Tree

6. Recursion + Memoization

• When: Overlapping subproblems
• Examples: Fibonacci, Climbing Stairs

7. Stack

• When: Matching pairs, parsing
• Examples: Valid Parentheses, Daily Temperatures

Phase 3: Problem Practice (Week 5-6)

The Intern 50: Essential Problems

Here are the 50 problems most likely to appear in intern interviews, in order of priority:

Tier 1: Must Know (Do first)

1. Two Sum
2. Valid Parentheses
3. Merge Two Sorted Lists
4. Best Time to Buy and Sell Stock
5. Valid Palindrome
6. Reverse Linked List
7. Maximum Subarray
8. Climbing Stairs
9. Binary Search
10. Invert Binary Tree

Tier 2: High Frequency 11. Maximum Depth of Binary Tree 12. Single Number 13. Linked List Cycle 14. Min Stack 15. Intersection of Two Linked Lists 16. Majority Element 17. Reverse Bits 18. Number of 1 Bits 19. Contains Duplicate 20. Missing Number

Tier 3: Important 21. Move Zeroes 22. Power of Three 23. Reverse String 24. First Unique Character 25. Fizz Buzz 26. Intersection of Two Arrays II 27. Plus One 28. Sqrt(x) 29. Merge Sorted Array 30. Pascal's Triangle

Tier 4: Common Follow-Ups 31. 3Sum 32. Product of Array Except Self 33. Group Anagrams 34. Longest Substring Without Repeating Characters 35. Container With Most Water 36. Search in Rotated Sorted Array 37. Coin Change 38. House Robber 39. Number of Islands 40. Course Schedule

Tier 5: Stretch Goals 41. Word Break 42. Longest Palindromic Substring 43. Merge Intervals 44. Top K Frequent Elements 45. Valid Sudoku 46. Letter Combinations of Phone Number 47. Generate Parentheses 48. Subsets 49. Word Search 50. Longest Common Subsequence

Phase 4: Interview Simulation (Week 7-8)

Solving problems in isolation isn't enough. You need to simulate real interviews.

What to practice:

• Thinking out loud while coding
• Time management (35-45 minutes per problem)
• Asking clarifying questions
• Handling hints gracefully
• Testing your solution

The 4-Week Accelerated Plan

If you only have 4 weeks, here's what to prioritize:

Week 1: Core Data Structures

• Day 1-2: Arrays + Strings + Hash Maps
• Day 3-4: Linked Lists + Stacks + Queues
• Day 5-6: Trees (Binary Trees, BST)
• Day 7: Review

Week 2: Core Patterns

• Day 1-2: Two Pointers + Sliding Window
• Day 3-4: Binary Search + Hash Map patterns
• Day 5-6: Tree traversals (BFS/DFS)
• Day 7: Review

Week 3: Problem Grinding

• Solve Tier 1 problems (10 problems)
• Solve Tier 2 problems (10 problems)
• Focus on understanding, not speed

Week 4: Interview Prep

• Timed practice sessions
• Mock interviews (with peers or AI)
• Review weak areas
• Rest before interviews

Common Mistakes New Grads Make

1. Jumping Straight to Code

Wrong approach:

Reads problem → Immediately starts typing

Right approach:

Reads problem → Asks clarifying questions → Discusses approach → Gets interviewer buy-in → Codes

2. Not Testing Edge Cases

Always test with:

• Empty input
• Single element
• All same elements
• Sorted/reverse sorted (if applicable)
• Maximum size

3. Ignoring Time/Space Complexity

What interviewers want to hear:

"This solution is O(n) time and O(1) space. We could use extra space to make it O(n log n) but I think the linear approach is better for this use case."

4. Going Silent

Interviewers can't read your mind. Even if you're stuck, talk through your thoughts:

• "I'm thinking about using a hash map because..."
• "I'm not sure if this handles the edge case where..."
• "Let me trace through this with a small example..."

5. Trying to Memorize Solutions

Pattern recognition > memorization. If you understand why a solution works, you can adapt it to new problems.

Language Choice: What Should You Use?

Best choices for intern interviews:

1. Python - Clean syntax, most forgiving, fastest to write
2. JavaScript/TypeScript - Great for web roles, good interviewer familiarity
3. Java - Verbose but standard, shows OOP knowledge
4. C++ - Shows low-level understanding, fast execution

What matters more than language:

• Consistency (use one language)
• Standard library familiarity
• Clean, readable code

Interview Day: Practical Tips

Before the Interview

• Test your setup (camera, mic, screen share)
• Have water nearby
• Have a notepad for notes
• Review your resume (they might ask about projects)

During the Interview

First 5 minutes:

• Read the problem carefully
• Ask clarifying questions
• Discuss edge cases

Middle 25-30 minutes:

• Explain your approach before coding
• Code incrementally, not all at once
• Comment on what you're doing

Last 5-10 minutes:

• Trace through with an example
• Discuss time/space complexity
• Ask: "Would you like me to optimize further?"

Questions to Ask Your Interviewer

Good questions:

• "What does a typical intern project look like?"
• "How is the team structured?"
• "What's the tech stack?"
• "What do successful interns do that stands out?"

Bad questions:

• "What does the company do?" (shows no research)
• "What's the salary?" (save for HR)
• Nothing (shows disinterest)

Resources We Recommend

For Learning

• NeetCode.io - Pattern-organized problem sets
• Visualgo - Visualize data structures
• Big-O Cheat Sheet - Quick complexity reference

For Practice

• LeetCode - Problem bank (filter by Difficulty: Easy)
• CodeSparring - AI mock interviews with feedback
• Pramp - Peer mock interviews

For Understanding

• Cracking the Coding Interview - The classic book
• Grokking the Coding Interview - Pattern-based learning
• YouTube: NeetCode, Back To Back SWE

The Mental Game

Dealing with Imposter Syndrome

Every intern feels underqualified. You're not expected to know everything. You're expected to:

• Show you can learn
• Demonstrate problem-solving ability
• Communicate clearly
• Be someone people want to work with

Handling Rejection

Rejection is part of the process. Top candidates get rejected too. After each interview:

1. Write down what went well
2. Write down what to improve
3. Move on to the next opportunity

Building Confidence

Confidence comes from preparation. If you've done the work:

• Solved 50+ problems
• Practiced talking through solutions
• Done mock interviews

You're ready. Trust the process.

Conclusion

Intern interviews are approachable. You don't need to be a genius or have years of experience. You need:

1. Solid fundamentals - Arrays, strings, hash maps, trees
2. Pattern recognition - 7 core patterns cover 80% of questions
3. Practice - 50 problems, properly studied
4. Interview skills - Think out loud, test your code, stay calm

Start today. Your future self will thank you.

Practice with AI mock interviews →

---

Quick Reference Card

Good luck with your interviews!