Hackwithinfy Guide

Overview

HackWithInfy is Infosys’s annual coding competition designed to identify and hire top coding talent for premium roles like Power Programmer. Winners get direct interview opportunities and higher salary packages (₹10-12 LPA).

HackWithInfy Benefits

Winners and top performers in HackWithInfy get:

• Direct interview opportunities for Power Programmer roles
• Higher salary packages (₹10-12 LPA vs ₹4-4.5 LPA for Systems Engineer)
• Fast-track hiring process
• Recognition and certificates

What is HackWithInfy?

HackWithInfy is a multi-round coding competition organized by Infosys for engineering students. It’s one of the most prestigious coding competitions in India, attracting thousands of participants annually.

Key features

Eligibility

• Final year engineering students (B.E./B.Tech)
• All branches eligible
• No CGPA requirement (but good academics help)
• Indian citizens

Format

• Online coding competition
• Multiple rounds (Prelims, Semifinals, Finals)
• Individual participation
• Multiple programming languages supported

Rewards

• Power Programmer roles (₹10-12 LPA)
• Direct interview opportunities
• Certificates and recognition
• Internship opportunities

Registration

• Free registration
• Through Infosys Careers portal
• Or via college placement cells
• Registration typically opens in March-April

HackWithInfy competition structure

Round 1: prelims

Parameter	Details
Duration	3 hours (180 minutes)
Problems	3 coding problems
Difficulty	Easy, Medium, Hard
Languages	C, C++, Java, Python
Platform	HackerEarth/Infosys platform
Selection	Top performers advance to Semifinals

Problems Typically Include:

• Array/string manipulation
• Greedy algorithms
• Dynamic programming basics
• Graph algorithms (BFS/DFS)
• Mathematical problems

Round 2: semifinals

Parameter	Details
Duration	3-4 hours
Problems	4-5 coding problems
Difficulty	Medium to Hard
Selection	Top 100-200 participants
Format	Similar to Prelims, tougher problems

Problem Types:

• Advanced algorithms
• Dynamic programming
• Graph algorithms
• String algorithms
• Mathematical optimization

Round 3: finals

Parameter	Details
Duration	4-5 hours
Problems	5-6 coding problems
Difficulty	Hard to Very Hard
Selection	Top 50-100 participants
Format	Onsite at Infosys offices or virtual

Problem Types:

• Complex algorithms
• System design elements
• Optimization problems
• Real-world problem solving

How to participate

Registration process

1. Visit Infosys Careers Portal

• Go to HackWithInfy registration page
• Or register through college placement cell

2. Fill Registration Form

• Personal details (name, email, phone)
• College details (name, branch, year)
• Academic details (CGPA, backlogs)
• Programming language preference

3. Verification

• Email verification
• College verification (if required)
• Confirmation email with login credentials

4. Prepare for Prelims

• Practice coding problems
• Review data structures and algorithms
• Take mock tests

Important dates

Event	Timeline
Registration Opens	March-April
Registration Closes	April-May
Prelims	May-June
Semifinals	June-July
Finals	July-August
Results & Interviews	August-September

Check Official Website

Exact dates vary each year. Always check the official Infosys Careers portal for current year dates and deadlines.

Previous year questions

Prelims questions

Problem 1: Array Manipulation

Problem: Given an array of integers, find the maximum sum of any contiguous subarray.

Difficulty: Easy-Medium

Approach: Kadane’s Algorithm

Solution (Python):

def max_subarray_sum(arr):
    max_sum = current_sum = arr[0]
    for i in range(1, len(arr)):
        current_sum = max(arr[i], current_sum + arr[i])
        max_sum = max(max_sum, current_sum)
    return max_sum

Problem 2: String Processing

Problem: Given a string, find the longest palindromic substring.

Difficulty: Medium

Approach: Dynamic Programming or Expand Around Centers

Solution (Python):

def longest_palindrome(s):
    n = len(s)
    dp = [[False] * n for _ in range(n)]
    start = 0
    max_len = 1

    for i in range(n):
        dp[i][i] = True

    for i in range(n - 1):
        if s[i] == s[i + 1]:
            dp[i][i + 1] = True
            start = i
            max_len = 2

    for length in range(3, n + 1):
        for i in range(n - length + 1):
            j = i + length - 1
            if s[i] == s[j] and dp[i + 1][j - 1]:
                dp[i][j] = True
                start = i
                max_len = length

    return s[start:start + max_len]

Problem 3: Graph Problem

Problem: Given a 2D grid, find the number of islands (1s represent land, 0s water).

Difficulty: Medium-Hard

Approach: DFS/BFS

Solution (Python):

def num_islands(grid):
    if not grid:
        return 0
    rows, cols = len(grid), len(grid[0])
    islands = 0

    def dfs(r, c):
        if r < 0 or c < 0 or r >= rows or c >= cols or grid[r][c] == '0':
            return
        grid[r][c] = '0'
        dfs(r + 1, c)
        dfs(r - 1, c)
        dfs(r, c + 1)
        dfs(r, c - 1)

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == '1':
                islands += 1
                dfs(r, c)
    return islands

Semifinals questions

Problem: Dynamic Programming

Problem: Given coins of different denominations and a total amount, find the minimum number of coins needed to make that amount.

Difficulty: Hard

Approach: Dynamic Programming

Solution (Python):

def coin_change(coins, amount):
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0

    for coin in coins:
        for i in range(coin, amount + 1):
            dp[i] = min(dp[i], dp[i - coin] + 1)

    return dp[amount] if dp[amount] != float('inf') else -1

Preparation strategy

3-Month preparation plan

Month 1: Foundation

Focus: Data Structures & Algorithms

• Master arrays, strings, linked lists

• Learn sorting and searching algorithms

• Practice 5-10 problems daily

• Focus on one programming language

  Resources:

• LeetCode Easy problems

• HackerRank Data Structures

• GeeksforGeeks tutorials

Month 2: Intermediate

Focus: Advanced Algorithms

• Dynamic programming basics

• Graph algorithms (BFS, DFS)

• Greedy algorithms

• Practice 10-15 problems daily

  Resources:

• LeetCode Medium problems

• Codeforces Div 2 problems

• Previous HackWithInfy questions

Month 3: Advanced

Focus: Competition Practice

• Solve previous HackWithInfy problems

• Practice time-bound coding (3 hours)

• Mock competitions

• Review and revise

  Resources:

• Previous year HackWithInfy questions

• CodeChef contests

• AtCoder problems

Topic-wise preparation

Arrays & strings

• Two-pointer technique
• Sliding window
• Prefix sums
• String manipulation
• Practice: 50+ problems

Dynamic programming

• 1D DP problems
• 2D DP problems
• Common patterns (knapsack, LCS, etc.)
• Practice: 30+ problems

Graphs

• BFS/DFS
• Shortest path algorithms
• Topological sort
• Practice: 30+ problems

Greedy

• Activity selection
• Interval problems
• Greedy patterns
• Practice: 20+ problems

Tips for success

During competition

1. Time Management

• Read all problems first
• Start with easiest problem
• Allocate time per problem
• Don’t spend too long on one problem

2. Problem Solving Approach

• Understand problem clearly
• Think of approach before coding
• Test with sample cases
• Handle edge cases

3. Code Quality

• Write clean, readable code
• Add comments for complex logic
• Use meaningful variable names
• Test thoroughly before submitting

4. Stay Calm

• Don’t panic if stuck
• Take breaks if needed
• Focus on solving, not ranking
• Stay hydrated and focused

Common mistakes to avoid

Time management

Mistake: Spending too much time on one problem
Solution: Set time limits, move on if stuck

Edge cases

Mistake: Not handling edge cases
Solution: Always test with edge cases

Code quality

Mistake: Writing messy, unreadable code
Solution: Write clean, well-structured code

Panic

Mistake: Panicking if can’t solve immediately
Solution: Stay calm, think step by step

Benefits of participating

Even if you don’t win

Experience

• Gain competition experience
• Improve problem-solving skills
• Learn new algorithms
• Build confidence

Resume

• Add to resume
• Shows coding skills
• Demonstrates initiative
• Stands out to recruiters

Learning

• Learn from mistakes
• Understand problem patterns
• Improve coding speed
• Better preparation for placements

Network

• Connect with other participants
• Learn from discussions
• Build coding community
• Share knowledge

Success stories

Story 1: power programmer selection

Participant: Ankit (name changed) College: Tier-2 Engineering College Result: Selected as Power Programmer, ₹10 LPA

Journey:

• Cleared Prelims (solved 2/3 problems)
• Cleared Semifinals (solved 3/5 problems)
• Reached Finals (solved 2/6 problems)
• Got direct interview call
• Selected in technical interview

Tips:

• Consistent practice (2-3 hours daily)
• Focused on DP and graphs
• Participated in multiple coding contests
• Stayed calm during competition

Resources for preparation

Online platforms

• LeetCode: Practice problems by difficulty
• HackerRank: Coding challenges and contests
• CodeChef: Competitive programming contests
• Codeforces: Regular contests and problems
• AtCoder: Japanese competitive programming platform
• GeeksforGeeks: Tutorials and practice problems

Books

• “Cracking the Coding Interview” by Gayle Laakmann McDowell
• “Introduction to Algorithms” by CLRS
• “Algorithm Design Manual” by Steven Skiena

Comments & Suggestions

Related resources

• Infosys Placement Papers - Complete preparation guide
• Infosys Coding Questions - Practice coding problems
• Infosys IRT Exam Pattern - Understand IRT structure
• Infosys Interview Experience - Learn from experiences

Similar companies

TCS · Wipro · Accenture · HCL · Google · Amazon