INFOSYS CAMPUS

RECRUITMENT
Preparatory Guidance

1
 INFOSYS ONLINE TEST
TEST FORMAT
Test usually contains 3 questions that will have to be attempted in 3 hours
Test will have a sectional cut-off as well as a total cut-off
Each question will belong to different difficulty level:
Easy – Simple questions that can be solved by basic application of
aptitude, algorithm and data structures
Medium – Usually a question based on Greedy algorithm
Hard – Usually a question based on Dynamic Programming
Code can be written for each question using one of the programming
language from C/C++/Java/Python/JavaScript

2
 INFOSYS ONLINE TEST – HOW TO PREPARE
DIFFICULTY OF QUESTION - MEDIUM
A Greedy algorithm is any algorithm that follows the problem-solving
heuristic of making the locally optimal choice at each stage

Types of Greedy algorithm:

1. Pure greedy algorithms

2. Orthogonal greedy algorithms
3. Relaxed greedy algorithms

3
 INFOSYS ONLINE TEST – HOW TO PREPARE
DIFFICULTY OF QUESTION - HARD
Dynamic Programming (DP) is an algorithmic technique for solving an
optimization problem by breaking it down into simpler subproblems and
utilizing the fact that the optimal solution to the overall problem depends
upon the optimal solution to its subproblems.

Principles of Dynamic Programming:

• Breaking the problem down into subproblems and calculating their

values. Next time, upon encountering the same subproblem, the value
can be reused instead of recalculation

• Avoid repeated work by remembering partial results, a common

approach for performance enhancement

4
 INFOSYS ONLINE TEST – HOW TO PREPARE
DIFFICULTY OF QUESTION - HARD
Characteristics of a Dynamic Programming problem

Following are the two main properties of a problem that suggest the given
problem can be solved using Dynamic Programming:

1. Overlapping subproblems
A problem has overlapping sub-problems if its solution involves solving the
same subproblem multiple times.
2. Optimal substructure properties
The overall optimal solution can be constructed from the optimal solutions
of its subproblems.

5
 INFOSYS ONLINE TEST – HOW TO PREPARE
DIFFICULTY OF QUESTION - HARD
Dynamic Programming methods
There are two different ways to store values for an overlapping
subproblem so that the values can be reused:
1. Top-down with Memorization
To solve a bigger problem, in this approach we recursively find the solution
to the smaller sub-problems and its result is cached. So next time the same
sub-problem is tried to solve, the cached memorized result is returned.
2. Bottom-up with Tabulation
In this approach, we solve the problem “bottoms-up” i.e., by filling up an
n-dimensional table. Based on the results in the table, the solution to the
top/original problem is then computed.

6
 INFOSYS ONLINE TEST – HOW TO PREPARE
DIFFICULTY OF QUESTION - HARD
Some examples of Dynamic Programming

• Knapsack problem
• Fibonacci Numbers
• Palindromic Subsequence
• Longest Common Substring
• Dijkstra's algorithm

7
 INFOSYS VIRTUAL INTERVIEW
This round will access your technical and behavioral skills.
STRUCTURE
Total duration of the interview will be around 1 hour

You might be asked to solve a puzzle/problem using programming

language of your choice

Students from CS/IT branch might be tested on: Algorithms, Data

structures, Automata theory, Compiler, Computer Network, Computer
Organization, Operating Systems, Digital Signal Processing and Object-
oriented programming

Students from other branches might be tested on: Algorithms, Data

structures, Computer Network, Digital Electronics, Digital Signal
Processing, Mathematics, Object-oriented programming and Control
system
8
THANK YOU
HACK WITH INFY
SAMPLE QUESTIONS
 Sample 1
Today you decided to go to the gym. You currently have E energy. Output:
There are N exercises in the gym. Each of these exercises drains Ai
-1
amount of energy from your body.
E = 10
You feel tired if your energy reaches 0 or below. Calculate the
minimum number of exercises you have to perform such that you By doing both the exercises 2 times you won’t feel tired.
become tired. Every unique exercise can only be performed at Case#: 3
most 2 times as others also have to use the machines.
If performing all the exercises does not make you feel tired, return
Input:
-1.
2
Parameters: 3
E :: INTEGER 1
The first line contains an integer, E, denoting the Energy. 5
E :: 1 -> 10^5 2
N :: INTEGER Output:
The next line contains an integer, N, denoting the number of 1
exercises. E=2
N :: 1 -> 10^5 Use 3rd exercise 1 time.
A :: INTEGER ARRAY Hence, total exercise done 1.
Each line i of the N subsequent lines (where 0 ≤ i < N) contains an
integer describing the amount of energy drained by ith exercise.
A[i] :: 1 -> 10^5
Case#: 1
Input:
6
2
1
2
Output:
4
E=6
Do 1st exercise 2 times
Do 2nd exercise 2 times
Hence, total exercise done 4.
Case#: 2
Input:
10
2
1
2

External Document © 2024 Infosys Limited

Sample 2
There is a battle between heroes and villains going on. You have 3
M heroes, all of them have the same health H. There are N villains,
1
health of the ith villain is Vi.
3
When a hero, with health H battles a villain with health Vi, one of
the three scenarios can happen: 3

if H > Vi: The villain is defeated and the health of the hero is Output:
decreased by Vi 0
if H < Vi: The villain wins, his health is not affected and the hero is [3, 1, 3, 3]. We have 4 heroes will health 3. The heroes 1 will fight
no longer able to fight. villain 1. Both get defeated. The hero 2 fights villain 2. It wins the
if H = Vi: Both of them are considered defeated and neither can battle and now his health is 2. He fights the third villain and loses,
fight. the villain still has health 3. The hero 3 fights villain 3 and both get
defeated. Hero 4 fights villain 4 and both get defeated. So no need
The heroes start fighting villains one by one in the same order, first
to remove any villain.
villain 1 then villain 2 and so on. It is might be possible that before
defeating all the villains, all the heroes are defeated. Therefore, to Case#: 2
ensure the victory of the heroes, you want to remove some villains Input:
from the front.
5
Your task is to find the minimum number of villains you need
3
to remove from the front such that the victory of the heroes is
guaranteed. 3

Note: If in the last battle, both the hero and villain are defeated 1
and no more heroes or villains remain, it would still be considered 2
a victory since all the villains are defeated.
3
Parameters:
1
N :: INTEGER
1
The first line contains an integer, N, denoting the number of
Output:
villains
0
N :: 1 -> 2*10^5
The fight will take place and hero 1 will defeat villain 1 and 2. Hero
M :: INTEGER
2 will defeat villain 2. Hero 3 will defeat villain 3 and 4
The next line contains an integer, M, denoting the number of
Case#: 3
heroes
Input:
M :: 1 -> 2*10^5
5
H :: INTEGER
1
The next line contains an integer, H, denoting the health of each of
the heroes 4

H :: 1 -> 10^9 1

array :: INTEGER ARRAY 2

Each line i of the N subsequent lines (where 0 ≤ i < N) contains an 3

integer describing the health of each of the villains. 1
array[i] :: 1 -> 10^9 3
Case#: 1 Output:
Input: 3
4 Only 1 hero is present with health 4. Since you can only remove
4 villain from the front, you will have to remove the first 3 villains to
ensure victory. The hero can fight the last 2 villain of health 1 and 3
3
respectively and win the battle.

External Document © 2024 Infosys Limited

 Sample 3
You need to build a road in a rugged terrain. You know the sea -1
level of each segment of the rugged terrain, i.e. the i-th segment is
1
Li meters from sea level.
1
You needs to transform the terrain into a strictly downward
sloping terrain for the road, i.e, for each i-th segment where 2 <= i 1
<= N, resultant Li-1 > Li. In order to do so, you employ a powerful Output:
digging team to help you dig and reduce the sea level of the
3
segments. On day D, the team can reduce the sea level for each
segments that you scheduled that day by 2D-1 meters each. One of the possible way:

You are allowed to assign the team to dig on multiple segments On day 1, we can dig on 1st and 4th segment, resulting in {-2, 1, 1,
and/or dig on the same segments for multiple days. 0}

Your task is to find the minimum number of days needed to On day 2, we can dig on 3rd and 4th segments, resulting in {-2, 1,
transform the terrain as per your requirements. -1, -2}

Parameters: On day 3, we can dig on 2nd, 3rd and 4th segments, resulting in
{-2, -3, -5, -6}
N :: INTEGER
The first line contains an integer, N, denoting the number of
elements in L.
N :: 1 -> 10^5
L :: INTEGER ARRAY
Each line i of the N subsequent lines (where 0 < i ≤ N) contains an
integer describing Li, the sea level of the i-th segment.
L[i] :: -10^9 -> 10^9
Case#: 1
Input:
2
3
3
Output:
1
We can dig on the 2nd segment, reducing it from 3-meter sea level
to 2. Resulting in {3, 2} which is strictly decreasing.
Case#: 2
Input:
2
5
-3
Output:
0
It is already strictly decreasing before start.
Case#: 3
Input:
4

External Document © 2024 Infosys Limited

Sample 4
You are given an array of size N. You need to change this array 1
into a mountain. By mountain we mean, the either ends of the 1
array should have equal elements. Then as we move towards the
1
middle from both ends, the next element is just one more than the
previous one. So it would have a peak in the middle and decreases Output:
if you go towards either end, just like a mountain. 4
Examples of mountains are [1, 2, 3, 2, 1] or [6, 7, 8, 8, 7, 6]. But array = [1, 1, 1, 2, 3, 2, 1, 1, 1]. We can change the array to [-1, 0, 1, 2,
the array [1, 2, 4, 2, 1] is not a mountain because from 2 to 4 the 3, 2, 1, 0, -1]
difference is 2. The array [1, 2, 3, 1] is also not a mountain because
Case#: 3
the elements 2 and 3 are not equal from both ends.
Input:
You need to find the minimum number of elements that should be
changed in order to make the array a mountain. You can make the 6
elements negative or zero as well. 3
Parameters: 3
N :: INTEGER 4
The first line contains an integer, N, denoting the number of 4
elements in array.
5
N :: 1 -> 10^5
5
array :: INTEGER ARRAY
Output:
Each line i of the N subsequent lines (where 0 ≤ i < N) contains an
3
integer describing i-th element of array.
array = [3, 3, 4, 4, 5, 5]. We can chage the array to [2, 3, 4, 4, 3, 2]
array[i] :: 1 -> 10^6
Case#: 1
Input:
5
1
2
3
4
5
Output:
2
array = [1, 2, 3, 4, 5] . We can change 4 and 5 to make it [1, 2, 3, 2, 1]
Case#: 2
Input:
9
1
1
1
2
3
2

External Document © 2024 Infosys Limited

 Sample 5
You have an interesting string S of length N. It is interesting
because you can rearrange the characters of this string in any
order. You want to cut this string into some contiguous pieces
such that after cutting, all the pieces are equal to one another.
You can’t rearrange the characters in the cut pieces or join the
pieces together. You want to make the number of pieces as large
as possible. What is the maximum number of pieces you can get?
Note: You can observe that you may not want to cut the string at
all, therefore the number of pieces is 1. Hence, the answer always
exists.
Parameters:
S :: STRING
The first line contains a string, S, denoting the string.
len(S) :: 1 -> 2 * 10^5
Case#: 1
Input:
zzzzz
Output:
5
You can cut it into 5 pieces “z” + “z” + “z” + “z” + “z”
Case#: 2
Input:
ababcc
Output:
2
Rearrange the string as abcabc. you can cut it into “abc” + “abc”,
hence the answer is 2
Case#: 3
Input:
abccdcabacda
Output:
2
Rearrange the string as “dcbaca” + “dcbaca”, the answer is 2.

External Document © 2024 Infosys Limited

Sample 6
You are given an array A of size N. 2
You are allowed to choose at most one pair of elements such that 1
distance (defined as the difference of their indices) is at most K and 3
swap them.
Output:
Find the smallest lexicographical array possible after swapping.
2
Notes:
4
An array x is lexicographically smaller than an array y if there exists
3
an index i such that xi<yi, and xj=yj for all 0≤j<i. Less formally, at
the first index i in which they differ, xi<yi 5

Parameters: 1

N :: INTEGER Here A=[5,4,3,2,1] K=3, we can swap elements at index 0 and index
3 which makes A=[2,4,3,5,1].
The first line contains an integer, N, denoting the number of
elements in A. Case#: 3

N :: 1 -> 10^5 Input:

A :: INTEGER ARRAY 5

Each line i of the N subsequent lines (where 0 ≤ i < N) contains an 2

integer describing A[i]. 1
A[i] :: 1 -> 10^5 1
K :: INTEGER 1
The next line contains an integer, K, denoting the upper bound on 1
distance of index.
3
K :: 1 -> N
Output:
Case#: 1
1
Input:
1
3
1
2
2
2
1
2
Here A=[2,1,1,1,1] K=3, we can swap elements at index 0 and index
1 3 which makes A=[1,1,1,2,1].
Output:
2
2
2
Here as all the array values are equal swapping will not change the
final result.
Case#: 2
Input:
5
5
4
3

External Document © 2024 Infosys Limited

Sample 7
There is a restaurant that offers different types of dishes. A=[1,2,4,2,3]
Your friend knows that there are exactly N dishes in the restaurant. For example, start with type 1 or 4, then double the amount by
The type of the dishes is described by an array Arr. This means that eating two of type 2 dishes.
if two elements of Arr have the same value, then they are from the Case#: 2
same type.
Input:
Your friend wants to eat as many dishes as possible. However, your
friend will never order more than one serving of a particular dish. 7

It is given that the restaurant will not let you order the dishes of 2
the same type more than once. Moreover, if you order A dishes in 2
the restaurant your next order must contain (2*A) dishes. It is also
1
given that the restaurant does not accept orders containing more
than one type of dishes in the same order. 1

Your friend can start eating with any number of dishes. Find the 1
maximum number of dishes that your friend can eat. 1
Notes: 1
Your friend is a foodie and can eat any amount of food that is Output:
served to him by the restaurant.
6
Parameters:
N=7
N :: INTEGER
A=[2,2,1,1,1,1,1]
The first line contains an integer, N, denoting the number of
Start with eating two dishes of type 2, then eat four dishes of type
elements in Arr.
1.
N :: 1 -> 10^5
Note that you can’t start with one dish of type one, then two
Arr :: INTEGER ARRAY dishes of type 2, and get back to eat to a dish of size 1 again, your
Each line i of the N subsequent lines (where 0 ≤ i < N) contains an friend cannot eat the same type of dishes multiple times.
integer describing Arr[i]. Case#: 3
Arr[i] :: 1 -> 10^9 Input:
Case#: 1 4
Input: 1
5 1
1 1
2 1
4 Output:
2 4
3 N=4
Output: A=[1,1,1,1]
3 Your friend can eat all 4 dishes in the first order.
N=5

For more information, contact askus@infosys.com

© 2024 Infosys Limited, Bengaluru, India. All Rights Reserved. Infosys believes the information in this document is accurate as of its publication date; such information is subject to change without notice. Infosys
acknowledges the proprietary rights of other companies to the trademarks, product names and such other intellectual property rights mentioned in this document. Except as expressly permitted, neither this
documentation nor any part of it may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, electronic, mechanical, printing, photocopying, recording or otherwise, without the
prior permission of Infosys Limited and/ or any named intellectual property rights holders under this document.

Infosys.com | NYSE: INFY Stay Connected