All companies
Virtusa logo
Indian IT
Regular Coder (5 LPA)
HirePro (Adaptive, No Negative Marking)

Virtusa Interview Questions & Placement Prep (2026)

A complete, exam-focused roadmap to crack the Virtusa Regular Coder role from scratch — the exact HirePro exam structure, a prioritized topic list, free resources, a 4-week plan, and practice banks for DSA, SQL, OOPs and OS.

~54 MCQs + 4 coding problems in ~100 minutes (excluding breaks)

Last updated:

Exam Pattern

~54 MCQs + 4 coding problems in ~100 minutes (excluding breaks)

SectionQuestionsTimeTypeDifficulty
Aptitude1010 minMCQEasy–Medium
CS Fundamentals3030 minMCQMedium
Pseudo Code1010 minMCQMedium
Coding Challenge450 minCodingMedium

Section-Wise Syllabus

Everything that appears in the assessment, grouped by section.

1. Aptitude (10 Qs, 10 min)

Quantitative

  • • Number System
  • • Percentages
  • • Profit & Loss
  • • Averages
  • • Ratio & Proportion
  • • Time & Work
  • • Speed–Time–Distance
  • • Probability
  • • Permutations (basic)

Logical Reasoning

  • • Series
  • • Attention to Details
  • • Visual Reasoning
  • • Analytical Reasoning

Verbal

  • • Reading Comprehension
  • • Grammar (Error Detection, Sentence Correction)
  • • Fill in the Blanks
  • • Para Jumbles
  • • Email / Essay Writing (high weightage)

2. CS Fundamentals (30 Qs, 30 min)

Data Structures

  • • Arrays
  • • Strings
  • • Linked Lists
  • • Stacks
  • • Queues
  • • Trees
  • • Graphs (basic)
  • • Hashing

OOPs

  • • Classes & Objects
  • • Inheritance
  • • Polymorphism
  • • Encapsulation
  • • Abstraction
  • • Access Specifiers
  • • Virtual / Static
  • • Abstract Class vs Interface

Operating Systems

  • • Process & Threads
  • • Scheduling
  • • Deadlock
  • • Memory Management
  • • Paging
  • • Virtual Memory

DBMS & SQL

  • • ER Model
  • • Normalization
  • • Keys (Primary, Unique, Foreign)
  • • SQL Joins (Inner, Left, Right, Full)
  • • Subqueries
  • • Aggregate Functions
  • • GROUP BY / HAVING

Programming Concepts

  • • C / C++ / Java basics
  • • Pointers (C++)
  • • Memory Layout
  • • Recursion
  • • Time Complexity basics

3. Pseudo Code (10 Qs, 10 min)

What is asked

  • • Predict output of loops, conditionals and recursion
  • • Array / string manipulation tracing
  • • Identify logical and control-flow errors
  • • Basic time complexity reasoning

4. Coding Challenge (4 Qs, 50 min)

Arrays & Strings

  • • Reversal
  • • Duplicates
  • • Rotation
  • • Frequency
  • • Substring checks

Sorting & Searching

  • • Implement sorting
  • • Binary search concepts

Recursion

  • • Simple recursive functions
  • • Base cases

OOP-based coding

  • • Small design snippets
  • • Encapsulation snippets

Math / Number logic

  • • Digit sum
  • • Perfect squares
  • • Parity checks

Most Asked Topics

Highest-frequency areas across recent test papers.

String manipulation

Remove duplicates, rearrange vowels/consonants, decode strings, panagram check, subsequence problems.

Array operations

Reverse, rotate, remove duplicates (sorted), count elements at same index after sorting, Kadane's max subarray sum.

SQL joins

Inner, Left/Right Outer, ON vs WHERE, Primary vs Unique key.

OOPs theory + code

Encapsulation structure, access specifiers, abstract vs interface, real-life examples.

Sorting comparison

Merge vs Quick Sort — when to use which.

Recursion vs iteration

Pros/cons and writing simple recursive logic.

OS basics

Scheduling algorithms and deadlock conditions.

Free Resources

Curated practice links per section.

Aptitude & Verbal

CS Fundamentals

Pseudo Code & Output Prediction

Coding Practice & PYQs

50+ DSA Practice Problems

Solve in order — arrays and strings first, then sorting and recursion.

Arrays (15)

  1. Reverse an array (in-place)
  2. Remove duplicates from sorted array (in-place)
  3. Rotate array left by k
  4. Rotate array right by k
  5. Find max element in array
  6. Find second largest element
  7. Count occurrences of a number
  8. Check if array is sorted
  9. Move all zeros to end
  10. Find missing number in 1–N array
  11. Find duplicate in array (1–N)
  12. Majority element (> N/2)
  13. Two Sum (pair with given sum)
  14. Three Sum (triplets with sum = 0)
  15. Kadane's Algorithm (max subarray sum)

Strings (15)

  1. Reverse a string (in-place)
  2. Check if string is palindrome
  3. Remove duplicates from string (preserve order)
  4. Count vowels and consonants
  5. Check if two strings are anagrams
  6. Check if string B is substring of A
  7. Find first non-repeating character
  8. Find all permutations of a string
  9. Longest substring without repeating characters
  10. Count palindromic substrings
  11. Check panagram (all 26 letters)
  12. Rearrange vowels at odd, consonants at even indices
  13. Decode string: "3[a]2[bc]" → "aaabcbc"
  14. Count numeric substrings surrounded by lowercase
  15. Longest common prefix among N strings

Sorting (10)

  1. Bubble Sort (ascending)
  2. Selection Sort (ascending)
  3. Insertion Sort (ascending)
  4. Merge Sort (recursive)
  5. Quick Sort (recursive, pivot = last)
  6. Sort array of 0s, 1s, 2s (Dutch Flag)
  7. Sort array by frequency
  8. Sort array by parity (evens first, odds last)
  9. Sort array by absolute value
  10. Merge two sorted arrays (in-place if possible)

Recursion (10)

  1. Factorial of N
  2. Fibonacci (Nth term)
  3. Sum of first N natural numbers
  4. Power function (x^n)
  5. GCD of two numbers
  6. Check if array is sorted (recursive)
  7. Binary Search (recursive)
  8. Count zeros in sorted binary array
  9. Print all subsequences of a string
  10. Count all palindromic subsequences in a string

Previous Year Questions & Patterns

Repeat coding questions with the expected approach.

Core practice patterns

  • Reverse an array
  • Remove duplicates from a string (preserve order)
  • Remove duplicates from a sorted array (in-place)
  • Rotate array left by k
  • Maximum subarray sum (Kadane's algorithm)
  • Check if B is a substring of A
  • Count distinct years from text (DD-MM-YYYY)
  • Most frequent character (return 0 if tie)
  • Digit sum minimum from an array
  • Check panagram (all 26 letters present)

Recent 2025 questions

  • Rearranging vowels at odd indices, consonants at even indices
  • Count elements staying at the same index after sorting
  • Count valid numerical substrings surrounded by lowercase letters

PYQ patterns & approach

  • Reverse Array — swap arr[i] with arr[n-1-i]
  • Remove Duplicates (Sorted Array) — two-pointer, in-place
  • Rotate Array Left by k — reverse first k, reverse rest, reverse all
  • Remove Duplicates from String — hash set, preserve order
  • Check Substring B in A — A.find(B) or two loops
  • Count Distinct Years from Text — extract YYYY, store in set
  • Most Frequent Character (0 if tie) — frequency array, track max + count
  • Digit Sum Minimum — sum digits of each number, find min
  • Panagram Check — boolean array of size 26
  • Rearrange Vowels/Consonants — separate, then merge
  • Count Elements at Same Index After Sorting — compare sorted vs original
  • Valid Numerical Substrings — regex or manual lowercase-surround check

20+ SQL Query Bank

Write these out by hand — joins and subqueries are asked in both the test and the interview.

Basic Queries

SELECT * FROM employees WHERE salary > 50000;
SELECT name, salary FROM employees ORDER BY salary DESC;
SELECT COUNT(*) FROM employees WHERE department = 'IT';
SELECT AVG(salary) FROM employees;
SELECT MAX(salary), MIN(salary) FROM employees;

Group By + Aggregates

SELECT department, COUNT(*) FROM employees GROUP BY department;
SELECT department, AVG(salary)
FROM employees
GROUP BY department
HAVING AVG(salary) > 60000;
SELECT department, SUM(salary)
FROM employees
GROUP BY department
ORDER BY SUM(salary) DESC;

Departments with more than 5 employees

SELECT dept_id, COUNT(*)
FROM employees
GROUP BY dept_id
HAVING COUNT(*) > 5;

Joins

Inner join

SELECT e.name, d.dept_name
FROM employees e
INNER JOIN departments d ON e.dept_id = d.id;

Left join

SELECT e.name, d.dept_name
FROM employees e
LEFT JOIN departments d ON e.dept_id = d.id;

Right join

SELECT e.name, d.dept_name
FROM employees e
RIGHT JOIN departments d ON e.dept_id = d.id;

Full outer join

SELECT e.name, d.dept_name
FROM employees e
FULL OUTER JOIN departments d ON e.dept_id = d.id;

Self join (employee → manager)

SELECT e.name, m.name AS manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.id;

Employees earning more than their manager

SELECT e.name
FROM employees e
JOIN employees m ON e.manager_id = m.id
WHERE e.salary > m.salary;

Subqueries

SELECT name FROM employees
WHERE salary > (SELECT AVG(salary) FROM employees);
SELECT name FROM employees
WHERE dept_id IN (SELECT id FROM departments WHERE dept_name = 'IT');
SELECT name FROM employees
WHERE NOT EXISTS (
  SELECT 1 FROM departments WHERE departments.id = employees.dept_id
);

Employees without a department

SELECT name FROM employees
WHERE dept_id NOT IN (SELECT id FROM departments);

Advanced

Second highest salary

SELECT MAX(salary) FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees);

Nth highest salary (N = 3)

SELECT DISTINCT salary FROM employees
ORDER BY salary DESC
LIMIT 1 OFFSET 2;

Employees with the same salary

SELECT salary, COUNT(*) FROM employees
GROUP BY salary
HAVING COUNT(*) > 1;

Duplicate emails

SELECT email, COUNT(*) FROM users
GROUP BY email
HAVING COUNT(*) > 1;

★ Featured Virtusa PYQ — total matches played & won

WITH one AS (
    SELECT teamA AS team FROM matches
    UNION ALL
    SELECT teamB AS team FROM matches
),
two AS (
    SELECT team, COUNT(*) AS match_played FROM one GROUP BY team
),
three AS (
    SELECT winner AS team, COUNT(*) AS match_won FROM matches GROUP BY winner
)
SELECT a.team, a.match_played, COALESCE(b.match_won, 0) AS match_won
FROM two a
LEFT JOIN three b ON a.team = b.team
ORDER BY a.team;

DBMS & Core Interview Q&A

Short answers you should be able to say out loud.

Difference between INNER JOIN and LEFT JOIN?

INNER: only matching rows from both tables. LEFT: all rows from the left table + matching rows from the right (NULL if no match).

What is Normalization?

Process to minimize redundancy and anomalies — 1NF, 2NF, 3NF, BCNF.

Primary vs Unique key?

Primary: one per table, NOT NULL. Unique: multiple allowed, can have one NULL.

What is a View?

A virtual table based on a SELECT query; it does not store data itself.

Clustered vs Non-Clustered Index?

Clustered: data stored in index order (one per table). Non-clustered: separate index structure (multiple allowed).

What is a Transaction? ACID?

Transaction: an atomic set of operations. ACID: Atomicity, Consistency, Isolation, Durability.

Difference between DELETE and TRUNCATE?

DELETE: DML, supports WHERE, logs each row. TRUNCATE: DDL, removes all rows, no WHERE, faster.

What is a Foreign Key?

An attribute that references the primary key of another table.

What is Caching?

Storing frequently accessed data in fast memory to reduce access time.

Paging vs Segmentation?

Paging: fixed-size pages, hardware-managed. Segmentation: variable-size segments, compiler-managed.

OOPs Concepts + 10 Code Snippets

Theory plus the exact snippets asked in the technical round.

Encapsulation

Bundling data + methods in a class; private data with public methods.

Abstraction

Hiding internal details; exposing only essential features.

Inheritance

Base → Derived class; extends (Java), : public (C++).

Polymorphism

Compile-time (overloading) vs runtime (overriding).

Access Specifiers

private, protected, public.

Virtual Function

Base class function overridden in derived class (C++).

Abstract Class

Cannot be instantiated; contains abstract methods.

Interface

All methods abstract (Java); enables multiple inheritance.

1. Encapsulation

cpp

class BankAccount {
private:
    double balance;
public:
    void deposit(double amount) { balance += amount; }
    double getBalance() { return balance; }
};

2. Inheritance

cpp

class Animal { public: void eat() { cout << "Eating..."; } };
class Dog : public Animal { public: void bark() { cout << "Barking..."; } };

3. Method Overriding

java

class Parent { void show() { System.out.println("Parent"); } }
class Child extends Parent { void show() { System.out.println("Child"); } }

4. Abstract Class

java

abstract class Shape { abstract void draw(); }
class Circle extends Shape { void draw() { System.out.println("Circle"); } }

5. Interface

java

interface Drawable { void draw(); }
class Rectangle implements Drawable { public void draw() { System.out.println("Rectangle"); } }

6. Virtual Function

cpp

class Base { public: virtual void show() { cout << "Base"; } };
class Derived : public Base { public: void show() { cout << "Derived"; } };

7. Access Specifiers

cpp

class Test {
private: int a;
protected: int b;
public: int c;
};

8. Constructor + Copy Constructor

cpp

class Point {
    int x, y;
public:
    Point(int x, int y) : x(x), y(y) {}
    Point(const Point &p) : x(p.x), y(p.y) {}
};

9. Static Member

cpp

class Counter {
    static int count;
public:
    Counter() { count++; }
    static int getCount() { return count; }
};
int Counter::count = 0;

10. Friend Function

cpp

class A {
    int data;
    friend void show(A obj);
};
void show(A obj) { cout << obj.data; }

Operating System Basics

Scheduling, deadlock and memory management essentials.

Scheduling Algorithms

  • • FCFS — First-Come, First-Served (non-preemptive).
  • • SJF — Shortest Job First (optimal average waiting time).
  • • SRTF — Shortest Remaining Time First (preemptive SJF).
  • • Round Robin — time quantum-based preemptive.
  • • Priority Scheduling — based on priority (preemptive / non-preemptive).

Deadlock

  • • 4 necessary conditions: Mutual Exclusion, Hold and Wait, No Preemption, Circular Wait.
  • • Prevention: break any one of the four conditions.
  • • Avoidance: Banker's Algorithm.
  • • Detection + Recovery: Resource Allocation Graph.

Memory Management

  • • Paging — fixed-size pages; eliminates external fragmentation.
  • • Segmentation — variable-size segments; logical division.
  • • Virtual Memory — demand paging + page replacement (FIFO, LRU, Optimal).
  • • Cache — stores frequently accessed data; reduces access time.

4-Week Preparation Roadmap

From zero to test-ready in 28 days.

Week 1

Foundations + Aptitude

  • 1 hr Aptitude (Quant + Logical) + 1 hr Verbal (RC + Grammar)
  • CS: OOPs (C++/Java) + basic Data Structures (Arrays, Strings, Linked Lists)
  • Coding: 2 easy problems/day (Arrays, Strings)

Goal: Be comfortable with 80%+ of GFG Easy on Arrays/Strings.

Week 2

Core CS + Pseudo Code

  • 45 min Aptitude/Verbal, 1 hr CS (OS, DBMS), 1.5 hr Coding
  • Focus: SQL Joins (10+ queries), OS basics, Pseudo Code output questions
  • Coding: add Recursion and Sorting (Bubble, Insertion, Selection, Merge, Quick)
  • PYQ start: solve 5–6 PYQ patterns from LetsCode/PrepInsta

Goal: Confidently write all join types and trace pseudo code without errors.

Week 3

Coding Intensive + Mocks

  • 2–3 coding problems (mix of easy + medium)
  • 1 full timed Aptitude + CS + Pseudo Code mock
  • Revision: SQL Joins, OOPs theory, OS/DBMS MCQs
  • PYQ: focus on recent 2025 string/array problems

Goal: Solve medium array/string problems within 12–15 minutes each.

Week 4

Final Push

  • 2 full online test simulations (timed sections)
  • Coding: re-do all PYQ patterns; focus on speed & correctness
  • Theory: quick notes on OOPs, OS, DBMS, sorting/searching
  • Interview prep: practise OOPs + SQL questions aloud (20–30 min/day)

Goal: Hit target scores in a full HirePro simulation and explain answers aloud.

Exam Day Strategy

Score targets and time allocation.

Section targets

  • Aptitude: Aim 8–9 / 10 in 8–9 min; don't overthink.
  • CS Fundamentals: Target 25–28 / 30; skip only truly unknown questions.
  • Pseudo Code: Target 7–9 / 10; trace carefully.
  • Coding: Prioritize 3 fully correct solutions over 4 partial ones.

Coding time split (50 min)

  • Q1 — ~10 min (Easy: Array/String)
  • Q2 — ~12 min (Easy–Medium: Sorting/Searching)
  • Q3 — ~13 min (Medium: Recursion/Hashing)
  • Q4 — ~15 min (Medium: String/Array logic)

Interview Process

What follows the online test.

Technical Interview (25–30 min)

  • • OOPs concepts + code snippets (Encapsulation, Access Specifiers, Abstract vs Interface)
  • • SQL Joins — write queries (Inner, Right Outer examples)
  • • Sorting (Merge vs Quick), Recursion vs Iteration, basic algorithm choices
  • • OS: Scheduling, Deadlock, Memory concepts

HR Interview (10–15 min)

  • • Relocation flexibility
  • • Internships / projects explanation
  • • Why Virtusa?
  • • Bond agreement

Interview experience highlights (2023 on-campus)

  • • Technical: encapsulation code, access specifiers, library design, Date methods (JS), sorting/searching choices, Merge vs Quick, recursion salary-increment problem, SQL Joins, Primary vs Unique key.
  • • HR: relocation, internships, project explanation, bond, language flexibility (Python/Java).

Mock Test Plan

Four simulations to run before the real test.

Mock 1 — Aptitude + CS + Pseudo Code

  • • Aptitude: 10 Qs in 10 min (target 8–9 correct)
  • • CS MCQs: 30 Qs in 30 min (target 25–28 correct)
  • • Pseudo Code: 10 Qs in 10 min (target 7–9 correct)

Mock 2 — Coding Challenge

  • • Q1: Easy (Array/String) — 10 min
  • • Q2: Easy–Medium (Sorting/Searching) — 12 min
  • • Q3: Medium (Recursion/Hashing) — 13 min
  • • Q4: Medium (String/Array logic) — 15 min

Mock 3 — Full HirePro Simulation

  • • Aptitude + CS + Pseudo Code + 4 Coding (100 min total)
  • • Use a strict timer; no breaks during sections

Mock 4 — Interview Simulation

  • • Technical: 25 min (OOPs, SQL, OS, DSA)
  • • HR: 10 min (relocation, projects, bond, why Virtusa)

Final Checklist

Tick all of these before test day.

50+ DSA problems solved (Arrays, Strings, Sorting, Recursion)
20+ SQL queries practised (all join types, subqueries, group by)
OOPs concepts + 10 coding snippets memorized
OS basics (scheduling, deadlock, memory) revised
3–4 full timed mocks completed
10+ PYQ patterns solved (LetsCode/PrepInsta)
SQL Joins + DBMS question bank reviewed

Recent Interview Experiences

First-hand write-ups from students who actually sat the Virtusa process.

Be the first to share a Virtusa interview experience.

Frequently Asked Questions

What is the Virtusa Regular Coder exam pattern in 2026?

Four sections on HirePro: Aptitude (10 Qs / 10 min), CS Fundamentals (30 Qs / 30 min), Pseudo Code (10 Qs / 10 min) and a Coding Challenge (4 problems / 50 min) — roughly 54 MCQs plus 4 coding problems in about 100 minutes. The test is adaptive with no negative marking.

Is there negative marking in the Virtusa online test?

No. The HirePro assessment used by Virtusa has no negative marking, so attempt every question you can reason about.

What is the package for the Virtusa Regular Coder role?

The Regular Coder role is offered at approximately 5 LPA.

How long does it take to prepare for Virtusa from scratch?

Four focused weeks are enough: Week 1 foundations + aptitude, Week 2 core CS + pseudo code, Week 3 coding intensive + mocks, Week 4 final push with full timed simulations.

What comes after the Virtusa online test?

A technical interview of 25–30 minutes covering OOPs, SQL joins, sorting, recursion and OS, followed by a 10–15 minute HR round on relocation, projects, motivation and the bond agreement.

Want the full structured prep for Virtusa?

The Premium Vault covers Aptitude, Core CS, DSA, SQL and HR rounds with module-wise courses and drill sheets.

Explore Premium VaultVirtusa Company Sheet

Related Prep

Next steps chosen from the Virtusa pattern and other IT Services (Mass Hiring) recruiters.

Other IT Services (Mass Hiring) companies

Cognizant Technology Solutions Interview Prep Guide

Cognizant Technology Solutions exam pattern, syllabus and previous year questions · ₹4–9 LPA.

Accenture Interview Prep Guide

Accenture exam pattern, syllabus and previous year questions · ₹4.5–11 LPA.

TCS Interview Prep Guide

TCS exam pattern, syllabus and previous year questions · ₹3.5–12 LPA.

Core CS subjects for this pattern

DBMS & SQL Essentials

Normalisation, keys, transactions and the SQL queries asked in written rounds.

OOPs Essentials for Interviews

The four pillars with the exact code snippets interviewers ask you to explain.

Operating System Essentials

Processes, scheduling, deadlock and memory management in interview-ready form.

Recommended practice path

DSA 101 Practice Sheet

Beginner-friendly problem set that matches the Virtusa coding section.