Tools
Back to HackWithInfy Guide

HackWithInfy 2026 Syllabus

Complete topic breakdown for Round 1, Round 2, and Grand Finale — with 100+ DSA patterns, DP problem lists, and Greedy algorithm strategies

3 Rounds
Progressive Difficulty
100+ Patterns
DSA Coverage
Batch 2027
Eligibility

Syllabus at a Glance

Round 1

Screening Round

  • • Arrays & Strings
  • • Sorting & Searching
  • • Basic Math & Hashing
  • • LeetCode Easy-Medium

Round 2

Advanced Round

  • • Graphs & Trees
  • • Dynamic Programming
  • • Greedy Algorithms
  • • LeetCode Medium-Hard

Grand Finale

Top 100 Teams

  • • System Design
  • • Real-world Problems
  • • Full-stack Development
  • • Innovation & Optimization

Round 1 — Screening Round

3 hours | 20-25 MCQs + 2-3 Coding Problems | LeetCode Easy-Medium

1. Arrays (High Priority ⭐⭐⭐)

Core Topics:

  • Two-pointer technique (sorted/unsorted arrays)
  • Sliding window (fixed/variable size)
  • Prefix sum & difference arrays
  • Kadane's algorithm (max subarray sum)
  • 2D array manipulation (matrix rotation, spiral)
  • Merging intervals, next greater/smaller element

🎯 Practice Problems:

Two Sum, Container With Most Water, Longest Substring Without Repeating, Max Subarray Sum, Merge Intervals, Rotate Matrix, Spiral Matrix

2. Strings (High Priority ⭐⭐⭐)

Core Topics:

  • Pattern matching (KMP, Rabin-Karp basics)
  • Palindrome checks & generation
  • Anagrams & string permutations
  • String reversal & rotation
  • Longest common prefix/suffix
  • String compression & encoding

🎯 Practice Problems:

Valid Palindrome, Longest Palindromic Substring, Group Anagrams, Implement strStr(), Longest Common Prefix, String Compression

3. Sorting & Searching (Medium Priority ⭐⭐)

Core Topics:

  • Binary search (basic & variants)
  • Quicksort, Mergesort implementation
  • Sorting in O(n) — Counting, Radix sort
  • Search in rotated sorted array
  • Find first/last occurrence in sorted array
  • Kth smallest/largest element

🎯 Practice Problems:

Binary Search, Search in Rotated Array, Find Peak Element, Kth Largest Element, Merge Sorted Arrays, Sort Colors (Dutch National Flag)

4. Math & Hashing (Medium Priority ⭐⭐)

Core Topics:

  • Prime numbers (Sieve of Eratosthenes)
  • GCD, LCM, modular arithmetic
  • Hash maps for frequency counting
  • Set operations (union, intersection)
  • Power set generation (bit manipulation)
  • Combinatorics (nCr, nPr)

🎯 Practice Problems:

Count Primes, Power of Two, Happy Number, Subarray Sum Equals K, Longest Consecutive Sequence, First Unique Character

5. Recursion & Backtracking (Low-Medium Priority ⭐)

Core Topics:

  • Generate all subsets/permutations
  • N-Queens, Sudoku solver (basics)
  • Combination sum problems
  • Word search in grid

🎯 Practice Problems:

Subsets, Permutations, Combination Sum, Letter Combinations of Phone Number, Word Search

Round 2 — Advanced Round

4 hours | 3-4 Coding Problems | LeetCode Medium-Hard | Top 500-1000 qualify

1. Graphs (Highest Priority ⭐⭐⭐⭐)

Must-Know Algorithms:

  • BFS & DFS (recursive & iterative)
  • Dijkstra's shortest path
  • Floyd-Warshall (all-pairs shortest path)
  • Topological sort (Kahn's algorithm, DFS)
  • Cycle detection (directed & undirected)
  • Union-Find (Disjoint Set Union)
  • Minimum Spanning Tree (Kruskal, Prim)
  • Strongly Connected Components (Kosaraju)

🎯 Practice Problems:

Number of Islands, Course Schedule, Clone Graph, Network Delay Time, Cheapest Flights Within K Stops, Word Ladder, Redundant Connection, Critical Connections

2. Dynamic Programming (Highest Priority ⭐⭐⭐⭐)

Critical DP Patterns:

  • 0/1 Knapsack & variants
  • Unbounded Knapsack (Coin Change)
  • Longest Common Subsequence (LCS)
  • Longest Increasing Subsequence (LIS)
  • Edit Distance (Levenshtein)
  • Matrix Chain Multiplication
  • Partition problems (subset sum, equal sum)
  • DP on trees (max path sum, diameter)

🎯 Practice Problems:

Climbing Stairs, House Robber, Coin Change, Longest Palindromic Subsequence, Edit Distance, Partition Equal Subset Sum, Target Sum, Word Break

⚡ Pro Tip:

Master both top-down (memoization) and bottom-up (tabulation) approaches. HackWithInfy often asks for space-optimized solutions.

3. Trees & Binary Search Trees (High Priority ⭐⭐⭐)

Core Concepts:

  • Tree traversals (inorder, preorder, postorder)
  • Level-order traversal (BFS on tree)
  • Lowest Common Ancestor (LCA)
  • Tree diameter, max path sum
  • BST operations (insert, delete, search)
  • Validate BST, Kth smallest in BST

🎯 Practice Problems:

Binary Tree Level Order, Validate BST, Lowest Common Ancestor, Binary Tree Maximum Path Sum, Serialize/Deserialize Tree, Kth Smallest Element in BST

4. Greedy Algorithms (High Priority ⭐⭐⭐)

Key Patterns:

  • Activity Selection / Interval Scheduling
  • Fractional Knapsack
  • Job Sequencing with Deadlines
  • Huffman Coding (priority queue)
  • Minimum Platforms / Meeting Rooms
  • Gas Station Problem

🎯 Practice Problems:

Jump Game, Minimum Number of Arrows, Meeting Rooms II, Non-overlapping Intervals, Task Scheduler, Gas Station

5. Advanced DSA (Medium Priority ⭐⭐)

Additional Topics:

  • Trie (prefix tree) for string problems
  • Segment Tree (range queries)
  • Binary Indexed Tree (Fenwick Tree)
  • Heap / Priority Queue applications

🎯 Practice Problems:

Implement Trie, Word Search II, Kth Largest Element in Stream, Top K Frequent Elements, Range Sum Query

Grand Finale — Top 100 Teams

24-48 hours | Real-world Problem | Full-stack + System Design

Problem Solving

  • • End-to-end solution design
  • • Innovation & creativity
  • • Algorithm optimization
  • • Edge case handling

System Design

  • • Scalability considerations
  • • Database schema design
  • • API architecture
  • • Caching strategies

Implementation

  • • Working prototype/demo
  • • Code quality & documentation
  • • UI/UX design
  • • Presentation skills

8-Week Preparation Timeline

Weeks 1-2

Foundation Building

  • • Arrays & Strings (50 problems)
  • • Sorting & Searching (30 problems)
  • • Basic Math & Hashing (20 problems)

Weeks 3-5

Advanced Topics

  • • Graphs (40 problems)
  • • Dynamic Programming (60 problems)
  • • Trees (35 problems)

Week 6

Greedy & Advanced

  • • Greedy Algorithms (25 problems)
  • • Trie, Segment Tree (15 problems)
  • • Mixed practice

Weeks 7-8

Mock Tests & Revision

  • • Full-length mock tests (5-6)
  • • Weak topic revision
  • • Speed optimization

Related Resources

HackWithInfy Complete Guide

Full preparation roadmap, eligibility, and exam pattern

Salary & Job Roles

₹3.6L to ₹12L package breakdown and career growth

Ready to Start Preparing?

Access the complete HackWithInfy preparation guide with practice problems, mock tests, and interview tips.

View Complete Guide