NTT DATA Interview Questions & Placement Prep (2026)
NTT DATA's fresher hiring runs through four stages — an online assessment (English, Quantitative Ability, Logical Reasoning and Computer Programming), a group discussion or managerial communication round, a technical interview and an HR interview. This guide covers the exact section-wise question distribution, syllabus, previous-year-style questions, formulas, ready code and a week-by-week roadmap.
99 MCQs across English, Quant, Logical Reasoning and Computer Programming in ~120–130 minutes
Last updated:
Exam Pattern
99 MCQs across English, Quant, Logical Reasoning and Computer Programming in ~120–130 minutes
| Section | Questions | Time | Type | Difficulty |
|---|---|---|---|---|
| English Ability | 25 | 25 min | MCQ | Easy–Medium |
| Quantitative Ability | 25 | 35 min | MCQ | Medium |
| Logical and Analytical Reasoning | 24 | 35 min | MCQ | Medium |
| Computer Programming | 25 | 25 min | MCQ | Medium |
| GD / Managerial Round | Group discussion | Varies | Communication | Elimination |
| Technical + HR Interview | Varies | 20–30 min | Interview | Elimination |
Section-Wise Syllabus
Everything that appears in the assessment, grouped by section.
1. Online Assessment — Section-wise Distribution (99 Qs / ~120–130 min)
English Ability (25 Qs)
- • Reading comprehension
- • Main idea & title
- • Inference-based questions
- • Vocabulary in context
- • Synonyms & antonyms
- • Sentence correction
- • Error spotting
- • Fill in the blanks
- • Sentence completion
- • Para jumbles
Quantitative Ability (25 Qs)
- • Number system, HCF & LCM
- • Percentages, profit/loss, discount
- • Ratio, proportion, averages
- • Mixtures & allegations
- • SI/CI, time & work, pipes & cisterns
- • Time-speed-distance, trains, boats & streams
- • Probability, permutation & combination
- • Data interpretation
Logical and Analytical Reasoning (24 Qs)
- • Number & letter series
- • Coding-decoding
- • Analogy & classification
- • Blood relations
- • Direction sense
- • Seating arrangement & puzzles
- • Syllogisms, statement & conclusion
- • Data sufficiency
- • Cubes, dice & Venn diagrams
Computer Programming (25 Qs)
- • Variables, data types, operators
- • Conditionals & loops
- • Functions, arrays, strings
- • Pointers, references, recursion
- • Sorting & searching
- • Bitwise operators & output prediction
- • Time and space complexity
- • C, C++, Java or Python fundamentals
2. Core Computer Science (Interview Stage)
Data Structures & Algorithms
- • Arrays, strings, linked lists
- • Stacks, queues, hash maps
- • Trees, BSTs, heaps, graphs
- • Sorting & searching
- • Recursion, greedy, DP
- • BFS/DFS
- • Time and space complexity
OOP
- • Class & object
- • Encapsulation & abstraction
- • Inheritance & polymorphism
- • Constructor/destructor
- • Function overloading vs overriding
- • Virtual functions, abstract classes, interfaces
- • Access modifiers
- • Static members
DBMS & SQL
- • Primary, foreign, candidate & composite keys
- • Functional dependency
- • 1NF, 2NF, 3NF, BCNF
- • SQL joins, aggregates
- • GROUP BY / HAVING
- • Subqueries, indexing
- • Transactions, ACID, serialisability
- • Deadlocks, views
Operating Systems
- • Process & thread, context switching
- • CPU scheduling
- • Synchronisation, mutex & semaphore
- • Deadlock
- • Paging, segmentation, virtual memory
- • Page replacement
- • File systems
- • User mode vs kernel mode
Computer Networks & Unix
- • OSI & TCP/IP models
- • TCP vs UDP
- • IP addressing, DNS, DHCP, ARP
- • HTTP/HTTPS, routing
- • Three-way handshake, congestion control
- • Linux commands, file permissions
- • Processes and signals
- • Pipes and redirection, shell basics
3. Selection Process
Stages
- • Online written test — aptitude, English, reasoning and programming
- • Group discussion / managerial round — communication, confidence, teamwork and reasoning
- • Technical interview — programming, DSA, CS fundamentals, SQL and project
- • HR interview — behaviour, relocation, joining and role fit
4. Pattern Caveats & Reminders
Before the drive
- • Public sources disagree slightly about total duration — expect 120–130 minutes
- • Some drives use AMCAT or another third-party assessment platform
- • The test may be sectional, so practise within individual section time limits
- • Do not assume question counts or negative-marking rules stay identical across batches
- • Use the instructions in your NTT DATA assessment email as the final authority
Most Asked Topics
Highest-frequency areas across recent test papers.
Output tracing
Pre/post increment, integer division, modulus, nested loops, recursion, array indexing and pass-by-value vs pass-by-reference dominate the programming section.
Arithmetic core
Percentages, profit & loss, SI/CI, time & work, time-speed-distance and averages repeat every slot.
Logical series & coding-decoding
Number/letter series, coding-decoding and blood relations are near-guaranteed each drive.
Reading comprehension & error spotting
English focuses on inference, vocabulary in context and grammar correctness.
DBMS normalisation
1NF/2NF/3NF/BCNF and key types are staple technical-interview questions.
OS scheduling & deadlock
FCFS, SJF, Round Robin and the four deadlock conditions are frequently asked.
Networking basics
OSI layers, TCP vs UDP, DNS resolution and the three-way handshake.
Project deep dive
Every technical interview starts from the final-year project — role, stack, architecture and challenges faced.
Free Resources
Curated practice links per section.
Aptitude & Reasoning
Computer Programming & CS
Interview experiences
50+ DSA Practice Problems
Solve in order — arrays and strings first, then sorting and recursion.
Easy — Foundations (10)
- Reverse an array in-place
- Reverse a string without built-ins
- Check whether a string is a palindrome
- Find the second largest element
- Count vowels and consonants
- Sum of digits of a number
- Factorial using recursion
- Fibonacci series up to n terms
- Check Armstrong numbers in a range
- Find the missing number using n(n+1)/2
Medium — Arrays & Strings (10)
- Two Sum using hashing
- Maximum subarray sum (Kadane's algorithm)
- Longest substring without repeating characters
- Rotate an array by k positions
- Merge two sorted arrays
- Valid parenthesis check
- Find duplicates in an array
- Longest palindromic substring
- Anagram check using sorting and hashing
- Count occurrences of each character
Trees, Graphs & Recursion (8)
- Inorder, preorder, postorder traversal of a BST
- Level-order traversal (BFS)
- Height of a binary tree
- Graph traversal: BFS and DFS
- Detect a cycle in a graph
- Check if a binary tree is balanced
- Print all subsequences of a string
- Binary search (recursive)
Fundamentals to code from memory (8)
- Bubble, selection and insertion sort
- Linear and binary search
- Prime check in O(√n)
- GCD using the Euclidean algorithm
- Hash table lookup implementation basics
- Stack-based valid bracket matching
- Queue implementation using two stacks
- Simple LRU cache design discussion
Previous Year Questions & Patterns
Repeat coding questions with the expected approach.
English PYQs
- Choose the correct sentence — 'Neither of the answers is correct' is grammatically right
- Closest meaning of 'mitigate' → Reduce the severity
- Logical arrangement: Requirements analysed → code written → code tested → application deployed
- In RC passages, an example is generally used to support or explain the author's argument
Quantitative PYQs
- A train 180 m long crosses a pole in 9 seconds → speed = 72 km/h
- Article marked 30% above cost, sold at 10% discount → profit = 17%
- A and B complete a job in 12 and 18 days → combined time = 7.2 days
- Average of five numbers is 28; after removing one it becomes 25 → removed number = 40
- Series 2, 6, 12, 20, 30, ? → next term = 42
- Bag has 5 red and 3 blue balls, draw 2 without replacement → P(both red) = 5/14
Logical Reasoning PYQs
- DATA coded as EBUB → CODE coded as DPEF
- Walk 5 km north, turn right 3 km, turn right 5 km → 3 km east of start
- All programmers are logical; some logical people are gamers → cannot conclude some programmers are gamers
- Seating arrangement with partial constraints → additional constraint needed to fix full order
Programming & CS PYQs
- Which data structure follows LIFO? → Stack
- Which BST traversal produces sorted order? → Inorder
- Which normal form removes partial dependency? → Second Normal Form (2NF)
- Which protocol is connection-oriented? → TCP
- Average lookup complexity of a hash table → O(1)
- int x=3; for(i=1;i<=3;i++) x*=i; cout<<x; → Output: 18
- Nested loop i from 0..n, j from i..n → time complexity O(n^2)
- Linux command to list files → ls; command to change directory → cd
HR questions
- Tell me about yourself
- Why NTT DATA? What do you know about the company?
- Strengths and weaknesses
- Describe a time you faced conflict in a team project
- Are you willing to relocate and work flexible shifts?
- Where do you see yourself in five years?
20+ SQL Query Bank
Write these out by hand — joins and subqueries are asked in both the test and the interview.
Basics & aggregation
Filter and sort
SELECT name, department
FROM employees
WHERE salary > 50000
ORDER BY salary DESC;Aggregates
SELECT COUNT(*) AS total,
AVG(salary) AS avg_salary,
MAX(salary) AS max_salary,
MIN(salary) AS min_salary
FROM employees;GROUP BY with HAVING
SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department
HAVING MAX(salary) > 60000;Joins
INNER JOIN
SELECT e.name, d.department_name
FROM employees e
INNER JOIN departments d
ON e.dept_id = d.dept_id;LEFT JOIN
SELECT e.name, d.department_name
FROM employees e
LEFT JOIN departments d
ON e.dept_id = d.dept_id;SELF JOIN — employee and manager
SELECT e1.name AS employee, e2.name AS manager
FROM employees e1
JOIN employees e2
ON e1.manager_id = e2.emp_id;Subqueries
Second-highest salary
SELECT MAX(salary) AS second_highest
FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees);Employees above the overall average
SELECT name, salary
FROM employees
WHERE salary > (SELECT AVG(salary) FROM employees);DBMS & Core Interview Q&A
Short answers you should be able to say out loud.
WHERE vs HAVING?
WHERE filters rows before grouping; HAVING filters groups after GROUP BY and may use aggregates.
What is a functional dependency?
A relationship where one attribute uniquely determines another, used to derive normal forms.
What is normalisation?
Structuring tables through 1NF, 2NF, 3NF and BCNF to remove redundancy and update anomalies.
Primary key vs candidate key?
A candidate key is any minimal set of attributes that can uniquely identify a row; the primary key is the chosen candidate key.
What are ACID properties?
Atomicity, Consistency, Isolation and Durability — the guarantees of a reliable transaction.
What is an index?
A lookup structure that speeds reads at the cost of storage and slower writes.
What is a deadlock?
A condition where processes wait indefinitely for resources held by one another; requires mutual exclusion, hold-and-wait, no preemption and circular wait.
Process vs thread?
A process has its own memory space; threads share the memory of their parent process.
OOPs Concepts + 10 Code Snippets
Theory plus the exact snippets asked in the technical round.
Encapsulation
Keep fields private and expose controlled accessors — e.g. a Bank class with a private balance and deposit()/getBalance().
Abstraction
Show only what matters and hide implementation behind interfaces or abstract classes.
Inheritance
Derive Child from Parent to reuse behaviour and extend it with new methods.
Polymorphism
Compile-time overloading versus runtime overriding (virtual functions in C++, method overriding in Python/Java).
Class vs object
A class is the blueprint; an object is an instance holding its own state.
Constructor
Initialises an object; __init__ in Python, same-name method in C++/Java; can be overloaded.
Virtual functions
Enable runtime dispatch in C++; mark overrides with the override keyword.
Time complexity basics
Linear search O(n), binary search O(log n), bubble/selection/insertion O(n^2), quicksort O(n log n) average.
1. Binary search (C++)
int binarySearch(int arr[], int n, int target) {
int left = 0, right = n - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target) return mid;
else if (arr[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}2. Output tracing — division and modulus (C++)
int x = 5, y = 2;
cout << x / y << " " << x % y;
// Output: 2 13. Doubling loop — log n complexity (C++)
for (int i = 1; i <= n; i *= 2)
cout << i;
// Time complexity: O(log n)4. Kadane's maximum subarray (C++)
int maxSubArraySum(int arr[], int n) {
int maxSum = arr[0], cur = arr[0];
for (int i = 1; i < n; i++) {
cur = max(arr[i], cur + arr[i]);
maxSum = max(maxSum, cur);
}
return maxSum;
}5. Two Sum with hashing (C++)
vector<int> twoSum(int arr[], int n, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < n; i++) {
int complement = target - arr[i];
if (seen.count(complement)) return {seen[complement], i};
seen[arr[i]] = i;
}
return {};
}6. BST inorder traversal (C++)
struct Node { int val; Node *left, *right; };
void inorder(Node* root, vector<int>& out) {
if (!root) return;
inorder(root->left, out);
out.push_back(root->val);
inorder(root->right, out);
}7. Prime check and GCD (C++)
bool isPrime(int n) {
if (n < 2) return false;
for (int i = 2; i * i <= n; i++) if (n % i == 0) return false;
return true;
}
int gcd(int a, int b) {
while (b) { int t = b; b = a % b; a = t; }
return a;
}8. Bubble / selection / insertion sort (Python)
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
def insertion_sort(arr):
for i in range(1, len(arr)):
key, j = arr[i], i - 1
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr9. Missing number and vowel count (Python)
def find_missing(arr, n):
return n * (n + 1) // 2 - sum(arr)
def count_vowels_consonants(s):
vowels = set('aeiouAEIOU')
v = c = 0
for ch in s:
if ch.isalpha():
if ch in vowels: v += 1
else: c += 1
return v, c10. OOP — inheritance and encapsulation (Python)
class Animal:
def sound(self):
print('Some sound')
class Dog(Animal):
def sound(self):
print('Bark')
class Bank:
def __init__(self):
self.__balance = 0 # private
def deposit(self, amount):
self.__balance += amount
def get_balance(self):
return self.__balanceOperating System Basics
Scheduling, deadlock and memory management essentials.
Operating Systems
- • Process versus thread and the cost of context switching.
- • Deadlock and its four necessary conditions.
- • Paging, segmentation and virtual memory.
- • Scheduling: FCFS, SJF, SRTF, Round Robin, Priority.
- • Mutex versus semaphore; race conditions.
Computer Networks & Unix
- • OSI layers: Physical, Data Link, Network, Transport, Session, Presentation, Application.
- • TCP (connection-oriented, reliable) versus UDP (connectionless, fast).
- • Three-way handshake and congestion control basics.
- • IP addressing, DNS, DHCP and ARP fundamentals.
- • Common Linux commands: ls, cd, chmod; file permissions, processes and pipes.
DBMS Essentials
- • Primary, foreign, candidate and composite keys.
- • 1NF, 2NF, 3NF and BCNF with examples.
- • ACID properties and transaction isolation levels.
- • Indexing strategies and when they help or hurt.
- • Deadlocks in databases and how to avoid them.
Role expectations
- • Software Engineer Associate: strong fundamentals in aptitude, programming output tracing and CS core subjects.
- • Coding round performance and interview clarity drive final offer and project mapping.
- • A clear final-year project narrative with technical depth is essential at the interview stage.
- • Communication skills matter heavily in the GD/managerial round.
4-Week Preparation Roadmap
From zero to test-ready in 28 days.
Aptitude & Reasoning Foundation
- 50 quantitative questions
- 50 reasoning questions
- Revise one formula sheet section
- 15 English grammar/vocabulary questions
Goal: Finish percentages, profit & loss, SI/CI, time & work, speed-time-distance, permutations, seating arrangements and blood relations.
Computer Programming MCQs
- 20+ output-prediction questions
- Revise loops, recursion, pointers
- Practice bitwise operator questions
- Time & space complexity drills
Goal: Be able to trace any loop or recursive call in under a minute and answer programming MCQs from memory.
DSA, DBMS, OS & Networks (Interview Prep)
- 5 array/string/tree problems from LeetCode/GFG
- Revise DBMS normalisation and write 3 SQL queries
- Revise OS scheduling and deadlock conditions
- Revise OSI layers, TCP/UDP and DNS resolution
Goal: 50+ easy-medium DSA problems solved, DBMS/OS/Networks fundamentals interview-ready.
GD, Mock Interviews & Final Revision
- Practice a group discussion topic aloud
- Record HR answers and review fillers
- One peer mock technical interview
- One full timed simulation of the 99-MCQ test
Goal: Confident GD participation, a crisp project story, and a completed full-length mock assessment.
Exam Day Strategy
Score targets and time allocation.
Section targets
- English Ability (25 Qs): 25 min — skim passages, answer direct vocabulary/grammar questions first.
- Quantitative Ability (25 Qs): 35 min — solve familiar formula-based questions before DI sets.
- Logical Reasoning (24 Qs): 35 min — skip lengthy puzzles on the first pass, return if time remains.
- Computer Programming (25 Qs): 25 min — trace loops on paper, watch operator precedence.
- Buffer: 5–10 min review; aim for a strong, balanced score across all four sections.
Coding time split (50 min)
- Read the question carefully — note input/output format
- Trace sample inputs manually before coding
- Write the core logic first, then handle edge cases
- Test with empty, single-element and duplicate inputs
- Recheck operator precedence and loop boundaries before submitting
Interview Process
What follows the online test.
Technical Interview
- • Explain your final-year project: your role, challenges and tech stack.
- • DSA: explain your approach for array/string/tree problems with complexity.
- • OOP basics: inheritance, polymorphism, encapsulation with real examples.
- • DBMS: normalisation, keys, and SQL queries (joins, GROUP BY, subqueries).
- • OS: process vs thread, deadlock, scheduling algorithms.
- • Networking: OSI layers, TCP vs UDP, DNS resolution.
GD / Managerial Round
- • Current-affairs or technology-themed group discussion topics.
- • Assessed on clarity, confidence, listening and structured argumentation.
- • Avoid dominating the discussion; build on others' points constructively.
- • Conclude with a clear summary if given the chance to close.
HR Interview
- • Tell me about yourself; why NTT DATA?
- • Strengths and weaknesses with evidence.
- • A time you faced conflict in a team.
- • Willingness to relocate and work flexible shifts.
- • What do you know about NTT DATA's business and services?
- • Where do you see yourself in five years?
Mock Test Plan
Four simulations to run before the real test.
Mock 1 — Full Online Assessment
- • 99 MCQs in 120 minutes with the exact section split
- • Target a balanced score across all four sections
Mock 2 — Programming Output Sprint
- • 30 output-prediction questions in 30 minutes
- • Trace on paper; log every loop or pointer mistake
Mock 3 — DSA Practice Round
- • 5 array/string/tree problems in 60 minutes
- • Test with empty, single-element and duplicate inputs
Mock 4 — GD Simulation
- • One 15-minute group discussion with peers on a tech topic
- • Record and review clarity, confidence and listening
Mock 5 — Interview Simulation
- • 20 min technical + project deep dive
- • 10 min HR covering relocation, shifts and motivation
Final Checklist
Tick all of these before test day.
Recent Interview Experiences
First-hand write-ups from students who actually sat the NTT DATA process.
Be the first to share a NTT DATA interview experience.
Frequently Asked Questions
What is the NTT DATA Software Engineer Associate exam pattern in 2026?
An online assessment with 99 MCQs (25 English, 25 Quant, 24 Logical Reasoning, 25 Computer Programming) in approximately 120–130 minutes, followed by a GD/managerial round, a technical interview and an HR interview.
How is the Computer Programming section different from Quant or Reasoning?
It focuses on output prediction, loops, recursion, pointers, arrays, strings and time/space complexity rather than general aptitude, and typically has 25 questions in 25 minutes.
Is there negative marking in the NTT DATA assessment?
Rules vary by batch and platform, so always confirm from your official assessment email or instructions screen before starting.
What is asked in the NTT DATA technical interview?
Your final-year project, DSA problem-solving approach, OOP concepts, DBMS normalisation and SQL queries, OS scheduling/deadlock, and basic networking concepts like OSI layers and TCP vs UDP.
How important is the GD/managerial round?
It is an elimination stage that tests communication, confidence, teamwork and structured reasoning — treat it with the same seriousness as the technical interview.
Which programming languages can I use for the technical assessment?
The Computer Programming MCQ section is language-agnostic (concepts in C, C++, Java or Python), while the interview typically lets you choose your strongest language for coding discussions.
Want the full structured prep for NTT DATA?
The Premium Vault covers Aptitude, Core CS, DSA, SQL and HR rounds with module-wise courses and drill sheets.
Related Prep
Next steps chosen from the NTT DATA pattern and other IT Services (Mass Hiring) recruiters.
Other IT Services (Mass Hiring) companies
Virtusa Interview Prep Guide
Virtusa exam pattern, syllabus and previous year questions · ₹3.5–7 LPA.
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.
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